' }\n */\n async getRequestHeaders() {\n const accessTokenResponse = await this.getAccessToken();\n const headers = new Headers({\n authorization: `Bearer ${accessTokenResponse.token}`,\n });\n return this.addSharedMetadataHeaders(headers);\n }\n request(opts, callback) {\n if (callback) {\n this.requestAsync(opts).then(r => callback(null, r), e => {\n return callback(e, e.response);\n });\n }\n else {\n return this.requestAsync(opts);\n }\n }\n /**\n * @return A promise that resolves with the project ID corresponding to the\n * current workload identity pool or current workforce pool if\n * determinable. For workforce pool credential, it returns the project ID\n * corresponding to the workforcePoolUserProject.\n * This is introduced to match the current pattern of using the Auth\n * library:\n * const projectId = await auth.getProjectId();\n * const url = `https://dns.googleapis.com/dns/v1/projects/${projectId}`;\n * const res = await client.request({ url });\n * The resource may not have permission\n * (resourcemanager.projects.get) to call this API or the required\n * scopes may not be selected:\n * https://cloud.google.com/resource-manager/reference/rest/v1/projects/get#authorization-scopes\n */\n async getProjectId() {\n const projectNumber = this.projectNumber || this.workforcePoolUserProject;\n if (this.projectId) {\n // Return previously determined project ID.\n return this.projectId;\n }\n else if (projectNumber) {\n // Preferable not to use request() to avoid retrial policies.\n const headers = await this.getRequestHeaders();\n const opts = {\n ...BaseExternalAccountClient.RETRY_CONFIG,\n headers,\n url: `${this.cloudResourceManagerURL.toString()}${projectNumber}`,\n responseType: 'json',\n };\n authclient_1.AuthClient.setMethodName(opts, 'getProjectId');\n const response = await this.transporter.request(opts);\n this.projectId = response.data.projectId;\n return this.projectId;\n }\n return null;\n }\n /**\n * Authenticates the provided HTTP request, processes it and resolves with the\n * returned response.\n * @param opts The HTTP request options.\n * @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure.\n * @return A promise that resolves with the successful response.\n */\n async requestAsync(opts, reAuthRetried = false) {\n let response;\n try {\n const requestHeaders = await this.getRequestHeaders();\n opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);\n this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);\n response = await this.transporter.request(opts);\n }\n catch (e) {\n const res = e.response;\n if (res) {\n const statusCode = res.status;\n // Retry the request for metadata if the following criteria are true:\n // - We haven't already retried. It only makes sense to retry once.\n // - The response was a 401 or a 403\n // - The request didn't send a readableStream\n // - forceRefreshOnFailure is true\n const isReadableStream = res.config.data instanceof stream.Readable;\n const isAuthErr = statusCode === 401 || statusCode === 403;\n if (!reAuthRetried &&\n isAuthErr &&\n !isReadableStream &&\n this.forceRefreshOnFailure) {\n await this.refreshAccessTokenAsync();\n return await this.requestAsync(opts, true);\n }\n }\n throw e;\n }\n return response;\n }\n /**\n * Forces token refresh, even if unexpired tokens are currently cached.\n * External credentials are exchanged for GCP access tokens via the token\n * exchange endpoint and other settings provided in the client options\n * object.\n * If the service_account_impersonation_url is provided, an additional\n * step to exchange the external account GCP access token for a service\n * account impersonated token is performed.\n * @return A promise that resolves with the fresh GCP access tokens.\n */\n async refreshAccessTokenAsync() {\n // Use an existing access token request, or cache a new one\n this.#pendingAccessToken =\n this.#pendingAccessToken || this.#internalRefreshAccessTokenAsync();\n try {\n return await this.#pendingAccessToken;\n }\n finally {\n // clear pending access token for future requests\n this.#pendingAccessToken = null;\n }\n }\n async #internalRefreshAccessTokenAsync() {\n // Retrieve the external credential.\n const subjectToken = await this.retrieveSubjectToken();\n // Construct the STS credentials options.\n const stsCredentialsOptions = {\n grantType: STS_GRANT_TYPE,\n audience: this.audience,\n requestedTokenType: STS_REQUEST_TOKEN_TYPE,\n subjectToken,\n subjectTokenType: this.subjectTokenType,\n // generateAccessToken requires the provided access token to have\n // scopes:\n // https://www.googleapis.com/auth/iam or\n // https://www.googleapis.com/auth/cloud-platform\n // The new service account access token scopes will match the user\n // provided ones.\n scope: this.serviceAccountImpersonationUrl\n ? [DEFAULT_OAUTH_SCOPE]\n : this.getScopesArray(),\n };\n // Exchange the external credentials for a GCP access token.\n // Client auth is prioritized over passing the workforcePoolUserProject\n // parameter for STS token exchange.\n const additionalOptions = !this.clientAuth && this.workforcePoolUserProject\n ? { userProject: this.workforcePoolUserProject }\n : undefined;\n const additionalHeaders = new Headers({\n 'x-goog-api-client': this.getMetricsHeaderValue(),\n });\n const stsResponse = await this.stsCredential.exchangeToken(stsCredentialsOptions, additionalHeaders, additionalOptions);\n if (this.serviceAccountImpersonationUrl) {\n this.cachedAccessToken = await this.getImpersonatedAccessToken(stsResponse.access_token);\n }\n else if (stsResponse.expires_in) {\n // Save response in cached access token.\n this.cachedAccessToken = {\n access_token: stsResponse.access_token,\n expiry_date: new Date().getTime() + stsResponse.expires_in * 1000,\n res: stsResponse.res,\n };\n }\n else {\n // Save response in cached access token.\n this.cachedAccessToken = {\n access_token: stsResponse.access_token,\n res: stsResponse.res,\n };\n }\n // Save credentials.\n this.credentials = {};\n Object.assign(this.credentials, this.cachedAccessToken);\n delete this.credentials.res;\n // Trigger tokens event to notify external listeners.\n this.emit('tokens', {\n refresh_token: null,\n expiry_date: this.cachedAccessToken.expiry_date,\n access_token: this.cachedAccessToken.access_token,\n token_type: 'Bearer',\n id_token: null,\n });\n // Return the cached access token.\n return this.cachedAccessToken;\n }\n /**\n * Returns the workload identity pool project number if it is determinable\n * from the audience resource name.\n * @param audience The STS audience used to determine the project number.\n * @return The project number associated with the workload identity pool, if\n * this can be determined from the STS audience field. Otherwise, null is\n * returned.\n */\n getProjectNumber(audience) {\n // STS audience pattern:\n // //iam.googleapis.com/projects/$PROJECT_NUMBER/locations/...\n const match = audience.match(/\\/projects\\/([^/]+)/);\n if (!match) {\n return null;\n }\n return match[1];\n }\n /**\n * Exchanges an external account GCP access token for a service\n * account impersonated access token using iamcredentials\n * GenerateAccessToken API.\n * @param token The access token to exchange for a service account access\n * token.\n * @return A promise that resolves with the service account impersonated\n * credentials response.\n */\n async getImpersonatedAccessToken(token) {\n const opts = {\n ...BaseExternalAccountClient.RETRY_CONFIG,\n url: this.serviceAccountImpersonationUrl,\n method: 'POST',\n headers: {\n 'content-type': 'application/json',\n authorization: `Bearer ${token}`,\n },\n data: {\n scope: this.getScopesArray(),\n lifetime: this.serviceAccountImpersonationLifetime + 's',\n },\n responseType: 'json',\n };\n authclient_1.AuthClient.setMethodName(opts, 'getImpersonatedAccessToken');\n const response = await this.transporter.request(opts);\n const successResponse = response.data;\n return {\n access_token: successResponse.accessToken,\n // Convert from ISO format to timestamp.\n expiry_date: new Date(successResponse.expireTime).getTime(),\n res: response,\n };\n }\n /**\n * Returns whether the provided credentials are expired or not.\n * If there is no expiry time, assumes the token is not expired or expiring.\n * @param accessToken The credentials to check for expiration.\n * @return Whether the credentials are expired or not.\n */\n isExpired(accessToken) {\n const now = new Date().getTime();\n return accessToken.expiry_date\n ? now >= accessToken.expiry_date - this.eagerRefreshThresholdMillis\n : false;\n }\n /**\n * @return The list of scopes for the requested GCP access token.\n */\n getScopesArray() {\n // Since scopes can be provided as string or array, the type should\n // be normalized.\n if (typeof this.scopes === 'string') {\n return [this.scopes];\n }\n return this.scopes || [DEFAULT_OAUTH_SCOPE];\n }\n getMetricsHeaderValue() {\n const nodeVersion = process.version.replace(/^v/, '');\n const saImpersonation = this.serviceAccountImpersonationUrl !== undefined;\n const credentialSourceType = this.credentialSourceType\n ? this.credentialSourceType\n : 'unknown';\n return `gl-node/${nodeVersion} auth/${shared_cjs_1.pkg.version} google-byoid-sdk source/${credentialSourceType} sa-impersonation/${saImpersonation} config-lifetime/${this.configLifetimeRequested}`;\n }\n getTokenUrl() {\n return this.tokenUrl;\n }\n}\nexports.BaseExternalAccountClient = BaseExternalAccountClient;\n//# sourceMappingURL=baseexternalclient.js.map", "\"use strict\";\n// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.FileSubjectTokenSupplier = void 0;\nconst util_1 = require(\"util\");\nconst fs = require(\"fs\");\n// fs.readfile is undefined in browser karma tests causing\n// `npm run browser-test` to fail as test.oauth2.ts imports this file via\n// src/index.ts.\n// Fallback to void function to avoid promisify throwing a TypeError.\nconst readFile = (0, util_1.promisify)(fs.readFile ?? (() => { }));\nconst realpath = (0, util_1.promisify)(fs.realpath ?? (() => { }));\nconst lstat = (0, util_1.promisify)(fs.lstat ?? (() => { }));\n/**\n * Internal subject token supplier implementation used when a file location\n * is configured in the credential configuration used to build an {@link IdentityPoolClient}\n */\nclass FileSubjectTokenSupplier {\n filePath;\n formatType;\n subjectTokenFieldName;\n /**\n * Instantiates a new file based subject token supplier.\n * @param opts The file subject token supplier options to build the supplier\n * with.\n */\n constructor(opts) {\n this.filePath = opts.filePath;\n this.formatType = opts.formatType;\n this.subjectTokenFieldName = opts.subjectTokenFieldName;\n }\n /**\n * Returns the subject token stored at the file specified in the constructor.\n * @param context {@link ExternalAccountSupplierContext} from the calling\n * {@link IdentityPoolClient}, contains the requested audience and subject\n * token type for the external account identity. Not used.\n */\n async getSubjectToken() {\n // Make sure there is a file at the path. lstatSync will throw if there is\n // nothing there.\n let parsedFilePath = this.filePath;\n try {\n // Resolve path to actual file in case of symlink. Expect a thrown error\n // if not resolvable.\n parsedFilePath = await realpath(parsedFilePath);\n if (!(await lstat(parsedFilePath)).isFile()) {\n throw new Error();\n }\n }\n catch (err) {\n if (err instanceof Error) {\n err.message = `The file at ${parsedFilePath} does not exist, or it is not a file. ${err.message}`;\n }\n throw err;\n }\n let subjectToken;\n const rawText = await readFile(parsedFilePath, { encoding: 'utf8' });\n if (this.formatType === 'text') {\n subjectToken = rawText;\n }\n else if (this.formatType === 'json' && this.subjectTokenFieldName) {\n const json = JSON.parse(rawText);\n subjectToken = json[this.subjectTokenFieldName];\n }\n if (!subjectToken) {\n throw new Error('Unable to parse the subject_token from the credential_source file');\n }\n return subjectToken;\n }\n}\nexports.FileSubjectTokenSupplier = FileSubjectTokenSupplier;\n//# sourceMappingURL=filesubjecttokensupplier.js.map", "\"use strict\";\n// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.UrlSubjectTokenSupplier = void 0;\nconst authclient_1 = require(\"./authclient\");\n/**\n * Internal subject token supplier implementation used when a URL\n * is configured in the credential configuration used to build an {@link IdentityPoolClient}\n */\nclass UrlSubjectTokenSupplier {\n url;\n headers;\n formatType;\n subjectTokenFieldName;\n additionalGaxiosOptions;\n /**\n * Instantiates a URL subject token supplier.\n * @param opts The URL subject token supplier options to build the supplier with.\n */\n constructor(opts) {\n this.url = opts.url;\n this.formatType = opts.formatType;\n this.subjectTokenFieldName = opts.subjectTokenFieldName;\n this.headers = opts.headers;\n this.additionalGaxiosOptions = opts.additionalGaxiosOptions;\n }\n /**\n * Sends a GET request to the URL provided in the constructor and resolves\n * with the returned external subject token.\n * @param context {@link ExternalAccountSupplierContext} from the calling\n * {@link IdentityPoolClient}, contains the requested audience and subject\n * token type for the external account identity. Not used.\n */\n async getSubjectToken(context) {\n const opts = {\n ...this.additionalGaxiosOptions,\n url: this.url,\n method: 'GET',\n headers: this.headers,\n responseType: this.formatType,\n };\n authclient_1.AuthClient.setMethodName(opts, 'getSubjectToken');\n let subjectToken;\n if (this.formatType === 'text') {\n const response = await context.transporter.request(opts);\n subjectToken = response.data;\n }\n else if (this.formatType === 'json' && this.subjectTokenFieldName) {\n const response = await context.transporter.request(opts);\n subjectToken = response.data[this.subjectTokenFieldName];\n }\n if (!subjectToken) {\n throw new Error('Unable to parse the subject_token from the credential_source URL');\n }\n return subjectToken;\n }\n}\nexports.UrlSubjectTokenSupplier = UrlSubjectTokenSupplier;\n//# sourceMappingURL=urlsubjecttokensupplier.js.map", "\"use strict\";\n// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CertificateSubjectTokenSupplier = exports.InvalidConfigurationError = exports.CertificateSourceUnavailableError = exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE = void 0;\nconst util_1 = require(\"../util\");\nconst fs = require(\"fs\");\nconst crypto_1 = require(\"crypto\");\nconst https = require(\"https\");\nexports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE = 'GOOGLE_API_CERTIFICATE_CONFIG';\n/**\n * Thrown when the certificate source cannot be located or accessed.\n */\nclass CertificateSourceUnavailableError extends Error {\n constructor(message) {\n super(message);\n this.name = 'CertificateSourceUnavailableError';\n }\n}\nexports.CertificateSourceUnavailableError = CertificateSourceUnavailableError;\n/**\n * Thrown for invalid configuration that is not related to file availability.\n */\nclass InvalidConfigurationError extends Error {\n constructor(message) {\n super(message);\n this.name = 'InvalidConfigurationError';\n }\n}\nexports.InvalidConfigurationError = InvalidConfigurationError;\n/**\n * A subject token supplier that uses a client certificate for authentication.\n * It provides the certificate chain as the subject token for identity federation.\n */\nclass CertificateSubjectTokenSupplier {\n certificateConfigPath;\n trustChainPath;\n cert;\n key;\n /**\n * Initializes a new instance of the CertificateSubjectTokenSupplier.\n * @param opts The configuration options for the supplier.\n */\n constructor(opts) {\n if (!opts.useDefaultCertificateConfig && !opts.certificateConfigLocation) {\n throw new InvalidConfigurationError('Either `useDefaultCertificateConfig` must be true or a `certificateConfigLocation` must be provided.');\n }\n if (opts.useDefaultCertificateConfig && opts.certificateConfigLocation) {\n throw new InvalidConfigurationError('Both `useDefaultCertificateConfig` and `certificateConfigLocation` cannot be provided.');\n }\n this.trustChainPath = opts.trustChainPath;\n this.certificateConfigPath = opts.certificateConfigLocation ?? '';\n }\n /**\n * Creates an HTTPS agent configured with the client certificate and private key for mTLS.\n * @returns An mTLS-configured https.Agent.\n */\n async createMtlsHttpsAgent() {\n if (!this.key || !this.cert) {\n throw new InvalidConfigurationError('Cannot create mTLS Agent with missing certificate or key');\n }\n return new https.Agent({ key: this.key, cert: this.cert });\n }\n /**\n * Constructs the subject token, which is the base64-encoded certificate chain.\n * @returns A promise that resolves with the subject token.\n */\n async getSubjectToken() {\n // The \"subject token\" in this context is the processed certificate chain.\n this.certificateConfigPath = await this.#resolveCertificateConfigFilePath();\n const { certPath, keyPath } = await this.#getCertAndKeyPaths();\n ({ cert: this.cert, key: this.key } = await this.#getKeyAndCert(certPath, keyPath));\n return await this.#processChainFromPaths(this.cert);\n }\n /**\n * Resolves the absolute path to the certificate configuration file\n * by checking the \"certificate_config_location\" provided in the ADC file,\n * or the \"GOOGLE_API_CERTIFICATE_CONFIG\" environment variable\n * or in the default gcloud path.\n * @param overridePath An optional path to check first.\n * @returns The resolved file path.\n */\n async #resolveCertificateConfigFilePath() {\n // 1. Check for the override path from constructor options.\n const overridePath = this.certificateConfigPath;\n if (overridePath) {\n if (await (0, util_1.isValidFile)(overridePath)) {\n return overridePath;\n }\n throw new CertificateSourceUnavailableError(`Provided certificate config path is invalid: ${overridePath}`);\n }\n // 2. Check the standard environment variable.\n const envPath = process.env[exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE];\n if (envPath) {\n if (await (0, util_1.isValidFile)(envPath)) {\n return envPath;\n }\n throw new CertificateSourceUnavailableError(`Path from environment variable \"${exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE}\" is invalid: ${envPath}`);\n }\n // 3. Check the well-known gcloud config location.\n const wellKnownPath = (0, util_1.getWellKnownCertificateConfigFileLocation)();\n if (await (0, util_1.isValidFile)(wellKnownPath)) {\n return wellKnownPath;\n }\n // 4. If none are found, throw an error.\n throw new CertificateSourceUnavailableError('Could not find certificate configuration file. Searched override path, ' +\n `the \"${exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE}\" env var, and the gcloud path (${wellKnownPath}).`);\n }\n /**\n * Reads and parses the certificate config JSON file to extract the certificate and key paths.\n * @returns An object containing the certificate and key paths.\n */\n async #getCertAndKeyPaths() {\n const configPath = this.certificateConfigPath;\n let fileContents;\n try {\n fileContents = await fs.promises.readFile(configPath, 'utf8');\n }\n catch (err) {\n throw new CertificateSourceUnavailableError(`Failed to read certificate config file at: ${configPath}`);\n }\n try {\n const config = JSON.parse(fileContents);\n const certPath = config?.cert_configs?.workload?.cert_path;\n const keyPath = config?.cert_configs?.workload?.key_path;\n if (!certPath || !keyPath) {\n throw new InvalidConfigurationError(`Certificate config file (${configPath}) is missing required \"cert_path\" or \"key_path\" in the workload config.`);\n }\n return { certPath, keyPath };\n }\n catch (e) {\n if (e instanceof InvalidConfigurationError)\n throw e;\n throw new InvalidConfigurationError(`Failed to parse certificate config from ${configPath}: ${e.message}`);\n }\n }\n /**\n * Reads and parses the cert and key files get their content and check valid format.\n * @returns An object containing the cert content and key content in buffer format.\n */\n async #getKeyAndCert(certPath, keyPath) {\n let cert, key;\n try {\n cert = await fs.promises.readFile(certPath);\n new crypto_1.X509Certificate(cert);\n }\n catch (err) {\n const message = err instanceof Error ? err.message : String(err);\n throw new CertificateSourceUnavailableError(`Failed to read certificate file at ${certPath}: ${message}`);\n }\n try {\n key = await fs.promises.readFile(keyPath);\n (0, crypto_1.createPrivateKey)(key);\n }\n catch (err) {\n const message = err instanceof Error ? err.message : String(err);\n throw new CertificateSourceUnavailableError(`Failed to read private key file at ${keyPath}: ${message}`);\n }\n return { cert, key };\n }\n /**\n * Reads the leaf certificate and trust chain, combines them,\n * and returns a JSON array of base64-encoded certificates.\n * @returns A stringified JSON array of the certificate chain.\n */\n async #processChainFromPaths(leafCertBuffer) {\n const leafCert = new crypto_1.X509Certificate(leafCertBuffer);\n // If no trust chain is provided, just use the successfully parsed leaf certificate.\n if (!this.trustChainPath) {\n return JSON.stringify([leafCert.raw.toString('base64')]);\n }\n // Handle the trust chain logic.\n try {\n const chainPems = await fs.promises.readFile(this.trustChainPath, 'utf8');\n const pemBlocks = chainPems.match(/-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----/g) ?? [];\n const chainCerts = pemBlocks.map((pem, index) => {\n try {\n return new crypto_1.X509Certificate(pem);\n }\n catch (err) {\n const message = err instanceof Error ? err.message : String(err);\n // Throw a more precise error if a single certificate in the chain is invalid.\n throw new InvalidConfigurationError(`Failed to parse certificate at index ${index} in trust chain file ${this.trustChainPath}: ${message}`);\n }\n });\n const leafIndex = chainCerts.findIndex(chainCert => leafCert.raw.equals(chainCert.raw));\n let finalChain;\n if (leafIndex === -1) {\n // Leaf not found, so prepend it to the chain.\n finalChain = [leafCert, ...chainCerts];\n }\n else if (leafIndex === 0) {\n // Leaf is already the first element, so the chain is correctly ordered.\n finalChain = chainCerts;\n }\n else {\n // Leaf is in the chain but not at the top, which is invalid.\n throw new InvalidConfigurationError(`Leaf certificate exists in the trust chain but is not the first entry (found at index ${leafIndex}).`);\n }\n return JSON.stringify(finalChain.map(cert => cert.raw.toString('base64')));\n }\n catch (err) {\n // Re-throw our specific configuration errors.\n if (err instanceof InvalidConfigurationError)\n throw err;\n const message = err instanceof Error ? err.message : String(err);\n throw new CertificateSourceUnavailableError(`Failed to process certificate chain from ${this.trustChainPath}: ${message}`);\n }\n }\n}\nexports.CertificateSubjectTokenSupplier = CertificateSubjectTokenSupplier;\n//# sourceMappingURL=certificatesubjecttokensupplier.js.map", "\"use strict\";\n// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.IdentityPoolClient = void 0;\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\nconst util_1 = require(\"../util\");\nconst filesubjecttokensupplier_1 = require(\"./filesubjecttokensupplier\");\nconst urlsubjecttokensupplier_1 = require(\"./urlsubjecttokensupplier\");\nconst certificatesubjecttokensupplier_1 = require(\"./certificatesubjecttokensupplier\");\nconst stscredentials_1 = require(\"./stscredentials\");\nconst gaxios_1 = require(\"gaxios\");\n/**\n * Defines the Url-sourced and file-sourced external account clients mainly\n * used for K8s and Azure workloads.\n */\nclass IdentityPoolClient extends baseexternalclient_1.BaseExternalAccountClient {\n subjectTokenSupplier;\n /**\n * Instantiate an IdentityPoolClient instance using the provided JSON\n * object loaded from an external account credentials file.\n * An error is thrown if the credential is not a valid file-sourced or\n * url-sourced credential or a workforce pool user project is provided\n * with a non workforce audience.\n * @param options The external account options object typically loaded\n * from the external account JSON credential file. The camelCased options\n * are aliases for the snake_cased options.\n */\n constructor(options) {\n super(options);\n const opts = (0, util_1.originalOrCamelOptions)(options);\n const credentialSource = opts.get('credential_source');\n const subjectTokenSupplier = opts.get('subject_token_supplier');\n // Validate credential sourcing configuration.\n if (!credentialSource && !subjectTokenSupplier) {\n throw new Error('A credential source or subject token supplier must be specified.');\n }\n if (credentialSource && subjectTokenSupplier) {\n throw new Error('Only one of credential source or subject token supplier can be specified.');\n }\n if (subjectTokenSupplier) {\n this.subjectTokenSupplier = subjectTokenSupplier;\n this.credentialSourceType = 'programmatic';\n }\n else {\n const credentialSourceOpts = (0, util_1.originalOrCamelOptions)(credentialSource);\n const formatOpts = (0, util_1.originalOrCamelOptions)(credentialSourceOpts.get('format'));\n // Text is the default format type.\n const formatType = formatOpts.get('type') || 'text';\n const formatSubjectTokenFieldName = formatOpts.get('subject_token_field_name');\n if (formatType !== 'json' && formatType !== 'text') {\n throw new Error(`Invalid credential_source format \"${formatType}\"`);\n }\n if (formatType === 'json' && !formatSubjectTokenFieldName) {\n throw new Error('Missing subject_token_field_name for JSON credential_source format');\n }\n const file = credentialSourceOpts.get('file');\n const url = credentialSourceOpts.get('url');\n const certificate = credentialSourceOpts.get('certificate');\n const headers = credentialSourceOpts.get('headers');\n if ((file && url) || (url && certificate) || (file && certificate)) {\n throw new Error('No valid Identity Pool \"credential_source\" provided, must be either file, url, or certificate.');\n }\n else if (file) {\n this.credentialSourceType = 'file';\n this.subjectTokenSupplier = new filesubjecttokensupplier_1.FileSubjectTokenSupplier({\n filePath: file,\n formatType: formatType,\n subjectTokenFieldName: formatSubjectTokenFieldName,\n });\n }\n else if (url) {\n this.credentialSourceType = 'url';\n this.subjectTokenSupplier = new urlsubjecttokensupplier_1.UrlSubjectTokenSupplier({\n url: url,\n formatType: formatType,\n subjectTokenFieldName: formatSubjectTokenFieldName,\n headers: headers,\n additionalGaxiosOptions: IdentityPoolClient.RETRY_CONFIG,\n });\n }\n else if (certificate) {\n this.credentialSourceType = 'certificate';\n const certificateSubjecttokensupplier = new certificatesubjecttokensupplier_1.CertificateSubjectTokenSupplier({\n useDefaultCertificateConfig: certificate.use_default_certificate_config,\n certificateConfigLocation: certificate.certificate_config_location,\n trustChainPath: certificate.trust_chain_path,\n });\n this.subjectTokenSupplier = certificateSubjecttokensupplier;\n }\n else {\n throw new Error('No valid Identity Pool \"credential_source\" provided, must be either file, url, or certificate.');\n }\n }\n }\n /**\n * Triggered when a external subject token is needed to be exchanged for a GCP\n * access token via GCP STS endpoint. Gets a subject token by calling\n * the configured {@link SubjectTokenSupplier}\n * @return A promise that resolves with the external subject token.\n */\n async retrieveSubjectToken() {\n const subjectToken = await this.subjectTokenSupplier.getSubjectToken(this.supplierContext);\n if (this.subjectTokenSupplier instanceof certificatesubjecttokensupplier_1.CertificateSubjectTokenSupplier) {\n const mtlsAgent = await this.subjectTokenSupplier.createMtlsHttpsAgent();\n this.stsCredential = new stscredentials_1.StsCredentials({\n tokenExchangeEndpoint: this.getTokenUrl(),\n clientAuthentication: this.clientAuth,\n transporter: new gaxios_1.Gaxios({ agent: mtlsAgent }),\n });\n this.transporter = new gaxios_1.Gaxios({\n ...(this.transporter.defaults || {}),\n agent: mtlsAgent,\n });\n }\n return subjectToken;\n }\n}\nexports.IdentityPoolClient = IdentityPoolClient;\n//# sourceMappingURL=identitypoolclient.js.map", "\"use strict\";\n// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AwsRequestSigner = void 0;\nconst gaxios_1 = require(\"gaxios\");\nconst crypto_1 = require(\"../crypto/crypto\");\n/** AWS Signature Version 4 signing algorithm identifier. */\nconst AWS_ALGORITHM = 'AWS4-HMAC-SHA256';\n/**\n * The termination string for the AWS credential scope value as defined in\n * https://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html\n */\nconst AWS_REQUEST_TYPE = 'aws4_request';\n/**\n * Implements an AWS API request signer based on the AWS Signature Version 4\n * signing process.\n * https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html\n */\nclass AwsRequestSigner {\n getCredentials;\n region;\n crypto;\n /**\n * Instantiates an AWS API request signer used to send authenticated signed\n * requests to AWS APIs based on the AWS Signature Version 4 signing process.\n * This also provides a mechanism to generate the signed request without\n * sending it.\n * @param getCredentials A mechanism to retrieve AWS security credentials\n * when needed.\n * @param region The AWS region to use.\n */\n constructor(getCredentials, region) {\n this.getCredentials = getCredentials;\n this.region = region;\n this.crypto = (0, crypto_1.createCrypto)();\n }\n /**\n * Generates the signed request for the provided HTTP request for calling\n * an AWS API. This follows the steps described at:\n * https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html\n * @param amzOptions The AWS request options that need to be signed.\n * @return A promise that resolves with the GaxiosOptions containing the\n * signed HTTP request parameters.\n */\n async getRequestOptions(amzOptions) {\n if (!amzOptions.url) {\n throw new RangeError('\"url\" is required in \"amzOptions\"');\n }\n // Stringify JSON requests. This will be set in the request body of the\n // generated signed request.\n const requestPayloadData = typeof amzOptions.data === 'object'\n ? JSON.stringify(amzOptions.data)\n : amzOptions.data;\n const url = amzOptions.url;\n const method = amzOptions.method || 'GET';\n const requestPayload = amzOptions.body || requestPayloadData;\n const additionalAmzHeaders = amzOptions.headers;\n const awsSecurityCredentials = await this.getCredentials();\n const uri = new URL(url);\n if (typeof requestPayload !== 'string' && requestPayload !== undefined) {\n throw new TypeError(`'requestPayload' is expected to be a string if provided. Got: ${requestPayload}`);\n }\n const headerMap = await generateAuthenticationHeaderMap({\n crypto: this.crypto,\n host: uri.host,\n canonicalUri: uri.pathname,\n canonicalQuerystring: uri.search.slice(1),\n method,\n region: this.region,\n securityCredentials: awsSecurityCredentials,\n requestPayload,\n additionalAmzHeaders,\n });\n // Append additional optional headers, eg. X-Amz-Target, Content-Type, etc.\n const headers = gaxios_1.Gaxios.mergeHeaders(\n // Add x-amz-date if available.\n headerMap.amzDate ? { 'x-amz-date': headerMap.amzDate } : {}, {\n authorization: headerMap.authorizationHeader,\n host: uri.host,\n }, additionalAmzHeaders || {});\n if (awsSecurityCredentials.token) {\n gaxios_1.Gaxios.mergeHeaders(headers, {\n 'x-amz-security-token': awsSecurityCredentials.token,\n });\n }\n const awsSignedReq = {\n url,\n method: method,\n headers,\n };\n if (requestPayload !== undefined) {\n awsSignedReq.body = requestPayload;\n }\n return awsSignedReq;\n }\n}\nexports.AwsRequestSigner = AwsRequestSigner;\n/**\n * Creates the HMAC-SHA256 hash of the provided message using the\n * provided key.\n *\n * @param crypto The crypto instance used to facilitate cryptographic\n * operations.\n * @param key The HMAC-SHA256 key to use.\n * @param msg The message to hash.\n * @return The computed hash bytes.\n */\nasync function sign(crypto, key, msg) {\n return await crypto.signWithHmacSha256(key, msg);\n}\n/**\n * Calculates the signing key used to calculate the signature for\n * AWS Signature Version 4 based on:\n * https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html\n *\n * @param crypto The crypto instance used to facilitate cryptographic\n * operations.\n * @param key The AWS secret access key.\n * @param dateStamp The '%Y%m%d' date format.\n * @param region The AWS region.\n * @param serviceName The AWS service name, eg. sts.\n * @return The signing key bytes.\n */\nasync function getSigningKey(crypto, key, dateStamp, region, serviceName) {\n const kDate = await sign(crypto, `AWS4${key}`, dateStamp);\n const kRegion = await sign(crypto, kDate, region);\n const kService = await sign(crypto, kRegion, serviceName);\n const kSigning = await sign(crypto, kService, 'aws4_request');\n return kSigning;\n}\n/**\n * Generates the authentication header map needed for generating the AWS\n * Signature Version 4 signed request.\n *\n * @param option The options needed to compute the authentication header map.\n * @return The AWS authentication header map which constitutes of the following\n * components: amz-date, authorization header and canonical query string.\n */\nasync function generateAuthenticationHeaderMap(options) {\n const additionalAmzHeaders = gaxios_1.Gaxios.mergeHeaders(options.additionalAmzHeaders);\n const requestPayload = options.requestPayload || '';\n // iam.amazonaws.com host => iam service.\n // sts.us-east-2.amazonaws.com => sts service.\n const serviceName = options.host.split('.')[0];\n const now = new Date();\n // Format: '%Y%m%dT%H%M%SZ'.\n const amzDate = now\n .toISOString()\n .replace(/[-:]/g, '')\n .replace(/\\.[0-9]+/, '');\n // Format: '%Y%m%d'.\n const dateStamp = now.toISOString().replace(/[-]/g, '').replace(/T.*/, '');\n // Add AWS token if available.\n if (options.securityCredentials.token) {\n additionalAmzHeaders.set('x-amz-security-token', options.securityCredentials.token);\n }\n // Header keys need to be sorted alphabetically.\n const amzHeaders = gaxios_1.Gaxios.mergeHeaders({\n host: options.host,\n }, \n // Previously the date was not fixed with x-amz- and could be provided manually.\n // https://github.com/boto/botocore/blob/879f8440a4e9ace5d3cf145ce8b3d5e5ffb892ef/tests/unit/auth/aws4_testsuite/get-header-value-trim.req\n additionalAmzHeaders.has('date') ? {} : { 'x-amz-date': amzDate }, additionalAmzHeaders);\n let canonicalHeaders = '';\n // TypeScript is missing `Headers#keys` at the time of writing\n const signedHeadersList = [\n ...amzHeaders.keys(),\n ].sort();\n signedHeadersList.forEach(key => {\n canonicalHeaders += `${key}:${amzHeaders.get(key)}\\n`;\n });\n const signedHeaders = signedHeadersList.join(';');\n const payloadHash = await options.crypto.sha256DigestHex(requestPayload);\n // https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html\n const canonicalRequest = `${options.method.toUpperCase()}\\n` +\n `${options.canonicalUri}\\n` +\n `${options.canonicalQuerystring}\\n` +\n `${canonicalHeaders}\\n` +\n `${signedHeaders}\\n` +\n `${payloadHash}`;\n const credentialScope = `${dateStamp}/${options.region}/${serviceName}/${AWS_REQUEST_TYPE}`;\n // https://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html\n const stringToSign = `${AWS_ALGORITHM}\\n` +\n `${amzDate}\\n` +\n `${credentialScope}\\n` +\n (await options.crypto.sha256DigestHex(canonicalRequest));\n // https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html\n const signingKey = await getSigningKey(options.crypto, options.securityCredentials.secretAccessKey, dateStamp, options.region, serviceName);\n const signature = await sign(options.crypto, signingKey, stringToSign);\n // https://docs.aws.amazon.com/general/latest/gr/sigv4-add-signature-to-request.html\n const authorizationHeader = `${AWS_ALGORITHM} Credential=${options.securityCredentials.accessKeyId}/` +\n `${credentialScope}, SignedHeaders=${signedHeaders}, ` +\n `Signature=${(0, crypto_1.fromArrayBufferToHex)(signature)}`;\n return {\n // Do not return x-amz-date if date is available.\n amzDate: additionalAmzHeaders.has('date') ? undefined : amzDate,\n authorizationHeader,\n canonicalQuerystring: options.canonicalQuerystring,\n };\n}\n//# sourceMappingURL=awsrequestsigner.js.map", "\"use strict\";\n// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DefaultAwsSecurityCredentialsSupplier = void 0;\nconst authclient_1 = require(\"./authclient\");\n/**\n * Internal AWS security credentials supplier implementation used by {@link AwsClient}\n * when a credential source is provided instead of a user defined supplier.\n * The logic is summarized as:\n * 1. If imdsv2_session_token_url is provided in the credential source, then\n * fetch the aws session token and include it in the headers of the\n * metadata requests. This is a requirement for IDMSv2 but optional\n * for IDMSv1.\n * 2. Retrieve AWS region from availability-zone.\n * 3a. Check AWS credentials in environment variables. If not found, get\n * from security-credentials endpoint.\n * 3b. Get AWS credentials from security-credentials endpoint. In order\n * to retrieve this, the AWS role needs to be determined by calling\n * security-credentials endpoint without any argument. Then the\n * credentials can be retrieved via: security-credentials/role_name\n * 4. Generate the signed request to AWS STS GetCallerIdentity action.\n * 5. Inject x-goog-cloud-target-resource into header and serialize the\n * signed request. This will be the subject-token to pass to GCP STS.\n */\nclass DefaultAwsSecurityCredentialsSupplier {\n regionUrl;\n securityCredentialsUrl;\n imdsV2SessionTokenUrl;\n additionalGaxiosOptions;\n /**\n * Instantiates a new DefaultAwsSecurityCredentialsSupplier using information\n * from the credential_source stored in the ADC file.\n * @param opts The default aws security credentials supplier options object to\n * build the supplier with.\n */\n constructor(opts) {\n this.regionUrl = opts.regionUrl;\n this.securityCredentialsUrl = opts.securityCredentialsUrl;\n this.imdsV2SessionTokenUrl = opts.imdsV2SessionTokenUrl;\n this.additionalGaxiosOptions = opts.additionalGaxiosOptions;\n }\n /**\n * Returns the active AWS region. This first checks to see if the region\n * is available as an environment variable. If it is not, then the supplier\n * will call the region URL.\n * @param context {@link ExternalAccountSupplierContext} from the calling\n * {@link AwsClient}, contains the requested audience and subject token type\n * for the external account identity.\n * @return A promise that resolves with the AWS region string.\n */\n async getAwsRegion(context) {\n // Priority order for region determination:\n // AWS_REGION > AWS_DEFAULT_REGION > metadata server.\n if (this.#regionFromEnv) {\n return this.#regionFromEnv;\n }\n const metadataHeaders = new Headers();\n if (!this.#regionFromEnv && this.imdsV2SessionTokenUrl) {\n metadataHeaders.set('x-aws-ec2-metadata-token', await this.#getImdsV2SessionToken(context.transporter));\n }\n if (!this.regionUrl) {\n throw new RangeError('Unable to determine AWS region due to missing ' +\n '\"options.credential_source.region_url\"');\n }\n const opts = {\n ...this.additionalGaxiosOptions,\n url: this.regionUrl,\n method: 'GET',\n responseType: 'text',\n headers: metadataHeaders,\n };\n authclient_1.AuthClient.setMethodName(opts, 'getAwsRegion');\n const response = await context.transporter.request(opts);\n // Remove last character. For example, if us-east-2b is returned,\n // the region would be us-east-2.\n return response.data.substr(0, response.data.length - 1);\n }\n /**\n * Returns AWS security credentials. This first checks to see if the credentials\n * is available as environment variables. If it is not, then the supplier\n * will call the security credentials URL.\n * @param context {@link ExternalAccountSupplierContext} from the calling\n * {@link AwsClient}, contains the requested audience and subject token type\n * for the external account identity.\n * @return A promise that resolves with the AWS security credentials.\n */\n async getAwsSecurityCredentials(context) {\n // Check environment variables for permanent credentials first.\n // https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html\n if (this.#securityCredentialsFromEnv) {\n return this.#securityCredentialsFromEnv;\n }\n const metadataHeaders = new Headers();\n if (this.imdsV2SessionTokenUrl) {\n metadataHeaders.set('x-aws-ec2-metadata-token', await this.#getImdsV2SessionToken(context.transporter));\n }\n // Since the role on a VM can change, we don't need to cache it.\n const roleName = await this.#getAwsRoleName(metadataHeaders, context.transporter);\n // Temporary credentials typically last for several hours.\n // Expiration is returned in response.\n // Consider future optimization of this logic to cache AWS tokens\n // until their natural expiration.\n const awsCreds = await this.#retrieveAwsSecurityCredentials(roleName, metadataHeaders, context.transporter);\n return {\n accessKeyId: awsCreds.AccessKeyId,\n secretAccessKey: awsCreds.SecretAccessKey,\n token: awsCreds.Token,\n };\n }\n /**\n * @param transporter The transporter to use for requests.\n * @return A promise that resolves with the IMDSv2 Session Token.\n */\n async #getImdsV2SessionToken(transporter) {\n const opts = {\n ...this.additionalGaxiosOptions,\n url: this.imdsV2SessionTokenUrl,\n method: 'PUT',\n responseType: 'text',\n headers: { 'x-aws-ec2-metadata-token-ttl-seconds': '300' },\n };\n authclient_1.AuthClient.setMethodName(opts, '#getImdsV2SessionToken');\n const response = await transporter.request(opts);\n return response.data;\n }\n /**\n * @param headers The headers to be used in the metadata request.\n * @param transporter The transporter to use for requests.\n * @return A promise that resolves with the assigned role to the current\n * AWS VM. This is needed for calling the security-credentials endpoint.\n */\n async #getAwsRoleName(headers, transporter) {\n if (!this.securityCredentialsUrl) {\n throw new Error('Unable to determine AWS role name due to missing ' +\n '\"options.credential_source.url\"');\n }\n const opts = {\n ...this.additionalGaxiosOptions,\n url: this.securityCredentialsUrl,\n method: 'GET',\n responseType: 'text',\n headers: headers,\n };\n authclient_1.AuthClient.setMethodName(opts, '#getAwsRoleName');\n const response = await transporter.request(opts);\n return response.data;\n }\n /**\n * Retrieves the temporary AWS credentials by calling the security-credentials\n * endpoint as specified in the `credential_source` object.\n * @param roleName The role attached to the current VM.\n * @param headers The headers to be used in the metadata request.\n * @param transporter The transporter to use for requests.\n * @return A promise that resolves with the temporary AWS credentials\n * needed for creating the GetCallerIdentity signed request.\n */\n async #retrieveAwsSecurityCredentials(roleName, headers, transporter) {\n const opts = {\n ...this.additionalGaxiosOptions,\n url: `${this.securityCredentialsUrl}/${roleName}`,\n headers: headers,\n responseType: 'json',\n };\n authclient_1.AuthClient.setMethodName(opts, '#retrieveAwsSecurityCredentials');\n const response = await transporter.request(opts);\n return response.data;\n }\n get #regionFromEnv() {\n // The AWS region can be provided through AWS_REGION or AWS_DEFAULT_REGION.\n // Only one is required.\n return (process.env['AWS_REGION'] || process.env['AWS_DEFAULT_REGION'] || null);\n }\n get #securityCredentialsFromEnv() {\n // Both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required.\n if (process.env['AWS_ACCESS_KEY_ID'] &&\n process.env['AWS_SECRET_ACCESS_KEY']) {\n return {\n accessKeyId: process.env['AWS_ACCESS_KEY_ID'],\n secretAccessKey: process.env['AWS_SECRET_ACCESS_KEY'],\n token: process.env['AWS_SESSION_TOKEN'],\n };\n }\n return null;\n }\n}\nexports.DefaultAwsSecurityCredentialsSupplier = DefaultAwsSecurityCredentialsSupplier;\n//# sourceMappingURL=defaultawssecuritycredentialssupplier.js.map", "\"use strict\";\n// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AwsClient = void 0;\nconst awsrequestsigner_1 = require(\"./awsrequestsigner\");\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\nconst defaultawssecuritycredentialssupplier_1 = require(\"./defaultawssecuritycredentialssupplier\");\nconst util_1 = require(\"../util\");\nconst gaxios_1 = require(\"gaxios\");\n/**\n * AWS external account client. This is used for AWS workloads, where\n * AWS STS GetCallerIdentity serialized signed requests are exchanged for\n * GCP access token.\n */\nclass AwsClient extends baseexternalclient_1.BaseExternalAccountClient {\n environmentId;\n awsSecurityCredentialsSupplier;\n regionalCredVerificationUrl;\n awsRequestSigner;\n region;\n static #DEFAULT_AWS_REGIONAL_CREDENTIAL_VERIFICATION_URL = 'https://sts.{region}.amazonaws.com?Action=GetCallerIdentity&Version=2011-06-15';\n /**\n * @deprecated AWS client no validates the EC2 metadata address.\n **/\n static AWS_EC2_METADATA_IPV4_ADDRESS = '169.254.169.254';\n /**\n * @deprecated AWS client no validates the EC2 metadata address.\n **/\n static AWS_EC2_METADATA_IPV6_ADDRESS = 'fd00:ec2::254';\n /**\n * Instantiates an AwsClient instance using the provided JSON\n * object loaded from an external account credentials file.\n * An error is thrown if the credential is not a valid AWS credential.\n * @param options The external account options object typically loaded\n * from the external account JSON credential file.\n */\n constructor(options) {\n super(options);\n const opts = (0, util_1.originalOrCamelOptions)(options);\n const credentialSource = opts.get('credential_source');\n const awsSecurityCredentialsSupplier = opts.get('aws_security_credentials_supplier');\n // Validate credential sourcing configuration.\n if (!credentialSource && !awsSecurityCredentialsSupplier) {\n throw new Error('A credential source or AWS security credentials supplier must be specified.');\n }\n if (credentialSource && awsSecurityCredentialsSupplier) {\n throw new Error('Only one of credential source or AWS security credentials supplier can be specified.');\n }\n if (awsSecurityCredentialsSupplier) {\n this.awsSecurityCredentialsSupplier = awsSecurityCredentialsSupplier;\n this.regionalCredVerificationUrl =\n AwsClient.#DEFAULT_AWS_REGIONAL_CREDENTIAL_VERIFICATION_URL;\n this.credentialSourceType = 'programmatic';\n }\n else {\n const credentialSourceOpts = (0, util_1.originalOrCamelOptions)(credentialSource);\n this.environmentId = credentialSourceOpts.get('environment_id');\n // This is only required if the AWS region is not available in the\n // AWS_REGION or AWS_DEFAULT_REGION environment variables.\n const regionUrl = credentialSourceOpts.get('region_url');\n // This is only required if AWS security credentials are not available in\n // environment variables.\n const securityCredentialsUrl = credentialSourceOpts.get('url');\n const imdsV2SessionTokenUrl = credentialSourceOpts.get('imdsv2_session_token_url');\n this.awsSecurityCredentialsSupplier =\n new defaultawssecuritycredentialssupplier_1.DefaultAwsSecurityCredentialsSupplier({\n regionUrl: regionUrl,\n securityCredentialsUrl: securityCredentialsUrl,\n imdsV2SessionTokenUrl: imdsV2SessionTokenUrl,\n });\n this.regionalCredVerificationUrl = credentialSourceOpts.get('regional_cred_verification_url');\n this.credentialSourceType = 'aws';\n // Data validators.\n this.validateEnvironmentId();\n }\n this.awsRequestSigner = null;\n this.region = '';\n }\n validateEnvironmentId() {\n const match = this.environmentId?.match(/^(aws)(\\d+)$/);\n if (!match || !this.regionalCredVerificationUrl) {\n throw new Error('No valid AWS \"credential_source\" provided');\n }\n else if (parseInt(match[2], 10) !== 1) {\n throw new Error(`aws version \"${match[2]}\" is not supported in the current build.`);\n }\n }\n /**\n * Triggered when an external subject token is needed to be exchanged for a\n * GCP access token via GCP STS endpoint. This will call the\n * {@link AwsSecurityCredentialsSupplier} to retrieve an AWS region and AWS\n * Security Credentials, then use them to create a signed AWS STS request that\n * can be exchanged for a GCP access token.\n * @return A promise that resolves with the external subject token.\n */\n async retrieveSubjectToken() {\n // Initialize AWS request signer if not already initialized.\n if (!this.awsRequestSigner) {\n this.region = await this.awsSecurityCredentialsSupplier.getAwsRegion(this.supplierContext);\n this.awsRequestSigner = new awsrequestsigner_1.AwsRequestSigner(async () => {\n return this.awsSecurityCredentialsSupplier.getAwsSecurityCredentials(this.supplierContext);\n }, this.region);\n }\n // Generate signed request to AWS STS GetCallerIdentity API.\n // Use the required regional endpoint. Otherwise, the request will fail.\n const options = await this.awsRequestSigner.getRequestOptions({\n ...AwsClient.RETRY_CONFIG,\n url: this.regionalCredVerificationUrl.replace('{region}', this.region),\n method: 'POST',\n });\n // The GCP STS endpoint expects the headers to be formatted as:\n // [\n // {key: 'x-amz-date', value: '...'},\n // {key: 'authorization', value: '...'},\n // ...\n // ]\n // And then serialized as:\n // encodeURIComponent(JSON.stringify({\n // url: '...',\n // method: 'POST',\n // headers: [{key: 'x-amz-date', value: '...'}, ...]\n // }))\n const reformattedHeader = [];\n const extendedHeaders = gaxios_1.Gaxios.mergeHeaders({\n // The full, canonical resource name of the workload identity pool\n // provider, with or without the HTTPS prefix.\n // Including this header as part of the signature is recommended to\n // ensure data integrity.\n 'x-goog-cloud-target-resource': this.audience,\n }, options.headers);\n // Reformat header to GCP STS expected format.\n extendedHeaders.forEach((value, key) => reformattedHeader.push({ key, value }));\n // Serialize the reformatted signed request.\n return encodeURIComponent(JSON.stringify({\n url: options.url,\n method: options.method,\n headers: reformattedHeader,\n }));\n }\n}\nexports.AwsClient = AwsClient;\n//# sourceMappingURL=awsclient.js.map", "\"use strict\";\n// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InvalidSubjectTokenError = exports.InvalidMessageFieldError = exports.InvalidCodeFieldError = exports.InvalidTokenTypeFieldError = exports.InvalidExpirationTimeFieldError = exports.InvalidSuccessFieldError = exports.InvalidVersionFieldError = exports.ExecutableResponseError = exports.ExecutableResponse = void 0;\nconst SAML_SUBJECT_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:saml2';\nconst OIDC_SUBJECT_TOKEN_TYPE1 = 'urn:ietf:params:oauth:token-type:id_token';\nconst OIDC_SUBJECT_TOKEN_TYPE2 = 'urn:ietf:params:oauth:token-type:jwt';\n/**\n * Defines the response of a 3rd party executable run by the pluggable auth client.\n */\nclass ExecutableResponse {\n /**\n * The version of the Executable response. Only version 1 is currently supported.\n */\n version;\n /**\n * Whether the executable ran successfully.\n */\n success;\n /**\n * The epoch time for expiration of the token in seconds.\n */\n expirationTime;\n /**\n * The type of subject token in the response, currently supported values are:\n * urn:ietf:params:oauth:token-type:saml2\n * urn:ietf:params:oauth:token-type:id_token\n * urn:ietf:params:oauth:token-type:jwt\n */\n tokenType;\n /**\n * The error code from the executable.\n */\n errorCode;\n /**\n * The error message from the executable.\n */\n errorMessage;\n /**\n * The subject token from the executable, format depends on tokenType.\n */\n subjectToken;\n /**\n * Instantiates an ExecutableResponse instance using the provided JSON object\n * from the output of the executable.\n * @param responseJson Response from a 3rd party executable, loaded from a\n * run of the executable or a cached output file.\n */\n constructor(responseJson) {\n // Check that the required fields exist in the json response.\n if (!responseJson.version) {\n throw new InvalidVersionFieldError(\"Executable response must contain a 'version' field.\");\n }\n if (responseJson.success === undefined) {\n throw new InvalidSuccessFieldError(\"Executable response must contain a 'success' field.\");\n }\n this.version = responseJson.version;\n this.success = responseJson.success;\n // Validate required fields for a successful response.\n if (this.success) {\n this.expirationTime = responseJson.expiration_time;\n this.tokenType = responseJson.token_type;\n // Validate token type field.\n if (this.tokenType !== SAML_SUBJECT_TOKEN_TYPE &&\n this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE1 &&\n this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE2) {\n throw new InvalidTokenTypeFieldError(\"Executable response must contain a 'token_type' field when successful \" +\n `and it must be one of ${OIDC_SUBJECT_TOKEN_TYPE1}, ${OIDC_SUBJECT_TOKEN_TYPE2}, or ${SAML_SUBJECT_TOKEN_TYPE}.`);\n }\n // Validate subject token.\n if (this.tokenType === SAML_SUBJECT_TOKEN_TYPE) {\n if (!responseJson.saml_response) {\n throw new InvalidSubjectTokenError(`Executable response must contain a 'saml_response' field when token_type=${SAML_SUBJECT_TOKEN_TYPE}.`);\n }\n this.subjectToken = responseJson.saml_response;\n }\n else {\n if (!responseJson.id_token) {\n throw new InvalidSubjectTokenError(\"Executable response must contain a 'id_token' field when \" +\n `token_type=${OIDC_SUBJECT_TOKEN_TYPE1} or ${OIDC_SUBJECT_TOKEN_TYPE2}.`);\n }\n this.subjectToken = responseJson.id_token;\n }\n }\n else {\n // Both code and message must be provided for unsuccessful responses.\n if (!responseJson.code) {\n throw new InvalidCodeFieldError(\"Executable response must contain a 'code' field when unsuccessful.\");\n }\n if (!responseJson.message) {\n throw new InvalidMessageFieldError(\"Executable response must contain a 'message' field when unsuccessful.\");\n }\n this.errorCode = responseJson.code;\n this.errorMessage = responseJson.message;\n }\n }\n /**\n * @return A boolean representing if the response has a valid token. Returns\n * true when the response was successful and the token is not expired.\n */\n isValid() {\n return !this.isExpired() && this.success;\n }\n /**\n * @return A boolean representing if the response is expired. Returns true if the\n * provided timeout has passed.\n */\n isExpired() {\n return (this.expirationTime !== undefined &&\n this.expirationTime < Math.round(Date.now() / 1000));\n }\n}\nexports.ExecutableResponse = ExecutableResponse;\n/**\n * An error thrown by the ExecutableResponse class.\n */\nclass ExecutableResponseError extends Error {\n constructor(message) {\n super(message);\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\nexports.ExecutableResponseError = ExecutableResponseError;\n/**\n * An error thrown when the 'version' field in an executable response is missing or invalid.\n */\nclass InvalidVersionFieldError extends ExecutableResponseError {\n}\nexports.InvalidVersionFieldError = InvalidVersionFieldError;\n/**\n * An error thrown when the 'success' field in an executable response is missing or invalid.\n */\nclass InvalidSuccessFieldError extends ExecutableResponseError {\n}\nexports.InvalidSuccessFieldError = InvalidSuccessFieldError;\n/**\n * An error thrown when the 'expiration_time' field in an executable response is missing or invalid.\n */\nclass InvalidExpirationTimeFieldError extends ExecutableResponseError {\n}\nexports.InvalidExpirationTimeFieldError = InvalidExpirationTimeFieldError;\n/**\n * An error thrown when the 'token_type' field in an executable response is missing or invalid.\n */\nclass InvalidTokenTypeFieldError extends ExecutableResponseError {\n}\nexports.InvalidTokenTypeFieldError = InvalidTokenTypeFieldError;\n/**\n * An error thrown when the 'code' field in an executable response is missing or invalid.\n */\nclass InvalidCodeFieldError extends ExecutableResponseError {\n}\nexports.InvalidCodeFieldError = InvalidCodeFieldError;\n/**\n * An error thrown when the 'message' field in an executable response is missing or invalid.\n */\nclass InvalidMessageFieldError extends ExecutableResponseError {\n}\nexports.InvalidMessageFieldError = InvalidMessageFieldError;\n/**\n * An error thrown when the subject token in an executable response is missing or invalid.\n */\nclass InvalidSubjectTokenError extends ExecutableResponseError {\n}\nexports.InvalidSubjectTokenError = InvalidSubjectTokenError;\n//# sourceMappingURL=executable-response.js.map", "\"use strict\";\n// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PluggableAuthHandler = exports.ExecutableError = void 0;\nconst executable_response_1 = require(\"./executable-response\");\nconst childProcess = require(\"child_process\");\nconst fs = require(\"fs\");\n/**\n * Error thrown from the executable run by PluggableAuthClient.\n */\nclass ExecutableError extends Error {\n /**\n * The exit code returned by the executable.\n */\n code;\n constructor(message, code) {\n super(`The executable failed with exit code: ${code} and error message: ${message}.`);\n this.code = code;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\nexports.ExecutableError = ExecutableError;\n/**\n * A handler used to retrieve 3rd party token responses from user defined\n * executables and cached file output for the PluggableAuthClient class.\n */\nclass PluggableAuthHandler {\n commandComponents;\n timeoutMillis;\n outputFile;\n /**\n * Instantiates a PluggableAuthHandler instance using the provided\n * PluggableAuthHandlerOptions object.\n */\n constructor(options) {\n if (!options.command) {\n throw new Error('No command provided.');\n }\n this.commandComponents = PluggableAuthHandler.parseCommand(options.command);\n this.timeoutMillis = options.timeoutMillis;\n if (!this.timeoutMillis) {\n throw new Error('No timeoutMillis provided.');\n }\n this.outputFile = options.outputFile;\n }\n /**\n * Calls user provided executable to get a 3rd party subject token and\n * returns the response.\n * @param envMap a Map of additional Environment Variables required for\n * the executable.\n * @return A promise that resolves with the executable response.\n */\n retrieveResponseFromExecutable(envMap) {\n return new Promise((resolve, reject) => {\n // Spawn process to run executable using added environment variables.\n const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {\n env: { ...process.env, ...Object.fromEntries(envMap) },\n });\n let output = '';\n // Append stdout to output as executable runs.\n child.stdout.on('data', (data) => {\n output += data;\n });\n // Append stderr as executable runs.\n child.stderr.on('data', (err) => {\n output += err;\n });\n // Set up a timeout to end the child process and throw an error.\n const timeout = setTimeout(() => {\n // Kill child process and remove listeners so 'close' event doesn't get\n // read after child process is killed.\n child.removeAllListeners();\n child.kill();\n return reject(new Error('The executable failed to finish within the timeout specified.'));\n }, this.timeoutMillis);\n child.on('close', (code) => {\n // Cancel timeout if executable closes before timeout is reached.\n clearTimeout(timeout);\n if (code === 0) {\n // If the executable completed successfully, try to return the parsed response.\n try {\n const responseJson = JSON.parse(output);\n const response = new executable_response_1.ExecutableResponse(responseJson);\n return resolve(response);\n }\n catch (error) {\n if (error instanceof executable_response_1.ExecutableResponseError) {\n return reject(error);\n }\n return reject(new executable_response_1.ExecutableResponseError(`The executable returned an invalid response: ${output}`));\n }\n }\n else {\n return reject(new ExecutableError(output, code.toString()));\n }\n });\n });\n }\n /**\n * Checks user provided output file for response from previous run of\n * executable and return the response if it exists, is formatted correctly, and is not expired.\n */\n async retrieveCachedResponse() {\n if (!this.outputFile || this.outputFile.length === 0) {\n return undefined;\n }\n let filePath;\n try {\n filePath = await fs.promises.realpath(this.outputFile);\n }\n catch {\n // If file path cannot be resolved, return undefined.\n return undefined;\n }\n if (!(await fs.promises.lstat(filePath)).isFile()) {\n // If path does not lead to file, return undefined.\n return undefined;\n }\n const responseString = await fs.promises.readFile(filePath, {\n encoding: 'utf8',\n });\n if (responseString === '') {\n return undefined;\n }\n try {\n const responseJson = JSON.parse(responseString);\n const response = new executable_response_1.ExecutableResponse(responseJson);\n // Check if response is successful and unexpired.\n if (response.isValid()) {\n return new executable_response_1.ExecutableResponse(responseJson);\n }\n return undefined;\n }\n catch (error) {\n if (error instanceof executable_response_1.ExecutableResponseError) {\n throw error;\n }\n throw new executable_response_1.ExecutableResponseError(`The output file contained an invalid response: ${responseString}`);\n }\n }\n /**\n * Parses given command string into component array, splitting on spaces unless\n * spaces are between quotation marks.\n */\n static parseCommand(command) {\n // Split the command into components by splitting on spaces,\n // unless spaces are contained in quotation marks.\n const components = command.match(/(?:[^\\s\"]+|\"[^\"]*\")+/g);\n if (!components) {\n throw new Error(`Provided command: \"${command}\" could not be parsed.`);\n }\n // Remove quotation marks from the beginning and end of each component if they are present.\n for (let i = 0; i < components.length; i++) {\n if (components[i][0] === '\"' && components[i].slice(-1) === '\"') {\n components[i] = components[i].slice(1, -1);\n }\n }\n return components;\n }\n}\nexports.PluggableAuthHandler = PluggableAuthHandler;\n//# sourceMappingURL=pluggable-auth-handler.js.map", "\"use strict\";\n// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PluggableAuthClient = exports.ExecutableError = void 0;\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\nconst executable_response_1 = require(\"./executable-response\");\nconst pluggable_auth_handler_1 = require(\"./pluggable-auth-handler\");\nvar pluggable_auth_handler_2 = require(\"./pluggable-auth-handler\");\nObject.defineProperty(exports, \"ExecutableError\", { enumerable: true, get: function () { return pluggable_auth_handler_2.ExecutableError; } });\n/**\n * The default executable timeout when none is provided, in milliseconds.\n */\nconst DEFAULT_EXECUTABLE_TIMEOUT_MILLIS = 30 * 1000;\n/**\n * The minimum allowed executable timeout in milliseconds.\n */\nconst MINIMUM_EXECUTABLE_TIMEOUT_MILLIS = 5 * 1000;\n/**\n * The maximum allowed executable timeout in milliseconds.\n */\nconst MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS = 120 * 1000;\n/**\n * The environment variable to check to see if executable can be run.\n * Value must be set to '1' for the executable to run.\n */\nconst GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES = 'GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES';\n/**\n * The maximum currently supported executable version.\n */\nconst MAXIMUM_EXECUTABLE_VERSION = 1;\n/**\n * PluggableAuthClient enables the exchange of workload identity pool external credentials for\n * Google access tokens by retrieving 3rd party tokens through a user supplied executable. These\n * scripts/executables are completely independent of the Google Cloud Auth libraries. These\n * credentials plug into ADC and will call the specified executable to retrieve the 3rd party token\n * to be exchanged for a Google access token.\n *\n * To use these credentials, the GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES environment variable\n * must be set to '1'. This is for security reasons.\n *\n *
Both OIDC and SAML are supported. The executable must adhere to a specific response format\n * defined below.\n *\n *
The executable must print out the 3rd party token to STDOUT in JSON format. When an\n * output_file is specified in the credential configuration, the executable must also handle writing the\n * JSON response to this file.\n *\n *
\n * OIDC response sample:\n * {\n * \"version\": 1,\n * \"success\": true,\n * \"token_type\": \"urn:ietf:params:oauth:token-type:id_token\",\n * \"id_token\": \"HEADER.PAYLOAD.SIGNATURE\",\n * \"expiration_time\": 1620433341\n * }\n *\n * SAML2 response sample:\n * {\n * \"version\": 1,\n * \"success\": true,\n * \"token_type\": \"urn:ietf:params:oauth:token-type:saml2\",\n * \"saml_response\": \"...\",\n * \"expiration_time\": 1620433341\n * }\n *\n * Error response sample:\n * {\n * \"version\": 1,\n * \"success\": false,\n * \"code\": \"401\",\n * \"message\": \"Error message.\"\n * }\n * \n *\n * The \"expiration_time\" field in the JSON response is only required for successful\n * responses when an output file was specified in the credential configuration\n *\n *
The auth libraries will populate certain environment variables that will be accessible by the\n * executable, such as: GOOGLE_EXTERNAL_ACCOUNT_AUDIENCE, GOOGLE_EXTERNAL_ACCOUNT_TOKEN_TYPE,\n * GOOGLE_EXTERNAL_ACCOUNT_INTERACTIVE, GOOGLE_EXTERNAL_ACCOUNT_IMPERSONATED_EMAIL, and\n * GOOGLE_EXTERNAL_ACCOUNT_OUTPUT_FILE.\n *\n *
Please see this repositories README for a complete executable request/response specification.\n */\nclass PluggableAuthClient extends baseexternalclient_1.BaseExternalAccountClient {\n /**\n * The command used to retrieve the third party token.\n */\n command;\n /**\n * The timeout in milliseconds for running executable,\n * set to default if none provided.\n */\n timeoutMillis;\n /**\n * The path to file to check for cached executable response.\n */\n outputFile;\n /**\n * Executable and output file handler.\n */\n handler;\n /**\n * Instantiates a PluggableAuthClient instance using the provided JSON\n * object loaded from an external account credentials file.\n * An error is thrown if the credential is not a valid pluggable auth credential.\n * @param options The external account options object typically loaded from\n * the external account JSON credential file.\n */\n constructor(options) {\n super(options);\n if (!options.credential_source.executable) {\n throw new Error('No valid Pluggable Auth \"credential_source\" provided.');\n }\n this.command = options.credential_source.executable.command;\n if (!this.command) {\n throw new Error('No valid Pluggable Auth \"credential_source\" provided.');\n }\n // Check if the provided timeout exists and if it is valid.\n if (options.credential_source.executable.timeout_millis === undefined) {\n this.timeoutMillis = DEFAULT_EXECUTABLE_TIMEOUT_MILLIS;\n }\n else {\n this.timeoutMillis = options.credential_source.executable.timeout_millis;\n if (this.timeoutMillis < MINIMUM_EXECUTABLE_TIMEOUT_MILLIS ||\n this.timeoutMillis > MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS) {\n throw new Error(`Timeout must be between ${MINIMUM_EXECUTABLE_TIMEOUT_MILLIS} and ` +\n `${MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS} milliseconds.`);\n }\n }\n this.outputFile = options.credential_source.executable.output_file;\n this.handler = new pluggable_auth_handler_1.PluggableAuthHandler({\n command: this.command,\n timeoutMillis: this.timeoutMillis,\n outputFile: this.outputFile,\n });\n this.credentialSourceType = 'executable';\n }\n /**\n * Triggered when an external subject token is needed to be exchanged for a\n * GCP access token via GCP STS endpoint.\n * This uses the `options.credential_source` object to figure out how\n * to retrieve the token using the current environment. In this case,\n * this calls a user provided executable which returns the subject token.\n * The logic is summarized as:\n * 1. Validated that the executable is allowed to run. The\n * GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES environment must be set to\n * 1 for security reasons.\n * 2. If an output file is specified by the user, check the file location\n * for a response. If the file exists and contains a valid response,\n * return the subject token from the file.\n * 3. Call the provided executable and return response.\n * @return A promise that resolves with the external subject token.\n */\n async retrieveSubjectToken() {\n // Check if the executable is allowed to run.\n if (process.env[GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES] !== '1') {\n throw new Error('Pluggable Auth executables need to be explicitly allowed to run by ' +\n 'setting the GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES environment ' +\n 'Variable to 1.');\n }\n let executableResponse = undefined;\n // Try to get cached executable response from output file.\n if (this.outputFile) {\n executableResponse = await this.handler.retrieveCachedResponse();\n }\n // If no response from output file, call the executable.\n if (!executableResponse) {\n // Set up environment map with required values for the executable.\n const envMap = new Map();\n envMap.set('GOOGLE_EXTERNAL_ACCOUNT_AUDIENCE', this.audience);\n envMap.set('GOOGLE_EXTERNAL_ACCOUNT_TOKEN_TYPE', this.subjectTokenType);\n // Always set to 0 because interactive mode is not supported.\n envMap.set('GOOGLE_EXTERNAL_ACCOUNT_INTERACTIVE', '0');\n if (this.outputFile) {\n envMap.set('GOOGLE_EXTERNAL_ACCOUNT_OUTPUT_FILE', this.outputFile);\n }\n const serviceAccountEmail = this.getServiceAccountEmail();\n if (serviceAccountEmail) {\n envMap.set('GOOGLE_EXTERNAL_ACCOUNT_IMPERSONATED_EMAIL', serviceAccountEmail);\n }\n executableResponse =\n await this.handler.retrieveResponseFromExecutable(envMap);\n }\n if (executableResponse.version > MAXIMUM_EXECUTABLE_VERSION) {\n throw new Error(`Version of executable is not currently supported, maximum supported version is ${MAXIMUM_EXECUTABLE_VERSION}.`);\n }\n // Check that response was successful.\n if (!executableResponse.success) {\n throw new pluggable_auth_handler_1.ExecutableError(executableResponse.errorMessage, executableResponse.errorCode);\n }\n // Check that response contains expiration time if output file was specified.\n if (this.outputFile) {\n if (!executableResponse.expirationTime) {\n throw new executable_response_1.InvalidExpirationTimeFieldError('The executable response must contain the `expiration_time` field for successful responses when an output_file has been specified in the configuration.');\n }\n }\n // Check that response is not expired.\n if (executableResponse.isExpired()) {\n throw new Error('Executable response is expired.');\n }\n // Return subject token from response.\n return executableResponse.subjectToken;\n }\n}\nexports.PluggableAuthClient = PluggableAuthClient;\n//# sourceMappingURL=pluggable-auth-client.js.map", "\"use strict\";\n// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExternalAccountClient = void 0;\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\nconst identitypoolclient_1 = require(\"./identitypoolclient\");\nconst awsclient_1 = require(\"./awsclient\");\nconst pluggable_auth_client_1 = require(\"./pluggable-auth-client\");\n/**\n * Dummy class with no constructor. Developers are expected to use fromJSON.\n */\nclass ExternalAccountClient {\n constructor() {\n throw new Error('ExternalAccountClients should be initialized via: ' +\n 'ExternalAccountClient.fromJSON(), ' +\n 'directly via explicit constructors, eg. ' +\n 'new AwsClient(options), new IdentityPoolClient(options), new' +\n 'PluggableAuthClientOptions, or via ' +\n 'new GoogleAuth(options).getClient()');\n }\n /**\n * This static method will instantiate the\n * corresponding type of external account credential depending on the\n * underlying credential source.\n *\n * **IMPORTANT**: This method does not validate the credential configuration.\n * A security risk occurs when a credential configuration configured with\n * malicious URLs is used. When the credential configuration is accepted from\n * an untrusted source, you should validate it before using it with this\n * method. For more details, see\n * https://cloud.google.com/docs/authentication/external/externally-sourced-credentials.\n *\n * @param options The external account options object typically loaded\n * from the external account JSON credential file.\n * @return A BaseExternalAccountClient instance or null if the options\n * provided do not correspond to an external account credential.\n */\n static fromJSON(options) {\n if (options && options.type === baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {\n if (options.credential_source?.environment_id) {\n return new awsclient_1.AwsClient(options);\n }\n else if (options.credential_source?.executable) {\n return new pluggable_auth_client_1.PluggableAuthClient(options);\n }\n else {\n return new identitypoolclient_1.IdentityPoolClient(options);\n }\n }\n else {\n return null;\n }\n }\n}\nexports.ExternalAccountClient = ExternalAccountClient;\n//# sourceMappingURL=externalclient.js.map", "\"use strict\";\n// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExternalAccountAuthorizedUserClient = exports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = void 0;\nconst authclient_1 = require(\"./authclient\");\nconst oauth2common_1 = require(\"./oauth2common\");\nconst gaxios_1 = require(\"gaxios\");\nconst stream = require(\"stream\");\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\n/**\n * The credentials JSON file type for external account authorized user clients.\n */\nexports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = 'external_account_authorized_user';\nconst DEFAULT_TOKEN_URL = 'https://sts.{universeDomain}/v1/oauthtoken';\n/**\n * Handler for token refresh requests sent to the token_url endpoint for external\n * authorized user credentials.\n */\nclass ExternalAccountAuthorizedUserHandler extends oauth2common_1.OAuthClientAuthHandler {\n #tokenRefreshEndpoint;\n /**\n * Initializes an ExternalAccountAuthorizedUserHandler instance.\n * @param url The URL of the token refresh endpoint.\n * @param transporter The transporter to use for the refresh request.\n * @param clientAuthentication The client authentication credentials to use\n * for the refresh request.\n */\n constructor(options) {\n super(options);\n this.#tokenRefreshEndpoint = options.tokenRefreshEndpoint;\n }\n /**\n * Requests a new access token from the token_url endpoint using the provided\n * refresh token.\n * @param refreshToken The refresh token to use to generate a new access token.\n * @param additionalHeaders Optional additional headers to pass along the\n * request.\n * @return A promise that resolves with the token refresh response containing\n * the requested access token and its expiration time.\n */\n async refreshToken(refreshToken, headers) {\n const opts = {\n ...ExternalAccountAuthorizedUserHandler.RETRY_CONFIG,\n url: this.#tokenRefreshEndpoint,\n method: 'POST',\n headers,\n data: new URLSearchParams({\n grant_type: 'refresh_token',\n refresh_token: refreshToken,\n }),\n responseType: 'json',\n };\n authclient_1.AuthClient.setMethodName(opts, 'refreshToken');\n // Apply OAuth client authentication.\n this.applyClientAuthenticationOptions(opts);\n try {\n const response = await this.transporter.request(opts);\n // Successful response.\n const tokenRefreshResponse = response.data;\n tokenRefreshResponse.res = response;\n return tokenRefreshResponse;\n }\n catch (error) {\n // Translate error to OAuthError.\n if (error instanceof gaxios_1.GaxiosError && error.response) {\n throw (0, oauth2common_1.getErrorFromOAuthErrorResponse)(error.response.data, \n // Preserve other fields from the original error.\n error);\n }\n // Request could fail before the server responds.\n throw error;\n }\n }\n}\n/**\n * External Account Authorized User Client. This is used for OAuth2 credentials\n * sourced using external identities through Workforce Identity Federation.\n * Obtaining the initial access and refresh token can be done through the\n * Google Cloud CLI.\n */\nclass ExternalAccountAuthorizedUserClient extends authclient_1.AuthClient {\n cachedAccessToken;\n externalAccountAuthorizedUserHandler;\n refreshToken;\n /**\n * Instantiates an ExternalAccountAuthorizedUserClient instances using the\n * provided JSON object loaded from a credentials files.\n * An error is throws if the credential is not valid.\n * @param options The external account authorized user option object typically\n * from the external accoutn authorized user JSON credential file.\n */\n constructor(options) {\n super(options);\n if (options.universe_domain) {\n this.universeDomain = options.universe_domain;\n }\n this.refreshToken = options.refresh_token;\n const clientAuthentication = {\n confidentialClientType: 'basic',\n clientId: options.client_id,\n clientSecret: options.client_secret,\n };\n this.externalAccountAuthorizedUserHandler =\n new ExternalAccountAuthorizedUserHandler({\n tokenRefreshEndpoint: options.token_url ??\n DEFAULT_TOKEN_URL.replace('{universeDomain}', this.universeDomain),\n transporter: this.transporter,\n clientAuthentication,\n });\n this.cachedAccessToken = null;\n this.quotaProjectId = options.quota_project_id;\n // As threshold could be zero,\n // eagerRefreshThresholdMillis || EXPIRATION_TIME_OFFSET will override the\n // zero value.\n if (typeof options?.eagerRefreshThresholdMillis !== 'number') {\n this.eagerRefreshThresholdMillis = baseexternalclient_1.EXPIRATION_TIME_OFFSET;\n }\n else {\n this.eagerRefreshThresholdMillis = options\n .eagerRefreshThresholdMillis;\n }\n this.forceRefreshOnFailure = !!options?.forceRefreshOnFailure;\n }\n async getAccessToken() {\n // If cached access token is unavailable or expired, force refresh.\n if (!this.cachedAccessToken || this.isExpired(this.cachedAccessToken)) {\n await this.refreshAccessTokenAsync();\n }\n // Return GCP access token in GetAccessTokenResponse format.\n return {\n token: this.cachedAccessToken.access_token,\n res: this.cachedAccessToken.res,\n };\n }\n async getRequestHeaders() {\n const accessTokenResponse = await this.getAccessToken();\n const headers = new Headers({\n authorization: `Bearer ${accessTokenResponse.token}`,\n });\n return this.addSharedMetadataHeaders(headers);\n }\n request(opts, callback) {\n if (callback) {\n this.requestAsync(opts).then(r => callback(null, r), e => {\n return callback(e, e.response);\n });\n }\n else {\n return this.requestAsync(opts);\n }\n }\n /**\n * Authenticates the provided HTTP request, processes it and resolves with the\n * returned response.\n * @param opts The HTTP request options.\n * @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure.\n * @return A promise that resolves with the successful response.\n */\n async requestAsync(opts, reAuthRetried = false) {\n let response;\n try {\n const requestHeaders = await this.getRequestHeaders();\n opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);\n this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);\n response = await this.transporter.request(opts);\n }\n catch (e) {\n const res = e.response;\n if (res) {\n const statusCode = res.status;\n // Retry the request for metadata if the following criteria are true:\n // - We haven't already retried. It only makes sense to retry once.\n // - The response was a 401 or a 403\n // - The request didn't send a readableStream\n // - forceRefreshOnFailure is true\n const isReadableStream = res.config.data instanceof stream.Readable;\n const isAuthErr = statusCode === 401 || statusCode === 403;\n if (!reAuthRetried &&\n isAuthErr &&\n !isReadableStream &&\n this.forceRefreshOnFailure) {\n await this.refreshAccessTokenAsync();\n return await this.requestAsync(opts, true);\n }\n }\n throw e;\n }\n return response;\n }\n /**\n * Forces token refresh, even if unexpired tokens are currently cached.\n * @return A promise that resolves with the refreshed credential.\n */\n async refreshAccessTokenAsync() {\n // Refresh the access token using the refresh token.\n const refreshResponse = await this.externalAccountAuthorizedUserHandler.refreshToken(this.refreshToken);\n this.cachedAccessToken = {\n access_token: refreshResponse.access_token,\n expiry_date: new Date().getTime() + refreshResponse.expires_in * 1000,\n res: refreshResponse.res,\n };\n if (refreshResponse.refresh_token !== undefined) {\n this.refreshToken = refreshResponse.refresh_token;\n }\n return this.cachedAccessToken;\n }\n /**\n * Returns whether the provided credentials are expired or not.\n * If there is no expiry time, assumes the token is not expired or expiring.\n * @param credentials The credentials to check for expiration.\n * @return Whether the credentials are expired or not.\n */\n isExpired(credentials) {\n const now = new Date().getTime();\n return credentials.expiry_date\n ? now >= credentials.expiry_date - this.eagerRefreshThresholdMillis\n : false;\n }\n}\nexports.ExternalAccountAuthorizedUserClient = ExternalAccountAuthorizedUserClient;\n//# sourceMappingURL=externalAccountAuthorizedUserClient.js.map", "\"use strict\";\n// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GdchClient = exports.GDCH_SERVICE_ACCOUNT_TYPE = void 0;\nconst crypto = require(\"crypto\");\nconst fs = require(\"fs\");\nconst https = require(\"https\");\nconst oauth2client_1 = require(\"./oauth2client\");\nconst DEFAULT_LIFETIME_IN_SECONDS = 3600;\nexports.GDCH_SERVICE_ACCOUNT_TYPE = 'gdch_service_account';\nclass GdchClient extends oauth2client_1.OAuth2Client {\n projectId;\n privateKeyId;\n privateKey;\n serviceIdentityName;\n tokenServerUri;\n caCertPath;\n apiAudience;\n lifetime;\n gdchOptions;\n caAgentPromise;\n cachedCaCertPath;\n lastCaCertReadTime = 0;\n CA_CERT_TTL_MS = 5 * 60 * 1000;\n constructor(options = {}) {\n super(options);\n this.gdchOptions = options;\n this.projectId = options.projectId || undefined;\n this.privateKeyId = options.privateKeyId;\n this.privateKey = options.privateKey;\n this.serviceIdentityName = options.serviceIdentityName;\n this.tokenServerUri = options.tokenServerUri;\n this.caCertPath = options.caCertPath;\n this.apiAudience = options.apiAudience;\n this.lifetime = options.lifetime || DEFAULT_LIFETIME_IN_SECONDS;\n // Start with an expired refresh token, which will automatically be\n // refreshed before the first API call is made.\n this.credentials = { refresh_token: 'gdch-placeholder', expiry_date: 1 };\n }\n createWithGdchAudience(apiAudience) {\n if (!apiAudience) {\n throw new Error('Audience cannot be null or empty for GDCH service account credentials.');\n }\n return new GdchClient({\n ...this.gdchOptions,\n projectId: this.projectId,\n privateKeyId: this.privateKeyId,\n privateKey: this.privateKey,\n serviceIdentityName: this.serviceIdentityName,\n tokenServerUri: this.tokenServerUri,\n caCertPath: this.caCertPath,\n lifetime: this.lifetime,\n apiAudience,\n });\n }\n fromJSON(json) {\n if (!json) {\n throw new Error('Must pass in a JSON object containing the GDCH credentials settings.');\n }\n if (json.type !== exports.GDCH_SERVICE_ACCOUNT_TYPE) {\n throw new Error(`The incoming JSON object does not have the \"${exports.GDCH_SERVICE_ACCOUNT_TYPE}\" type`);\n }\n if (json.format_version !== '1') {\n throw new Error('Only format version 1 is supported.');\n }\n if (!json.project) {\n throw new Error('The incoming JSON object does not contain a project field');\n }\n if (!json.private_key_id) {\n throw new Error('The incoming JSON object does not contain a private_key_id field');\n }\n if (!json.private_key) {\n throw new Error('The incoming JSON object does not contain a private_key field');\n }\n if (!json.name) {\n throw new Error('The incoming JSON object does not contain a name field');\n }\n if (!json.token_uri) {\n throw new Error('The incoming JSON object does not contain a token_uri field');\n }\n this.projectId = json.project;\n this.privateKeyId = json.private_key_id;\n this.privateKey = json.private_key;\n this.serviceIdentityName = json.name;\n this.tokenServerUri = json.token_uri;\n this.caCertPath = json.ca_cert_path;\n this.gdchOptions = {\n ...this.gdchOptions,\n projectId: json.project,\n privateKeyId: json.private_key_id,\n privateKey: json.private_key,\n serviceIdentityName: json.name,\n tokenServerUri: json.token_uri,\n caCertPath: json.ca_cert_path,\n };\n }\n async refreshTokenNoCache() {\n if (!this.apiAudience) {\n throw new Error('Audience cannot be null or empty for GDCH service account credentials. ' +\n 'Specify the audience by calling createWithGdchAudience.');\n }\n if (!this.privateKey) {\n throw new Error('Private key is not configured for GDCH credentials.');\n }\n if (!this.privateKeyId) {\n throw new Error('Private key ID is not configured for GDCH credentials.');\n }\n if (!this.projectId) {\n throw new Error('Project is not configured for GDCH credentials.');\n }\n if (!this.serviceIdentityName) {\n throw new Error('Service identity name is not configured for GDCH credentials.');\n }\n if (!this.tokenServerUri) {\n throw new Error('Token server URI is not configured for GDCH credentials.');\n }\n const assertion = this.createAssertion();\n const data = {\n audience: this.apiAudience,\n grant_type: 'urn:ietf:params:oauth:token-type:token-exchange',\n requested_token_type: 'urn:ietf:params:oauth:token-type:access_token',\n subject_token: assertion,\n subject_token_type: 'urn:k8s:params:oauth:token-type:serviceaccount',\n };\n const requestOpts = {\n url: this.tokenServerUri,\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n },\n data,\n responseType: 'json',\n timeout: 10000,\n retry: true,\n retryConfig: {\n httpMethodsToRetry: ['POST'],\n statusCodesToRetry: [[500, 599]],\n noResponseRetries: 3,\n },\n };\n if (this.caCertPath) {\n requestOpts.agent = await this.getCaAgent();\n }\n try {\n const res = await this.transporter.request(requestOpts);\n const tokenResponse = res.data;\n if (!tokenResponse.access_token) {\n throw new Error('Token response did not contain an access_token.');\n }\n if (!tokenResponse.expires_in) {\n throw new Error('Token response did not contain an expires_in field.');\n }\n const tokens = {\n access_token: tokenResponse.access_token,\n token_type: 'STS-Bearer',\n expiry_date: Date.now() + tokenResponse.expires_in * 1000,\n };\n this.emit('tokens', tokens);\n return { res, tokens };\n }\n catch (e) {\n if (e && e.config && e.config.data) {\n try {\n if (typeof e.config.data === 'string') {\n const parsedData = JSON.parse(e.config.data);\n if (parsedData.subject_token) {\n parsedData.subject_token = '***REDACTED***';\n e.config.data = JSON.stringify(parsedData);\n }\n }\n else if (typeof e.config.data === 'object' && e.config.data.subject_token) {\n e.config.data.subject_token = '***REDACTED***';\n }\n }\n catch { }\n }\n if (e instanceof Error) {\n e.message = `Error getting access token for GDCH service account: ${e.message}, iss: ${this.serviceIdentityName}`;\n }\n throw e;\n }\n }\n createAssertion() {\n const header = {\n alg: 'ES256',\n typ: 'JWT',\n kid: this.privateKeyId,\n };\n const issSub = `system:serviceaccount:${this.projectId}:${this.serviceIdentityName}`;\n const currentTime = Math.floor(Date.now() / 1000);\n const payload = {\n iss: issSub,\n sub: issSub,\n iat: currentTime,\n exp: currentTime + this.lifetime,\n aud: this.tokenServerUri,\n };\n const encodedHeader = this.base64UrlEncode(JSON.stringify(header));\n const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));\n const signingInput = `${encodedHeader}.${encodedPayload}`;\n const signature = crypto.sign('sha256', Buffer.from(signingInput), {\n key: this.privateKey,\n dsaEncoding: 'ieee-p1363',\n });\n const encodedSignature = this.base64UrlEncode(signature);\n return `${signingInput}.${encodedSignature}`;\n }\n async requestAsync(opts, retry = false) {\n if (this.caCertPath && !opts.agent) {\n const url = (opts.url || '').toString();\n if (!url.includes('googleapis.com') && !url.includes('google.com')) {\n opts.agent = await this.getCaAgent();\n }\n }\n return super.requestAsync(opts, retry);\n }\n getCaAgent() {\n if (!this.caCertPath) {\n this.caAgentPromise = undefined;\n this.cachedCaCertPath = undefined;\n this.lastCaCertReadTime = 0;\n return undefined;\n }\n const now = Date.now();\n const isCacheExpired = now - this.lastCaCertReadTime > this.CA_CERT_TTL_MS;\n if (this.caAgentPromise &&\n this.caCertPath === this.cachedCaCertPath &&\n !isCacheExpired) {\n return this.caAgentPromise;\n }\n this.cachedCaCertPath = this.caCertPath;\n this.lastCaCertReadTime = now;\n const currentPath = this.caCertPath;\n this.caAgentPromise = (async () => {\n try {\n const ca = await fs.promises.readFile(currentPath);\n return new https.Agent({ ca });\n }\n catch (err) {\n if (this.cachedCaCertPath === currentPath) {\n this.caAgentPromise = undefined;\n this.cachedCaCertPath = undefined;\n this.lastCaCertReadTime = 0;\n }\n if (err instanceof Error) {\n err.message = `Error reading certificate file from CA cert path, value '${currentPath}': ${err.message}`;\n }\n throw err;\n }\n })();\n return this.caAgentPromise;\n }\n toJSON() {\n return {\n ...this,\n privateKey: this.privateKey ? '***REDACTED***' : undefined,\n _clientSecret: this._clientSecret ? '***REDACTED***' : undefined,\n apiKey: this.apiKey ? '***REDACTED***' : undefined,\n gdchOptions: this.gdchOptions\n ? {\n ...this.gdchOptions,\n privateKey: this.gdchOptions.privateKey ? '***REDACTED***' : undefined,\n clientSecret: this.gdchOptions.clientSecret ? '***REDACTED***' : undefined,\n client_secret: this.gdchOptions.client_secret ? '***REDACTED***' : undefined,\n apiKey: this.gdchOptions.apiKey ? '***REDACTED***' : undefined,\n credentials: this.gdchOptions.credentials\n ? {\n ...this.gdchOptions.credentials,\n access_token: this.gdchOptions.credentials.access_token\n ? '***REDACTED***'\n : undefined,\n refresh_token: this.gdchOptions.credentials.refresh_token\n ? '***REDACTED***'\n : undefined,\n }\n : undefined,\n }\n : undefined,\n credentials: {\n ...this.credentials,\n access_token: this.credentials?.access_token ? '***REDACTED***' : undefined,\n refresh_token: this.credentials?.refresh_token ? '***REDACTED***' : undefined,\n },\n };\n }\n [Symbol.for('nodejs.util.inspect.custom')]() {\n return this.toJSON();\n }\n base64UrlEncode(str) {\n const buffer = typeof str === 'string' ? Buffer.from(str) : str;\n return buffer.toString('base64url');\n }\n}\nexports.GdchClient = GdchClient;\n//# sourceMappingURL=gdchclient.js.map", "\"use strict\";\n// Copyright 2019 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GoogleAuth = exports.GoogleAuthExceptionMessages = void 0;\nconst child_process_1 = require(\"child_process\");\nconst fs = require(\"fs\");\nconst gaxios_1 = require(\"gaxios\");\nconst gcpMetadata = require(\"gcp-metadata\");\nconst os = require(\"os\");\nconst path = require(\"path\");\nconst crypto_1 = require(\"../crypto/crypto\");\nconst computeclient_1 = require(\"./computeclient\");\nconst idtokenclient_1 = require(\"./idtokenclient\");\nconst envDetect_1 = require(\"./envDetect\");\nconst jwtclient_1 = require(\"./jwtclient\");\nconst refreshclient_1 = require(\"./refreshclient\");\nconst impersonated_1 = require(\"./impersonated\");\nconst externalclient_1 = require(\"./externalclient\");\nconst baseexternalclient_1 = require(\"./baseexternalclient\");\nconst authclient_1 = require(\"./authclient\");\nconst externalAccountAuthorizedUserClient_1 = require(\"./externalAccountAuthorizedUserClient\");\nconst gdchclient_1 = require(\"./gdchclient\");\nconst util_1 = require(\"../util\");\nexports.GoogleAuthExceptionMessages = {\n API_KEY_WITH_CREDENTIALS: 'API Keys and Credentials are mutually exclusive authentication methods and cannot be used together.',\n NO_PROJECT_ID_FOUND: 'Unable to detect a Project Id in the current environment. \\n' +\n 'To learn more about authentication and Google APIs, visit: \\n' +\n 'https://cloud.google.com/docs/authentication/getting-started',\n NO_CREDENTIALS_FOUND: 'Unable to find credentials in current environment. \\n' +\n 'To learn more about authentication and Google APIs, visit: \\n' +\n 'https://cloud.google.com/docs/authentication/getting-started',\n NO_ADC_FOUND: 'Could not load the default credentials. Browse to https://cloud.google.com/docs/authentication/getting-started for more information.',\n NO_UNIVERSE_DOMAIN_FOUND: 'Unable to detect a Universe Domain in the current environment.\\n' +\n 'To learn more about Universe Domain retrieval, visit: \\n' +\n 'https://cloud.google.com/compute/docs/metadata/predefined-metadata-keys',\n};\nclass GoogleAuth {\n /**\n * Caches a value indicating whether the auth layer is running on Google\n * Compute Engine.\n * @private\n */\n checkIsGCE = undefined;\n useJWTAccessWithScope;\n defaultServicePath;\n // Note: this properly is only public to satisfy unit tests.\n // https://github.com/Microsoft/TypeScript/issues/5228\n get isGCE() {\n return this.checkIsGCE;\n }\n _findProjectIdPromise;\n _cachedProjectId;\n // To save the contents of the JSON credential file\n jsonContent = null;\n apiKey;\n cachedCredential = null;\n /**\n * A pending {@link AuthClient}. Used for concurrent {@link GoogleAuth.getClient} calls.\n */\n #pendingAuthClient = null;\n /**\n * Scopes populated by the client library by default. We differentiate between\n * these and user defined scopes when deciding whether to use a self-signed JWT.\n */\n defaultScopes;\n keyFilename;\n scopes;\n clientOptions = {};\n /**\n * Configuration is resolved in the following order of precedence:\n * - {@link GoogleAuthOptions.credentials `credentials`}\n * - {@link GoogleAuthOptions.keyFilename `keyFilename`}\n * - {@link GoogleAuthOptions.keyFile `keyFile`}\n *\n * {@link GoogleAuthOptions.clientOptions `clientOptions`} are passed to the\n * {@link AuthClient `AuthClient`s}.\n *\n * @param opts\n */\n constructor(opts = {}) {\n this._cachedProjectId = opts.projectId || null;\n this.cachedCredential = opts.authClient || null;\n this.keyFilename = opts.keyFilename || opts.keyFile;\n this.scopes = opts.scopes;\n this.clientOptions = opts.clientOptions || {};\n this.jsonContent = opts.credentials || null;\n this.apiKey = opts.apiKey || this.clientOptions.apiKey || null;\n // Cannot use both API Key + Credentials\n if (this.apiKey && (this.jsonContent || this.clientOptions.credentials)) {\n throw new RangeError(exports.GoogleAuthExceptionMessages.API_KEY_WITH_CREDENTIALS);\n }\n if (opts.universeDomain) {\n this.clientOptions.universeDomain = opts.universeDomain;\n }\n }\n // GAPIC client libraries should always use self-signed JWTs. The following\n // variables are set on the JWT client in order to indicate the type of library,\n // and sign the JWT with the correct audience and scopes (if not supplied).\n setGapicJWTValues(client) {\n client.defaultServicePath = this.defaultServicePath;\n client.useJWTAccessWithScope = this.useJWTAccessWithScope;\n client.defaultScopes = this.defaultScopes;\n }\n getProjectId(callback) {\n if (callback) {\n this.getProjectIdAsync().then(r => callback(null, r), callback);\n }\n else {\n return this.getProjectIdAsync();\n }\n }\n /**\n * A temporary method for internal `getProjectId` usages where `null` is\n * acceptable. In a future major release, `getProjectId` should return `null`\n * (as the `Promise` base signature describes) and this private\n * method should be removed.\n *\n * @returns Promise that resolves with project id (or `null`)\n */\n async getProjectIdOptional() {\n try {\n return await this.getProjectId();\n }\n catch (e) {\n if (e instanceof Error &&\n e.message === exports.GoogleAuthExceptionMessages.NO_PROJECT_ID_FOUND) {\n return null;\n }\n else {\n throw e;\n }\n }\n }\n /**\n * A private method for finding and caching a projectId.\n *\n * Supports environments in order of precedence:\n * - GCLOUD_PROJECT or GOOGLE_CLOUD_PROJECT environment variable\n * - GOOGLE_APPLICATION_CREDENTIALS JSON file\n * - Cloud SDK: `gcloud config config-helper --format json`\n * - GCE project ID from metadata server\n *\n * @returns projectId\n */\n async findAndCacheProjectId() {\n let projectId = null;\n projectId ||= await this.getProductionProjectId();\n projectId ||= await this.getFileProjectId();\n projectId ||= await this.getDefaultServiceProjectId();\n projectId ||= await this.getGCEProjectId();\n projectId ||= await this.getExternalAccountClientProjectId();\n if (projectId) {\n this._cachedProjectId = projectId;\n return projectId;\n }\n else {\n throw new Error(exports.GoogleAuthExceptionMessages.NO_PROJECT_ID_FOUND);\n }\n }\n async getProjectIdAsync() {\n if (this._cachedProjectId) {\n return this._cachedProjectId;\n }\n if (!this._findProjectIdPromise) {\n this._findProjectIdPromise = this.findAndCacheProjectId();\n }\n return this._findProjectIdPromise;\n }\n /**\n * Retrieves a universe domain from the metadata server via\n * {@link gcpMetadata.universe}.\n *\n * @returns a universe domain\n */\n async getUniverseDomainFromMetadataServer() {\n let universeDomain;\n try {\n universeDomain = await gcpMetadata.universe('universe-domain');\n universeDomain ||= authclient_1.DEFAULT_UNIVERSE;\n }\n catch (e) {\n if (e && e?.response?.status === 404) {\n universeDomain = authclient_1.DEFAULT_UNIVERSE;\n }\n else {\n throw e;\n }\n }\n return universeDomain;\n }\n /**\n * Retrieves, caches, and returns the universe domain in the following order\n * of precedence:\n * - The universe domain in {@link GoogleAuth.clientOptions}\n * - An existing or ADC {@link AuthClient}'s universe domain\n * - {@link gcpMetadata.universe}, if {@link Compute} client\n *\n * @returns The universe domain\n */\n async getUniverseDomain() {\n let universeDomain = (0, util_1.originalOrCamelOptions)(this.clientOptions).get('universe_domain');\n try {\n universeDomain ??= (await this.getClient()).universeDomain;\n }\n catch {\n // client or ADC is not available\n universeDomain ??= authclient_1.DEFAULT_UNIVERSE;\n }\n return universeDomain;\n }\n /**\n * @returns Any scopes (user-specified or default scopes specified by the\n * client library) that need to be set on the current Auth client.\n */\n getAnyScopes() {\n return this.scopes || this.defaultScopes;\n }\n getApplicationDefault(optionsOrCallback = {}, callback) {\n let options;\n if (typeof optionsOrCallback === 'function') {\n callback = optionsOrCallback;\n }\n else {\n options = optionsOrCallback;\n }\n if (callback) {\n this.getApplicationDefaultAsync(options).then(r => callback(null, r.credential, r.projectId), callback);\n }\n else {\n return this.getApplicationDefaultAsync(options);\n }\n }\n async getApplicationDefaultAsync(options = {}) {\n // If we've already got a cached credential, return it.\n // This will also preserve one's configured quota project, in case they\n // set one directly on the credential previously.\n if (this.cachedCredential) {\n // cache, while preserving existing quota project preferences\n return await this.#prepareAndCacheClient(this.cachedCredential, null);\n }\n let credential;\n // Check for the existence of a local environment variable pointing to the\n // location of the credential file. This is typically used in local\n // developer scenarios.\n credential =\n await this._tryGetApplicationCredentialsFromEnvironmentVariable(options);\n if (credential) {\n if (credential instanceof jwtclient_1.JWT) {\n credential.scopes = this.scopes;\n }\n else if (credential instanceof baseexternalclient_1.BaseExternalAccountClient) {\n credential.scopes = this.getAnyScopes();\n }\n return await this.#prepareAndCacheClient(credential);\n }\n // Look in the well-known credential file location.\n credential =\n await this._tryGetApplicationCredentialsFromWellKnownFile(options);\n if (credential) {\n if (credential instanceof jwtclient_1.JWT) {\n credential.scopes = this.scopes;\n }\n else if (credential instanceof baseexternalclient_1.BaseExternalAccountClient) {\n credential.scopes = this.getAnyScopes();\n }\n return await this.#prepareAndCacheClient(credential);\n }\n // Determine if we're running on GCE.\n if (await this._checkIsGCE()) {\n options.scopes = this.getAnyScopes();\n return await this.#prepareAndCacheClient(new computeclient_1.Compute(options));\n }\n throw new Error(exports.GoogleAuthExceptionMessages.NO_ADC_FOUND);\n }\n async #prepareAndCacheClient(credential, quotaProjectIdOverride = process.env['GOOGLE_CLOUD_QUOTA_PROJECT'] || null) {\n const projectId = await this.getProjectIdOptional();\n if (quotaProjectIdOverride) {\n credential.quotaProjectId = quotaProjectIdOverride;\n }\n this.cachedCredential = credential;\n return { credential, projectId };\n }\n /**\n * Determines whether the auth layer is running on Google Compute Engine.\n * Checks for GCP Residency, then fallback to checking if metadata server\n * is available.\n *\n * @returns A promise that resolves with the boolean.\n * @api private\n */\n async _checkIsGCE() {\n if (this.checkIsGCE === undefined) {\n this.checkIsGCE =\n gcpMetadata.getGCPResidency() || (await gcpMetadata.isAvailable());\n }\n return this.checkIsGCE;\n }\n /**\n * Attempts to load default credentials from the environment variable path..\n * @returns Promise that resolves with the OAuth2Client or null.\n * @api private\n */\n async _tryGetApplicationCredentialsFromEnvironmentVariable(options) {\n const credentialsPath = process.env['GOOGLE_APPLICATION_CREDENTIALS'] ||\n process.env['google_application_credentials'];\n if (!credentialsPath || credentialsPath.length === 0) {\n return null;\n }\n try {\n return await this._getApplicationCredentialsFromFilePath(credentialsPath, options);\n }\n catch (e) {\n if (e instanceof Error) {\n e.message = `Unable to read the credential file specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable: ${e.message}`;\n }\n throw e;\n }\n }\n /**\n * Attempts to load default credentials from a well-known file location\n * @return Promise that resolves with the OAuth2Client or null.\n * @api private\n */\n async _tryGetApplicationCredentialsFromWellKnownFile(options) {\n // First, figure out the location of the Cloud SDK config directory. The\n // `CLOUDSDK_CONFIG` environment variable overrides the platform-specific\n // default location; when it is set, `gcloud` stores the application default\n // credentials file there, so it takes precedence.\n let configDir = process.env['CLOUDSDK_CONFIG'];\n if (!configDir) {\n if (this._isWindows()) {\n // Windows\n if (process.env['APPDATA']) {\n configDir = path.join(process.env['APPDATA'], 'gcloud');\n }\n }\n else {\n // Linux or Mac\n const home = process.env['HOME'];\n if (home) {\n configDir = path.join(home, '.config', 'gcloud');\n }\n }\n }\n // The config directory could not be determined.\n if (!configDir) {\n return null;\n }\n const location = path.join(configDir, 'application_default_credentials.json');\n // The file does not exist.\n if (!fs.existsSync(location)) {\n return null;\n }\n // The file seems to exist. Try to use it.\n const client = await this._getApplicationCredentialsFromFilePath(location, options);\n return client;\n }\n /**\n * Attempts to load default credentials from a file at the given path..\n * @param filePath The path to the file to read.\n * @returns Promise that resolves with the OAuth2Client\n * @api private\n */\n async _getApplicationCredentialsFromFilePath(filePath, options = {}) {\n // Make sure the path looks like a string.\n if (!filePath || filePath.length === 0) {\n throw new Error('The file path is invalid.');\n }\n // Make sure there is a file at the path. lstatSync will throw if there is\n // nothing there.\n try {\n // Resolve path to actual file in case of symlink. Expect a thrown error\n // if not resolvable.\n filePath = fs.realpathSync(filePath);\n if (!fs.lstatSync(filePath).isFile()) {\n throw new Error();\n }\n }\n catch (err) {\n if (err instanceof Error) {\n err.message = `The file at ${filePath} does not exist, or it is not a file. ${err.message}`;\n }\n throw err;\n }\n // Now open a read stream on the file, and parse it.\n const readStream = fs.createReadStream(filePath);\n return this.fromStream(readStream, options);\n }\n /**\n * Create a credentials instance using a given impersonated input options.\n * @param json The impersonated input object.\n * @returns JWT or UserRefresh Client with data\n */\n fromImpersonatedJSON(json) {\n if (!json) {\n throw new Error('Must pass in a JSON object containing an impersonated refresh token');\n }\n if (json.type !== impersonated_1.IMPERSONATED_ACCOUNT_TYPE) {\n throw new Error(`The incoming JSON object does not have the \"${impersonated_1.IMPERSONATED_ACCOUNT_TYPE}\" type`);\n }\n if (!json.source_credentials) {\n throw new Error('The incoming JSON object does not contain a source_credentials field');\n }\n if (!json.service_account_impersonation_url) {\n throw new Error('The incoming JSON object does not contain a service_account_impersonation_url field');\n }\n const sourceClient = this.fromJSON(json.source_credentials);\n if (json.service_account_impersonation_url?.length > 256) {\n /**\n * Prevents DOS attacks.\n * @see {@link https://github.com/googleapis/google-auth-library-nodejs/security/code-scanning/85}\n **/\n throw new RangeError(`Target principal is too long: ${json.service_account_impersonation_url}`);\n }\n // Extract service account from service_account_impersonation_url\n const targetPrincipal = /(?[^/]+):(generateAccessToken|generateIdToken)$/.exec(json.service_account_impersonation_url)?.groups?.target;\n if (!targetPrincipal) {\n throw new RangeError(`Cannot extract target principal from ${json.service_account_impersonation_url}`);\n }\n const targetScopes = (this.scopes || json.scopes || this.defaultScopes) ?? [];\n return new impersonated_1.Impersonated({\n ...json,\n sourceClient,\n targetPrincipal,\n targetScopes: Array.isArray(targetScopes) ? targetScopes : [targetScopes],\n });\n }\n /**\n * Create a credentials instance using the given input options.\n * This client is not cached.\n *\n * **Important**: If you accept a credential configuration (credential JSON/File/Stream) from an external source for authentication to Google Cloud, you must validate it before providing it to any Google API or library. Providing an unvalidated credential configuration to Google APIs can compromise the security of your systems and data. For more information, refer to {@link https://cloud.google.com/docs/authentication/external/externally-sourced-credentials Validate credential configurations from external sources}.\n *\n * @deprecated This method is being deprecated because of a potential security risk.\n *\n * This method does not validate the credential configuration. The security\n * risk occurs when a credential configuration is accepted from a source that\n * is not under your control and used without validation on your side.\n *\n * If you know that you will be loading credential configurations of a\n * specific type, it is recommended to use a credential-type-specific\n * constructor. This will ensure that an unexpected credential type with\n * potential for malicious intent is not loaded unintentionally. You might\n * still have to do validation for certain credential types. Please follow\n * the recommendation for that method. For example, if you want to load only\n * service accounts, you can use the `JWT` constructor:\n * ```\n * const {JWT} = require('google-auth-library');\n * const keys = require('/path/to/key.json');\n * const client = new JWT({\n * email: keys.client_email,\n * key: keys.private_key,\n * scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n * });\n * ```\n *\n * If you are loading your credential configuration from an untrusted source and have\n * not mitigated the risks (e.g. by validating the configuration yourself), make\n * these changes as soon as possible to prevent security risks to your environment.\n *\n * Regardless of the method used, it is always your responsibility to validate\n * configurations received from external sources.\n *\n * For more details, see https://cloud.google.com/docs/authentication/external/externally-sourced-credentials.\n *\n * @param json The input object.\n * @param options The JWT or UserRefresh options for the client\n * @returns JWT or UserRefresh Client with data\n */\n fromJSON(json, options = {}) {\n let client;\n // user's preferred universe domain\n const preferredUniverseDomain = (0, util_1.originalOrCamelOptions)(options).get('universe_domain');\n if (json.type === refreshclient_1.USER_REFRESH_ACCOUNT_TYPE) {\n client = new refreshclient_1.UserRefreshClient(options);\n client.fromJSON(json);\n }\n else if (json.type === impersonated_1.IMPERSONATED_ACCOUNT_TYPE) {\n client = this.fromImpersonatedJSON(json);\n }\n else if (json.type === baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {\n client = externalclient_1.ExternalAccountClient.fromJSON({\n ...json,\n ...options,\n });\n client.scopes = this.getAnyScopes();\n }\n else if (json.type === externalAccountAuthorizedUserClient_1.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE) {\n client = new externalAccountAuthorizedUserClient_1.ExternalAccountAuthorizedUserClient({\n ...json,\n ...options,\n });\n }\n else if (json.type === gdchclient_1.GDCH_SERVICE_ACCOUNT_TYPE) {\n client = new gdchclient_1.GdchClient(options);\n client.fromJSON(json);\n }\n else {\n options.scopes = this.scopes;\n client = new jwtclient_1.JWT(options);\n this.setGapicJWTValues(client);\n client.fromJSON(json);\n }\n if (preferredUniverseDomain) {\n client.universeDomain = preferredUniverseDomain;\n }\n return client;\n }\n /**\n * Return a JWT or UserRefreshClient from JavaScript object, caching both the\n * object used to instantiate and the client.\n * @param json The input object.\n * @param options The JWT or UserRefresh options for the client\n * @returns JWT or UserRefresh Client with data\n */\n _cacheClientFromJSON(json, options) {\n const client = this.fromJSON(json, options);\n // cache both raw data used to instantiate client and client itself.\n this.jsonContent = json;\n this.cachedCredential = client;\n return client;\n }\n fromStream(inputStream, optionsOrCallback = {}, callback) {\n let options = {};\n if (typeof optionsOrCallback === 'function') {\n callback = optionsOrCallback;\n }\n else {\n options = optionsOrCallback;\n }\n if (callback) {\n this.fromStreamAsync(inputStream, options).then(r => callback(null, r), callback);\n }\n else {\n return this.fromStreamAsync(inputStream, options);\n }\n }\n fromStreamAsync(inputStream, options) {\n return new Promise((resolve, reject) => {\n if (!inputStream) {\n throw new Error('Must pass in a stream containing the Google auth settings.');\n }\n const chunks = [];\n inputStream\n .setEncoding('utf8')\n .on('error', reject)\n .on('data', chunk => chunks.push(chunk))\n .on('end', () => {\n try {\n try {\n const data = JSON.parse(chunks.join(''));\n const r = this._cacheClientFromJSON(data, options);\n return resolve(r);\n }\n catch (err) {\n // If we failed parsing this.keyFileName, assume that it\n // is a PEM or p12 certificate:\n if (!this.keyFilename)\n throw err;\n const client = new jwtclient_1.JWT({\n ...this.clientOptions,\n keyFile: this.keyFilename,\n });\n this.cachedCredential = client;\n this.setGapicJWTValues(client);\n return resolve(client);\n }\n }\n catch (err) {\n return reject(err);\n }\n });\n });\n }\n /**\n * Create a credentials instance using the given API key string.\n * The created client is not cached. In order to create and cache it use the {@link GoogleAuth.getClient `getClient`} method after first providing an {@link GoogleAuth.apiKey `apiKey`}.\n *\n * @param apiKey The API key string\n * @param options An optional options object.\n * @returns A JWT loaded from the key\n */\n fromAPIKey(apiKey, options = {}) {\n return new jwtclient_1.JWT({ ...options, apiKey });\n }\n /**\n * Determines whether the current operating system is Windows.\n * @api private\n */\n _isWindows() {\n const sys = os.platform();\n if (sys && sys.length >= 3) {\n if (sys.substring(0, 3).toLowerCase() === 'win') {\n return true;\n }\n }\n return false;\n }\n /**\n * Run the Google Cloud SDK command that prints the default project ID\n */\n async getDefaultServiceProjectId() {\n return new Promise(resolve => {\n (0, child_process_1.exec)('gcloud config config-helper --format json', (err, stdout) => {\n if (!err && stdout) {\n try {\n const projectId = JSON.parse(stdout).configuration.properties.core.project;\n resolve(projectId);\n return;\n }\n catch (e) {\n // ignore errors\n }\n }\n resolve(null);\n });\n });\n }\n /**\n * Loads the project id from environment variables.\n * @api private\n */\n getProductionProjectId() {\n return (process.env['GCLOUD_PROJECT'] ||\n process.env['GOOGLE_CLOUD_PROJECT'] ||\n process.env['gcloud_project'] ||\n process.env['google_cloud_project']);\n }\n /**\n * Loads the project id from the GOOGLE_APPLICATION_CREDENTIALS json file.\n * @api private\n */\n async getFileProjectId() {\n if (this.cachedCredential) {\n // Try to read the project ID from the cached credentials file\n return this.cachedCredential.projectId;\n }\n // Ensure the projectId is loaded from the keyFile if available.\n if (this.keyFilename) {\n const creds = await this.getClient();\n if (creds && creds.projectId) {\n return creds.projectId;\n }\n }\n // Try to load a credentials file and read its project ID\n const r = await this._tryGetApplicationCredentialsFromEnvironmentVariable();\n if (r) {\n return r.projectId;\n }\n else {\n return null;\n }\n }\n /**\n * Gets the project ID from external account client if available.\n */\n async getExternalAccountClientProjectId() {\n if (!this.jsonContent || this.jsonContent.type !== baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {\n return null;\n }\n const creds = await this.getClient();\n // Do not suppress the underlying error, as the error could contain helpful\n // information for debugging and fixing. This is especially true for\n // external account creds as in order to get the project ID, the following\n // operations have to succeed:\n // 1. Valid credentials file should be supplied.\n // 2. Ability to retrieve access tokens from STS token exchange API.\n // 3. Ability to exchange for service account impersonated credentials (if\n // enabled).\n // 4. Ability to get project info using the access token from step 2 or 3.\n // Without surfacing the error, it is harder for developers to determine\n // which step went wrong.\n return await creds.getProjectId();\n }\n /**\n * Gets the Compute Engine project ID if it can be inferred.\n */\n async getGCEProjectId() {\n try {\n const r = await gcpMetadata.project('project-id');\n return r;\n }\n catch (e) {\n // Ignore any errors\n return null;\n }\n }\n getCredentials(callback) {\n if (callback) {\n this.getCredentialsAsync().then(r => callback(null, r), callback);\n }\n else {\n return this.getCredentialsAsync();\n }\n }\n async getCredentialsAsync() {\n const client = await this.getClient();\n if (client instanceof impersonated_1.Impersonated) {\n return { client_email: client.getTargetPrincipal() };\n }\n if (client instanceof baseexternalclient_1.BaseExternalAccountClient) {\n const serviceAccountEmail = client.getServiceAccountEmail();\n if (serviceAccountEmail) {\n return {\n client_email: serviceAccountEmail,\n universe_domain: client.universeDomain,\n };\n }\n }\n if (this.jsonContent) {\n return {\n client_email: this.jsonContent.client_email,\n private_key: this.jsonContent.private_key,\n universe_domain: this.jsonContent.universe_domain,\n };\n }\n if (await this._checkIsGCE()) {\n const [client_email, universe_domain] = await Promise.all([\n gcpMetadata.instance('service-accounts/default/email'),\n this.getUniverseDomain(),\n ]);\n return { client_email, universe_domain };\n }\n throw new Error(exports.GoogleAuthExceptionMessages.NO_CREDENTIALS_FOUND);\n }\n /**\n * Automatically obtain an {@link AuthClient `AuthClient`} based on the\n * provided configuration. If no options were passed, use Application\n * Default Credentials.\n */\n async getClient() {\n if (this.cachedCredential) {\n return this.cachedCredential;\n }\n // Use an existing auth client request, or cache a new one\n this.#pendingAuthClient =\n this.#pendingAuthClient || this.#determineClient();\n try {\n const client = await this.#pendingAuthClient;\n if (client instanceof gdchclient_1.GdchClient && !client.apiAudience) {\n const opts = this.clientOptions;\n const endpoint = opts.apiEndpoint || opts.servicePath;\n if (endpoint) {\n const scheme = endpoint.startsWith('http') ? '' : 'https://';\n const formattedAudience = `${scheme}${endpoint}`.replace(/\\/+$/, '');\n const newClient = client.createWithGdchAudience(formattedAudience);\n this.cachedCredential = newClient;\n return newClient;\n }\n }\n return client;\n }\n finally {\n // reset the pending auth client in case it is changed later\n this.#pendingAuthClient = null;\n }\n }\n async #determineClient() {\n if (this.jsonContent) {\n return this._cacheClientFromJSON(this.jsonContent, this.clientOptions);\n }\n else if (this.keyFilename) {\n const filePath = path.resolve(this.keyFilename);\n const stream = fs.createReadStream(filePath);\n return await this.fromStreamAsync(stream, this.clientOptions);\n }\n else if (this.apiKey) {\n const client = await this.fromAPIKey(this.apiKey, this.clientOptions);\n client.scopes = this.scopes;\n const { credential } = await this.#prepareAndCacheClient(client);\n return credential;\n }\n else {\n const { credential } = await this.getApplicationDefaultAsync(this.clientOptions);\n return credential;\n }\n }\n /**\n * Creates a client which will fetch an ID token for authorization.\n * @param targetAudience the audience for the fetched ID token.\n * @returns IdTokenClient for making HTTP calls authenticated with ID tokens.\n */\n async getIdTokenClient(targetAudience) {\n const client = await this.getClient();\n if (!('fetchIdToken' in client)) {\n throw new Error('Cannot fetch ID token in this environment, use GCE or set the GOOGLE_APPLICATION_CREDENTIALS environment variable to a service account credentials JSON file.');\n }\n return new idtokenclient_1.IdTokenClient({ targetAudience, idTokenProvider: client });\n }\n /**\n * Automatically obtain application default credentials, and return\n * an access token for making requests.\n */\n async getAccessToken() {\n const client = await this.getClient();\n return (await client.getAccessToken()).token;\n }\n /**\n * Obtain the HTTP headers that will provide authorization for a given\n * request.\n */\n async getRequestHeaders(url) {\n const client = await this.getClient();\n return client.getRequestHeaders(url);\n }\n /**\n * Obtain credentials for a request, then attach the appropriate headers to\n * the request options.\n * @param opts Axios or Request options on which to attach the headers\n */\n async authorizeRequest(opts = {}) {\n const url = opts.url;\n const client = await this.getClient();\n const headers = await client.getRequestHeaders(url);\n opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers, headers);\n return opts;\n }\n /**\n * A {@link fetch `fetch`} compliant API for {@link GoogleAuth}.\n *\n * @see {@link GoogleAuth.request} for the classic method.\n *\n * @remarks\n *\n * This is useful as a drop-in replacement for `fetch` API usage.\n *\n * @example\n *\n * ```ts\n * const auth = new GoogleAuth();\n * const fetchWithAuth: typeof fetch = (...args) => auth.fetch(...args);\n * await fetchWithAuth('https://example.com');\n * ```\n *\n * @param args `fetch` API or {@link Gaxios.fetch `Gaxios#fetch`} parameters\n * @returns the {@link GaxiosResponse} with Gaxios-added properties\n */\n async fetch(...args) {\n const client = await this.getClient();\n return client.fetch(...args);\n }\n /**\n * Automatically obtain application default credentials, and make an\n * HTTP request using the given options.\n *\n * @see {@link GoogleAuth.fetch} for the modern method.\n *\n * @param opts Axios request options for the HTTP request.\n */\n async request(opts) {\n const client = await this.getClient();\n return client.request(opts);\n }\n /**\n * Determine the compute environment in which the code is running.\n */\n getEnv() {\n return (0, envDetect_1.getEnv)();\n }\n /**\n * Sign the given data with the current private key, or go out\n * to the IAM API to sign it.\n * @param data The data to be signed.\n * @param endpoint A custom endpoint to use.\n *\n * @example\n * ```\n * sign('data', 'https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/');\n * ```\n */\n async sign(data, endpoint) {\n const client = await this.getClient();\n const universe = await this.getUniverseDomain();\n endpoint =\n endpoint ||\n `https://iamcredentials.${universe}/v1/projects/-/serviceAccounts/`;\n if (client instanceof impersonated_1.Impersonated) {\n const signed = await client.sign(data);\n return signed.signedBlob;\n }\n const crypto = (0, crypto_1.createCrypto)();\n if (client instanceof jwtclient_1.JWT && client.key) {\n const sign = await crypto.sign(client.key, data);\n return sign;\n }\n const creds = await this.getCredentials();\n if (!creds.client_email) {\n throw new Error('Cannot sign data without `client_email`.');\n }\n return this.signBlob(crypto, creds.client_email, data, endpoint);\n }\n async signBlob(crypto, emailOrUniqueId, data, endpoint) {\n const url = new URL(endpoint + `${emailOrUniqueId}:signBlob`);\n const res = await this.request({\n method: 'POST',\n url: url.href,\n data: {\n payload: crypto.encodeBase64StringUtf8(data),\n },\n retry: true,\n retryConfig: {\n httpMethodsToRetry: ['POST'],\n },\n });\n return res.data.signedBlob;\n }\n}\nexports.GoogleAuth = GoogleAuth;\n//# sourceMappingURL=googleauth.js.map", "\"use strict\";\n// Copyright 2014 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.IAMAuth = void 0;\nclass IAMAuth {\n selector;\n token;\n /**\n * IAM credentials.\n *\n * @param selector the iam authority selector\n * @param token the token\n * @constructor\n */\n constructor(selector, token) {\n this.selector = selector;\n this.token = token;\n this.selector = selector;\n this.token = token;\n }\n /**\n * Acquire the HTTP headers required to make an authenticated request.\n */\n getRequestHeaders() {\n return {\n 'x-goog-iam-authority-selector': this.selector,\n 'x-goog-iam-authorization-token': this.token,\n };\n }\n}\nexports.IAMAuth = IAMAuth;\n//# sourceMappingURL=iam.js.map", "\"use strict\";\n// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DownscopedClient = exports.EXPIRATION_TIME_OFFSET = exports.MAX_ACCESS_BOUNDARY_RULES_COUNT = void 0;\nconst gaxios_1 = require(\"gaxios\");\nconst stream = require(\"stream\");\nconst authclient_1 = require(\"./authclient\");\nconst sts = require(\"./stscredentials\");\n/**\n * The required token exchange grant_type: rfc8693#section-2.1\n */\nconst STS_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:token-exchange';\n/**\n * The requested token exchange requested_token_type: rfc8693#section-2.1\n */\nconst STS_REQUEST_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token';\n/**\n * The requested token exchange subject_token_type: rfc8693#section-2.1\n */\nconst STS_SUBJECT_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token';\n/**\n * The maximum number of access boundary rules a Credential Access Boundary\n * can contain.\n */\nexports.MAX_ACCESS_BOUNDARY_RULES_COUNT = 10;\n/**\n * Offset to take into account network delays and server clock skews.\n */\nexports.EXPIRATION_TIME_OFFSET = 5 * 60 * 1000;\n/**\n * Defines a set of Google credentials that are downscoped from an existing set\n * of Google OAuth2 credentials. This is useful to restrict the Identity and\n * Access Management (IAM) permissions that a short-lived credential can use.\n * The common pattern of usage is to have a token broker with elevated access\n * generate these downscoped credentials from higher access source credentials\n * and pass the downscoped short-lived access tokens to a token consumer via\n * some secure authenticated channel for limited access to Google Cloud Storage\n * resources.\n */\nclass DownscopedClient extends authclient_1.AuthClient {\n authClient;\n credentialAccessBoundary;\n cachedDownscopedAccessToken;\n stsCredential;\n /**\n * Instantiates a downscoped client object using the provided source\n * AuthClient and credential access boundary rules.\n * To downscope permissions of a source AuthClient, a Credential Access\n * Boundary that specifies which resources the new credential can access, as\n * well as an upper bound on the permissions that are available on each\n * resource, has to be defined. A downscoped client can then be instantiated\n * using the source AuthClient and the Credential Access Boundary.\n * @param options the {@link DownscopedClientOptions `DownscopedClientOptions`} to use. Passing an `AuthClient` directly is **@DEPRECATED**.\n * @param credentialAccessBoundary **@DEPRECATED**. Provide a {@link DownscopedClientOptions `DownscopedClientOptions`} object in the first parameter instead.\n */\n constructor(\n /**\n * AuthClient is for backwards-compatibility.\n */\n options, \n /**\n * @deprecated - provide a {@link DownscopedClientOptions `DownscopedClientOptions`} object in the first parameter instead\n */\n credentialAccessBoundary = {\n accessBoundary: {\n accessBoundaryRules: [],\n },\n }) {\n super(options instanceof authclient_1.AuthClient ? {} : options);\n if (options instanceof authclient_1.AuthClient) {\n this.authClient = options;\n this.credentialAccessBoundary = credentialAccessBoundary;\n }\n else {\n this.authClient = options.authClient;\n this.credentialAccessBoundary = options.credentialAccessBoundary;\n }\n // Check 1-10 Access Boundary Rules are defined within Credential Access\n // Boundary.\n if (this.credentialAccessBoundary.accessBoundary.accessBoundaryRules\n .length === 0) {\n throw new Error('At least one access boundary rule needs to be defined.');\n }\n else if (this.credentialAccessBoundary.accessBoundary.accessBoundaryRules.length >\n exports.MAX_ACCESS_BOUNDARY_RULES_COUNT) {\n throw new Error('The provided access boundary has more than ' +\n `${exports.MAX_ACCESS_BOUNDARY_RULES_COUNT} access boundary rules.`);\n }\n // Check at least one permission should be defined in each Access Boundary\n // Rule.\n for (const rule of this.credentialAccessBoundary.accessBoundary\n .accessBoundaryRules) {\n if (rule.availablePermissions.length === 0) {\n throw new Error('At least one permission should be defined in access boundary rules.');\n }\n }\n this.stsCredential = new sts.StsCredentials({\n tokenExchangeEndpoint: `https://sts.${this.universeDomain}/v1/token`,\n });\n this.cachedDownscopedAccessToken = null;\n }\n /**\n * Provides a mechanism to inject Downscoped access tokens directly.\n * The expiry_date field is required to facilitate determination of the token\n * expiration which would make it easier for the token consumer to handle.\n * @param credentials The Credentials object to set on the current client.\n */\n setCredentials(credentials) {\n if (!credentials.expiry_date) {\n throw new Error('The access token expiry_date field is missing in the provided ' +\n 'credentials.');\n }\n super.setCredentials(credentials);\n this.cachedDownscopedAccessToken = credentials;\n }\n async getAccessToken() {\n // If the cached access token is unavailable or expired, force refresh.\n // The Downscoped access token will be returned in\n // DownscopedAccessTokenResponse format.\n if (!this.cachedDownscopedAccessToken ||\n this.isExpired(this.cachedDownscopedAccessToken)) {\n await this.refreshAccessTokenAsync();\n }\n // Return Downscoped access token in DownscopedAccessTokenResponse format.\n return {\n token: this.cachedDownscopedAccessToken.access_token,\n expirationTime: this.cachedDownscopedAccessToken.expiry_date,\n res: this.cachedDownscopedAccessToken.res,\n };\n }\n /**\n * The main authentication interface. It takes an optional url which when\n * present is the endpoint being accessed, and returns a Promise which\n * resolves with authorization header fields.\n *\n * The result has the form:\n * { authorization: 'Bearer ' }\n */\n async getRequestHeaders() {\n const accessTokenResponse = await this.getAccessToken();\n const headers = new Headers({\n authorization: `Bearer ${accessTokenResponse.token}`,\n });\n return this.addSharedMetadataHeaders(headers);\n }\n request(opts, callback) {\n if (callback) {\n this.requestAsync(opts).then(r => callback(null, r), e => {\n return callback(e, e.response);\n });\n }\n else {\n return this.requestAsync(opts);\n }\n }\n /**\n * Authenticates the provided HTTP request, processes it and resolves with the\n * returned response.\n * @param opts The HTTP request options.\n * @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure\n * @return A promise that resolves with the successful response.\n */\n async requestAsync(opts, reAuthRetried = false) {\n let response;\n try {\n const requestHeaders = await this.getRequestHeaders();\n opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);\n this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);\n response = await this.transporter.request(opts);\n }\n catch (e) {\n const res = e.response;\n if (res) {\n const statusCode = res.status;\n // Retry the request for metadata if the following criteria are true:\n // - We haven't already retried. It only makes sense to retry once.\n // - The response was a 401 or a 403\n // - The request didn't send a readableStream\n // - forceRefreshOnFailure is true\n const isReadableStream = res.config.data instanceof stream.Readable;\n const isAuthErr = statusCode === 401 || statusCode === 403;\n if (!reAuthRetried &&\n isAuthErr &&\n !isReadableStream &&\n this.forceRefreshOnFailure) {\n await this.refreshAccessTokenAsync();\n return await this.requestAsync(opts, true);\n }\n }\n throw e;\n }\n return response;\n }\n /**\n * Forces token refresh, even if unexpired tokens are currently cached.\n * GCP access tokens are retrieved from authclient object/source credential.\n * Then GCP access tokens are exchanged for downscoped access tokens via the\n * token exchange endpoint.\n * @return A promise that resolves with the fresh downscoped access token.\n */\n async refreshAccessTokenAsync() {\n // Retrieve GCP access token from source credential.\n const subjectToken = (await this.authClient.getAccessToken()).token;\n // Construct the STS credentials options.\n const stsCredentialsOptions = {\n grantType: STS_GRANT_TYPE,\n requestedTokenType: STS_REQUEST_TOKEN_TYPE,\n subjectToken: subjectToken,\n subjectTokenType: STS_SUBJECT_TOKEN_TYPE,\n };\n // Exchange the source AuthClient access token for a Downscoped access\n // token.\n const stsResponse = await this.stsCredential.exchangeToken(stsCredentialsOptions, undefined, this.credentialAccessBoundary);\n /**\n * The STS endpoint will only return the expiration time for the downscoped\n * access token if the original access token represents a service account.\n * The downscoped token's expiration time will always match the source\n * credential expiration. When no expires_in is returned, we can copy the\n * source credential's expiration time.\n */\n const sourceCredExpireDate = this.authClient.credentials?.expiry_date || null;\n const expiryDate = stsResponse.expires_in\n ? new Date().getTime() + stsResponse.expires_in * 1000\n : sourceCredExpireDate;\n // Save response in cached access token.\n this.cachedDownscopedAccessToken = {\n access_token: stsResponse.access_token,\n expiry_date: expiryDate,\n res: stsResponse.res,\n };\n // Save credentials.\n this.credentials = {};\n Object.assign(this.credentials, this.cachedDownscopedAccessToken);\n delete this.credentials.res;\n // Trigger tokens event to notify external listeners.\n this.emit('tokens', {\n refresh_token: null,\n expiry_date: this.cachedDownscopedAccessToken.expiry_date,\n access_token: this.cachedDownscopedAccessToken.access_token,\n token_type: 'Bearer',\n id_token: null,\n });\n // Return the cached access token.\n return this.cachedDownscopedAccessToken;\n }\n /**\n * Returns whether the provided credentials are expired or not.\n * If there is no expiry time, assumes the token is not expired or expiring.\n * @param downscopedAccessToken The credentials to check for expiration.\n * @return Whether the credentials are expired or not.\n */\n isExpired(downscopedAccessToken) {\n const now = new Date().getTime();\n return downscopedAccessToken.expiry_date\n ? now >=\n downscopedAccessToken.expiry_date - this.eagerRefreshThresholdMillis\n : false;\n }\n}\nexports.DownscopedClient = DownscopedClient;\n//# sourceMappingURL=downscopedclient.js.map", "\"use strict\";\n// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PassThroughClient = void 0;\nconst authclient_1 = require(\"./authclient\");\n/**\n * An AuthClient without any Authentication information. Useful for:\n * - Anonymous access\n * - Local Emulators\n * - Testing Environments\n *\n */\nclass PassThroughClient extends authclient_1.AuthClient {\n /**\n * Creates a request without any authentication headers or checks.\n *\n * @remarks\n *\n * In testing environments it may be useful to change the provided\n * {@link AuthClient.transporter} for any desired request overrides/handling.\n *\n * @param opts\n * @returns The response of the request.\n */\n async request(opts) {\n return this.transporter.request(opts);\n }\n /**\n * A required method of the base class.\n * Always will return an empty object.\n *\n * @returns {}\n */\n async getAccessToken() {\n return {};\n }\n /**\n * A required method of the base class.\n * Always will return an empty object.\n *\n * @returns {}\n */\n async getRequestHeaders() {\n return new Headers();\n }\n}\nexports.PassThroughClient = PassThroughClient;\n//# sourceMappingURL=passthrough.js.map", "\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n var desc = Object.getOwnPropertyDescriptor(m, k);\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n desc = { enumerable: true, get: function() { return m[k]; } };\n }\n Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GoogleAuth = exports.auth = exports.GDCH_SERVICE_ACCOUNT_TYPE = exports.GdchClient = exports.PassThroughClient = exports.ExternalAccountAuthorizedUserClient = exports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = exports.ExecutableError = exports.PluggableAuthClient = exports.DownscopedClient = exports.BaseExternalAccountClient = exports.ExternalAccountClient = exports.IdentityPoolClient = exports.AwsRequestSigner = exports.AwsClient = exports.UserRefreshClient = exports.LoginTicket = exports.ClientAuthentication = exports.OAuth2Client = exports.CodeChallengeMethod = exports.Impersonated = exports.JWT = exports.JWTAccess = exports.IdTokenClient = exports.IAMAuth = exports.GCPEnv = exports.Compute = exports.DEFAULT_UNIVERSE = exports.AuthClient = exports.gaxios = exports.gcpMetadata = void 0;\n// Copyright 2017 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nconst googleauth_1 = require(\"./auth/googleauth\");\nObject.defineProperty(exports, \"GoogleAuth\", { enumerable: true, get: function () { return googleauth_1.GoogleAuth; } });\n// Export common deps to ensure types/instances are the exact match. Useful\n// for consistently configuring the library across versions.\nexports.gcpMetadata = require(\"gcp-metadata\");\nexports.gaxios = require(\"gaxios\");\nvar authclient_1 = require(\"./auth/authclient\");\nObject.defineProperty(exports, \"AuthClient\", { enumerable: true, get: function () { return authclient_1.AuthClient; } });\nObject.defineProperty(exports, \"DEFAULT_UNIVERSE\", { enumerable: true, get: function () { return authclient_1.DEFAULT_UNIVERSE; } });\nvar computeclient_1 = require(\"./auth/computeclient\");\nObject.defineProperty(exports, \"Compute\", { enumerable: true, get: function () { return computeclient_1.Compute; } });\nvar envDetect_1 = require(\"./auth/envDetect\");\nObject.defineProperty(exports, \"GCPEnv\", { enumerable: true, get: function () { return envDetect_1.GCPEnv; } });\nvar iam_1 = require(\"./auth/iam\");\nObject.defineProperty(exports, \"IAMAuth\", { enumerable: true, get: function () { return iam_1.IAMAuth; } });\nvar idtokenclient_1 = require(\"./auth/idtokenclient\");\nObject.defineProperty(exports, \"IdTokenClient\", { enumerable: true, get: function () { return idtokenclient_1.IdTokenClient; } });\nvar jwtaccess_1 = require(\"./auth/jwtaccess\");\nObject.defineProperty(exports, \"JWTAccess\", { enumerable: true, get: function () { return jwtaccess_1.JWTAccess; } });\nvar jwtclient_1 = require(\"./auth/jwtclient\");\nObject.defineProperty(exports, \"JWT\", { enumerable: true, get: function () { return jwtclient_1.JWT; } });\nvar impersonated_1 = require(\"./auth/impersonated\");\nObject.defineProperty(exports, \"Impersonated\", { enumerable: true, get: function () { return impersonated_1.Impersonated; } });\nvar oauth2client_1 = require(\"./auth/oauth2client\");\nObject.defineProperty(exports, \"CodeChallengeMethod\", { enumerable: true, get: function () { return oauth2client_1.CodeChallengeMethod; } });\nObject.defineProperty(exports, \"OAuth2Client\", { enumerable: true, get: function () { return oauth2client_1.OAuth2Client; } });\nObject.defineProperty(exports, \"ClientAuthentication\", { enumerable: true, get: function () { return oauth2client_1.ClientAuthentication; } });\nvar loginticket_1 = require(\"./auth/loginticket\");\nObject.defineProperty(exports, \"LoginTicket\", { enumerable: true, get: function () { return loginticket_1.LoginTicket; } });\nvar refreshclient_1 = require(\"./auth/refreshclient\");\nObject.defineProperty(exports, \"UserRefreshClient\", { enumerable: true, get: function () { return refreshclient_1.UserRefreshClient; } });\nvar awsclient_1 = require(\"./auth/awsclient\");\nObject.defineProperty(exports, \"AwsClient\", { enumerable: true, get: function () { return awsclient_1.AwsClient; } });\nvar awsrequestsigner_1 = require(\"./auth/awsrequestsigner\");\nObject.defineProperty(exports, \"AwsRequestSigner\", { enumerable: true, get: function () { return awsrequestsigner_1.AwsRequestSigner; } });\nvar identitypoolclient_1 = require(\"./auth/identitypoolclient\");\nObject.defineProperty(exports, \"IdentityPoolClient\", { enumerable: true, get: function () { return identitypoolclient_1.IdentityPoolClient; } });\nvar externalclient_1 = require(\"./auth/externalclient\");\nObject.defineProperty(exports, \"ExternalAccountClient\", { enumerable: true, get: function () { return externalclient_1.ExternalAccountClient; } });\nvar baseexternalclient_1 = require(\"./auth/baseexternalclient\");\nObject.defineProperty(exports, \"BaseExternalAccountClient\", { enumerable: true, get: function () { return baseexternalclient_1.BaseExternalAccountClient; } });\nvar downscopedclient_1 = require(\"./auth/downscopedclient\");\nObject.defineProperty(exports, \"DownscopedClient\", { enumerable: true, get: function () { return downscopedclient_1.DownscopedClient; } });\nvar pluggable_auth_client_1 = require(\"./auth/pluggable-auth-client\");\nObject.defineProperty(exports, \"PluggableAuthClient\", { enumerable: true, get: function () { return pluggable_auth_client_1.PluggableAuthClient; } });\nObject.defineProperty(exports, \"ExecutableError\", { enumerable: true, get: function () { return pluggable_auth_client_1.ExecutableError; } });\nvar externalAccountAuthorizedUserClient_1 = require(\"./auth/externalAccountAuthorizedUserClient\");\nObject.defineProperty(exports, \"EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE\", { enumerable: true, get: function () { return externalAccountAuthorizedUserClient_1.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE; } });\nObject.defineProperty(exports, \"ExternalAccountAuthorizedUserClient\", { enumerable: true, get: function () { return externalAccountAuthorizedUserClient_1.ExternalAccountAuthorizedUserClient; } });\nvar passthrough_1 = require(\"./auth/passthrough\");\nObject.defineProperty(exports, \"PassThroughClient\", { enumerable: true, get: function () { return passthrough_1.PassThroughClient; } });\nvar gdchclient_1 = require(\"./auth/gdchclient\");\nObject.defineProperty(exports, \"GdchClient\", { enumerable: true, get: function () { return gdchclient_1.GdchClient; } });\nObject.defineProperty(exports, \"GDCH_SERVICE_ACCOUNT_TYPE\", { enumerable: true, get: function () { return gdchclient_1.GDCH_SERVICE_ACCOUNT_TYPE; } });\n__exportStar(require(\"./gtoken/googleToken\"), exports);\nconst auth = new googleauth_1.GoogleAuth();\nexports.auth = auth;\n//# sourceMappingURL=index.js.map", "import { OutputHandler, OutputOptions, ConsoleOutputConfig } from './types';\n\n/**\n * Console output handler\n * Supports colored output and multiple log levels\n */\nexport class ConsoleOutputHandler implements OutputHandler {\n type = 'console' as const;\n private config: ConsoleOutputConfig;\n\n // ANSI color codes\n private colors = {\n reset: '\\x1b[0m',\n bright: '\\x1b[1m',\n dim: '\\x1b[2m',\n red: '\\x1b[31m',\n green: '\\x1b[32m',\n yellow: '\\x1b[33m',\n blue: '\\x1b[34m',\n magenta: '\\x1b[35m',\n cyan: '\\x1b[36m',\n white: '\\x1b[37m'\n };\n\n constructor(config: ConsoleOutputConfig = {}) {\n this.config = {\n colors: true,\n level: 'log',\n ...config\n };\n }\n\n /**\n * Format output data\n */\n private formatData(data: any, options: OutputOptions): string {\n const { format = 'text', timestamp = true, prefix, metadata } = options || {};\n\n // Build prefix\n let output = '';\n\n if (timestamp) {\n const time = new Date().toISOString();\n output += this.config.colors\n ? `${this.colors.cyan}[${time}]${this.colors.reset} `\n : `[${time}] `;\n }\n\n if (prefix) {\n output += this.config.colors\n ? `${this.colors.bright}${prefix}${this.colors.reset} `\n : `${prefix} `;\n }\n\n // Format data\n switch (format) {\n case 'json':\n output += JSON.stringify(data, null, 2);\n break;\n\n case 'markdown':\n if (typeof data === 'object') {\n output += this.toMarkdown(data);\n } else {\n output += String(data);\n }\n break;\n\n case 'text':\n default:\n if (typeof data === 'object') {\n output += JSON.stringify(data, null, 2);\n } else {\n output += String(data);\n }\n break;\n }\n\n // Add metadata\n if (metadata && Object.keys(metadata).length > 0) {\n output += '\\n' + (this.config.colors ? `${this.colors.dim}` : '');\n output += 'Metadata: ' + JSON.stringify(metadata, null, 2);\n if (this.config.colors) output += this.colors.reset;\n }\n\n return output;\n }\n\n /**\n * Convert object to Markdown format\n */\n private toMarkdown(data: any, indent = 0): string {\n const padding = ' '.repeat(indent);\n\n if (Array.isArray(data)) {\n return data.map(item => {\n if (typeof item === 'object') {\n return `${padding}-\\n${this.toMarkdown(item, indent + 1)}`;\n }\n return `${padding}- ${item}`;\n }).join('\\n');\n }\n\n if (typeof data === 'object' && data !== null) {\n return Object.entries(data).map(([key, value]) => {\n if (typeof value === 'object' && value !== null) {\n return `${padding}${key}:\\n${this.toMarkdown(value, indent + 1)}`;\n }\n return `${padding}${key}: ${value}`;\n }).join('\\n');\n }\n\n return `${padding}${data}`;\n }\n\n /**\n * Output data\n */\n async output(data: any, options: OutputOptions = {}): Promise {\n try {\n const formatted = this.formatData(data, options);\n const logMethod = this.config.level || 'log';\n\n // Output based on configured log level\n switch (logMethod) {\n case 'info':\n console.info(formatted);\n break;\n case 'warn':\n console.warn(formatted);\n break;\n case 'error':\n console.error(formatted);\n break;\n case 'debug':\n console.debug(formatted);\n break;\n case 'log':\n default:\n console.log(formatted);\n break;\n }\n\n return true;\n } catch (error) {\n console.error('[ConsoleOutputHandler] Output failed:', error);\n return false;\n }\n }\n}\n", "import { OutputHandler, OutputOptions, WebhookOutputConfig } from './types';\n\n/**\n * Webhook output handler\n * Supports sending data to HTTP endpoints with retry and authentication\n */\nexport class WebhookOutputHandler implements OutputHandler {\n type = 'webhook' as const;\n private config: WebhookOutputConfig;\n private defaultTimeout = 30000; // 30 second default timeout\n private logger: any = null;\n\n setLogger(logger: any): void {\n this.logger = logger;\n if (this.logger) {\n if (typeof this.logger.info === 'function') this.logger.info = this.logger.info.bind(this.logger);\n if (typeof this.logger.warn === 'function') this.logger.warn = this.logger.warn.bind(this.logger);\n if (typeof this.logger.error === 'function') this.logger.error = this.logger.error.bind(this.logger);\n }\n }\n\n constructor(config: WebhookOutputConfig) {\n if (!config.url) {\n throw new Error('Webhook URL is required');\n }\n this.config = {\n method: 'POST',\n retry: {\n maxAttempts: 3,\n backoffMs: 1000\n },\n silent: false,\n ...config\n };\n }\n\n /**\n * Build request headers\n */\n private buildHeaders(): Record {\n const headers: Record = {\n 'Content-Type': 'application/json',\n ...(this.config.headers || {})\n };\n\n // Add authentication headers\n if (this.config.auth) {\n switch (this.config.auth.type) {\n case 'bearer':\n if (this.config.auth.token) {\n headers['Authorization'] = `Bearer ${this.config.auth.token}`;\n }\n break;\n\n case 'basic':\n if (this.config.auth.username && this.config.auth.password) {\n const credentials = Buffer.from(\n `${this.config.auth.username}:${this.config.auth.password}`\n ).toString('base64');\n headers['Authorization'] = `Basic ${credentials}`;\n }\n break;\n\n case 'custom':\n if (this.config.auth.custom) {\n headers[this.config.auth.custom.header] = this.config.auth.custom.value;\n }\n break;\n }\n }\n\n return headers;\n }\n\n /**\n * Build request body\n */\n private buildBody(data: any, options: OutputOptions): any {\n const { timestamp = true, prefix, metadata } = options || {};\n\n const body: any = {\n data\n };\n\n if (timestamp) {\n body.timestamp = new Date().toISOString();\n }\n\n if (prefix) {\n body.prefix = prefix;\n }\n\n if (metadata && Object.keys(metadata).length > 0) {\n body.metadata = metadata;\n }\n\n return body;\n }\n\n /**\n * Send HTTP request\n */\n private async sendRequest(\n url: string,\n method: string,\n headers: Record,\n body: any,\n timeout: number\n ): Promise {\n const controller = new AbortController();\n const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n try {\n const response = await fetch(url, {\n method,\n headers,\n body: JSON.stringify(body),\n signal: controller.signal\n });\n\n clearTimeout(timeoutId);\n\n if (!response.ok) {\n throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n }\n\n return response;\n } catch (error) {\n clearTimeout(timeoutId);\n throw error;\n }\n }\n\n /**\n * Delay function (for retry backoff)\n */\n private delay(ms: number): Promise {\n return new Promise(resolve => setTimeout(resolve, ms));\n }\n\n /**\n * Send request with retry\n */\n private async sendWithRetry(\n url: string,\n method: string,\n headers: Record,\n body: any,\n timeout: number,\n retry: { maxAttempts: number; backoffMs: number }\n ): Promise {\n let lastError: Error | null = null;\n\n for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {\n try {\n return await this.sendRequest(url, method, headers, body, timeout);\n } catch (error) {\n lastError = error as Error;\n\n // If this is the last attempt, throw error directly\n if (attempt === retry.maxAttempts) {\n break;\n }\n\n // Calculate backoff time (exponential backoff)\n const backoffTime = retry.backoffMs * Math.pow(2, attempt - 1);\n\n (this.logger?.warn ?? console.warn)(\n `[WebhookOutputHandler] Request failed (attempt ${attempt}/${retry.maxAttempts}), ` +\n `retrying in ${backoffTime}ms...`,\n (error as Error).message\n );\n\n await this.delay(backoffTime);\n }\n }\n\n throw lastError;\n }\n\n /**\n * Output data to Webhook\n */\n async output(data: any, options: OutputOptions = {}): Promise {\n const timeout = options.timeout || this.defaultTimeout;\n\n try {\n const headers = this.buildHeaders();\n const body = this.buildBody(data, options);\n\n await this.sendWithRetry(\n this.config.url,\n this.config.method!,\n headers,\n body,\n timeout,\n this.config.retry!\n );\n\n return true;\n } catch (error) {\n const errorMessage = error instanceof Error ? error.message : String(error);\n\n if (this.config.silent) {\n (this.logger?.error ?? console.error)(`[WebhookOutputHandler] Failed to send data: ${errorMessage}`);\n return false;\n }\n\n throw new Error(`Webhook output failed: ${errorMessage}`, { cause: error });\n }\n }\n}\n", "import { OutputHandler, OutputOptions } from './types';\nimport { writeFileSync, existsSync, mkdirSync } from 'fs';\nimport { join } from 'path';\nimport { tmpdir } from 'os';\n\n/**\n * Temp file output handler configuration\n */\nexport interface TempFileOutputConfig {\n /**\n * Subdirectory under system temp directory (default: 'claude-code-router')\n */\n subdirectory?: string;\n\n /**\n * File extension (default: 'json')\n */\n extension?: string;\n\n /**\n * Whether to include timestamp in filename (default: true)\n */\n includeTimestamp?: boolean;\n\n /**\n * Custom prefix for temp files (default: 'session')\n */\n prefix?: string;\n}\n\n/**\n * Temp file output handler\n * Writes data to temporary files in system temp directory\n */\nexport class TempFileOutputHandler implements OutputHandler {\n type = 'temp-file' as const;\n private config: TempFileOutputConfig;\n private baseDir: string;\n\n constructor(config: TempFileOutputConfig = {}) {\n this.config = {\n subdirectory: 'claude-code-router',\n extension: 'json',\n includeTimestamp: false,\n prefix: 'session',\n ...config\n };\n\n // Use system temp directory\n const systemTempDir = tmpdir();\n this.baseDir = join(systemTempDir, this.config.subdirectory!);\n\n // Ensure directory exists\n this.ensureDir();\n }\n\n /**\n * Ensure directory exists\n */\n private ensureDir(): void {\n try {\n if (!existsSync(this.baseDir)) {\n mkdirSync(this.baseDir, { recursive: true });\n }\n } catch {\n // Silently fail\n }\n }\n\n /**\n * Extract session ID from user_id string\n * Format: \"user_..._session_\"\n */\n private extractSessionId(userId: string): string | null {\n try {\n const match = userId.match(/_session_([a-f0-9-]+)/i);\n return match ? match[1] : null;\n } catch {\n return null;\n }\n }\n\n /**\n * Get file path for temp file\n */\n private getFilePath(sessionId: string): string {\n const prefix = this.config.prefix || 'session';\n const ext = this.config.extension ? `.${this.config.extension}` : '';\n\n let filename: string;\n if (this.config.includeTimestamp) {\n // Include timestamp in filename: prefix-sessionId-timestamp.ext\n const timestamp = Date.now();\n filename = `${prefix}-${sessionId}-${timestamp}${ext}`;\n } else {\n // Simple filename: prefix-sessionId.ext\n filename = `${prefix}-${sessionId}${ext}`;\n }\n\n return join(this.baseDir, filename);\n }\n\n /**\n * Output data to temp file\n */\n async output(data: any, options: OutputOptions = {}): Promise {\n try {\n // Extract session ID from metadata\n const sessionId = options.metadata?.sessionId;\n\n if (!sessionId) {\n // No session ID, skip output\n return false;\n }\n\n // Prepare output data\n const outputData = {\n ...data,\n timestamp: Date.now(),\n sessionId\n };\n\n // Write to file\n const filePath = this.getFilePath(sessionId);\n writeFileSync(filePath, JSON.stringify(outputData, null, 2), 'utf-8');\n\n return true;\n } catch {\n // Silently fail to avoid disrupting main flow\n return false;\n }\n }\n\n /**\n * Get the base directory where temp files are stored\n */\n getBaseDir(): string {\n return this.baseDir;\n }\n}\n", "import { OutputHandler, OutputOptions, OutputHandlerConfig } from './types';\nimport { ConsoleOutputHandler } from './console-handler';\nimport { WebhookOutputHandler } from './webhook-handler';\nimport { TempFileOutputHandler } from './temp-file-handler';\n\n/**\n * Output manager\n * Manages multiple output handlers and provides unified output interface\n */\nclass OutputManager {\n private handlers: Map = new Map();\n private defaultOptions: OutputOptions = {};\n private logger: any = null;\n\n setLogger(logger: any): void {\n this.logger = logger;\n if (this.logger) {\n if (typeof this.logger.info === 'function') this.logger.info = this.logger.info.bind(this.logger);\n if (typeof this.logger.warn === 'function') this.logger.warn = this.logger.warn.bind(this.logger);\n if (typeof this.logger.error === 'function') this.logger.error = this.logger.error.bind(this.logger);\n }\n }\n\n /**\n * Register output handler\n * @param name Output handler name\n * @param handler Output handler instance\n */\n registerHandler(name: string, handler: OutputHandler): void {\n this.handlers.set(name, handler);\n }\n\n /**\n * Register output handlers in batch\n * @param configs Output handler configuration array\n */\n registerHandlers(configs: OutputHandlerConfig[]): void {\n for (const config of configs) {\n if (config.enabled === false) {\n continue;\n }\n\n try {\n const handler = this.createHandler(config);\n const name = config.type + '_' + Date.now();\n this.registerHandler(name, handler);\n } catch (error) {\n (this.logger?.error ?? console.error)(`[OutputManager] Failed to register ${config.type} handler:`, error);\n }\n }\n }\n\n /**\n * Create output handler instance\n * @param config Output handler configuration\n */\n private createHandler(config: OutputHandlerConfig): OutputHandler {\n let handler: OutputHandler;\n\n switch (config.type) {\n case 'console':\n handler = new ConsoleOutputHandler(config.config as any);\n break;\n\n case 'webhook':\n handler = new WebhookOutputHandler(config.config as any);\n break;\n\n case 'temp-file':\n handler = new TempFileOutputHandler(config.config as any);\n break;\n\n // Reserved for other output handler types\n // case 'websocket':\n // return new WebSocketOutputHandler(config.config as any);\n\n default:\n throw new Error(`Unknown output handler type: ${config.type}`);\n }\n\n if (this.logger && typeof (handler as any).setLogger === 'function') {\n (handler as any).setLogger(this.logger);\n }\n return handler;\n }\n\n /**\n * Remove output handler\n * @param name Output handler name\n */\n unregisterHandler(name: string): boolean {\n return this.handlers.delete(name);\n }\n\n /**\n * Get output handler\n * @param name Output handler name\n */\n getHandler(name: string): OutputHandler | undefined {\n return this.handlers.get(name);\n }\n\n /**\n * Get all output handlers\n */\n getAllHandlers(): Map {\n return new Map(this.handlers);\n }\n\n /**\n * Clear all output handlers\n */\n clearHandlers(): void {\n this.handlers.clear();\n }\n\n /**\n * Set default output options\n * @param options Output options\n */\n setDefaultOptions(options: OutputOptions): void {\n this.defaultOptions = { ...this.defaultOptions, ...options };\n }\n\n /**\n * Get default output options\n */\n getDefaultOptions(): OutputOptions {\n return { ...this.defaultOptions };\n }\n\n /**\n * Output data to all registered output handlers\n * @param data Data to output\n * @param options Output options\n * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers\n */\n async output(\n data: any,\n options?: OutputOptions\n ): Promise<{ success: string[]; failed: string[] }> {\n const mergedOptions = { ...this.defaultOptions, ...options };\n const results = { success: [] as string[], failed: [] as string[] };\n\n // Send data to all handlers in parallel\n const promises = Array.from(this.handlers.entries()).map(\n async ([name, handler]) => {\n try {\n const success = await handler.output(data, mergedOptions);\n if (success) {\n results.success.push(name);\n } else {\n results.failed.push(name);\n }\n } catch (error) {\n (this.logger?.error ?? console.error)(`[OutputManager] Handler ${name} failed:`, error);\n results.failed.push(name);\n }\n }\n );\n\n await Promise.all(promises);\n return results;\n }\n\n /**\n * Output data to specified output handlers\n * @param handlerNames Array of output handler names\n * @param data Data to output\n * @param options Output options\n * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers\n */\n async outputTo(\n handlerNames: string[],\n data: any,\n options?: OutputOptions\n ): Promise<{ success: string[]; failed: string[] }> {\n const mergedOptions = { ...this.defaultOptions, ...options };\n const results = { success: [] as string[], failed: [] as string[] };\n\n const promises = handlerNames.map(async name => {\n const handler = this.handlers.get(name);\n if (!handler) {\n (this.logger?.warn ?? console.warn)(`[OutputManager] Handler ${name} not found`);\n results.failed.push(name);\n return;\n }\n\n try {\n const success = await handler.output(data, mergedOptions);\n if (success) {\n results.success.push(name);\n } else {\n results.failed.push(name);\n }\n } catch (error) {\n (this.logger?.error ?? console.error)(`[OutputManager] Handler ${name} failed:`, error);\n results.failed.push(name);\n }\n });\n\n await Promise.all(promises);\n return results;\n }\n\n /**\n * Output data to specified type of output handlers\n * @param type Output handler type\n * @param data Data to output\n * @param options Output options\n * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers\n */\n async outputToType(\n type: string,\n data: any,\n options?: OutputOptions\n ): Promise<{ success: string[]; failed: string[] }> {\n const targetHandlers = Array.from(this.handlers.entries())\n .filter(([_, handler]) => handler.type === type)\n .map(([name]) => name);\n\n return this.outputTo(targetHandlers, data, options);\n }\n}\n\n/**\n * Global output manager instance\n */\nexport const outputManager = new OutputManager();\n\n/**\n * Convenience method: Quickly output data to all registered handlers\n * @param data Data to output\n * @param options Output options\n */\nexport async function output(data: any, options?: OutputOptions) {\n return outputManager.output(data, options);\n}\n\n/**\n * Convenience method: Quickly output data to specified type of handlers\n * @param type Output handler type ('console' | 'webhook' | 'websocket')\n * @param data Data to output\n * @param options Output options\n */\nexport async function outputTo(type: string, data: any, options?: OutputOptions) {\n return outputManager.outputToType(type, data, options);\n}\n", "import Fastify, {\n FastifyInstance,\n FastifyPluginAsync,\n FastifyPluginCallback,\n FastifyPluginOptions,\n FastifyRegisterOptions,\n preHandlerHookHandler,\n onRequestHookHandler,\n preParsingHookHandler,\n preValidationHookHandler,\n preSerializationHookHandler,\n onSendHookHandler,\n onResponseHookHandler,\n onTimeoutHookHandler,\n onErrorHookHandler,\n onRouteHookHandler,\n onRegisterHookHandler,\n onReadyHookHandler,\n onListenHookHandler,\n onCloseHookHandler,\n FastifyServerOptions,\n} from \"fastify\";\nimport cors from \"@fastify/cors\";\nimport rateLimit from \"@fastify/rate-limit\";\nimport { RATE_LIMIT_CONFIG } from \"@caeliq/ccr-shared\";\nimport { ConfigService, AppConfig } from \"./services/config\";\nimport { errorHandler } from \"./api/middleware\";\nimport { registerApiRoutes } from \"./api/routes\";\nimport { ProviderService } from \"./services/provider\";\nimport { TransformerService } from \"./services/transformer\";\nimport { TokenizerService } from \"./services/tokenizer\";\nimport { router, calculateTokenCount, searchProjectBySession } from \"./utils/router\";\nimport { sessionUsageCache } from \"./utils/cache\";\nimport { matchClientProtocol } from \"./routing/protocol-endpoints\";\nimport {\n logMessageBody,\n resolveLogBodyMaxBytes,\n resolveLogBodySelection,\n} from \"./utils/message-debug\";\n\n// Extend FastifyRequest to include custom properties\ndeclare module \"fastify\" {\n interface FastifyRequest {\n provider?: string;\n model?: string;\n scenarioType?: string;\n }\n interface FastifyInstance {\n _server?: Server;\n }\n}\n\ninterface ServerOptions extends FastifyServerOptions {\n initialConfig?: AppConfig;\n}\n\n// Application factory\nfunction createApp(options: FastifyServerOptions = {}): FastifyInstance {\n const fastify = Fastify({\n bodyLimit: 50 * 1024 * 1024,\n ...options,\n });\n\n // Register error handler\n fastify.setErrorHandler(errorHandler);\n\n // Register CORS\n fastify.register(cors);\n\n fastify.register(rateLimit, {\n global: true,\n ...RATE_LIMIT_CONFIG,\n });\n\n return fastify;\n}\n\n// Server class\nclass Server {\n app: FastifyInstance;\n configService: ConfigService;\n providerService!: ProviderService;\n transformerService: TransformerService;\n tokenizerService: TokenizerService;\n\n constructor(options: ServerOptions = {}) {\n // `initialConfig` is forwarded to ConfigService below via `...options`; keep it out of Fastify options.\n const { initialConfig: _initialConfig, ...fastifyOptions } = options;\n this.app = createApp({\n ...fastifyOptions,\n logger: fastifyOptions.logger ?? true,\n });\n this.configService = new ConfigService({\n ...options,\n logger: this.app.log,\n });\n this.transformerService = new TransformerService(\n this.configService,\n this.app.log\n );\n this.tokenizerService = new TokenizerService(\n this.configService,\n this.app.log\n );\n this.transformerService.initialize().finally(() => {\n this.providerService = new ProviderService(\n this.configService,\n this.transformerService,\n this.app.log\n );\n });\n // Initialize tokenizer service\n this.tokenizerService.initialize().catch((error) => {\n this.app.log.error(`Failed to initialize TokenizerService: ${error}`);\n });\n }\n\n async register(\n plugin: FastifyPluginAsync | FastifyPluginCallback,\n options?: FastifyRegisterOptions\n ): Promise {\n await (this.app as any).register(plugin, options);\n }\n\n addHook(hookName: \"onRequest\", hookFunction: onRequestHookHandler): void;\n addHook(hookName: \"preParsing\", hookFunction: preParsingHookHandler): void;\n addHook(\n hookName: \"preValidation\",\n hookFunction: preValidationHookHandler\n ): void;\n addHook(hookName: \"preHandler\", hookFunction: preHandlerHookHandler): void;\n addHook(\n hookName: \"preSerialization\",\n hookFunction: preSerializationHookHandler\n ): void;\n addHook(hookName: \"onSend\", hookFunction: onSendHookHandler): void;\n addHook(hookName: \"onResponse\", hookFunction: onResponseHookHandler): void;\n addHook(hookName: \"onTimeout\", hookFunction: onTimeoutHookHandler): void;\n addHook(hookName: \"onError\", hookFunction: onErrorHookHandler): void;\n addHook(hookName: \"onRoute\", hookFunction: onRouteHookHandler): void;\n addHook(hookName: \"onRegister\", hookFunction: onRegisterHookHandler): void;\n addHook(hookName: \"onReady\", hookFunction: onReadyHookHandler): void;\n addHook(hookName: \"onListen\", hookFunction: onListenHookHandler): void;\n addHook(hookName: \"onClose\", hookFunction: onCloseHookHandler): void;\n public addHook(hookName: string, hookFunction: any): void {\n this.app.addHook(hookName as any, hookFunction);\n }\n\n public async registerNamespace(name: string, options?: any) {\n if (!name) throw new Error(\"name is required\");\n if (name === '/') {\n await this.app.register(async (fastify) => {\n fastify.decorate('configService', this.configService);\n fastify.decorate('transformerService', this.transformerService);\n fastify.decorate('providerService', this.providerService);\n fastify.decorate('tokenizerService', this.tokenizerService);\n await registerApiRoutes(fastify);\n });\n return\n }\n if (!options) throw new Error(\"options is required\");\n const configService = new ConfigService({\n initialConfig: {\n providers: options.Providers,\n Router: options.Router,\n }\n });\n const transformerService = new TransformerService(\n configService,\n this.app.log\n );\n await transformerService.initialize();\n const providerService = new ProviderService(\n configService,\n transformerService,\n this.app.log\n );\n const tokenizerService = new TokenizerService(\n configService,\n this.app.log\n );\n await tokenizerService.initialize();\n await this.app.register(async (fastify) => {\n fastify.decorate('configService', configService);\n fastify.decorate('transformerService', transformerService);\n fastify.decorate('providerService', providerService);\n fastify.decorate('tokenizerService', tokenizerService);\n await registerApiRoutes(fastify);\n }, { prefix: name });\n }\n\n async start(): Promise {\n try {\n this.app._server = this;\n\n this.app.addHook(\"preHandler\", (req, reply, done) => {\n const url = new URL(`http://127.0.0.1${req.url}`);\n const match = matchClientProtocol(req.method, url.pathname);\n if (match && req.body) {\n const body = req.body as any;\n const selection = resolveLogBodySelection(this.configService);\n if (selection !== undefined) {\n logMessageBody(body, {\n logger: req.log,\n direction: \"client\u2192ccr\",\n level: \"debug\",\n reqId: req.id,\n protocol: match.protocol,\n model: typeof body?.model === \"string\" ? body.model : undefined,\n maxBytes: resolveLogBodyMaxBytes(this.configService),\n selection,\n });\n } else if (match.protocol === \"anthropic_messages\") {\n // Legacy Messages-only info log when body capture is not opted in.\n req.log.info({ data: body, type: \"request body\" });\n }\n if (match.protocol === \"anthropic_messages\" && !body.stream) {\n body.stream = false;\n }\n }\n done();\n });\n\n await this.registerNamespace('/')\n\n\n const address = await this.app.listen({\n port: parseInt(this.configService.get(\"PORT\") || \"3000\", 10),\n host: this.configService.get(\"HOST\") || \"127.0.0.1\",\n });\n\n this.app.log.info(`\uD83D\uDE80 LLMs API server listening on ${address}`);\n\n const shutdown = async (signal: string) => {\n this.app.log.info(`Received ${signal}, shutting down gracefully...`);\n await this.app.close();\n process.exit(0);\n };\n\n process.on(\"SIGINT\", () => shutdown(\"SIGINT\"));\n process.on(\"SIGTERM\", () => shutdown(\"SIGTERM\"));\n } catch (error) {\n this.app.log.error(`Error starting server: ${error}`);\n process.exit(1);\n }\n }\n}\n\n// Export for external use\nexport default Server;\nexport { sessionUsageCache };\nexport { closeProxyDispatchers } from \"./utils/request\";\nexport { closeTokenCountWorkers } from \"./utils/token-count-worker\";\nexport { router };\nexport { calculateTokenCount };\nexport { searchProjectBySession };\nexport type { RouterScenarioType, RouterFallbackConfig } from \"./utils/router\";\nexport { ConfigService } from \"./services/config\";\nexport { ProviderService } from \"./services/provider\";\nexport { TransformerService } from \"./services/transformer\";\nexport { TokenizerService } from \"./services/tokenizer\";\nexport { pluginManager, tokenSpeedPlugin, getTokenSpeedStats, getGlobalTokenSpeedStats, CCRPlugin, CCRPluginOptions, PluginMetadata } from \"./plugins\";\nexport { SSEParserTransform, SSESerializerTransform, rewriteStream } from \"./utils/sse\";\nexport { isClientAbortError } from \"./utils/retry\";\nexport {\n sanitizeHeadersForLog,\n diffHeadersForLog,\n sanitizeBodyForLog,\n DEFAULT_LOG_BODY_MAX_BYTES,\n} from \"./utils/redact\";\nexport {\n logMessageBody,\n bodyToLogString,\n shouldLogSSEEvents,\n resolveLogBodyMaxBytes,\n resolveLogBodySelection,\n isTruthyConfigFlag,\n type MessageDebugDirection,\n} from \"./utils/message-debug\";\nexport {\n tapUpstreamSSEDebug,\n tapClientSSEDebug,\n} from \"./utils/sse-debug-tap\";\nexport {\n exchangeAuthorizationCode,\n fetchUserEmail,\n resolveProjectId,\n saveTokens,\n loadTokens,\n getValidAccessToken,\n getValidAccessToken as getAntigravityAccessToken,\n ANTIGRAVITY_CLIENT_ID,\n ANTIGRAVITY_CLIENT_SECRET,\n ANTIGRAVITY_REDIRECT_URI,\n ANTIGRAVITY_SCOPES,\n type AntigravityTokens,\n} from \"./utils/antigravity-auth\";\nexport { getValidAccessToken as getClaudeAccessToken } from \"./utils/claude-auth\";\nexport {\n getValidAccessToken as getCodexAccessToken,\n} from \"./utils/codex-auth\";\nexport { getValidAccessToken as getQwenAccessToken } from \"./utils/qwen-auth\";\nexport { getValidAccessToken as getXaiAccessToken } from \"./utils/xai-auth\";\nexport {\n matchClientProtocol,\n isRoutedLlmPost,\n listClientRouteRegistrations,\n type ClientProtocol,\n type ClientProtocolContext,\n type ProtocolRouteMatch,\n} from \"./routing/protocol-endpoints\";\nexport { protocolErrorBody } from \"./routing/protocol-errors\";\nexport { setHealthReporter } from \"./utils/health-reporter\";\nexport type { HealthReporter } from \"./utils/health-reporter\";\n", "import { readFileSync, existsSync } from \"fs\";\nimport { join } from \"path\";\nimport { config } from \"dotenv\";\nimport JSON5 from 'json5';\n\nexport interface ConfigOptions {\n envPath?: string;\n jsonPath?: string;\n useEnvFile?: boolean;\n useJsonFile?: boolean;\n useEnvironmentVariables?: boolean;\n initialConfig?: AppConfig;\n logger?: any;\n}\n\nexport interface AppConfig {\n [key: string]: any;\n}\n\nexport class ConfigService {\n private config: AppConfig = {};\n private options: ConfigOptions;\n private logger: any;\n\n constructor(\n options: ConfigOptions = {\n jsonPath: \"./config.json\",\n }\n ) {\n this.options = {\n envPath: options.envPath || \".env\",\n jsonPath: options.jsonPath,\n useEnvFile: false,\n useJsonFile: options.useJsonFile !== false,\n useEnvironmentVariables: options.useEnvironmentVariables !== false,\n ...options,\n };\n this.logger = options.logger;\n // Bind logger methods to preserve context (needed for Pino)\n if (this.logger) {\n if (typeof this.logger.info === 'function') this.logger.info = this.logger.info.bind(this.logger);\n if (typeof this.logger.warn === 'function') this.logger.warn = this.logger.warn.bind(this.logger);\n if (typeof this.logger.error === 'function') this.logger.error = this.logger.error.bind(this.logger);\n }\n \n this.loadConfig();\n }\n\n private loadConfig(): void {\n if (this.options.useJsonFile && this.options.jsonPath) {\n this.loadJsonConfig();\n }\n\n if (this.options.initialConfig) {\n this.config = { ...this.config, ...this.options.initialConfig };\n }\n\n if (this.options.useEnvFile) {\n this.loadEnvConfig();\n }\n\n // if (this.options.useEnvironmentVariables) {\n // this.loadEnvironmentVariables();\n // }\n\n if (this.config.LOG_FILE) {\n process.env.LOG_FILE = this.config.LOG_FILE;\n }\n if (this.config.LOG) {\n process.env.LOG = this.config.LOG;\n }\n }\n\n private loadJsonConfig(): void {\n if (!this.options.jsonPath) return;\n\n const jsonPath = this.isAbsolutePath(this.options.jsonPath)\n ? this.options.jsonPath\n : join(process.cwd(), this.options.jsonPath);\n\n if (existsSync(jsonPath)) {\n try {\n const jsonContent = readFileSync(jsonPath, \"utf-8\");\n const jsonConfig = JSON5.parse(jsonContent);\n this.config = { ...this.config, ...jsonConfig };\n (this.logger?.info ?? console.log)(`Loaded JSON config from: ${jsonPath}`);\n } catch (error) {\n (this.logger?.warn ?? console.warn)(`Failed to load JSON config from ${jsonPath}:`, error);\n }\n } else {\n (this.logger?.warn ?? console.warn)(`JSON config file not found: ${jsonPath}`);\n }\n }\n\n private loadEnvConfig(): void {\n const envPath = this.isAbsolutePath(this.options.envPath!)\n ? this.options.envPath!\n : join(process.cwd(), this.options.envPath!);\n\n if (existsSync(envPath)) {\n try {\n const result = config({ path: envPath });\n if (result.parsed) {\n this.config = {\n ...this.config,\n ...this.parseEnvConfig(result.parsed),\n };\n }\n } catch (error) {\n (this.logger?.warn ?? console.warn)(`Failed to load .env config from ${envPath}:`, error);\n }\n }\n }\n\n private loadEnvironmentVariables(): void {\n const envConfig = this.parseEnvConfig(process.env);\n this.config = { ...this.config, ...envConfig };\n }\n\n private parseEnvConfig(\n env: Record\n ): Partial {\n const parsed: Partial = {};\n\n Object.assign(parsed, env);\n\n return parsed;\n }\n\n private isAbsolutePath(path: string): boolean {\n return path.startsWith(\"/\") || path.includes(\":\");\n }\n\n public get(key: keyof AppConfig): T | undefined;\n public get(key: keyof AppConfig, defaultValue: T): T;\n public get(key: keyof AppConfig, defaultValue?: T): T | undefined {\n const value = this.config[key];\n return value !== undefined ? (value as T) : defaultValue;\n }\n\n public getAll(): AppConfig {\n return { ...this.config };\n }\n\n public getHttpsProxy(): string | undefined {\n return (\n this.get(\"HTTPS_PROXY\") ||\n this.get(\"https_proxy\") ||\n this.get(\"httpsProxy\") ||\n this.get(\"PROXY_URL\")\n );\n }\n\n public has(key: keyof AppConfig): boolean {\n return this.config[key] !== undefined;\n }\n\n public set(key: keyof AppConfig, value: any): void {\n this.config[key] = value;\n }\n\n public reload(): void {\n this.config = {};\n this.loadConfig();\n }\n\n public getConfigSummary(): string {\n const summary: string[] = [];\n\n if (this.options.initialConfig) {\n summary.push(\"Initial Config\");\n }\n\n if (this.options.useJsonFile && this.options.jsonPath) {\n summary.push(`JSON: ${this.options.jsonPath}`);\n }\n\n if (this.options.useEnvFile) {\n summary.push(`ENV: ${this.options.envPath}`);\n }\n\n if (this.options.useEnvironmentVariables) {\n summary.push(\"Environment Variables\");\n }\n\n return `Config sources: ${summary.join(\", \")}`;\n }\n}\n", "/**\n * Privacy-safe redaction for upstream errors and debug logs.\n * Keep enough diagnostic signal (status, error type) without leaking secrets.\n */\n\nconst SENSITIVE_JSON_KEYS =\n \"(?:proxy[-_])?authorization|x[-_]?api[-_]?key|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|client[-_]?secret|secret|password|passwd|token|cookie|set[-_]?cookie\";\n\nexport function sanitizeUpstreamErrorText(value: string): string {\n return value\n .replace(/\\b(?:https?|wss?):\\/\\/[^\\s\"'<>]+/gi, \"[redacted-url]\")\n .replace(/\\bBearer\\s+[A-Za-z0-9._~+/=-]{8,}/gi, \"Bearer [redacted]\")\n .replace(/\\b(?:sk|rk|pk)-[A-Za-z0-9_-]{12,}/gi, \"[redacted-secret]\")\n .replace(\n new RegExp(\n `\"(${SENSITIVE_JSON_KEYS})\"\\\\s*:\\\\s*\"(?:\\\\\\\\.|[^\"\\\\\\\\])*\"`,\n \"gi\"\n ),\n '\"$1\":\"[redacted]\"'\n )\n .replace(\n /\\b(?:authorization|x-api-key|api-key|api_key|access_token|token)\\s*[:=]\\s*[\"']?[^\\s,;\"']+/gi,\n (match) => `${match.split(/\\s*[:=]/, 1)[0]}=[redacted]`\n )\n .replace(/\\[[0-9a-f:]+\\](?::\\d+)?/gi, \"[redacted-address]\")\n .replace(/\\b(?:\\d{1,3}\\.){3}\\d{1,3}(?::\\d+)?\\b/g, \"[redacted-address]\")\n .replace(\n /\\b(connect(?:ing)?(?:\\s+to)?|from|to)\\s+(?:localhost|(?:[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?\\.)+[a-z]{2,63})(?::\\d+)?\\b/gi,\n \"$1 [redacted-address]\"\n )\n .replace(/([?&](?:api_?key|key|token|access_token|auth)=)[^&\\s]+/gi, \"$1[redacted]\")\n .replace(/\\s+/g, \" \")\n .trim()\n .slice(0, 240);\n}\n\nconst SENSITIVE_BODY_KEY = new RegExp(`^(?:${SENSITIVE_JSON_KEYS})$`, \"i\");\n\nconst MAX_BODY_DEPTH = 6;\nconst MAX_BODY_ARRAY_ITEMS = 20;\n\n/**\n * Deep-sanitize a parsed upstream error body before it is logged or\n * serialized to a client: secret-bearing keys are redacted outright and\n * every string value passes through sanitizeUpstreamErrorText. Depth and\n * array length are bounded so an adversarial body cannot balloon.\n */\nexport function sanitizeUpstreamErrorBody(\n value: unknown,\n depth: number = 0\n): unknown {\n if (value == null) return value;\n if (depth > MAX_BODY_DEPTH) return undefined;\n if (typeof value === \"string\") return sanitizeUpstreamErrorText(value);\n if (Array.isArray(value)) {\n return value\n .slice(0, MAX_BODY_ARRAY_ITEMS)\n .map((item) => sanitizeUpstreamErrorBody(item, depth + 1));\n }\n if (typeof value === \"object\") {\n const out: Record = {};\n for (const [key, entry] of Object.entries(\n value as Record\n )) {\n out[key] = SENSITIVE_BODY_KEY.test(key)\n ? \"[redacted]\"\n : sanitizeUpstreamErrorBody(entry, depth + 1);\n }\n return out;\n }\n return value;\n}\n\n/** Default cap for a single logged request body. */\nexport const DEFAULT_LOG_BODY_MAX_BYTES = 32768;\n\n/**\n * Redact secrets from a request body that is about to be logged verbatim.\n *\n * Unlike sanitizeUpstreamErrorText this preserves whitespace, newlines and\n * full string values: the point of body capture is to read prompts and\n * message content back, so per-string truncation would defeat it. Only\n * secret-bearing patterns are rewritten, then the whole payload is capped.\n */\nexport function sanitizeBodyForLog(\n value: string,\n maxBytes: number = DEFAULT_LOG_BODY_MAX_BYTES\n): string {\n const redacted = value\n .replace(/\\bBearer\\s+[A-Za-z0-9._~+/=-]{8,}/gi, \"Bearer [redacted]\")\n .replace(/\\b(?:sk|rk|pk)-[A-Za-z0-9_-]{12,}/gi, \"[redacted-secret]\")\n // Responses reasoning ciphertext is huge and useless for UI/debug of\n // thinking text; keep the key so include/pass-through is still visible.\n .replace(\n /\"encrypted_content\"\\s*:\\s*\"(?:\\\\.|[^\"\\\\])*\"/gi,\n '\"encrypted_content\":\"[redacted-encrypted]\"'\n )\n .replace(\n new RegExp(\n `\"(${SENSITIVE_JSON_KEYS})\"\\\\s*:\\\\s*\"(?:\\\\\\\\.|[^\"\\\\\\\\])*\"`,\n \"gi\"\n ),\n '\"$1\":\"[redacted]\"'\n );\n\n const limit = Math.max(0, maxBytes);\n if (redacted.length <= limit) return redacted;\n const dropped = redacted.length - limit;\n return `${redacted.slice(0, limit)}\u2026[truncated ${dropped} bytes]`;\n}\n\nfunction sanitizeMultiline(value: string, maxLength: number): string {\n return value\n .split(\"\\n\")\n .map((line) => sanitizeUpstreamErrorText(line))\n .filter(Boolean)\n .join(\"\\n\")\n .slice(0, maxLength);\n}\n\nexport function sanitizeErrorForLog(error: unknown): {\n message: string;\n code?: string;\n type?: string;\n name?: string;\n statusCode?: number;\n stack?: string;\n cause?: string;\n} {\n const err = error as any;\n const rawMessage =\n typeof err?.message === \"string\"\n ? err.message\n : typeof error === \"string\"\n ? error\n : String(error);\n const rawCause =\n typeof err?.cause?.message === \"string\"\n ? err.cause.message\n : typeof err?.cause === \"string\"\n ? err.cause\n : undefined;\n return {\n message: sanitizeUpstreamErrorText(rawMessage) || \"Unknown error\",\n code: typeof err?.code === \"string\" ? err.code : undefined,\n type: typeof err?.type === \"string\" ? err.type : undefined,\n name: typeof err?.name === \"string\" ? err.name : undefined,\n statusCode:\n typeof err?.statusCode === \"number\" ? err.statusCode : undefined,\n stack:\n typeof err?.stack === \"string\"\n ? sanitizeMultiline(err.stack, 4_000)\n : undefined,\n cause: rawCause ? sanitizeUpstreamErrorText(rawCause) : undefined,\n };\n}\n\n\nconst SENSITIVE_HEADER_NAME =\n /^(?:authorization|x-api-key|api-key|cookie|set-cookie)$|token|secret|password|passwd/i;\n\nfunction isSensitiveHeaderName(name: string): boolean {\n return SENSITIVE_HEADER_NAME.test(name);\n}\n\n/** Flatten Fastify/Node header values to a single string for logging. */\nexport function normalizeHeaderValue(value: unknown): string | undefined {\n if (value == null) return undefined;\n if (Array.isArray(value)) {\n const parts = value\n .filter((v) => v != null && String(v).length > 0)\n .map((v) => String(v));\n return parts.length ? parts.join(\", \") : undefined;\n }\n const s = String(value);\n return s.length ? s : undefined;\n}\n\n/** Strip auth headers from a headers object for debug logging. */\nexport function sanitizeHeadersForLog(\n headers: Headers | Record | undefined\n): Record {\n const out: Record = {};\n if (!headers) return out;\n\n const entries: Array<[string, unknown]> =\n typeof (headers as Headers).forEach === \"function\" &&\n typeof (headers as any).entries === \"function\"\n ? Array.from((headers as any).entries() as Iterable<[string, unknown]>)\n : Object.entries(headers as Record);\n\n for (const [key, value] of entries) {\n const normalized = normalizeHeaderValue(value);\n if (normalized == null) continue;\n if (isSensitiveHeaderName(key)) {\n out[key] = \"[redacted]\";\n continue;\n }\n out[key] = normalized;\n }\n return out;\n}\n\n/**\n * Compare two header maps (case-insensitive names).\n * Values are sanitized the same way as sanitizeHeadersForLog.\n */\nexport function diffHeadersForLog(\n left: Headers | Record | undefined,\n right: Headers | Record | undefined\n): {\n onlyInLeft: Record;\n onlyInRight: Record;\n changed: Record;\n sameCount: number;\n} {\n const a = sanitizeHeadersForLog(left);\n const b = sanitizeHeadersForLog(right);\n const aMap = new Map(\n Object.entries(a).map(([k, v]) => [k.toLowerCase(), { key: k, value: v }])\n );\n const bMap = new Map(\n Object.entries(b).map(([k, v]) => [k.toLowerCase(), { key: k, value: v }])\n );\n\n const onlyInLeft: Record = {};\n const onlyInRight: Record = {};\n const changed: Record = {};\n let sameCount = 0;\n\n for (const [lk, { key, value }] of aMap) {\n const other = bMap.get(lk);\n if (!other) {\n onlyInLeft[key] = value;\n continue;\n }\n if (other.value === value) {\n sameCount += 1;\n } else {\n changed[key] = { from: value, to: other.value };\n }\n }\n for (const [rk, { key, value }] of bMap) {\n if (!aMap.has(rk)) {\n onlyInRight[key] = value;\n }\n }\n\n return { onlyInLeft, onlyInRight, changed, sameCount };\n}\n", "import type { FastifyReply, FastifyRequest } from \"fastify\";\n\nconst RETRY_BACKOFF_BASE_MS = 1_000;\nconst RETRY_BACKOFF_MAX_MS = 30_000;\nconst RETRY_AFTER_MAX_MS = 60_000;\n\nexport const CLIENT_DISCONNECT_REASON = \"client disconnected\";\n\nexport type ClientDisconnectHandle = {\n signal: AbortSignal;\n /** Attach response close/error listeners for the full upstream lifecycle. */\n arm: () => void;\n};\n\nexport function delay(ms: number, signal?: AbortSignal): Promise {\n if (ms <= 0) return Promise.resolve();\n if (signal?.aborted) {\n return Promise.reject(Object.assign(new Error(\"Aborted\"), { name: \"AbortError\", code: \"ABORT_ERR\" }));\n }\n\n return new Promise((resolve, reject) => {\n const timer = setTimeout(() => {\n if (signal) {\n signal.removeEventListener(\"abort\", onAbort);\n }\n resolve();\n }, ms);\n\n const onAbort = () => {\n clearTimeout(timer);\n reject(Object.assign(new Error(\"Aborted\"), { name: \"AbortError\", code: \"ABORT_ERR\" }));\n };\n\n if (signal) {\n signal.addEventListener(\"abort\", onAbort, { once: true });\n }\n });\n}\n\n/**\n * AbortSignal that fires when the HTTP client disconnects mid-response.\n * Used to cancel upstream provider fetches and tear down streams.\n *\n * Important: never treat request close/destroyed state as a disconnect after\n * Fastify has parsed the body. A response `close` event is also insufficient by\n * itself: only abort when the response or its socket is actually gone.\n */\nexport function createClientDisconnectSignal(\n _req: FastifyRequest,\n reply?: FastifyReply\n): ClientDisconnectHandle {\n const controller = new AbortController();\n const rawRes = reply?.raw;\n let armed = false;\n\n const onAbort = (reason: string = CLIENT_DISCONNECT_REASON) => {\n if (!controller.signal.aborted) {\n controller.abort(reason);\n }\n };\n\n const arm = () => {\n if (armed) return;\n armed = true;\n\n if (!rawRes) return;\n // Only the response socket matters here. Fastify sets req.raw.destroyed\n // after JSON body parsing while the client is still connected \u2014 checking\n // that falsely aborted OpenCode/Zen fetches as \"already destroyed\".\n if (isRawResponseGone(rawRes)) {\n onAbort(`${CLIENT_DISCONNECT_REASON} (already destroyed)`);\n return;\n }\n\n rawRes.on(\"close\", () => {\n if (!rawRes.writableEnded && isRawResponseGone(rawRes)) {\n onAbort(`${CLIENT_DISCONNECT_REASON} (response close)`);\n }\n });\n rawRes.on(\"error\", (err: any) => {\n if (\n err?.code === \"EPIPE\" ||\n err?.code === \"ECONNRESET\" ||\n err?.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n isClientAbortError(err)\n ) {\n onAbort(`${CLIENT_DISCONNECT_REASON} (response error)`);\n }\n });\n };\n\n return { signal: controller.signal, arm };\n}\n\nexport function parseRetryAfterHeaderMs(\n value: string | null | undefined\n): number | undefined {\n const trimmed = value?.trim();\n if (!trimmed) return undefined;\n const seconds = Number(trimmed);\n if (Number.isFinite(seconds) && seconds >= 0) {\n return Math.min(seconds * 1000, RETRY_AFTER_MAX_MS);\n }\n const retryAt = Date.parse(trimmed);\n if (!Number.isFinite(retryAt)) return undefined;\n return Math.min(Math.max(0, retryAt - Date.now()), RETRY_AFTER_MAX_MS);\n}\n\nexport function exponentialRetryBackoffMs(failedAttemptIndex: number): number {\n const exponent = Math.min(10, Math.max(0, failedAttemptIndex));\n return Math.min(RETRY_BACKOFF_MAX_MS, RETRY_BACKOFF_BASE_MS * 2 ** exponent);\n}\n\n/** Prefer Retry-After when present; otherwise exponential backoff. */\nexport function retryDelayAfterFailure(\n failedAttemptIndex: number,\n retryAfterHeader?: string | null\n): number {\n const retryAfterMs = parseRetryAfterHeaderMs(retryAfterHeader);\n if (retryAfterMs !== undefined && retryAfterMs > 0) {\n return retryAfterMs;\n }\n return exponentialRetryBackoffMs(failedAttemptIndex);\n}\n\nexport function selectFallbackModels(\n fallbackConfig: Record | undefined,\n scenarioType: string\n): string[] | undefined {\n if (!fallbackConfig) return undefined;\n const configured =\n scenarioType === \"subagent\"\n ? fallbackConfig.subagent ?? fallbackConfig.default\n : fallbackConfig[scenarioType];\n return Array.isArray(configured) ? configured : undefined;\n}\n\nconst NETWORK_ERROR_CODES = new Set([\n \"ECONNRESET\",\n \"ECONNREFUSED\",\n \"ENOTFOUND\",\n \"EAI_AGAIN\",\n \"ETIMEDOUT\",\n \"EPIPE\",\n \"UND_ERR_CONNECT_TIMEOUT\",\n \"UND_ERR_HEADERS_TIMEOUT\",\n \"UND_ERR_BODY_TIMEOUT\",\n \"UND_ERR_SOCKET\",\n \"UND_ERR_CONNECT\",\n]);\n\nfunction isTimeoutAbortError(error: unknown): boolean {\n const err = error as any;\n if (!err) return false;\n // DOMException TimeoutError from AbortSignal.timeout() uses numeric code 23.\n if (\n err.name === \"TimeoutError\" ||\n err.code === \"TIMEOUT_ERR\" ||\n err.code === 23\n ) {\n return true;\n }\n if (\n err.cause &&\n (err.cause.name === \"TimeoutError\" ||\n err.cause.code === \"TIMEOUT_ERR\" ||\n err.cause.code === 23)\n ) {\n return true;\n }\n const message = String(err.message || \"\");\n return /aborted due to timeout|operation was aborted due to timeout/i.test(\n message\n );\n}\n\nexport function toClientAbortError(\n reason: unknown = CLIENT_DISCONNECT_REASON\n): Error {\n const message =\n typeof reason === \"string\" && reason\n ? reason\n : reason instanceof Error && reason.message\n ? reason.message\n : CLIENT_DISCONNECT_REASON;\n return Object.assign(new Error(message), {\n name: \"AbortError\",\n code: \"ABORT_ERR\",\n reason,\n });\n}\n\n/** Linear-time client-disconnect check (avoids ReDoS from /client.*(closed|disconnect)/). */\nfunction isClientDisconnectMessage(message: string): boolean {\n const lower = message.toLowerCase();\n if (lower.includes(\"socket hang up\")) return true;\n const clientIdx = lower.indexOf(\"client\");\n if (clientIdx === -1) return false;\n const after = lower.slice(clientIdx);\n return after.includes(\"closed\") || after.includes(\"disconnect\");\n}\n\nexport function isClientAbortError(error: unknown): boolean {\n if (error == null || error === false) return false;\n\n // fetch() + AbortController.abort(string) rejects with the string itself\n // (not an Error). OpenCode false-aborts were logged as HTTP 500 because this\n // helper missed that shape and the errorHandler took the internal path.\n if (typeof error === \"string\") {\n return (\n error.startsWith(CLIENT_DISCONNECT_REASON) ||\n isClientDisconnectMessage(error)\n );\n }\n\n const err = error as any;\n // Request timeouts must not be treated as client disconnects (no 499 / skip fallback).\n if (isTimeoutAbortError(err)) return false;\n\n const reason = err.reason ?? err.cause;\n if (\n typeof reason === \"string\" &&\n reason.startsWith(CLIENT_DISCONNECT_REASON)\n ) {\n return true;\n }\n if (\n typeof err.message === \"string\" &&\n err.message.startsWith(CLIENT_DISCONNECT_REASON)\n ) {\n return true;\n }\n\n if (err.name === \"AbortError\") return true;\n if (err.code === \"ABORT_ERR\") return true;\n if (err.code === \"ERR_STREAM_PREMATURE_CLOSE\") return true;\n const message = String(err.message || \"\");\n return isClientDisconnectMessage(message);\n}\n\n/**\n * True only when the HTTP response socket is actually gone.\n * Prefer this over AbortSignal.aborted / isClientAbortError alone \u2014 those can\n * fire during Cursor SDK bootstrap or provider timeouts while the client is\n * still connected and able to receive a JSON body (false 499).\n */\nfunction isRawResponseGone(raw: any): boolean {\n if (!raw || raw.destroyed) return true;\n const socket = raw.socket;\n if (!socket) return false;\n if (socket.destroyed) return true;\n // Both sides closed \u21D2 client is gone even if destroyed flag lags.\n return socket.readable === false && socket.writable === false;\n}\n\nexport function isResponseSocketGone(reply: FastifyReply): boolean {\n return isRawResponseGone(reply.raw);\n}\n\nexport function isProviderNetworkError(error: unknown): boolean {\n if (!error || isClientAbortError(error)) return false;\n // AbortSignal.timeout / fetch TimeoutError \u2014 eligible for fallback, not a client abort.\n if (isTimeoutAbortError(error)) return true;\n const err = error as any;\n if (err.code === \"provider_network_error\") return true;\n if (typeof err.code === \"string\" && NETWORK_ERROR_CODES.has(err.code)) {\n return true;\n }\n if (err.cause?.code && NETWORK_ERROR_CODES.has(String(err.cause.code))) {\n return true;\n }\n const message = String(err.message || \"\");\n return /fetch failed|network|socket|ECONNRESET|ENOTFOUND|ETIMEDOUT|other side closed/i.test(\n message\n );\n}\n\n/**\n * HTTP statuses worth trying another model for: transient throttling,\n * contention, and server-side failures. Ordinary 4xx responses (validation,\n * authentication, permissions, model-not-found) are terminal \u2014 resending the\n * identical request to a fallback model would fail the same way.\n */\nexport function isFallbackEligibleStatus(\n status: number | undefined\n): boolean {\n if (typeof status !== \"number\" || !Number.isFinite(status)) return false;\n if (status === 408 || status === 409 || status === 425 || status === 429) {\n return true;\n }\n return status >= 500 && status <= 599;\n}\n\nexport function isFallbackEligibleError(error: unknown): boolean {\n const err = error as any;\n if (!err || isClientAbortError(err)) return false;\n // Network errors and provider timeouts are always retryable.\n if (isProviderNetworkError(err)) return true;\n const status =\n typeof err.statusCode === \"number\"\n ? err.statusCode\n : typeof err.upstream?.status === \"number\"\n ? err.upstream.status\n : undefined;\n if (status !== undefined) return isFallbackEligibleStatus(status);\n // No status information: only an explicit provider error code qualifies.\n return err.code === \"provider_response_error\";\n}", "import type { ClientProtocol } from \"./protocol-endpoints\";\n\nexport interface ProtocolErrorBody {\n statusCode: number;\n body: Record;\n}\n\n/**\n * Build a client-protocol-shaped error envelope for pre-provider failures\n * (auth, validation, missing Router.default, etc.).\n */\nexport function protocolErrorBody(\n protocol: ClientProtocol | undefined,\n message: string,\n statusCode: number,\n code: string,\n type: string = \"invalid_request_error\"\n): ProtocolErrorBody {\n switch (protocol) {\n case \"openai_chat_completions\":\n case \"openai_responses\":\n case \"openai_fim_completions\":\n return {\n statusCode,\n body: {\n error: {\n message,\n type,\n param: null,\n code,\n },\n },\n };\n case \"anthropic_messages\":\n default:\n return {\n statusCode,\n body: {\n error: {\n message,\n type: type === \"invalid_request_error\" ? \"invalid_request_error\" : type,\n code,\n },\n type: \"error\",\n },\n };\n }\n}\n", "import { FastifyRequest, FastifyReply } from \"fastify\";\nimport {\n sanitizeErrorForLog,\n sanitizeUpstreamErrorText,\n} from \"../utils/redact\";\nimport { isClientAbortError } from \"../utils/retry\";\nimport { protocolErrorBody } from \"../routing/protocol-errors\";\n\nexport interface ApiError extends Error {\n statusCode?: number;\n code?: string;\n type?: string;\n headers?: Record;\n}\n\nexport function createApiError(\n message: string,\n statusCode: number = 500,\n code: string = \"internal_error\",\n type: string = \"api_error\",\n headers?: Record\n): ApiError {\n const error = new Error(sanitizeUpstreamErrorText(message) || message) as ApiError;\n error.statusCode = statusCode;\n error.code = code;\n error.type = type;\n if (headers) error.headers = headers;\n return error;\n}\n\nexport async function errorHandler(\n error: ApiError,\n request: FastifyRequest,\n reply: FastifyReply\n) {\n // Client disconnects are expected; avoid noisy error responses/logs.\n if (isClientAbortError(error) || reply.raw.destroyed || reply.sent) {\n request.log.debug(sanitizeErrorForLog(error), \"request aborted or already closed\");\n if (!reply.sent && !reply.raw.destroyed && !reply.raw.headersSent) {\n // Must reset Content-Type: formatResponse may already have set\n // text/event-stream, and Fastify rejects object payloads for that type.\n reply.type(\"application/json\");\n return reply.code(499).send({\n error: {\n message: \"Client closed request\",\n type: \"api_error\",\n code: \"client_aborted\",\n },\n });\n }\n return;\n }\n\n request.log.error(sanitizeErrorForLog(error), \"request error\");\n\n const statusCode = error.statusCode || 500;\n const message =\n sanitizeUpstreamErrorText(error.message || \"Internal error\") ||\n \"Internal error\";\n const code = error.code || \"internal_error\";\n const type =\n error.type ||\n (statusCode >= 400 && statusCode < 500\n ? \"invalid_request_error\"\n : \"api_error\");\n\n // Prefer an explicit protocol body attached by throwProtocolError; then a\n // structured upstream error, reshaped into the caller's wire envelope;\n // otherwise shape from the detected client protocol (or Anthropic default).\n const protocol = (request as any).clientProtocol;\n let protocolBody: Record | undefined =\n (error as any).protocolBody;\n\n const upstreamBody = (error as any).upstream?.body;\n if (!protocolBody && upstreamBody && typeof upstreamBody === \"object\") {\n const upstreamError = (upstreamBody as any).error;\n if (\n (protocol === \"anthropic_messages\" || !protocol) &&\n (upstreamBody as any).type === \"error\" &&\n upstreamError &&\n typeof upstreamError === \"object\"\n ) {\n // Native Anthropic wire error: keep the envelope so clients recognize\n // e.g. prompt_too_long and the long-context credit rejections.\n protocolBody = {\n type: \"error\",\n error: {\n type:\n typeof upstreamError.type === \"string\" ? upstreamError.type : type,\n message:\n typeof upstreamError.message === \"string\"\n ? upstreamError.message\n : message,\n ...(typeof upstreamError.code === \"string\"\n ? { code: upstreamError.code }\n : {}),\n },\n };\n } else if (\n (protocol === \"openai_chat_completions\" ||\n protocol === \"openai_responses\") &&\n upstreamError &&\n typeof upstreamError === \"object\"\n ) {\n // OpenAI envelope: retain a meaningful upstream code (e.g.\n // context_length_exceeded) when the provider supplied one.\n protocolBody = {\n error: {\n message:\n typeof upstreamError.message === \"string\"\n ? upstreamError.message\n : message,\n type:\n typeof upstreamError.type === \"string\" ? upstreamError.type : type,\n param: upstreamError.param ?? null,\n code:\n typeof upstreamError.code === \"string\"\n ? upstreamError.code\n : code,\n },\n };\n }\n }\n\n if (!protocolBody) {\n protocolBody = protocolErrorBody(\n protocol,\n message,\n statusCode,\n code,\n type\n ).body;\n }\n\n if (error.headers) {\n reply.headers(error.headers);\n }\n\n // Reset Content-Type to application/json to prevent \"invalid payload type\" errors\n // when the reply previously had Content-Type set to a non-JSON value (e.g., text/event-stream\n // from a streaming response that failed before the stream was sent).\n reply.type(\"application/json\");\n\n return reply.code(statusCode).send(protocolBody);\n}\n", "import {\n FastifyInstance,\n FastifyRequest,\n FastifyReply,\n} from \"fastify\";\nimport { Readable } from \"stream\";\nimport { RegisterProviderRequest, LLMProvider } from \"@/types/llm\";\nimport { sendUnifiedRequest } from \"@/utils/request\";\nimport { createApiError } from \"./middleware\";\nimport { readHealthVitals } from \"@/utils/health-reporter\";\nimport { version } from \"../../package.json\";\nimport { ConfigService } from \"@/services/config\";\nimport { ProviderService } from \"@/services/provider\";\nimport { TransformerService } from \"@/services/transformer\";\nimport { Transformer } from \"@/types/transformer\";\nimport {\n // diffHeadersForLog,\n sanitizeErrorForLog,\n // sanitizeHeadersForLog,\n sanitizeUpstreamErrorBody,\n sanitizeUpstreamErrorText,\n} from \"@/utils/redact\";\nimport {\n CLIENT_DISCONNECT_REASON,\n createClientDisconnectSignal,\n delay,\n isClientAbortError,\n isFallbackEligibleError,\n isResponseSocketGone,\n retryDelayAfterFailure,\n selectFallbackModels,\n toClientAbortError,\n} from \"@/utils/retry\";\nimport { applyProviderNativeChatCaching } from \"../utils/openai.util\";\nimport { sanitizeResponsesWireCallIds } from \"../utils/openai.responses.util\";\nimport { applyOpenAIChatReasoning } from \"../utils/reasoning-effort\";\nimport { applyRawAnthropicPromptCaching } from \"../utils/cacheControl\";\nimport { resolveCachePrefixConversationId } from \"../utils/cache-prefix-debug\";\nimport {\n firstSubstantiveUserText,\n isStatuslinePollTurn,\n} from \"../utils/nested-agent\";\n\nfunction isOpencodeProvider(provider: any): boolean {\n const name = String(provider?.name || \"\").toLowerCase();\n if (name === \"opencode\" || name.startsWith(\"opencode\")) return true;\n const base = provider?.baseUrl || provider?.api_base_url || \"\";\n try {\n const host = new URL(base).hostname.toLowerCase();\n return host === \"opencode.ai\" || host.endsWith(\".opencode.ai\");\n } catch {\n return String(base).toLowerCase().includes(\"opencode.ai\");\n }\n}\nimport {\n logOutboundCacheStructure,\n tapClientSSEDebug,\n tapUpstreamSSEDebug,\n} from \"../utils/sse-debug-tap\";\nimport {\n logKeepWire,\n logMessageBody,\n resolveLogBodyMaxBytes,\n resolveLogBodySelection,\n shouldLogSSEEvents,\n} from \"../utils/message-debug\";\nimport { withSSEClientKeepalive } from \"@/utils/sse/client-keepalive\";\nimport { withChatCompletionsDoneBoundary } from \"@/utils/sse/done-boundary\";\nimport { sendWithUnauthorizedAuthRecovery } from \"@/utils/auth-recovery\";\nimport {\n canonicalizeOutboundHeaders,\n mergeHeadersCaseInsensitive,\n selectSafeDownstreamHeaders,\n} from \"@/utils/headers\";\nimport { RATE_LIMIT_CONFIG } from \"@caeliq/ccr-shared\";\nimport { TokenizerService } from \"@/services/tokenizer\";\nimport {\n listClientRouteRegistrations,\n matchClientProtocol,\n type ClientProtocol,\n} from \"@/routing/protocol-endpoints\";\nimport {\n cloneProtocolBody,\n sanitizePassthroughHeaders,\n} from \"@/routing/protocol-adapter\";\nimport {\n prepareInboundRequest,\n protocolAwareBypass,\n PreparedInboundRequest,\n} from \"@/routing/inbound-pipeline\";\nimport { handleFimEndpoint } from \"@/routing/fim-pipeline\";\nimport {\n compileTransformerPlan,\n cancelReplacedProviderResponse,\n isExactProtocolResponsePlan,\n isExactProtocolRequestPlan,\n isWireSafeMiddlewareForKeep,\n planContains,\n} from \"@/utils/transformer-plan\";\nimport {\n ensureRequestLatency,\n markLatency,\n attachLatencyMeta,\n emitLatencyRecord,\n tapResponseFirstByte,\n} from \"@/utils/request-latency\";\nimport {\n applyNativeClaudeOAuthCacheTtl,\n applyThirdPartyAnthropicPolicy,\n getAnthropicProviderMode,\n isNativeAnthropicClient,\n resolveNativeClaudeOAuthCacheTtlMode,\n} from \"@/utils/anthropic-client-policy\";\n\nfunction isManualExactProtocolPassthrough(\n provider: any,\n endpointTransformer: Transformer,\n protocolContext: any\n): boolean {\n return Boolean(\n protocolContext &&\n provider.transformer?.passthrough === true &&\n provider.transformer?.use?.some(\n (providerTransformer: Transformer) =>\n providerTransformer?.name === endpointTransformer.name\n )\n );\n}\n\nfunction isThirdPartyInScopeAnthropic(protocolContext: any): boolean {\n return Boolean(\n protocolContext?.anthropicDestinationInScope === true &&\n protocolContext?.anthropicClientKind === \"other\"\n );\n}\n\n/**\n * v1 wire-keep predicate: exact-protocol owner in compiled plan, third-party\n * Anthropic never keeps, claude-auth chains excluded for v1.\n * `anthropicNativeWire` and legacy passthrough are still covered by the\n * caller's own booleans; this helper covers the automatic multi-transformer\n * case only.\n */\nfunction computeWireKeepForProvider(\n provider: any,\n endpointTransformer: Transformer,\n protocolContext: any,\n modelName: string | undefined\n): { useWire: boolean; plan: any | undefined; isAutoKeep: boolean } {\n if (!protocolContext || isThirdPartyInScopeAnthropic(protocolContext)) {\n return { useWire: false, plan: undefined, isAutoKeep: false };\n }\n const providerUse = provider?.transformer?.use as any[] | undefined;\n const modelUse = (\n modelName ? provider?.transformer?.[modelName]?.use : undefined\n ) as any[] | undefined;\n let plan: any | undefined;\n try {\n // Compile without skipName so the owner stays in plan for the predicate.\n plan = compileTransformerPlan(providerUse, modelUse);\n } catch {\n return { useWire: false, plan: undefined, isAutoKeep: false };\n }\n if (planContains(plan, \"claude-auth\")) {\n return { useWire: false, plan, isAutoKeep: false };\n }\n const isAutoKeep = isExactProtocolRequestPlan(\n plan,\n endpointTransformer,\n protocolContext.ownerTransformerName\n );\n return { useWire: isAutoKeep, plan, isAutoKeep };\n}\n\n/**\n * Single keep/bypass decision for the provider POST.\n * Unified projection still exists for routing; this only chooses the\n * upstream body and whether the protocol owner may rebuild it.\n */\nfunction resolveClientWireKeep(\n provider: any,\n endpointTransformer: Transformer,\n protocolContext: any,\n modelName: string | undefined\n): {\n keepClientWire: boolean;\n bypass: boolean;\n isNativeWire: boolean;\n plan: any | undefined;\n isAutoKeep: boolean;\n} {\n const isNativeWire = Boolean(protocolContext?.anthropicNativeWire);\n const thirdParty = isThirdPartyInScopeAnthropic(protocolContext);\n const preserveManualWire =\n !thirdParty &&\n isManualExactProtocolPassthrough(\n provider,\n endpointTransformer,\n protocolContext\n );\n const deprecatedWillBypass =\n protocolAwareBypass(\n provider,\n endpointTransformer,\n protocolContext,\n modelName\n ) && !thirdParty;\n const autoKeep = computeWireKeepForProvider(\n provider,\n endpointTransformer,\n protocolContext,\n modelName\n );\n const keepClientWire =\n isNativeWire ||\n preserveManualWire ||\n autoKeep.useWire ||\n deprecatedWillBypass;\n return {\n keepClientWire,\n bypass: isNativeWire || deprecatedWillBypass,\n isNativeWire,\n plan: autoKeep.plan,\n isAutoKeep: autoKeep.isAutoKeep,\n };\n}\n\ntype RequestTransformKeep = {\n keepClientWire: boolean;\n bypass: boolean;\n wireKeepPlan?: any;\n};\n\n// Extend FastifyInstance to include custom services\ndeclare module \"fastify\" {\n interface FastifyInstance {\n configService: ConfigService;\n providerService: ProviderService;\n transformerService: TransformerService;\n tokenizerService: TokenizerService;\n }\n\n interface FastifyRequest {\n provider?: string;\n }\n}\n\n/**\n * Main handler for transformer endpoints.\n * Canonical lifecycle: normalize client\u2192Unified \u2192 route \u2192 provider In \u2192\n * upstream \u2192 provider Out \u2192 client In \u2192 format from protocol stream intent.\n */\nasync function handleTransformerEndpoint(\n req: FastifyRequest,\n reply: FastifyReply,\n fastify: FastifyInstance,\n transformer: any,\n routePath: string\n) {\n const disconnect = createClientDisconnectSignal(req, reply);\n const clientSignal = disconnect.signal;\n disconnect.arm();\n const latency = ensureRequestLatency(req as any);\n markLatency(latency, \"bodyParsed\");\n\n let prepared: PreparedInboundRequest;\n try {\n prepared = await prepareInboundRequest(\n req,\n reply,\n fastify,\n transformer,\n routePath\n );\n markLatency(latency, \"destinationPolicy\");\n } catch (error: any) {\n attachLatencyMeta(latency, {\n error: error?.message || String(error),\n cancelled: isClientAbortError(error) || clientSignal.aborted,\n });\n emitLatencyRecord(req.log, latency);\n if (isClientAbortError(error) || clientSignal.aborted) {\n throw typeof error === \"string\"\n ? toClientAbortError(error)\n : toClientAbortError(clientSignal.reason ?? error);\n }\n throw error;\n }\n\n const provider = fastify.providerService.getProvider(prepared.providerName);\n if (!provider) {\n attachLatencyMeta(latency, {\n provider: prepared.providerName,\n model: prepared.modelName,\n error: \"provider_not_found\",\n });\n emitLatencyRecord(req.log, latency);\n throw createApiError(\n `Provider '${prepared.providerName}' not found`,\n 404,\n \"provider_not_found\"\n );\n }\n\n attachLatencyMeta(latency, {\n protocol: prepared.protocolContext?.protocol,\n provider: prepared.providerName,\n model: prepared.modelName,\n method: req.method,\n url: req.url,\n scenario: (req as any).scenarioType,\n tokenCount: (req as any).tokenCount,\n });\n\n // Stash prepared state so fallback can reuse Unified + protocol context.\n (req as any)._preparedInbound = prepared;\n\n try {\n // Native Anthropic clients use the original wire body; legacy exact\n // protocol passthrough uses the adapted wire body. Same-protocol wire\n // keep (multi-transformer with owner in plan) also keeps clientWireBody\n // so prefix + vision bytes stay intact. Third-party Anthropic emulation\n // and all cross-protocol routes use the Unified projection.\n const keep = resolveClientWireKeep(\n provider,\n transformer,\n prepared.protocolContext,\n prepared.modelName\n );\n const isNativeWire = keep.isNativeWire;\n const useWireKeep = keep.keepClientWire;\n const exactWireSource = isNativeWire\n ? prepared.originalBody\n : prepared.clientWireBody ?? prepared.originalBody;\n let pipelineBody = useWireKeep\n ? {\n ...(typeof exactWireSource === \"object\" && exactWireSource\n ? cloneProtocolBody(exactWireSource)\n : {}),\n model: prepared.modelName,\n }\n : cloneProtocolBody(prepared.unifiedBody);\n (req as any)._wireKeep = useWireKeep;\n (req as any)._autoWireKeep = keep.isAutoKeep;\n\n recordClientCachePrefix(req, fastify, provider, pipelineBody);\n if (isNativeWire) {\n applyNativeClaudeOAuthCacheTtl(\n pipelineBody,\n prepared.protocolContext,\n resolveNativeClaudeOAuthCacheTtlMode(\n fastify.configService.get(\"CLAUDE_AUTH_NATIVE_CACHE_TTL\")\n )\n );\n }\n // Exact-wire keep skips the Responses owner's body rebuild, but call_id is\n // still provider-validated (<=64). Repair only those correlation fields\n // after the client snapshot so cache diagnostics attribute it to the wire.\n if (\n useWireKeep &&\n prepared.protocolContext.protocol === \"openai_responses\"\n ) {\n pipelineBody = sanitizeResponsesWireCallIds(\n pipelineBody,\n prepared.protocolContext.responsesCallIdMap\n );\n }\n\n const { requestBody, config, bypass, wireKeep } = await processRequestTransformers(\n pipelineBody,\n provider,\n transformer,\n req.headers,\n {\n req,\n provider,\n signal: clientSignal,\n clientProtocol: prepared.protocolContext.protocol,\n protocolContext: prepared.protocolContext,\n // Client\u2192Unified already ran in prepareInboundRequest (routing only).\n skipClientNormalization: true,\n },\n {\n keepClientWire: useWireKeep,\n bypass: keep.bypass,\n wireKeepPlan: keep.plan,\n }\n );\n markLatency(latency, \"requestTransformers\");\n attachLatencyMeta(latency, { bypass: bypass || wireKeep, wireKeep });\n if (wireKeep) {\n req.log.debug?.(\n {\n provider: provider?.name,\n protocol: prepared.protocolContext?.protocol,\n model: prepared.modelName,\n pipeline: \"wire-keep\",\n },\n \"same-protocol wire keep (owner skipped, middleware kept)\"\n );\n }\n\n // Fetch start/headers are stamped by sendUnifiedRequest or by ownsTransport\n // transformers (cursor-sdk). Do not mark start here \u2014 that would freeze the\n // stamp before the real POST and make upstreamTtftMs include auth/SDK setup.\n const response = await sendRequestToProvider(\n requestBody,\n config,\n provider,\n fastify,\n bypass,\n transformer,\n {\n req,\n signal: clientSignal,\n protocolContext: prepared.protocolContext,\n }\n );\n\n if (latency.stages.upstreamFetchStart === undefined) {\n markLatency(latency, \"upstreamFetchStart\");\n }\n if (latency.stages.upstreamHeaders === undefined) {\n markLatency(latency, \"upstreamHeaders\");\n }\n // Tap the raw provider body before response conversion so upstream TTFT\n // is not delayed by Responses\u2192Unified\u2192Anthropic buffering.\n const timedResponse = tapResponseFirstByte(response, () => {\n markLatency(latency, \"upstreamFirstByte\");\n });\n\n const finalResponse = await processResponseTransformers(\n requestBody,\n timedResponse,\n provider,\n transformer,\n bypass,\n {\n req,\n signal: clientSignal,\n protocolContext: prepared.protocolContext,\n skipClientNormalization: bypass,\n }\n );\n markLatency(latency, \"responseTransformers\");\n\n return await formatResponse(\n finalResponse,\n reply,\n prepared.originalBody,\n clientSignal,\n prepared.protocolContext.stream,\n prepared.protocolContext.protocol,\n {\n configService: fastify.configService,\n provider: provider?.name,\n model: prepared.modelName,\n }\n );\n } catch (error: any) {\n attachLatencyMeta(latency, {\n error: error?.code || error?.message || String(error),\n cancelled: isClientAbortError(error) || clientSignal.aborted,\n });\n emitLatencyRecord(req.log, latency);\n if (isClientAbortError(error)) {\n throw typeof error === \"string\" ? toClientAbortError(error) : error;\n }\n if (clientSignal.aborted) {\n throw toClientAbortError(clientSignal.reason ?? error);\n }\n if (isFallbackEligibleError(error)) {\n const fallbackResult = await handleFallback(\n req,\n reply,\n fastify,\n transformer,\n error,\n clientSignal\n );\n if (fallbackResult) {\n return fallbackResult;\n }\n if (clientSignal.aborted) {\n throw toClientAbortError(\n clientSignal.reason ?? CLIENT_DISCONNECT_REASON\n );\n }\n }\n throw error;\n }\n}\n\n/**\n * Handle fallback logic when request fails\n * Tries each fallback model in sequence until one succeeds\n */\nasync function handleFallback(\n req: FastifyRequest,\n reply: FastifyReply,\n fastify: FastifyInstance,\n transformer: any,\n error: any,\n clientSignal?: AbortSignal\n): Promise {\n const scenarioType = (req as any).scenarioType || 'default';\n const fallbackConfig = fastify.configService.get('fallback');\n\n const fallbackList = selectFallbackModels(fallbackConfig, scenarioType);\n if (!fallbackList?.length) {\n return null;\n }\n\n if (clientSignal?.aborted || isClientAbortError(error)) {\n return null;\n }\n\n req.log.warn(\n {\n scenarioType,\n fallbackCount: fallbackList.length,\n error: sanitizeErrorForLog(error),\n },\n `Request failed for ${scenarioType}, trying ${fallbackList.length} fallback models`\n );\n\n let failedAttemptIndex = 0;\n const initialDelayMs = retryDelayAfterFailure(\n failedAttemptIndex,\n error?.headers?.[\"Retry-After\"] ?? error?.headers?.[\"retry-after\"]\n );\n failedAttemptIndex += 1;\n if (initialDelayMs > 0) {\n req.log.info(`Waiting ${initialDelayMs}ms before first fallback attempt`);\n try {\n await delay(initialDelayMs, clientSignal);\n } catch (waitError: any) {\n if (isClientAbortError(waitError) || clientSignal?.aborted) {\n return null;\n }\n throw waitError;\n }\n }\n\n // Try each fallback model in sequence\n for (let i = 0; i < fallbackList.length; i += 1) {\n if (clientSignal?.aborted) {\n return null;\n }\n\n const fallbackModel = fallbackList[i];\n try {\n req.log.info(`Trying fallback model: ${fallbackModel}`);\n\n // Reuse the already-normalized Unified body + protocol context.\n const prepared = (req as any)._preparedInbound as\n | PreparedInboundRequest\n | undefined;\n const [fallbackProvider, ...fallbackModelName] = fallbackModel.split(\",\");\n const fallbackModelOnly = fallbackModelName.join(\",\");\n\n const provider = fastify.providerService.getProvider(fallbackProvider);\n if (!provider) {\n req.log.warn(\n `Fallback provider '${fallbackProvider}' not found, skipping`\n );\n continue;\n }\n\n const fallbackAnthropicMode = getAnthropicProviderMode(provider);\n const fallbackProtocolContext = prepared?.protocolContext\n ? {\n ...prepared.protocolContext,\n anthropicProviderMode: fallbackAnthropicMode,\n anthropicDestinationInScope:\n fallbackAnthropicMode !== \"out_of_scope\",\n anthropicNativeWire: Boolean(\n prepared.protocolContext.protocol === \"anthropic_messages\" &&\n fallbackAnthropicMode !== \"out_of_scope\" &&\n isNativeAnthropicClient(\n prepared.protocolContext.anthropicClientKind || \"other\"\n )\n ),\n anthropicPolicyApplied: false,\n anthropicSystemTransformed: false,\n claudeAuthToolNameMap: new Map(),\n }\n : prepared?.protocolContext;\n\n const unifiedBody = {\n ...cloneProtocolBody(\n prepared?.prePolicyUnifiedBody ||\n prepared?.unifiedBody ||\n (req as any).unifiedBody ||\n req.body\n ),\n model: fallbackModelOnly,\n };\n\n if (\n fallbackProtocolContext?.anthropicDestinationInScope &&\n fallbackProtocolContext.anthropicClientKind === \"other\"\n ) {\n await applyThirdPartyAnthropicPolicy(\n unifiedBody,\n fallbackProtocolContext,\n fastify.configService\n );\n }\n\n const newReq = {\n ...req,\n provider: fallbackProvider,\n model: fallbackModelOnly,\n body: prepared?.originalBody ?? req.body,\n unifiedBody,\n protocolContext: fallbackProtocolContext,\n clientProtocol: fallbackProtocolContext?.protocol,\n scenarioType,\n };\n\n const fallbackKeep = resolveClientWireKeep(\n provider,\n transformer,\n fallbackProtocolContext,\n fallbackModelOnly\n );\n const fallbackIsNativeWire = fallbackKeep.isNativeWire;\n const fallbackUseWireKeep = fallbackKeep.keepClientWire;\n const exactWireSource = fallbackIsNativeWire\n ? prepared?.originalBody\n : prepared?.clientWireBody ?? prepared?.originalBody;\n let pipelineBody = fallbackUseWireKeep\n ? {\n ...(typeof exactWireSource === \"object\" && exactWireSource\n ? cloneProtocolBody(exactWireSource)\n : {}),\n model: fallbackModelOnly,\n }\n : unifiedBody;\n\n recordClientCachePrefix(newReq, fastify, provider, pipelineBody);\n if (fallbackIsNativeWire) {\n applyNativeClaudeOAuthCacheTtl(\n pipelineBody,\n fallbackProtocolContext,\n resolveNativeClaudeOAuthCacheTtlMode(\n fastify.configService.get(\"CLAUDE_AUTH_NATIVE_CACHE_TTL\")\n )\n );\n }\n if (\n fallbackUseWireKeep &&\n fallbackProtocolContext?.protocol === \"openai_responses\"\n ) {\n pipelineBody = sanitizeResponsesWireCallIds(\n pipelineBody,\n fallbackProtocolContext.responsesCallIdMap\n );\n }\n\n const { requestBody, config, bypass, wireKeep } = await processRequestTransformers(\n pipelineBody,\n provider,\n transformer,\n req.headers,\n {\n req: newReq,\n provider,\n signal: clientSignal,\n clientProtocol: prepared?.protocolContext?.protocol,\n protocolContext: fallbackProtocolContext,\n skipClientNormalization: true,\n },\n {\n keepClientWire: fallbackUseWireKeep,\n bypass: fallbackKeep.bypass,\n wireKeepPlan: fallbackKeep.plan,\n }\n );\n if (wireKeep) {\n req.log.debug?.(\n {\n provider: provider?.name,\n protocol: fallbackProtocolContext?.protocol,\n model: fallbackModelOnly,\n pipeline: \"wire-keep-fallback\",\n },\n \"same-protocol wire keep on fallback\"\n );\n }\n\n const fallbackLatency = (newReq as any)._latency;\n const response = await sendRequestToProvider(\n requestBody,\n config,\n provider,\n fastify,\n bypass,\n transformer,\n {\n req: newReq,\n signal: clientSignal,\n protocolContext: fallbackProtocolContext,\n }\n );\n\n if (fallbackLatency?.stages?.upstreamFetchStart === undefined) {\n markLatency(fallbackLatency, \"upstreamFetchStart\");\n }\n if (fallbackLatency?.stages?.upstreamHeaders === undefined) {\n markLatency(fallbackLatency, \"upstreamHeaders\");\n }\n const timedResponse = tapResponseFirstByte(response, () => {\n markLatency(fallbackLatency, \"upstreamFirstByte\");\n });\n const finalResponse = await processResponseTransformers(\n requestBody,\n timedResponse,\n provider,\n transformer,\n bypass,\n {\n req: newReq,\n signal: clientSignal,\n protocolContext: fallbackProtocolContext,\n }\n );\n\n req.log.info(`Fallback model ${fallbackModel} succeeded`);\n\n return await formatResponse(\n finalResponse,\n reply,\n prepared?.originalBody ?? req.body,\n clientSignal,\n fallbackProtocolContext?.stream,\n fallbackProtocolContext?.protocol,\n {\n configService: fastify.configService,\n provider: provider?.name,\n model: typeof requestBody?.model === \"string\" ? requestBody.model : undefined,\n }\n );\n } catch (fallbackError: any) {\n if (isClientAbortError(fallbackError)) {\n throw fallbackError;\n }\n if (clientSignal?.aborted) {\n throw toClientAbortError(\n clientSignal.reason ?? CLIENT_DISCONNECT_REASON\n );\n }\n\n // A terminal (non-retryable) failure \u2014 validation, auth, permissions,\n // model-not-found \u2014 goes straight back to the caller: no further\n // fallback models, no Retry-After wait.\n if (!isFallbackEligibleError(fallbackError)) {\n req.log.warn(\n {\n fallbackModel,\n error: sanitizeErrorForLog(fallbackError),\n },\n `Fallback model ${fallbackModel} failed with a terminal error`\n );\n throw fallbackError;\n }\n\n req.log.warn(\n {\n fallbackModel,\n error: sanitizeErrorForLog(fallbackError),\n },\n `Fallback model ${fallbackModel} failed`\n );\n\n const hasMore = i < fallbackList.length - 1;\n if (hasMore) {\n const waitMs = retryDelayAfterFailure(\n failedAttemptIndex,\n fallbackError?.headers?.[\"Retry-After\"] ??\n fallbackError?.headers?.[\"retry-after\"]\n );\n failedAttemptIndex += 1;\n if (waitMs > 0) {\n req.log.info(\n `Waiting ${waitMs}ms before next fallback attempt`\n );\n try {\n await delay(waitMs, clientSignal);\n } catch (waitError: any) {\n if (isClientAbortError(waitError) || clientSignal?.aborted) {\n return null;\n }\n throw waitError;\n }\n }\n }\n continue;\n }\n }\n\n req.log.error(`All fallback models failed for ${scenarioType}`);\n return null;\n}\n\n/**\n * Process request transformer chain.\n * Client\u2192Unified already ran in prepareInboundRequest (routing projection).\n * `keep` chooses client wire vs Unified for the upstream POST; the protocol\n * owner does not rebuild a kept Responses/Anthropic body.\n */\nasync function processRequestTransformers(\n body: any,\n provider: any,\n transformer: any,\n headers: any,\n context: any,\n keep?: RequestTransformKeep\n) {\n let requestBody = body;\n let config: any = {};\n\n const thirdPartyAnthropic = isThirdPartyInScopeAnthropic(\n context?.protocolContext\n );\n const bypass = Boolean(keep?.bypass);\n const wireKeepPlan = keep?.wireKeepPlan;\n // claude-auth stays on the convert/skipName loop even if the caller kept\n // client bytes via passthrough \u2014 it is not wire-safe middleware in v1.\n const effectiveWireKeep =\n Boolean(keep?.keepClientWire) &&\n !bypass &&\n !(wireKeepPlan && planContains(wireKeepPlan, \"claude-auth\"));\n const manualExactPassthrough =\n !thirdPartyAnthropic &&\n isManualExactProtocolPassthrough(\n provider,\n transformer,\n context?.protocolContext\n );\n\n const skipBodyConversion =\n bypass ||\n effectiveWireKeep ||\n Boolean(keep?.keepClientWire) ||\n (!thirdPartyAnthropic && provider.transformer?.passthrough) ||\n context?.skipClientNormalization === true;\n\n // Client header copy and Anthropic cache_control injection are Anthropic-wire\n // only. Chat/Responses keep must not reuse this branch: a denylist copy\n // forwards openai-*/stainless headers, and applyRawAnthropicPromptCaching\n // stamps top-level cache_control that Chat Completions / Zen reject or ignore.\n const anthropicWireKeep =\n bypass ||\n (effectiveWireKeep &&\n (context?.protocolContext?.protocol === \"anthropic_messages\" ||\n (transformer as any)?.name === \"Anthropic\"));\n if (anthropicWireKeep) {\n config.headers = sanitizePassthroughHeaders(headers);\n if (isOpencodeProvider(provider)) {\n try {\n if (\n requestBody &&\n typeof requestBody === \"object\" &&\n (requestBody.system !== undefined ||\n Array.isArray(requestBody.messages))\n ) {\n requestBody = applyRawAnthropicPromptCaching(requestBody);\n }\n } catch {\n // never break the request path on caching\n }\n }\n }\n\n // prompt_cache_key is Responses-owner scoped \u2014 only keep when the compiled\n // plan actually contains the Responses owner (either legacy or wire-keep).\n const hasResponsesOwner = (() => {\n if (wireKeepPlan) return planContains(wireKeepPlan, \"openai-responses\");\n const use = provider.transformer?.use as any[] | undefined;\n return Boolean(\n Array.isArray(use) &&\n use.some((t: any) => t?.name === \"openai-responses\")\n );\n })();\n if (\n !bypass &&\n !effectiveWireKeep &&\n context?.protocolContext?.protocol === \"openai_responses\" &&\n !hasResponsesOwner\n ) {\n delete requestBody.prompt_cache_key;\n }\n\n if (\n !skipBodyConversion &&\n typeof transformer.transformRequestOut === \"function\"\n ) {\n const transformOut = await transformer.transformRequestOut(\n requestBody,\n context\n );\n if (transformOut.body) {\n requestBody = transformOut.body;\n config = transformOut.config || {};\n } else {\n requestBody = transformOut;\n }\n }\n\n // Build the plan for the middleware loop.\n // - bypass: skip entire chain (native wire || deprecated)\n // - wire keep: use the already-compiled plan, run allowlisted middleware + OpenAI owner\n // - otherwise: legacy compile with skipName for passthrough shim\n let plan: any | undefined;\n if (bypass) {\n plan = undefined;\n } else if (effectiveWireKeep) {\n plan = wireKeepPlan;\n } else {\n const modelUse = provider.transformer?.[body.model]?.use as\n | Transformer[]\n | undefined;\n const providerUse = provider.transformer?.use as Transformer[] | undefined;\n if (providerUse?.length || modelUse?.length) {\n try {\n plan = compileTransformerPlan(providerUse, modelUse, {\n skipName: manualExactPassthrough ? transformer.name : undefined,\n });\n } catch (error: any) {\n throw createApiError(\n error?.message || \"Invalid transformer configuration\",\n 400,\n \"invalid_request_error\",\n \"invalid_request_error\"\n );\n }\n }\n }\n\n // Wire-keep filtered loop: skip body rebuild for Anthropic/Responses owners,\n // run only wire-safe middleware + always run OpenAI owner (Chat === Unified).\n if (effectiveWireKeep && plan) {\n const ownerName = (transformer as any)?.name as string | undefined;\n for (const chainTransformer of plan.request) {\n if (\n !chainTransformer ||\n typeof chainTransformer.transformRequestIn !== \"function\"\n ) {\n continue;\n }\n const tName = (chainTransformer as any).name as string | undefined;\n const isOwner = tName === ownerName;\n if (isOwner) {\n if (tName === \"Anthropic\" || tName === \"openai-responses\") {\n continue;\n }\n // OpenAI owner: always run (policy + media extract) on kept wire\n } else if (!isWireSafeMiddlewareForKeep(tName, ownerName)) {\n continue;\n }\n const transformIn = await chainTransformer.transformRequestIn(\n requestBody,\n provider,\n context\n );\n if (transformIn.body) {\n requestBody = transformIn.body;\n const nextConfig = transformIn.config || {};\n const previousResponse = config.__providerResponse as\n | Response\n | undefined;\n const nextResponse = nextConfig.__providerResponse as\n | Response\n | undefined;\n cancelReplacedProviderResponse(previousResponse, nextResponse);\n config = {\n ...config,\n ...nextConfig,\n headers: mergeHeadersCaseInsensitive(\n config.headers,\n nextConfig.headers\n ),\n };\n } else {\n requestBody = transformIn;\n }\n }\n // Transport URL/headers for Anthropic/Responses keep were in the owner\n // In body rebuild; now pull them from auth() so fetch has a URL.\n const authOwnerName = (transformer as any)?.name as string | undefined;\n if (\n (authOwnerName === \"Anthropic\" || authOwnerName === \"openai-responses\") &&\n typeof transformer.auth === \"function\"\n ) {\n try {\n const authOut = await transformer.auth(requestBody, provider, context);\n if (authOut?.config?.url && !config.url) config.url = authOut.config.url;\n if (authOut?.config?.headers) {\n config.headers = mergeHeadersCaseInsensitive(\n config.headers,\n authOut.config.headers\n );\n if (authOut.config.__authRecovery) {\n config.__authRecovery = authOut.config.__authRecovery;\n }\n } else if (authOut?.config?.__authRecovery) {\n config.__authRecovery = authOut.config.__authRecovery;\n }\n } catch {\n // auth failure will surface on fetch; don't hide the request path\n }\n }\n } else if (plan) {\n for (const chainTransformer of plan.request) {\n if (\n !chainTransformer ||\n typeof chainTransformer.transformRequestIn !== \"function\"\n ) {\n continue;\n }\n const transformIn = await chainTransformer.transformRequestIn(\n requestBody,\n provider,\n context\n );\n if (transformIn.body) {\n requestBody = transformIn.body;\n const nextConfig = transformIn.config || {};\n const previousResponse = config.__providerResponse as\n | Response\n | undefined;\n const nextResponse = nextConfig.__providerResponse as\n | Response\n | undefined;\n cancelReplacedProviderResponse(previousResponse, nextResponse);\n config = {\n ...config,\n ...nextConfig,\n headers: mergeHeadersCaseInsensitive(\n config.headers,\n nextConfig.headers\n ),\n };\n } else {\n requestBody = transformIn;\n }\n }\n }\n\n if (\n !bypass &&\n !effectiveWireKeep &&\n !provider.transformer?.use?.length &&\n Array.isArray(requestBody?.messages)\n ) {\n requestBody = applyOpenAIChatReasoning(requestBody);\n requestBody = applyProviderNativeChatCaching(\n requestBody,\n provider,\n context\n );\n }\n\n return { requestBody, config, bypass, wireKeep: effectiveWireKeep };\n}\n\n/**\n * Snapshot the client-leg cache prefix before the provider transformer chain\n * runs. Held on the request so the wire snapshot can attribute a broken prefix\n * to the client or to our own transformers instead of leaving it ambiguous.\n */\nfunction cachePrefixConversation(req: any, body: any) {\n const nested =\n req?.protocolContext?.nestedAgent === true ||\n req?.protocolContext?.claudeCodeSubagent === true;\n return resolveCachePrefixConversationId({\n sessionId: typeof req?.sessionId === \"string\" ? req.sessionId : undefined,\n nestedAgent: nested,\n firstUserText: firstSubstantiveUserText(body || {}),\n });\n}\n\nfunction recordClientCachePrefix(\n req: any,\n fastify: FastifyInstance,\n provider: any,\n body: any\n): void {\n if (!req) return;\n if (isStatuslinePollTurn(body || {})) {\n // Statusline polls share the session id but are not a real turn. Committing\n // them as the baseline makes the next tool result look like a 25k-token miss.\n req._omitCachePrefix = true;\n return;\n }\n const conversation = cachePrefixConversation(req, body);\n req._cachePrefixConversation = conversation;\n req._cachePrefixClientDiff = logOutboundCacheStructure(body, {\n logger: req.log ?? fastify.log,\n reqId: req.id,\n provider: provider?.name,\n model: body?.model,\n conversationId: conversation.id,\n conversationIdSource: conversation.source,\n stage: \"client\",\n });\n}\n\n/**\n * Send request to LLM provider\n * Handle authentication, build request config, send request and handle errors\n */\nasync function sendRequestToProvider(\n requestBody: any,\n config: any,\n provider: any,\n fastify: FastifyInstance,\n bypass: boolean,\n transformer: any,\n context: any\n) {\n const conversation =\n context?.req?._cachePrefixConversation ??\n cachePrefixConversation(context?.req, requestBody);\n const debugOpts = {\n logger: context?.req?.log ?? fastify.log,\n reqId: context?.req?.id,\n provider: provider?.name,\n model: requestBody?.model,\n conversationId: conversation.id ?? context?.req?.sessionId,\n conversationIdSource: conversation.source,\n commitCachePrefix: context?.req?._omitCachePrefix ? false : undefined,\n };\n\n const tapProviderResponse = async (response: Response) => {\n if (context?.req?._omitCachePrefix) {\n return response;\n }\n const cursorLifecycle = context?.req?._cursorCacheLifecycle ?? null;\n const cacheDiff = logOutboundCacheStructure(requestBody, {\n ...debugOpts,\n stage: \"wire\",\n responseStatus: response?.status,\n clientStageDiff: context?.req?._cachePrefixClientDiff,\n outboundBody: requestBody,\n cursorLifecycle,\n cacheAffinity: {\n sessionId: config?.headers?.[\"session-id\"],\n threadId: config?.headers?.[\"thread-id\"],\n },\n });\n return tapUpstreamSSEDebug(response, {\n ...debugOpts,\n responseStatus: response?.status,\n clientStageDiff: context?.req?._cachePrefixClientDiff,\n cacheDiff,\n outboundBody: requestBody,\n cursorLifecycle,\n direction: \"provider\u2192ccr\",\n maxBytes: resolveLogBodyMaxBytes(fastify.configService),\n rawEvents: shouldLogSSEEvents(fastify.configService),\n });\n };\n\n const logOutboundRequestBody = () => {\n const logger = context?.req?.log ?? fastify.log;\n const model =\n typeof requestBody?.model === \"string\" ? requestBody.model : undefined;\n if (context?.req?._wireKeep) {\n // Keep has no Anthropic-style inbound `request body` info log, and the\n // global fetch wrapper omits bodies. Digest the\n // kept wire at debug so encrypted replay is greppable without a dump.\n logKeepWire(requestBody, {\n logger,\n reqId: context?.req?.id,\n provider: provider?.name,\n model,\n });\n }\n const selection = resolveLogBodySelection(fastify.configService);\n if (selection === undefined) return;\n logMessageBody(requestBody, {\n logger,\n direction: \"ccr\u2192provider\",\n reqId: context?.req?.id,\n provider: provider?.name,\n model,\n maxBytes: resolveLogBodyMaxBytes(fastify.configService),\n selection,\n });\n };\n\n // Allow a transformer to own the full upstream call (non-fetch transports,\n // agent SDKs, etc.) by returning a ready Response via __providerResponse.\n if (config?.__providerResponse) {\n // Body was already posted inside the owning transformer; still record it\n // so part capture covers OpenCode Zen / SDK-owned legs.\n logOutboundRequestBody();\n return tapProviderResponse(config.__providerResponse as Response);\n }\n\n // Handle authentication in passthrough mode\n const authTransformer =\n provider.transformer?.use?.find(\n (providerTransformer: Transformer) =>\n typeof providerTransformer?.auth === \"function\"\n ) || transformer;\n if (\n (bypass || provider.transformer?.passthrough) &&\n typeof authTransformer.auth === \"function\"\n ) {\n const auth = await authTransformer.auth(requestBody, provider, context);\n if (auth.body) {\n requestBody = auth.body;\n let headers = config.headers || {};\n if (auth.config?.headers) {\n headers = mergeHeadersCaseInsensitive(\n headers,\n auth.config.headers\n );\n delete headers.host;\n delete auth.config.headers;\n }\n config = {\n ...config,\n ...auth.config,\n headers,\n };\n } else {\n requestBody = auth;\n }\n }\n\n // Resolved after auth: a passthrough transformer's auth() is the stage that\n // knows the protocol-correct upstream path (e.g. Anthropic's\n // /v1/messages?beta=true derived from a bare provider origin).\n const url = config.url || new URL(provider.baseUrl);\n\n // Provider auth is generated independently from client headers. Canonicalize\n // casing and guarantee that only one authentication scheme survives.\n const requestHeaders = canonicalizeOutboundHeaders(\n config?.headers,\n provider.apiKey\n );\n\n // const clientHeaders = context?.req?.headers as\n // | Record\n // | undefined;\n // context?.req?.log?.debug?.(\n // {\n // reqId: context?.req?.id,\n // provider: provider.name,\n // outboundHeaders: sanitizeHeadersForLog(requestHeaders),\n // clientHeaders: sanitizeHeadersForLog(clientHeaders),\n // headerDiff: {\n // direction: \"client -> outbound\",\n // ...diffHeadersForLog(clientHeaders, requestHeaders),\n // },\n // },\n // \"provider request headers diff\"\n // );\n\n // Keep requestHeaders construction intact above; only the verbose header diff\n // logging is disabled here to reduce sensitive metadata in debug logs.\n\n\n const {\n __authRecovery,\n ...providerRequestConfig\n } = config || {};\n logOutboundRequestBody();\n const send = (headers: Record) =>\n sendUnifiedRequest(\n url,\n requestBody,\n {\n httpsProxy: fastify.configService.getHttpsProxy(),\n ...providerRequestConfig,\n headers: { ...headers },\n signal: context?.signal ?? providerRequestConfig.signal,\n },\n context,\n fastify.log\n );\n\n const response = await sendWithUnauthorizedAuthRecovery(\n send,\n requestHeaders,\n __authRecovery\n );\n\n // context?.req?.log?.debug?.(\n // {\n // reqId: context?.req?.id,\n // provider: provider.name,\n // status: response.status,\n // headers: sanitizeHeadersForLog(response.headers),\n // },\n // \"provider response headers\"\n // );\n\n // Keep status handling below active; only raw response header logging is\n // disabled here.\n\n // Handle request errors. Read the non-2xx body once and throw a structured\n // upstream error: the client-protocol boundary (errorHandler) reshapes the\n // sanitized body into the caller's wire envelope instead of flattening\n // every failure into an unrecognizable provider_response_error string.\n if (!response.ok) {\n const errorText = await response.text();\n const safeErrorText = sanitizeUpstreamErrorText(errorText) || errorText.slice(0, 240);\n\n let parsedBody: unknown;\n try {\n parsedBody = JSON.parse(errorText);\n } catch {\n parsedBody = undefined;\n }\n const upstreamError =\n parsedBody && typeof parsedBody === \"object\"\n ? (parsedBody as any).error\n : undefined;\n\n // Safe response-header map: retry/observability metadata only.\n const safeHeaders = selectSafeDownstreamHeaders(response.headers);\n let headers: Record | undefined =\n Object.keys(safeHeaders).length > 0 ? safeHeaders : undefined;\n\n // Retry-After may also hide inside a Google-RPC RetryInfo body detail.\n if (!headers?.[\"retry-after\"] && response.status === 429) {\n const details =\n (upstreamError as any)?.details || (parsedBody as any)?.details;\n if (Array.isArray(details)) {\n const retryInfo = details.find((d: any) => d['@type'] === 'type.googleapis.com/google.rpc.RetryInfo');\n if (retryInfo?.retryDelay) {\n const seconds = parseInt(retryInfo.retryDelay, 10);\n if (!isNaN(seconds)) {\n headers = { ...(headers || {}), 'retry-after': seconds.toString() };\n }\n }\n }\n }\n\n const upstreamMessage =\n typeof upstreamError?.message === \"string\"\n ? upstreamError.message\n : undefined;\n const safeMessage =\n sanitizeUpstreamErrorText(upstreamMessage || errorText) || safeErrorText;\n\n // Log parsed error details for observability (redacted)\n fastify.log.error(\n {\n status: response.status,\n provider: provider.name,\n model: requestBody.model,\n errorMessage: safeMessage,\n upstreamType:\n typeof upstreamError?.type === \"string\"\n ? upstreamError.type\n : undefined,\n upstreamCode:\n typeof upstreamError?.code === \"string\"\n ? upstreamError.code\n : undefined,\n },\n `[provider_response_error] ${provider.name},${requestBody.model}: ${safeMessage}`,\n );\n\n const error = createApiError(\n `Error from provider(${provider.name},${requestBody.model}: ${response.status}): ${safeMessage}`,\n response.status,\n typeof upstreamError?.code === \"string\"\n ? upstreamError.code\n : \"provider_response_error\",\n \"api_error\",\n headers\n );\n (error as any).upstream = {\n status: response.status,\n statusText: response.statusText,\n headers: headers ?? {},\n body:\n parsedBody !== undefined\n ? sanitizeUpstreamErrorBody(parsedBody)\n : undefined,\n // Log-side provenance only; never serialized to the client.\n provider: provider.name,\n model: requestBody.model,\n };\n throw error;\n }\n\n return tapProviderResponse(response);\n}\n\n/**\n * Process response transformer chain\n * Sequentially execute provider transformers, model-specific transformers, transformer's transformResponseIn\n */\nasync function processResponseTransformers(\n requestBody: any,\n response: any,\n provider: any,\n transformer: any,\n bypass: boolean,\n context: any\n) {\n let finalResponse = response;\n const thirdPartyAnthropic = isThirdPartyInScopeAnthropic(\n context?.protocolContext\n );\n // Raw provider bytes may reach the client only for an exact-protocol bypass,\n // including the legacy multi-transformer passthrough mode when its chain\n // explicitly contains the endpoint owner.\n const skipBodyConversion =\n bypass ||\n (!thirdPartyAnthropic &&\n isManualExactProtocolPassthrough(\n provider,\n transformer,\n context?.protocolContext\n )) ||\n (provider.transformer?.passthrough && !context?.protocolContext);\n const manualExactPassthrough =\n !thirdPartyAnthropic &&\n isManualExactProtocolPassthrough(\n provider,\n transformer,\n context?.protocolContext\n );\n\n // Response transformers get the provider too: the request-side context\n // already carries it, and provider identity is what scopes per-provider state\n // such as the Gemini thought-signature cache.\n const responseContext = { ...context, provider };\n\n const modelUse = !bypass\n ? (provider.transformer?.[requestBody.model]?.use as\n | Transformer[]\n | undefined)\n : undefined;\n const providerUse = !bypass\n ? (provider.transformer?.use as Transformer[] | undefined)\n : undefined;\n let exactProtocolResponse = false;\n\n if (providerUse?.length || modelUse?.length) {\n let plan;\n try {\n plan = compileTransformerPlan(providerUse, modelUse, {\n skipName: manualExactPassthrough ? transformer.name : undefined,\n });\n } catch (error: any) {\n throw createApiError(\n error?.message || \"Invalid transformer configuration\",\n 400,\n \"invalid_request_error\",\n \"invalid_request_error\"\n );\n }\n exactProtocolResponse = isExactProtocolResponsePlan(\n plan,\n transformer,\n context?.protocolContext?.ownerTransformerName\n );\n\n for (const chainTransformer of plan.response) {\n if (\n !chainTransformer ||\n (exactProtocolResponse &&\n chainTransformer.name === transformer.name) ||\n typeof chainTransformer.transformResponseOut !== \"function\"\n ) {\n continue;\n }\n finalResponse = await chainTransformer.transformResponseOut!(\n finalResponse,\n responseContext\n );\n }\n }\n\n // Execute transformer's transformResponseIn method\n if (\n !skipBodyConversion &&\n !exactProtocolResponse &&\n transformer.transformResponseIn\n ) {\n finalResponse = await transformer.transformResponseIn(\n finalResponse,\n context\n );\n }\n\n return finalResponse;\n}\n\n/**\n * Format and return response.\n * Stream intent comes from ClientProtocolContext when provided; body.stream\n * remains a fallback for legacy callers.\n */\nasync function formatResponse(\n response: any,\n reply: FastifyReply,\n body: any,\n clientSignal?: AbortSignal,\n streamIntent?: boolean,\n protocol?: ClientProtocol,\n debug?: {\n configService?: ConfigService;\n provider?: string;\n model?: string;\n }\n) {\n // Set HTTP status code\n if (!response.ok) {\n reply.code(response.status);\n }\n\n // Forward safe upstream observability headers (rate-limit metadata, request\n // ids, retry hints) that transformers preserved on the reshaped Response.\n // Local framing headers (Content-Type, Cache-Control, Connection) are set\n // afterwards, so they always win over anything copied here.\n const downstreamHeaders = selectSafeDownstreamHeaders(response.headers);\n for (const [name, value] of Object.entries(downstreamHeaders)) {\n reply.header(name, value);\n }\n\n const log = reply.log ?? (reply.request as any)?.log;\n const reqId = (reply.request as any)?.id;\n const rawSSE = shouldLogSSEEvents(debug?.configService);\n const bodySelection = resolveLogBodySelection(debug?.configService);\n const maxBytes = resolveLogBodyMaxBytes(debug?.configService);\n\n // Handle streaming response\n const isStream =\n typeof streamIntent === \"boolean\" ? streamIntent : body?.stream === true;\n if (isStream && response.ok) {\n // Convert Web API ReadableStream to Node.js stream for Fastify\n if (response.body && typeof response.body.getReader === \"function\") {\n // fromWeb() locks response.body; destroy() cancels via that reader.\n // Never call response.body.cancel() afterward \u2014 it rejects with\n // ERR_INVALID_STATE (\"ReadableStream is locked\") as an unhandledRejection.\n //\n // Keepalive comments every 10s of upstream silence so Claude Code's 20s\n // byte-idle spinner (\"Waiting for API response \u00B7 check your network\")\n // does not abort-and-retry during Anthropic's ~25\u201330s ping gaps.\n // Passthrough skips OpenAITransformer.transformResponseIn, so the\n // [DONE]/cost-trailer split has to live here \u2014 Chat Completions clients\n // JSON.parse the concatenated payload.\n const framed =\n protocol === \"openai_chat_completions\"\n ? withChatCompletionsDoneBoundary(response.body)\n : response.body;\n const keptAlive = withSSEClientKeepalive(framed);\n const clientBody = tapClientSSEDebug(keptAlive, {\n logger: log,\n reqId,\n provider: debug?.provider,\n model: debug?.model,\n protocol,\n maxBytes,\n rawEvents: rawSSE,\n });\n const nodeStream = Readable.fromWeb(clientBody as any);\n let cleanedUp = false;\n const latency = (reply.request as any)?._latency;\n const socketGone = isResponseSocketGone(reply);\n let sawFirstByte = false;\n\n const cleanup = () => {\n if (cleanedUp) return;\n cleanedUp = true;\n attachLatencyMeta(latency, {\n cancelled: Boolean(clientSignal?.aborted || socketGone),\n });\n emitLatencyRecord(reply.log ?? (reply.request as any)?.log, latency);\n try {\n if (!nodeStream.destroyed) {\n nodeStream.destroy();\n }\n } catch {\n // ignore\n }\n };\n\n nodeStream.once(\"data\", () => {\n if (!sawFirstByte) {\n sawFirstByte = true;\n markLatency(latency, \"downstreamFirstByte\");\n }\n });\n nodeStream.once(\"end\", () => {\n emitLatencyRecord(reply.log ?? (reply.request as any)?.log, latency);\n });\n\n const detachAbort = () => {\n if (clientSignal) {\n clientSignal.removeEventListener(\"abort\", cleanup);\n }\n };\n\n // Only 499 when the TCP socket is actually gone. A disconnect signal\n // alone is not proof \u2014 Cursor previously got false 499 JSON bodies\n // while still connected (\"cancel stream: null\" then status 499).\n if (socketGone) {\n cleanup();\n if (!reply.sent && !reply.raw.destroyed) {\n reply.type(\"application/json\");\n return reply.code(499).send({\n error: {\n message: \"Client closed request\",\n type: \"api_error\",\n code: \"client_aborted\",\n },\n });\n }\n return reply;\n }\n\n if (clientSignal?.aborted) {\n reply.log?.warn?.(\n {\n reason: String((clientSignal as any).reason ?? \"\"),\n headersSent: reply.raw.headersSent,\n writableEnded: reply.raw.writableEnded,\n },\n \"disconnect signal fired but socket still open; continuing SSE\"\n );\n }\n\n reply.header(\"Content-Type\", \"text/event-stream\");\n reply.header(\"Cache-Control\", \"no-cache\");\n reply.header(\"Connection\", \"keep-alive\");\n\n if (clientSignal) {\n clientSignal.addEventListener(\"abort\", cleanup, { once: true });\n }\n\n // Client gone / broken pipe while streaming \u2014 abort upstream quietly.\n reply.raw.on(\"error\", (err: any) => {\n if (\n err?.code === \"EPIPE\" ||\n err?.code === \"ECONNRESET\" ||\n err?.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n isClientAbortError(err)\n ) {\n cleanup();\n }\n });\n reply.raw.on(\"close\", () => {\n if (!reply.raw.writableEnded) {\n cleanup();\n }\n });\n\n nodeStream.on(\"error\", (err: any) => {\n if (\n err?.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n err?.code === \"ABORT_ERR\" ||\n isClientAbortError(err)\n ) {\n return;\n }\n reply.log?.error?.(\n sanitizeErrorForLog(err),\n \"upstream stream error\"\n );\n });\n\n // After a normal stream end, response close no longer aborts (writableEnded),\n // but drop the listener anyway so cleanup cannot run twice on teardown.\n nodeStream.once(\"end\", detachAbort);\n nodeStream.once(\"close\", detachAbort);\n\n return reply.send(nodeStream);\n }\n // Web ReadableStream is not a valid Fastify payload for text/event-stream.\n reply.header(\"Content-Type\", \"text/event-stream\");\n reply.header(\"Cache-Control\", \"no-cache\");\n reply.header(\"Connection\", \"keep-alive\");\n if (response.body && typeof (response.body as any).pipe === \"function\") {\n return reply.send(response.body);\n }\n throw createApiError(\n \"Streaming response body is not a readable stream\",\n 502,\n \"provider_response_error\"\n );\n } else {\n // Handle regular JSON response (including error responses)\n const json = await response.json();\n if (bodySelection !== undefined || rawSSE) {\n logMessageBody(json, {\n logger: log ?? { debug() {} },\n direction: \"ccr\u2192client\",\n reqId,\n protocol,\n provider: debug?.provider,\n model: debug?.model,\n maxBytes,\n selection: bodySelection,\n });\n }\n const latency = (reply.request as any)?._latency;\n markLatency(latency, \"downstreamFirstByte\");\n emitLatencyRecord(reply.log ?? (reply.request as any)?.log, latency);\n return reply.send(json);\n }\n}\n\nexport const registerApiRoutes = async (\n fastify: FastifyInstance\n) => {\n const rateLimitOptions = {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n };\n\n // Detect the wire protocol before body parsing and route validation so even\n // malformed JSON and other early failures receive the correct error shape.\n fastify.addHook(\"onRequest\", async (req: FastifyRequest) => {\n const pathname = String(req.url || \"\").split(\"?\")[0] || \"/\";\n const match = matchClientProtocol(req.method, pathname);\n (req as any).pathname = pathname;\n if (match) {\n (req as any).protocolMatch = match;\n (req as any).clientProtocol = match.protocol;\n }\n });\n\n // Health and info endpoints\n fastify.get(\"/\", rateLimitOptions, async () => {\n return { message: \"LLMs API\", version };\n });\n\n fastify.get(\"/health\", rateLimitOptions, async () => {\n // The liveness contract (status + timestamp) is fixed. The process owner\n // may attach richer vitals; when it does not, the probe is unchanged.\n const vitals = readHealthVitals();\n return {\n status: \"ok\",\n timestamp: new Date().toISOString(),\n ...(vitals ? { vitals } : {}),\n };\n });\n\n // Client protocol routes (canonical + aliases) from the protocol registry.\n // Owner transformers are resolved by name so Vercel cannot claim Chat.\n const allTransformers = fastify.transformerService.getAllTransformers();\n const resolveOwner = (ownerName: string): Transformer | undefined => {\n const entry = allTransformers.get(ownerName);\n if (!entry) return undefined;\n if (typeof entry === \"object\") return entry as Transformer;\n try {\n const instance = new (entry as any)();\n if (instance && typeof instance === \"object\") {\n (instance as any).logger = fastify.log;\n }\n return instance as Transformer;\n } catch {\n return undefined;\n }\n };\n\n const claimedPaths = new Set();\n for (const reg of listClientRouteRegistrations()) {\n const transformer = resolveOwner(reg.ownerTransformerName);\n if (!transformer) {\n fastify.log.warn(\n `protocol route ${reg.path}: owner transformer '${reg.ownerTransformerName}' not found`\n );\n continue;\n }\n for (const routePath of [reg.path, `${reg.path}/`]) {\n if (claimedPaths.has(routePath)) continue;\n claimedPaths.add(routePath);\n const isFim = reg.protocol === \"openai_fim_completions\";\n fastify.post(\n routePath,\n rateLimitOptions,\n async (req: FastifyRequest, reply: FastifyReply) => {\n if (isFim) {\n return handleFimEndpoint(\n req,\n reply,\n fastify,\n transformer,\n routePath\n );\n }\n return handleTransformerEndpoint(\n req,\n reply,\n fastify,\n transformer,\n routePath\n );\n }\n );\n }\n }\n\n // `endPoint` remains provider-transformer metadata, but client route\n // registration is intentionally limited to the explicit protocol registry.\n\n fastify.post(\n \"/providers\",\n {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n schema: {\n body: {\n type: \"object\",\n properties: {\n id: { type: \"string\" },\n name: { type: \"string\" },\n type: { type: \"string\", enum: [\"openai\", \"anthropic\"] },\n baseUrl: { type: \"string\" },\n apiKey: { type: \"string\" },\n models: { type: \"array\", items: { type: \"string\" } },\n },\n required: [\"id\", \"name\", \"type\", \"baseUrl\", \"apiKey\", \"models\"],\n },\n },\n },\n async (\n request: FastifyRequest<{ Body: RegisterProviderRequest }>,\n _reply: FastifyReply\n ) => {\n // Validation\n const { name, baseUrl, apiKey, models } = request.body;\n\n if (!name?.trim()) {\n throw createApiError(\n \"Provider name is required\",\n 400,\n \"invalid_request\"\n );\n }\n\n if (!baseUrl || !isValidUrl(baseUrl)) {\n throw createApiError(\n \"Valid base URL is required\",\n 400,\n \"invalid_request\"\n );\n }\n\n if (!apiKey?.trim()) {\n throw createApiError(\"API key is required\", 400, \"invalid_request\");\n }\n\n if (!models || !Array.isArray(models) || models.length === 0) {\n throw createApiError(\n \"At least one model is required\",\n 400,\n \"invalid_request\"\n );\n }\n\n // Check if provider already exists\n if (fastify.providerService.getProvider(request.body.name)) {\n throw createApiError(\n `Provider with name '${request.body.name}' already exists`,\n 400,\n \"provider_exists\"\n );\n }\n\n return fastify.providerService.registerProvider(request.body);\n }\n );\n\n fastify.get(\"/providers\", rateLimitOptions, async () => {\n return fastify.providerService.getProviders();\n });\n\n fastify.get(\n \"/providers/:id\",\n {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n schema: {\n params: {\n type: \"object\",\n properties: { id: { type: \"string\" } },\n required: [\"id\"],\n },\n },\n },\n async (request: FastifyRequest<{ Params: { id: string } }>) => {\n const provider = fastify.providerService.getProvider(\n request.params.id\n );\n if (!provider) {\n throw createApiError(\"Provider not found\", 404, \"provider_not_found\");\n }\n return provider;\n }\n );\n\n fastify.put(\n \"/providers/:id\",\n {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n schema: {\n params: {\n type: \"object\",\n properties: { id: { type: \"string\" } },\n required: [\"id\"],\n },\n body: {\n type: \"object\",\n properties: {\n name: { type: \"string\" },\n type: { type: \"string\", enum: [\"openai\", \"anthropic\"] },\n baseUrl: { type: \"string\" },\n apiKey: { type: \"string\" },\n models: { type: \"array\", items: { type: \"string\" } },\n enabled: { type: \"boolean\" },\n },\n },\n },\n },\n async (\n request: FastifyRequest<{\n Params: { id: string };\n Body: Partial;\n }>,\n _reply\n ) => {\n const provider = fastify.providerService.updateProvider(\n request.params.id,\n request.body\n );\n if (!provider) {\n throw createApiError(\"Provider not found\", 404, \"provider_not_found\");\n }\n return provider;\n }\n );\n\n fastify.delete(\n \"/providers/:id\",\n {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n schema: {\n params: {\n type: \"object\",\n properties: { id: { type: \"string\" } },\n required: [\"id\"],\n },\n },\n },\n async (request: FastifyRequest<{ Params: { id: string } }>) => {\n const success = fastify.providerService.deleteProvider(\n request.params.id\n );\n if (!success) {\n throw createApiError(\"Provider not found\", 404, \"provider_not_found\");\n }\n return { message: \"Provider deleted successfully\" };\n }\n );\n\n fastify.patch(\n \"/providers/:id/toggle\",\n {\n config: { rateLimit: { ...RATE_LIMIT_CONFIG } },\n schema: {\n params: {\n type: \"object\",\n properties: { id: { type: \"string\" } },\n required: [\"id\"],\n },\n body: {\n type: \"object\",\n properties: { enabled: { type: \"boolean\" } },\n required: [\"enabled\"],\n },\n },\n },\n async (\n request: FastifyRequest<{\n Params: { id: string };\n Body: { enabled: boolean };\n }>,\n _reply\n ) => {\n const success = fastify.providerService.toggleProvider(\n request.params.id,\n request.body.enabled\n );\n if (!success) {\n throw createApiError(\"Provider not found\", 404, \"provider_not_found\");\n }\n return {\n message: `Provider ${request.body.enabled ? \"enabled\" : \"disabled\"\n } successfully`,\n };\n }\n );\n};\n\n// Helper function\nfunction isValidUrl(url: string): boolean {\n try {\n new URL(url);\n return true;\n } catch {\n return false;\n }\n}\n", "import { ProxyAgent } from \"undici\";\nimport { UnifiedChatRequest } from \"../types/llm\";\n// import { diffHeadersForLog, sanitizeHeadersForLog } from \"./redact\";\nimport { createApiError } from \"../api/middleware\";\nimport {\n CLIENT_DISCONNECT_REASON,\n isClientAbortError,\n isProviderNetworkError,\n toClientAbortError,\n} from \"./retry\";\nimport { markLatency } from \"./request-latency\";\n\nconst proxyDispatchers = new Map();\n\n/** One Undici ProxyAgent per normalized proxy URL so connections can be reused. */\nexport function getProxyDispatcher(httpsProxy: string): ProxyAgent {\n const key = new URL(httpsProxy).toString();\n let agent = proxyDispatchers.get(key);\n if (!agent) {\n agent = new ProxyAgent(key);\n proxyDispatchers.set(key, agent);\n }\n return agent;\n}\n\n/** Close every cached ProxyAgent (call on server shutdown). */\nexport function closeProxyDispatchers(): void {\n for (const agent of proxyDispatchers.values()) {\n try {\n void agent.close();\n } catch {\n // Best-effort cleanup during shutdown.\n }\n }\n proxyDispatchers.clear();\n}\n\n/** Test-only: inspect the module-level dispatcher cache. */\nexport function __getProxyDispatcherCacheForTests(): Map {\n return proxyDispatchers;\n}\n\nfunction normalizeHostname(hostname: string): string {\n return hostname\n .trim()\n .toLowerCase()\n .replace(/^\\[(.*)\\]$/, \"$1\")\n .replace(/\\.$/, \"\");\n}\n\nfunction isPlainIp(value: string): boolean {\n return /^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(value);\n}\n\nfunction ipToInt(ip: string): number | null {\n const parts = ip.split(\".\");\n if (parts.length !== 4) return null;\n let result = 0;\n for (const part of parts) {\n const num = parseInt(part, 10);\n if (Number.isNaN(num) || num < 0 || num > 255) return null;\n result = (result << 8) | num;\n }\n return result >>> 0;\n}\n\nfunction isInCidr(ip: string, cidr: string): boolean {\n const [network, prefixStr] = cidr.split(\"/\");\n const prefix = parseInt(prefixStr, 10);\n if (Number.isNaN(prefix) || prefix < 0 || prefix > 32) return false;\n\n const ipInt = ipToInt(ip);\n const netInt = ipToInt(network);\n if (ipInt === null || netInt === null) return false;\n\n const mask = prefix === 0 ? 0 : (~0 << (32 - prefix)) >>> 0;\n return (ipInt & mask) === (netInt & mask);\n}\n\n/** Loopback and NO_PROXY/no_proxy hosts should not go through HTTPS_PROXY. */\nexport function shouldBypassProxy(target: URL | string): boolean {\n let url: URL;\n try {\n url = typeof target === \"string\" ? new URL(target) : target;\n } catch {\n // Fail closed to direct (no proxy) on unparseable URLs.\n return true;\n }\n\n const hostname = normalizeHostname(url.hostname);\n if (\n hostname === \"localhost\" ||\n hostname === \"127.0.0.1\" ||\n hostname.startsWith(\"127.\") ||\n hostname === \"0.0.0.0\" ||\n hostname === \"::1\" ||\n hostname === \"0:0:0:0:0:0:0:1\"\n ) {\n return true;\n }\n\n const noProxy = process.env.NO_PROXY || process.env.no_proxy;\n if (!noProxy) return false;\n\n const patterns = noProxy\n .split(\",\")\n .map((part) => part.trim())\n .filter(Boolean);\n\n for (const rawPattern of patterns) {\n const pattern = rawPattern.toLowerCase();\n if (pattern === \"*\") return true;\n\n // host:port \u2014 match hostname only. Keep IPv6 literals intact (multiple ':').\n const patternHost = stripNoProxyPort(pattern);\n\n if (patternHost.startsWith(\".\")) {\n if (\n hostname.endsWith(patternHost) ||\n hostname === patternHost.slice(1)\n ) {\n return true;\n }\n continue;\n }\n\n if (patternHost.includes(\"/\") && isPlainIp(hostname)) {\n if (isInCidr(hostname, patternHost)) return true;\n continue;\n }\n\n if (hostname === patternHost) return true;\n\n // \"*.example.com\" style\n if (patternHost.startsWith(\"*.\")) {\n const suffix = patternHost.slice(1); // \".example.com\"\n if (hostname.endsWith(suffix) || hostname === suffix.slice(1)) {\n return true;\n }\n }\n }\n\n return false;\n}\n\n/** Strip :port from NO_PROXY entries without mangling IPv6 addresses. */\nfunction stripNoProxyPort(pattern: string): string {\n if (pattern.startsWith(\"[\") && pattern.includes(\"]\")) {\n return pattern.slice(1, pattern.indexOf(\"]\"));\n }\n const colonCount = pattern.split(\":\").length - 1;\n if (colonCount === 1) {\n const [host, port] = pattern.split(\":\");\n if (/^\\d+$/.test(port)) return host;\n }\n return pattern;\n}\n\nexport async function sendUnifiedRequest(\n url: URL | string,\n request: UnifiedChatRequest,\n config: any,\n context: any,\n _logger?: any\n): Promise {\n const headers = new Headers({\n \"Content-Type\": \"application/json\",\n });\n if (config.headers) {\n Object.entries(config.headers).forEach(([key, value]) => {\n if (value) {\n headers.set(key, value as string);\n }\n });\n }\n const timeoutSignal = AbortSignal.timeout(config.TIMEOUT ?? 60 * 1000 * 60);\n // AbortSignal.any correctly handles already-aborted inputs.\n const combinedSignal: AbortSignal = config.signal\n ? AbortSignal.any([config.signal, timeoutSignal])\n : timeoutSignal;\n\n const fetchOptions: RequestInit = {\n method: \"POST\",\n headers: headers,\n body: JSON.stringify(request),\n signal: combinedSignal,\n };\n\n const requestUrl = typeof url === \"string\" ? url : url.toString();\n const useProxy =\n Boolean(config.httpsProxy) && !shouldBypassProxy(requestUrl);\n\n if (useProxy) {\n (fetchOptions as any).dispatcher = getProxyDispatcher(config.httpsProxy);\n }\n\n // const clientHeaders = context?.req?.headers as\n // | Record\n // | undefined;\n // const outboundHeaders = sanitizeHeadersForLog(headers);\n // logger?.debug(\n // {\n // reqId: context?.req?.id,\n // method: fetchOptions.method,\n // headers: outboundHeaders,\n // clientHeaders: sanitizeHeadersForLog(clientHeaders),\n // headerDiff: {\n // direction: \"client -> outbound\",\n // ...diffHeadersForLog(clientHeaders, headers),\n // },\n // requestUrl,\n // useProxy,\n // },\n // \"final request\"\n // );\n\n // Keep the request execution unchanged below; only verbose header logging is\n // disabled here.\n\n try {\n markLatency(context?.req?._latency, \"upstreamFetchStart\");\n const response = await fetch(requestUrl, fetchOptions);\n markLatency(context?.req?._latency, \"upstreamHeaders\");\n return response;\n } catch (error: any) {\n // AbortSignal.any + abort(string) may reject with a bare string. Normalize\n // so middleware classifies it as 499 instead of a 500 internal error.\n // Do NOT treat timeout aborts (AbortSignal.timeout) as client disconnects.\n if (isClientAbortError(error)) {\n throw typeof error === \"string\" ? toClientAbortError(error) : error;\n }\n if (\n config.signal?.aborted &&\n isClientAbortError(config.signal.reason ?? CLIENT_DISCONNECT_REASON)\n ) {\n throw toClientAbortError(config.signal.reason ?? error);\n }\n if (isProviderNetworkError(error)) {\n const networkError = createApiError(\n error?.message || \"Provider network error\",\n 502,\n \"provider_network_error\"\n );\n (networkError as any).cause = error;\n throw networkError;\n }\n throw error;\n }\n}\n", "/**\n * Request-stage latency timings. Allocation-light monotonic stamps; one\n * terminal structured record per request. No per-event logging, no tee.\n */\n\nexport type LatencyStage =\n | \"received\"\n | \"bodyParsed\"\n | \"normalized\"\n | \"projectLookup\"\n | \"tokenizeStart\"\n | \"tokenizeEnd\"\n | \"routeSelected\"\n | \"destinationPolicy\"\n | \"requestTransformers\"\n | \"upstreamFetchStart\"\n | \"upstreamHeaders\"\n | \"upstreamFirstByte\"\n | \"responseTransformers\"\n | \"downstreamFirstByte\"\n | \"complete\";\n\nexport type RequestLatency = {\n t0: number;\n stages: Partial>;\n meta: {\n protocol?: string;\n provider?: string;\n model?: string;\n method?: string;\n url?: string;\n scenario?: string;\n bypass?: boolean;\n wireKeep?: boolean;\n tokenCount?: number;\n tokenCountSource?: \"exact\" | \"estimate\" | \"skipped\";\n inputBytes?: number;\n upstreamAttempts?: number;\n cancelled?: boolean;\n error?: string;\n };\n emitted?: boolean;\n};\n\nexport function createRequestLatency(): RequestLatency {\n return {\n t0: performance.now(),\n stages: { received: 0 },\n meta: {},\n };\n}\n\nexport function markLatency(\n latency: RequestLatency | undefined | null,\n stage: LatencyStage\n): void {\n if (!latency || latency.emitted || latency.stages[stage] !== undefined) return;\n latency.stages[stage] = performance.now() - latency.t0;\n}\n\nexport function tapResponseFirstByte(\n response: Response,\n onFirstByte: () => void\n): Response {\n if (!response.body) return response;\n\n const reader = response.body.getReader();\n let firstByteSeen = false;\n let finished = false;\n const body = new ReadableStream({\n async pull(controller) {\n if (finished) return;\n try {\n const { done, value } = await reader.read();\n if (done) {\n finished = true;\n controller.close();\n return;\n }\n if (!firstByteSeen) {\n firstByteSeen = true;\n onFirstByte();\n }\n controller.enqueue(value);\n } catch (error) {\n finished = true;\n controller.error(error);\n }\n },\n async cancel(reason) {\n finished = true;\n await reader.cancel(reason).catch(() => undefined);\n },\n });\n\n return new Response(body, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n}\n\nexport function attachLatencyMeta(\n latency: RequestLatency | undefined | null,\n meta: Partial\n): void {\n if (!latency || latency.emitted) return;\n Object.assign(latency.meta, meta);\n}\n\n/** Emit one structured terminal latency record. Safe to call multiple times. */\nexport function emitLatencyRecord(\n logger: { info?: (obj: unknown, msg?: string) => void } | undefined | null,\n latency: RequestLatency | undefined | null\n): void {\n if (!latency || latency.emitted) return;\n latency.emitted = true;\n if (!latency.stages.complete) {\n latency.stages.complete = performance.now() - latency.t0;\n }\n const s = latency.stages;\n const tokenizeMs =\n s.tokenizeStart !== undefined && s.tokenizeEnd !== undefined\n ? s.tokenizeEnd - s.tokenizeStart\n : undefined;\n const upstreamHeaderMs =\n s.upstreamFetchStart !== undefined && s.upstreamHeaders !== undefined\n ? s.upstreamHeaders - s.upstreamFetchStart\n : undefined;\n const ccrTtftMs =\n s.downstreamFirstByte !== undefined ? s.downstreamFirstByte : undefined;\n const upstreamTtftMs =\n s.upstreamFirstByte !== undefined && s.upstreamFetchStart !== undefined\n ? s.upstreamFirstByte - s.upstreamFetchStart\n : undefined;\n const conversionDelayMs =\n s.downstreamFirstByte !== undefined && s.upstreamFirstByte !== undefined\n ? s.downstreamFirstByte - s.upstreamFirstByte\n : undefined;\n\n logger?.info?.(\n {\n type: \"latency\",\n ...latency.meta,\n stagesMs: s,\n tokenizeMs,\n upstreamHeaderMs,\n upstreamTtftMs,\n ccrTtftMs,\n conversionDelayMs,\n totalMs: s.complete,\n },\n \"request latency\"\n );\n}\n\nexport function ensureRequestLatency(req: {\n _latency?: RequestLatency;\n}): RequestLatency {\n if (!req._latency) {\n req._latency = createRequestLatency();\n }\n return req._latency;\n}\n", "/**\n * Optional process vitals for the `/health` probe.\n *\n * The API routes are registered inside encapsulated Fastify plugins, which\n * snapshot the instance they inherit from at registration time \u2014 a decorator\n * added to the root afterwards is invisible to them. Whoever owns the process\n * (the server package, which builds its health heartbeat after the routes are\n * up) therefore publishes the reporter here instead.\n */\nexport type HealthReporter = () => unknown;\n\nlet reporter: HealthReporter | undefined;\n\nexport function setHealthReporter(fn: HealthReporter | undefined): void {\n reporter = fn;\n}\n\n/** Vitals for the current instant, or `undefined` when none are published. */\nexport function readHealthVitals(): unknown {\n if (!reporter) return undefined;\n try {\n return reporter();\n } catch {\n // A liveness probe must answer even when the reporter is broken.\n return undefined;\n }\n}\n", "{\n \"name\": \"@caeliq/llms\",\n \"version\": \"1.0.71\",\n \"description\": \"A universal LLM API transformation server\",\n \"main\": \"dist/cjs/server.cjs\",\n \"module\": \"dist/esm/server.mjs\",\n \"types\": \"./dist/index.d.ts\",\n \"type\": \"module\",\n \"exports\": {\n \".\": {\n \"types\": \"./dist/index.d.ts\",\n \"import\": \"./dist/esm/server.mjs\",\n \"require\": \"./dist/cjs/server.cjs\"\n }\n },\n \"scripts\": {\n \"tsx\": \"tsx\",\n \"build\": \"tsx scripts/build.ts\",\n \"build:watch\": \"tsx scripts/build.ts --watch\",\n \"dev\": \"nodemon\",\n \"start\": \"node dist/cjs/server.cjs\",\n \"start:esm\": \"node dist/esm/server.mjs\",\n \"lint\": \"eslint src\",\n \"typecheck\": \"tsc -p tsconfig.json --noEmit\"\n },\n \"keywords\": [\n \"llm\",\n \"anthropic\",\n \"openai\",\n \"gemini\",\n \"transformer\",\n \"api\"\n ],\n \"author\": \"caeliq\",\n \"license\": \"MIT\",\n \"files\": [\n \"dist\",\n \"README.md\",\n \"LICENSE\"\n ],\n \"dependencies\": {\n \"@anthropic-ai/sdk\": \"^0.120.0\",\n \"@caeliq/ccr-shared\": \"workspace:*\",\n \"@cursor/sdk\": \"^1.0.32\",\n \"@fastify/cors\": \"^11.3.0\",\n \"@fastify/rate-limit\": \"^11.2.0\",\n \"@google/genai\": \"^2.18.0\",\n \"@huggingface/tokenizers\": \"^0.1.3\",\n \"dotenv\": \"^17.4.2\",\n \"fastify\": \"^5.12.1\",\n \"fastify-plugin\": \"^6.0.0\",\n \"google-auth-library\": \"^11.0.2\",\n \"json5\": \"^2.2.3\",\n \"jsonrepair\": \"^3.15.0\",\n \"latex-to-unicode\": \"^0.1.0\",\n \"lru-cache\": \"^11.5.2\",\n \"openai\": \"^7.5.0\",\n \"tiktoken\": \"^1.0.22\",\n \"undici\": \"^8.10.1\",\n \"uuid\": \"^14.0.2\"\n },\n \"devDependencies\": {\n \"@types/node\": \"^26.4.1\",\n \"esbuild\": \"^0.28.2\",\n \"tsx\": \"^4.23.13\",\n \"typescript\": \"^6.0.3\"\n },\n \"engines\": {\n \"node\": \">=22.19.0\"\n }\n}\n", "import { createHash } from \"crypto\";\nimport {\n UnifiedChatRequest,\n UnifiedMessage,\n MessageContent,\n TextContent,\n UnifiedTool,\n} from \"../types/llm\";\n\nconst ANTHROPIC_CACHE_CONTROL = { type: \"ephemeral\" } as const;\n\ntype CacheableLocation =\n | { kind: \"message\"; messageIndex: number }\n | { kind: \"content\"; messageIndex: number; contentIndex: number }\n | { kind: \"tool\"; toolIndex: number };\n\nexport interface CacheIntent {\n sessionKey?: string;\n breakpoints: CacheableLocation[];\n}\n\n/**\n * Strip cache_control from a single object (shallow clone).\n */\nexport function stripCacheControl>(obj: T): T {\n const clone = { ...obj };\n if (\"cache_control\" in clone) {\n delete clone.cache_control;\n }\n return clone;\n}\n\n/**\n * Strip cache_control from all messages and their content items.\n */\nexport function stripMessagesCacheControl(\n messages: UnifiedMessage[]\n): UnifiedMessage[] {\n return messages.map((msg) => {\n const cloned = { ...msg };\n\n if (Array.isArray(cloned.content)) {\n cloned.content = (cloned.content as MessageContent[]).map((item) => {\n if ((item as TextContent).cache_control) {\n const { cache_control: _cache_control, ...rest } = item as TextContent;\n return rest as MessageContent;\n }\n return item;\n });\n }\n\n if ((cloned as any).cache_control) {\n delete (cloned as any).cache_control;\n }\n if (Array.isArray(cloned.tool_calls)) {\n cloned.tool_calls = cloned.tool_calls.map((toolCall: any) => {\n const { cache_control: _cache_control, ...rest } = toolCall;\n return rest;\n });\n }\n\n return cloned;\n });\n}\n\n/**\n * Strip cache_control from tool definitions. Anthropic \u2192 Unified preserves\n * cache_control on tools so the Anthropic round-trip keeps prompt-cache hits,\n * but non-Anthropic providers reject it on tool definitions.\n */\nexport function stripToolsCacheControl(\n tools: UnifiedTool[] | undefined\n): UnifiedTool[] | undefined {\n if (!Array.isArray(tools)) return tools;\n return tools.map((tool) => {\n if (!(tool as any).cache_control) return tool;\n const { cache_control: _cache_control, ...rest } = tool as any;\n return rest as UnifiedTool;\n });\n}\n\nfunction hashCacheKey(value: string): string {\n return `ccr_${createHash(\"sha256\").update(value).digest(\"hex\").slice(0, 48)}`;\n}\n\nfunction readHeaderSessionId(headers: unknown): string | undefined {\n if (!headers || typeof headers !== \"object\") return undefined;\n const expected = [\n \"x-claude-code-session-id\",\n \"x-opencode-session\",\n \"x-kilo-session\",\n \"x-kilocode-taskid\",\n \"x-grok-session-id\",\n \"x-session-id\",\n \"x-session-affinity\",\n \"session-id\",\n \"x-conversation-id\",\n \"x-grok-conv-id\",\n ];\n for (const [rawName, rawValue] of Object.entries(\n headers as Record\n )) {\n if (!expected.includes(rawName.toLowerCase()) || rawValue == null) continue;\n const value = Array.isArray(rawValue)\n ? rawValue.find((item) => item != null && String(item))\n : rawValue;\n if (typeof value === \"string\" && value.trim()) return value.trim();\n }\n return undefined;\n}\n\nfunction metadataSessionId(metadataUserId: unknown): string | undefined {\n if (typeof metadataUserId !== \"string\" || !metadataUserId) {\n return undefined;\n }\n\n try {\n const parsed = JSON.parse(metadataUserId);\n if (parsed && typeof parsed.session_id === \"string\" && parsed.session_id) {\n return parsed.session_id;\n }\n } catch {\n // Non-JSON metadata.user_id is allowed.\n }\n\n const parts = metadataUserId.split(\"_session_\");\n if (parts.length > 1 && parts[1]) {\n return parts[1];\n }\n\n return metadataUserId;\n}\n\n/**\n * Conversation id from the client wire. Never uses harness version, billing\n * markers, or system-prompt text.\n */\nexport function extractClientSessionId(input: {\n body?: any;\n headers?: unknown;\n}): string | undefined {\n const body = input.body;\n const fromMetadata = metadataSessionId(body?.metadata?.user_id);\n if (fromMetadata) return fromMetadata;\n if (typeof body?.conversation === \"string\" && body.conversation.trim()) {\n return body.conversation.trim();\n }\n if (typeof body?.conversation_id === \"string\" && body.conversation_id.trim()) {\n return body.conversation_id.trim();\n }\n return readHeaderSessionId(input.headers);\n}\n\nfunction contentText(content: UnifiedMessage[\"content\"]): string {\n if (typeof content === \"string\") return content;\n if (!Array.isArray(content)) return \"\";\n return content\n .map((part: any) => {\n if (typeof part === \"string\") return part;\n if (part?.type === \"text\" && typeof part.text === \"string\") {\n return part.text;\n }\n return \"\";\n })\n .filter(Boolean)\n .join(\"\\n\");\n}\n\nexport function deriveCacheSessionKey(\n context: any,\n request: UnifiedChatRequest\n): string | undefined {\n const raw =\n context?.protocolContext?.sessionId ||\n context?.req?.protocolContext?.sessionId ||\n context?.req?.sessionId ||\n extractClientSessionId({\n body: request,\n headers: context?.req?.headers,\n });\n\n if (typeof raw === \"string\" && raw) {\n return hashCacheKey(raw);\n }\n\n // Anonymous clients only: first *user* text, never system (billing / CLAUDE.md).\n const firstUser = (request.messages || []).find((msg) => msg.role === \"user\");\n const fallbackText = firstUser ? contentText(firstUser.content) : \"\";\n return fallbackText.trim() ? hashCacheKey(fallbackText) : undefined;\n}\n\nfunction messageHasCacheControl(message: UnifiedMessage): boolean {\n if ((message as any).cache_control) return true;\n if (!Array.isArray(message.content)) return false;\n return message.content.some((part: any) => Boolean(part?.cache_control));\n}\n\nfunction countCacheBreakpoints(\n messages: UnifiedMessage[],\n tools?: UnifiedTool[]\n): number {\n const messageCount = messages.reduce((count, message) => {\n const messageMarker = (message as any).cache_control ? 1 : 0;\n const contentMarkers = Array.isArray(message.content)\n ? message.content.reduce(\n (sum: number, part: any) => sum + (part?.cache_control ? 1 : 0),\n 0\n )\n : 0;\n return count + messageMarker + contentMarkers;\n }, 0);\n const toolCount = (tools || []).reduce(\n (count, tool: any) => count + (tool?.cache_control ? 1 : 0),\n 0\n );\n return messageCount + toolCount;\n}\n\nfunction trimUnifiedCacheBreakpoints(\n messages: UnifiedMessage[],\n tools: UnifiedTool[] | undefined,\n maxBreakpoints: number\n): void {\n let seen = 0;\n const keep = (): boolean => {\n seen += 1;\n return seen <= maxBreakpoints;\n };\n\n for (const message of messages) {\n if ((message as any).cache_control && !keep()) {\n delete (message as any).cache_control;\n }\n if (!Array.isArray(message.content)) continue;\n for (const part of message.content as any[]) {\n if (part?.cache_control && !keep()) {\n delete part.cache_control;\n }\n }\n }\n\n for (const tool of tools || []) {\n if ((tool as any).cache_control && !keep()) {\n delete (tool as any).cache_control;\n }\n }\n}\n\nfunction hasCacheableText(message: UnifiedMessage): boolean {\n if (typeof message.content === \"string\") {\n return message.content.length > 0;\n }\n if (!Array.isArray(message.content)) {\n return false;\n }\n return message.content.some(\n (part: any) => part?.type === \"text\" && typeof part.text === \"string\" && part.text.length > 0\n );\n}\n\nfunction firstTextContentIndex(message: UnifiedMessage): number | undefined {\n if (!Array.isArray(message.content)) return undefined;\n const index = message.content.findIndex(\n (part: any) => part?.type === \"text\" && typeof part.text === \"string\" && part.text.length > 0\n );\n return index >= 0 ? index : undefined;\n}\n\nexport function selectCacheBreakpoints(\n request: UnifiedChatRequest,\n options: { maxBreakpoints: number; includeTools?: boolean }\n): CacheIntent {\n const breakpoints: CacheableLocation[] = [];\n const max = Math.max(0, options.maxBreakpoints);\n if (max === 0) return { breakpoints };\n\n for (let i = 0; i < request.messages.length && breakpoints.length < max; i += 1) {\n const message = request.messages[i];\n if (message.role !== \"system\" || messageHasCacheControl(message)) continue;\n const contentIndex = firstTextContentIndex(message);\n breakpoints.push(\n contentIndex === undefined\n ? { kind: \"message\", messageIndex: i }\n : { kind: \"content\", messageIndex: i, contentIndex }\n );\n }\n\n if (\n options.includeTools &&\n Array.isArray(request.tools) &&\n request.tools.length > 0 &&\n breakpoints.length < max\n ) {\n let toolIndex = -1;\n for (let i = request.tools.length - 1; i >= 0; i -= 1) {\n if (!(request.tools[i] as any)?.cache_control) {\n toolIndex = i;\n break;\n }\n }\n if (toolIndex >= 0) {\n breakpoints.push({ kind: \"tool\", toolIndex });\n }\n }\n\n for (\n let i = request.messages.length - 1;\n i >= 0 && breakpoints.length < max;\n i -= 1\n ) {\n const message = request.messages[i];\n if (message.role === \"system\") continue;\n if (messageHasCacheControl(message) || !hasCacheableText(message)) continue;\n const contentIndex = firstTextContentIndex(message);\n breakpoints.push(\n contentIndex === undefined\n ? { kind: \"message\", messageIndex: i }\n : { kind: \"content\", messageIndex: i, contentIndex }\n );\n }\n\n return { breakpoints };\n}\n\nfunction cloneMessages(messages: UnifiedMessage[]): UnifiedMessage[] {\n return messages.map((message) => ({\n ...message,\n content: Array.isArray(message.content)\n ? message.content.map((part: any) => ({ ...part }))\n : message.content,\n tool_calls: Array.isArray(message.tool_calls)\n ? message.tool_calls.map((toolCall) => ({\n ...toolCall,\n function: { ...toolCall.function },\n }))\n : message.tool_calls,\n thinking: message.thinking ? { ...message.thinking } : message.thinking,\n }));\n}\n\nfunction cloneTools(tools?: UnifiedTool[]): UnifiedTool[] | undefined {\n if (!Array.isArray(tools)) return tools;\n return tools.map((tool) => ({\n ...tool,\n function: {\n ...tool.function,\n parameters: { ...tool.function.parameters },\n },\n }));\n}\n\nfunction ensureMessageContentArray(message: UnifiedMessage): MessageContent[] {\n if (Array.isArray(message.content)) {\n return message.content;\n }\n const text = typeof message.content === \"string\" ? message.content : \"\";\n const content = [{ type: \"text\" as const, text }];\n message.content = content;\n return content;\n}\n\nfunction applyCacheLocation(\n messages: UnifiedMessage[],\n tools: UnifiedTool[] | undefined,\n location: CacheableLocation\n): void {\n if (location.kind === \"tool\") {\n if (tools?.[location.toolIndex]) {\n (tools[location.toolIndex] as any).cache_control = ANTHROPIC_CACHE_CONTROL;\n }\n return;\n }\n\n const message = messages[location.messageIndex];\n if (!message) return;\n\n if (location.kind === \"message\") {\n if (message.role === \"tool\") {\n (message as any).cache_control = ANTHROPIC_CACHE_CONTROL;\n return;\n }\n const content = ensureMessageContentArray(message);\n const index = firstTextContentIndex(message) ?? 0;\n if (content[index]) {\n (content[index] as any).cache_control = ANTHROPIC_CACHE_CONTROL;\n }\n return;\n }\n\n const content = ensureMessageContentArray(message);\n if (content[location.contentIndex]) {\n (content[location.contentIndex] as any).cache_control =\n ANTHROPIC_CACHE_CONTROL;\n }\n}\n\nexport function applyAnthropicPromptCaching(\n request: UnifiedChatRequest,\n options: { maxBreakpoints?: number; includeTools?: boolean } = {}\n): UnifiedChatRequest {\n const maxBreakpoints = options.maxBreakpoints ?? 4;\n const messages = cloneMessages(request.messages || []);\n const tools = cloneTools(request.tools);\n trimUnifiedCacheBreakpoints(messages, tools, maxBreakpoints);\n const existing = countCacheBreakpoints(messages, tools);\n const remaining = Math.max(0, maxBreakpoints - existing);\n\n if (remaining > 0) {\n const intent = selectCacheBreakpoints(\n { ...request, messages, tools },\n { maxBreakpoints: remaining, includeTools: options.includeTools ?? true }\n );\n for (const location of intent.breakpoints) {\n applyCacheLocation(messages, tools, location);\n }\n }\n\n return {\n ...request,\n messages,\n ...(tools ? { tools } : {}),\n };\n}\n\nexport function applyRawAnthropicPromptCaching>(\n request: T,\n options: { maxBreakpoints?: number } = {}\n): T {\n const maxBreakpoints = options.maxBreakpoints ?? 4;\n const clone: any = JSON.parse(JSON.stringify(request));\n const explicitMarkers: any[] = [];\n const collectMarker = (value: any): void => {\n if (value && typeof value === \"object\" && value.cache_control) {\n explicitMarkers.push(value);\n }\n };\n\n (Array.isArray(clone.tools) ? clone.tools : []).forEach(collectMarker);\n if (Array.isArray(clone.system)) {\n clone.system.forEach(collectMarker);\n } else {\n collectMarker(clone.system);\n }\n (Array.isArray(clone.messages) ? clone.messages : []).forEach(\n (message: any) => {\n collectMarker(message);\n if (Array.isArray(message?.content)) {\n message.content.forEach(collectMarker);\n }\n }\n );\n\n const hasAutomatic = Boolean(clone.cache_control);\n const explicitLimit = Math.max(0, maxBreakpoints - (hasAutomatic ? 1 : 0));\n if (explicitMarkers.length > explicitLimit) {\n for (const marker of explicitMarkers.slice(\n 0,\n explicitMarkers.length - explicitLimit\n )) {\n delete marker.cache_control;\n }\n }\n\n const remainingExplicit = Math.min(explicitMarkers.length, explicitLimit);\n if (!hasAutomatic && remainingExplicit < maxBreakpoints) {\n const latestControl =\n explicitMarkers[explicitMarkers.length - 1]?.cache_control;\n clone.cache_control = latestControl?.ttl\n ? { type: \"ephemeral\", ttl: latestControl.ttl }\n : ANTHROPIC_CACHE_CONTROL;\n }\n\n return clone as T;\n}\n\nexport function applyQwenPromptCaching(\n request: UnifiedChatRequest\n): UnifiedChatRequest {\n // stripMessagesCacheControl already clones each message (shallow) and\n // clones content items carrying cache_control. For items without\n // cache_control the reference is shared with the original, so we create a\n // new object when mutating instead of deep-cloning everything upfront.\n const messages = stripMessagesCacheControl(request.messages || []);\n const tools = stripToolsCacheControl(request.tools);\n\n for (let i = messages.length - 1; i >= 0; i -= 1) {\n const message = messages[i];\n if (typeof message.content === \"string\" && message.content) {\n message.content = [\n {\n type: \"text\",\n text: message.content,\n cache_control: ANTHROPIC_CACHE_CONTROL,\n },\n ];\n break;\n }\n if (!Array.isArray(message.content)) continue;\n for (let j = message.content.length - 1; j >= 0; j -= 1) {\n const part = message.content[j] as any;\n if (part?.type === \"text\" && part.text) {\n // Create a new object so the original request is not mutated.\n message.content[j] = { ...part, cache_control: ANTHROPIC_CACHE_CONTROL };\n return { ...request, messages, ...(tools ? { tools } : {}) };\n }\n }\n }\n\n return { ...request, messages, ...(tools ? { tools } : {}) };\n}\n", "import { UnifiedChatRequest, UnifiedMessage } from \"../types/llm\";\nimport {\n applyQwenPromptCaching,\n deriveCacheSessionKey,\n stripMessagesCacheControl,\n stripToolsCacheControl,\n} from \"./cacheControl\";\n\n/**\n * Validates OpenAI format messages to ensure complete tool_calls/tool message pairing.\n * Requires tool messages to immediately follow assistant messages with tool_calls.\n * Enforces strict immediate following sequence between tool_calls and tool messages.\n */\nexport function validateOpenAIToolCalls(messages: any[]): any[] {\n const validatedMessages: any[] = [];\n\n for (let i = 0; i < messages.length; i++) {\n const currentMessage = { ...messages[i] };\n\n // Process assistant messages with tool_calls\n if (currentMessage.role === \"assistant\" && currentMessage.tool_calls) {\n const validToolCalls: any[] = [];\n const removedToolCallIds: string[] = [];\n\n // Collect all immediately following tool messages\n const immediateToolMessages: any[] = [];\n let j = i + 1;\n while (j < messages.length && messages[j].role === \"tool\") {\n immediateToolMessages.push(messages[j]);\n j++;\n }\n\n // For each tool_call, check if there's an immediately following tool message\n currentMessage.tool_calls.forEach((toolCall: any) => {\n const hasImmediateToolMessage = immediateToolMessages.some(toolMsg =>\n toolMsg.tool_call_id === toolCall.id\n );\n\n if (hasImmediateToolMessage) {\n validToolCalls.push(toolCall);\n } else {\n removedToolCallIds.push(toolCall.id);\n }\n });\n\n // Update the assistant message\n if (validToolCalls.length > 0) {\n currentMessage.tool_calls = validToolCalls;\n } else {\n delete currentMessage.tool_calls;\n }\n\n // Only include message if it has content or valid tool_calls\n if (currentMessage.content || currentMessage.tool_calls) {\n validatedMessages.push(currentMessage);\n }\n }\n\n // Process tool messages\n else if (currentMessage.role === \"tool\") {\n let hasImmediateToolCall = false;\n\n // Check if the immediately preceding assistant message has matching tool_call\n if (i > 0) {\n const prevMessage = messages[i - 1];\n if (prevMessage.role === \"assistant\" && prevMessage.tool_calls) {\n hasImmediateToolCall = prevMessage.tool_calls.some((toolCall: any) =>\n toolCall.id === currentMessage.tool_call_id\n );\n } else if (prevMessage.role === \"tool\") {\n // Check for assistant message before the sequence of tool messages\n for (let k = i - 1; k >= 0; k--) {\n if (messages[k].role === \"tool\") continue;\n if (messages[k].role === \"assistant\" && messages[k].tool_calls) {\n hasImmediateToolCall = messages[k].tool_calls.some((toolCall: any) =>\n toolCall.id === currentMessage.tool_call_id\n );\n }\n break;\n }\n }\n }\n\n if (hasImmediateToolCall) {\n validatedMessages.push(currentMessage);\n }\n }\n\n // For all other message types, include as-is\n else {\n validatedMessages.push(currentMessage);\n }\n }\n\n return validatedMessages;\n}\n\n/**\n * Injects prompt caching hints into messages for Anthropic models.\n * Adds cache_control: { type: \"ephemeral\" } to system messages when model is Claude.\n */\nexport function injectPromptCaching(messages: any[], model: string): any[] {\n return messages.map((msg) => {\n // Add cache_control to system messages for Claude models\n if (msg.role === \"system\" && model.includes(\"claude\")) {\n if (Array.isArray(msg.content)) {\n return {\n ...msg,\n content: msg.content.map((item: any) => ({\n ...item,\n cache_control: { type: \"ephemeral\" } as const,\n })),\n };\n }\n }\n return msg;\n });\n}\n\nexport function supportsOpenAIExplicitPromptCache(model: string): boolean {\n const normalized = (model || \"\").toLowerCase();\n const match = normalized.match(/(?:^|\\/)gpt-(\\d+)(?:\\.(\\d+))?/);\n if (!match) return false;\n const major = Number(match[1]);\n const minor = Number(match[2] || 0);\n return major > 5 || (major === 5 && minor >= 6);\n}\n\nfunction isOpenAICacheableChatContent(content: any): boolean {\n return (\n content?.type === \"text\" ||\n content?.type === \"image_url\" ||\n content?.type === \"input_audio\" ||\n content?.type === \"file\" ||\n content?.type === \"refusal\"\n );\n}\n\nfunction lastCacheableContentIndex(content: any[]): number {\n for (let i = content.length - 1; i >= 0; i -= 1) {\n if (isOpenAICacheableChatContent(content[i])) return i;\n }\n return -1;\n}\n\nexport function applyOpenAIChatCaching(\n request: UnifiedChatRequest,\n _provider?: any,\n context?: any\n): UnifiedChatRequest {\n const next: UnifiedChatRequest = {\n ...request,\n messages: (request.messages || []).map((message) => ({\n ...message,\n content: Array.isArray(message.content)\n ? message.content.map((part: any) => ({ ...part }))\n : message.content,\n })),\n tools: Array.isArray(request.tools)\n ? request.tools.map((tool: any) =>\n tool?.function\n ? {\n ...tool,\n function: {\n ...tool.function,\n parameters: { ...tool.function.parameters },\n },\n }\n : { ...tool }\n )\n : request.tools,\n };\n\n const cacheKey = deriveCacheSessionKey(context, request);\n if (cacheKey && !(next as any).prompt_cache_key) {\n (next as any).prompt_cache_key = cacheKey;\n }\n\n if (supportsOpenAIExplicitPromptCache(next.model)) {\n const candidates: Array<{ messageIndex: number; contentIndex?: number }> = [];\n next.messages.forEach((message: UnifiedMessage, messageIndex: number) => {\n if ((message as any).cache_control) {\n if (typeof message.content === \"string\" && message.content) {\n candidates.push({ messageIndex });\n } else if (Array.isArray(message.content)) {\n const contentIndex = lastCacheableContentIndex(message.content);\n if (contentIndex >= 0) candidates.push({ messageIndex, contentIndex });\n }\n }\n if (Array.isArray(message.content)) {\n message.content.forEach((part: any, contentIndex: number) => {\n if (part?.cache_control && isOpenAICacheableChatContent(part)) {\n candidates.push({ messageIndex, contentIndex });\n }\n });\n }\n });\n\n for (const candidate of candidates.slice(-3)) {\n const message = next.messages[candidate.messageIndex];\n if (typeof message.content === \"string\") {\n message.content = [\n {\n type: \"text\",\n text: message.content,\n prompt_cache_breakpoint: { mode: \"explicit\" },\n } as any,\n ];\n } else if (\n Array.isArray(message.content) &&\n candidate.contentIndex !== undefined\n ) {\n (message.content[candidate.contentIndex] as any).prompt_cache_breakpoint =\n { mode: \"explicit\" };\n }\n }\n }\n\n next.messages = stripMessagesCacheControl(next.messages);\n next.tools = stripToolsCacheControl(next.tools);\n return next;\n}\n\nexport function openAIContentCacheBreakpoint(content: any, model: string): any {\n if (!supportsOpenAIExplicitPromptCache(model)) {\n return {};\n }\n return content?.prompt_cache_breakpoint\n ? { prompt_cache_breakpoint: content.prompt_cache_breakpoint }\n : {};\n}\n\nfunction providerName(provider?: any): string {\n return String(provider?.name || \"\").trim().toLowerCase();\n}\n\nfunction providerHost(provider?: any): string {\n const baseUrl = provider?.baseUrl || provider?.api_base_url || \"\";\n try {\n return new URL(baseUrl).hostname.toLowerCase();\n } catch {\n return String(baseUrl).toLowerCase();\n }\n}\n\nexport function applyRequestCacheKey(\n request: UnifiedChatRequest,\n context?: any\n): UnifiedChatRequest {\n const next = {\n ...request,\n messages: stripMessagesCacheControl(request.messages || []),\n tools: stripToolsCacheControl(request.tools),\n };\n const cacheKey = deriveCacheSessionKey(context, request);\n if (cacheKey) (next as any).prompt_cache_key = cacheKey;\n return next;\n}\n\nexport function applyProviderNativeChatCaching(\n request: UnifiedChatRequest,\n provider?: any,\n context?: any\n): UnifiedChatRequest {\n const name = providerName(provider);\n const host = providerHost(provider);\n\n if (\n name === \"openai\" ||\n name === \"azure-openai\" ||\n host === \"api.openai.com\" ||\n host.endsWith(\".openai.azure.com\")\n ) {\n return applyOpenAIChatCaching(request, provider, context);\n }\n\n if (\n name === \"qwen\" ||\n name === \"qwen-auth\" ||\n host.includes(\"dashscope\") ||\n host.endsWith(\".aliyuncs.com\") ||\n host === \"qwen.aikit.club\"\n ) {\n return applyQwenPromptCaching(request);\n }\n\n if (\n name === \"mistral\" ||\n name === \"cerebras\" ||\n host === \"api.mistral.ai\" ||\n host === \"api.cerebras.ai\"\n ) {\n return applyRequestCacheKey(request, context);\n }\n\n // Opencode Zen \u2013 mirrors native ProviderTransform.options() session affinity:\n // native sets promptCacheKey = sessionID for every opencode model (and gpt-5\n // via opencode). We inject prompt_cache_key in the Unified body so Zen's\n // downstream OpenAI/Moonshot cache + sticky routing stays hot across turns.\n if (\n name === \"opencode\" ||\n name.startsWith(\"opencode\") ||\n host === \"opencode.ai\" ||\n host.endsWith(\".opencode.ai\")\n ) {\n return applyRequestCacheKey(request, context);\n }\n\n return {\n ...request,\n messages: stripMessagesCacheControl(request.messages || []),\n tools: stripToolsCacheControl(request.tools),\n };\n}\n", "import { UnifiedChatRequest } from \"@/types/llm\";\nimport { createHash } from \"crypto\";\nimport { createApiError } from \"@/api/middleware\";\nimport { sanitizeResponsesCallId } from \"@/utils/toolCallId\";\nimport { canonicalReasoning } from \"@/utils/reasoning-effort\";\n\nfunction shouldLogResponsesPassthrough(): boolean {\n const env =\n process.env.LOG_RESPONSES_PASSTHROUGH ??\n process.env.CCR_LOG_RESPONSES_PASSTHROUGH ??\n process.env.CCR_DEBUG_RESPONSES_PASSTHROUGH;\n return env === \"1\" || env === \"true\";\n}\n\nexport interface ResponsesCallIdMap {\n /** Original client call_id \u2192 sanitized id (and reverse). */\n forward: Map;\n reverse: Map;\n}\n\nexport function createCallIdMap(): ResponsesCallIdMap {\n return { forward: new Map(), reverse: new Map() };\n}\n\n/** Sanitize and remember a stable per-turn mapping for function call correlation. */\nexport function mapCallId(\n map: ResponsesCallIdMap,\n id: unknown,\n direction: \"client_to_unified\" | \"unified_to_client\" = \"client_to_unified\"\n): string | undefined {\n if (typeof id !== \"string\" || !id) return undefined;\n if (direction === \"unified_to_client\") {\n const alreadyAssigned = sanitizeResponsesCallId(id) ?? id;\n if (map.reverse.has(alreadyAssigned)) {\n return alreadyAssigned;\n }\n }\n const existing = map.forward.get(id);\n if (existing) return existing;\n\n // Both directions must satisfy the client/provider Responses call_id\n // contract. A valid client id can equal another invalid id's sanitized form,\n // so resolve collisions per turn instead of relying on the hash suffix alone.\n let candidate = sanitizeResponsesCallId(id) ?? id;\n let collisionIndex = 0;\n while (map.reverse.has(candidate) && map.reverse.get(candidate) !== id) {\n collisionIndex += 1;\n candidate =\n sanitizeResponsesCallId(`${id}_${collisionIndex}`) ||\n `call_${collisionIndex}`;\n }\n map.forward.set(id, candidate);\n map.reverse.set(candidate, id);\n return candidate;\n}\n\n/**\n * Enforce the Responses call_id contract without rebuilding an exact-wire body.\n *\n * Same-protocol wire keep deliberately skips the Responses owner's full\n * transformRequestIn so images/files/reasoning/cache fields remain byte-faithful.\n * Call ids are still a provider validation boundary, though: Cursor-style\n * composite ids can exceed 64 characters. Rewrite only the identity field on\n * call/output items and reuse the normalization map so paired items and hash\n * collisions resolve identically in both directions.\n */\nexport function sanitizeResponsesWireCallIds(\n body: any,\n callIdMap: ResponsesCallIdMap = createCallIdMap()\n): any {\n if (!body || typeof body !== \"object\" || !Array.isArray(body.input)) {\n return body;\n }\n\n let changed = false;\n const input = body.input.map((item: any) => {\n if (!item || typeof item !== \"object\") return item;\n\n const isCall =\n item.type === \"function_call\" || item.type === \"custom_tool_call\";\n const isOutput =\n item.type === \"function_call_output\" ||\n item.type === \"custom_tool_call_output\";\n const rawCallId = isCall\n ? item.call_id || item.id\n : isOutput\n ? item.call_id\n : undefined;\n const mapped = mapCallId(callIdMap, rawCallId);\n if (!mapped || item.call_id === mapped) return item;\n\n // Calls may use id as a client-side fallback, but provider-bound Responses\n // input requires call_id. Keep the opaque item id and add/repair call_id.\n changed = true;\n return { ...item, call_id: mapped };\n });\n\n return changed ? { ...body, input } : body;\n}\n\n/**\n * Client Responses wire \u2192 Unified (Chat Completions shape).\n * Supports the Responses MVP subset; rejects CCR-unsupported stateful fields.\n */\nexport function responsesRequestToUnified(\n body: any,\n callIdMap: ResponsesCallIdMap = createCallIdMap(),\n customToolNames: Set = new Set()\n): UnifiedChatRequest {\n if (!body || typeof body !== \"object\") {\n throw createApiError(\"Invalid Responses body\", 400, \"invalid_body\");\n }\n if (typeof body.model !== \"string\" || !body.model.trim()) {\n throw createApiError(\n \"Responses requires model\",\n 400,\n \"invalid_body\",\n \"invalid_request_error\"\n );\n }\n\n rejectUnsupportedResponsesState(body);\n if (body.stream !== undefined && typeof body.stream !== \"boolean\") {\n throw createApiError(\n \"stream must be a boolean\",\n 400,\n \"invalid_stream\",\n \"invalid_request_error\"\n );\n }\n if (\n body.instructions !== undefined &&\n typeof body.instructions !== \"string\"\n ) {\n throw createApiError(\n \"instructions must be a string\",\n 400,\n \"invalid_instructions\",\n \"invalid_request_error\"\n );\n }\n if (body.max_tokens !== undefined) {\n throw createApiError(\n \"Responses uses max_output_tokens, not max_tokens\",\n 400,\n \"unsupported_field\",\n \"invalid_request_error\"\n );\n }\n if (body.max_output_tokens != null) {\n const maxOutputTokens = Number(body.max_output_tokens);\n if (!Number.isInteger(maxOutputTokens) || maxOutputTokens <= 0) {\n throw createApiError(\n \"max_output_tokens must be a positive integer\",\n 400,\n \"invalid_token_limit\",\n \"invalid_request_error\"\n );\n }\n }\n if (\n body.reasoning !== undefined &&\n (body.reasoning === null ||\n typeof body.reasoning !== \"object\" ||\n Array.isArray(body.reasoning))\n ) {\n throw createApiError(\n \"reasoning must be an object\",\n 400,\n \"invalid_reasoning\",\n \"invalid_request_error\"\n );\n }\n if (\n body.parallel_tool_calls !== undefined &&\n typeof body.parallel_tool_calls !== \"boolean\"\n ) {\n throw createApiError(\n \"parallel_tool_calls must be a boolean\",\n 400,\n \"invalid_parallel_tool_calls\",\n \"invalid_request_error\"\n );\n }\n if (\n body.prompt_cache_key !== undefined &&\n typeof body.prompt_cache_key !== \"string\"\n ) {\n throw createApiError(\n \"prompt_cache_key must be a string\",\n 400,\n \"invalid_prompt_cache_key\",\n \"invalid_request_error\"\n );\n }\n // Convert into the Chat Completions `response_format` shape (Unified IS\n // Chat Completions) \u2014 a verified mapping for the two structured formats\n // real backends (OpenAI/`codex`) actually support. Genuinely unknown\n // format types still reject rather than risk a silent wrong conversion.\n // Responses destinations reconstruct this into a native `text.format`\n // on the outbound request (OpenAIResponsesTransformer and Codex). See\n // customToolNames just below for the restore-only-for-codex pattern\n // applied to freeform tools.\n let responseFormat: any;\n if (body.text?.format && body.text.format.type !== \"text\") {\n const format = body.text.format;\n if (format.type === \"json_schema\") {\n responseFormat = {\n type: \"json_schema\",\n json_schema: {\n name: format.name,\n schema: format.schema,\n ...(format.strict !== undefined ? { strict: format.strict } : {}),\n },\n };\n } else if (format.type === \"json_object\") {\n responseFormat = { type: \"json_object\" };\n } else {\n throw createApiError(\n `Structured text formats are not supported without a verified mapping (received text.format.type=${JSON.stringify(\n format.type\n )})`,\n 400,\n \"unsupported_response_format\",\n \"invalid_request_error\"\n );\n }\n }\n for (const field of [\n \"metadata\",\n \"max_tool_calls\",\n \"service_tier\",\n \"safety_identifier\",\n \"top_logprobs\",\n \"truncation\",\n ]) {\n if (body[field] !== undefined && body[field] !== null) {\n throw createApiError(\n `Responses field '${field}' is not supported`,\n 400,\n \"unsupported_field\",\n \"invalid_request_error\"\n );\n }\n }\n\n const messages: any[] = [];\n if (typeof body.instructions === \"string\" && body.instructions) {\n messages.push({ role: \"system\", content: body.instructions });\n }\n\n const input = body.input;\n if (typeof input === \"string\") {\n messages.push({ role: \"user\", content: input });\n } else if (Array.isArray(input)) {\n if (input.length === 0) {\n throw createApiError(\n \"Responses input[] must not be empty\",\n 400,\n \"invalid_input\",\n \"invalid_request_error\"\n );\n }\n for (const item of input) {\n appendInputItem(messages, item, callIdMap);\n }\n } else {\n throw createApiError(\n \"Responses requires string input or input[]\",\n 400,\n \"invalid_input\",\n \"invalid_request_error\"\n );\n }\n\n if (messages.length === 0) {\n throw createApiError(\n \"Responses input did not contain a supported item\",\n 400,\n \"invalid_input\",\n \"invalid_request_error\"\n );\n }\n\n const tools = normalizeResponsesTools(body.tools, customToolNames);\n const toolChoice = normalizeResponsesToolChoice(body.tool_choice);\n\n const reasoning =\n body.reasoning && typeof body.reasoning === \"object\"\n ? {\n ...canonicalReasoning(body.reasoning.effort, true),\n summary: body.reasoning.summary,\n }\n : undefined;\n\n const unified: UnifiedChatRequest = {\n model: body.model,\n messages,\n tools,\n tool_choice: toolChoice,\n stream: body.stream === true,\n temperature: body.temperature,\n top_p: body.top_p,\n max_tokens: body.max_output_tokens ?? body.max_tokens,\n reasoning,\n parallel_tool_calls: body.parallel_tool_calls,\n } as UnifiedChatRequest;\n\n // Opaque same-protocol hints \u2014 preserved on Unified for Responses\u2192Responses.\n // Do not invent these for Chat/Anthropic inbound; only the Responses client\n // can express them.\n if (typeof body.prompt_cache_key === \"string\") {\n (unified as any).prompt_cache_key = body.prompt_cache_key;\n }\n const include = normalizeResponsesInclude(body.include);\n if (include) {\n (unified as any).include = include;\n }\n // store:true is rejected above; only an explicit false is a client signal\n // (AI SDK / OpenCode pair it with include: reasoning.encrypted_content).\n if (body.store === false) {\n (unified as any).store = false;\n }\n\n if (responseFormat) {\n (unified as any).response_format = responseFormat;\n }\n\n return unified;\n}\n\n/** Responses `include` is a string list; drop non-strings rather than invent values. */\nexport function normalizeResponsesInclude(\n include: unknown\n): string[] | undefined {\n if (!Array.isArray(include)) return undefined;\n const values = include.filter(\n (entry): entry is string => typeof entry === \"string\" && entry.length > 0\n );\n return values.length > 0 ? values : undefined;\n}\n\nfunction rejectUnsupportedResponsesState(body: any): void {\n if (body.store === true) {\n throw createApiError(\n \"store: true is not supported; CCR does not own Responses state\",\n 400,\n \"unsupported_store\",\n \"invalid_request_error\"\n );\n }\n if (body.previous_response_id) {\n throw createApiError(\n \"previous_response_id is not supported\",\n 400,\n \"unsupported_previous_response_id\",\n \"invalid_request_error\"\n );\n }\n if (body.conversation) {\n throw createApiError(\n \"conversation is not supported\",\n 400,\n \"unsupported_conversation\",\n \"invalid_request_error\"\n );\n }\n if (body.background === true) {\n throw createApiError(\n \"background: true is not supported\",\n 400,\n \"unsupported_background\",\n \"invalid_request_error\"\n );\n }\n\n // Tool-type allowlisting lives in normalizeResponsesTools: every inbound\n // Responses tool (function, custom, web_search, and other hosted types) is\n // projected onto a Unified Chat Completions function tool. Reject only\n // tools that lack a type string so conversion has something to key on.\n if (Array.isArray(body.tools)) {\n for (const tool of body.tools) {\n const type = tool?.type;\n if (typeof type !== \"string\" || !type) {\n throw createApiError(\n \"Responses tools require a type\",\n 400,\n \"invalid_tool\",\n \"invalid_request_error\"\n );\n }\n }\n }\n}\n\n/**\n * Chat Completions (and DeepSeek) require one assistant message carrying every\n * parallel tool_call plus any same-turn text. Responses emits those as separate\n * items (text then function_call, or the reverse), so fold both onto the\n * trailing assistant. A tool result ends the turn; the next function_call\n * starts a new assistant.\n */\nfunction assistantContentIsEmpty(message: any): boolean {\n return (\n message?.content === null ||\n message?.content === undefined ||\n message?.content === \"\"\n );\n}\n\nfunction appendAssistantToolCall(messages: any[], toolCall: any): void {\n const last = messages[messages.length - 1];\n if (last && last.role === \"assistant\") {\n if (Array.isArray(last.tool_calls)) {\n last.tool_calls.push(toolCall);\n } else {\n last.tool_calls = [toolCall];\n }\n return;\n }\n messages.push({\n role: \"assistant\",\n content: null,\n tool_calls: [toolCall],\n });\n}\n\nfunction appendAssistantContent(messages: any[], content: any): boolean {\n const last = messages[messages.length - 1];\n if (\n last?.role === \"assistant\" &&\n Array.isArray(last.tool_calls) &&\n last.tool_calls.length > 0 &&\n assistantContentIsEmpty(last)\n ) {\n last.content = content;\n return true;\n }\n return false;\n}\n\nfunction reasoningSummaryText(item: any): string {\n if (typeof item?.content === \"string\" && item.content) return item.content;\n if (typeof item?.reasoning === \"string\" && item.reasoning) return item.reasoning;\n if (!Array.isArray(item?.summary)) return \"\";\n return item.summary\n .map((part: any) =>\n typeof part === \"string\" ? part : typeof part?.text === \"string\" ? part.text : \"\"\n )\n .filter(Boolean)\n .join(\"\\n\");\n}\n\n/** Responses/Codex reasoning item ids look like `rs_` or `rs_`. */\nconst RESPONSES_REASONING_ITEM_ID = /^rs_[A-Za-z0-9]+$/;\n\nexport function isResponsesReasoningItemId(value: unknown): value is string {\n return typeof value === \"string\" && RESPONSES_REASONING_ITEM_ID.test(value);\n}\n\n/**\n * Ciphertext Codex/OpenAI will verify. Item ids and Anthropic/Gemini\n * signatures are not encrypted_content \u2014 replaying them 400s with\n * `invalid_encrypted_content`.\n */\nexport function responsesEncryptedContentFrom(\n value: unknown\n): string | undefined {\n if (typeof value !== \"string\" || !value) return undefined;\n if (isResponsesReasoningItemId(value)) return undefined;\n return value;\n}\n\nexport interface UnifiedAssistantThinking {\n content: string;\n signature?: string;\n encrypted_content?: string;\n id?: string;\n}\n\n/** Anthropic/Gemini thinking.signature \u2014 never a Responses item id. */\nexport function anthropicThinkingSignatureFrom(\n thinking: { signature?: string } | undefined\n): string | undefined {\n const signature =\n typeof thinking?.signature === \"string\" ? thinking.signature : \"\";\n if (!signature || isResponsesReasoningItemId(signature)) return undefined;\n return signature;\n}\n\n/** Responses `reasoning` item \u2192 Unified assistant.thinking. */\nexport function thinkingFromResponsesReasoningItem(\n item: any\n): UnifiedAssistantThinking | undefined {\n if (!item || typeof item !== \"object\") return undefined;\n const content = reasoningSummaryText(item);\n const encrypted_content = responsesEncryptedContentFrom(item.encrypted_content);\n const id =\n isUsableReasoningItemId(item.id)\n ? item.id\n : isResponsesReasoningItemId(item.encrypted_content)\n ? item.encrypted_content\n : undefined;\n if (!content && !encrypted_content && !id) return undefined;\n return {\n content,\n ...(encrypted_content ? { encrypted_content } : {}),\n ...(id ? { id } : {}),\n };\n}\n\n/**\n * Record streamed reasoning summary text for one item. Late handlers\n * (`output_item.done`, `response.completed`) consult this map so they can\n * emit ciphertext / id without re-sending content \u2014 Unified\n * `delta.thinking.content` is additive in every downstream consumer.\n */\nexport function recordReasoningSummaryDelta(\n deliveredContentByItemId: Map,\n itemId: unknown,\n delta: unknown\n): void {\n if (typeof itemId !== \"string\" || !itemId) return;\n if (typeof delta !== \"string\" || !delta) return;\n deliveredContentByItemId.set(\n itemId,\n (deliveredContentByItemId.get(itemId) || \"\") + delta\n );\n}\n\n/**\n * Late Responses reasoning handlers exist to rescue `encrypted_content` /\n * item id after summary deltas have already streamed the text. If this\n * item's content was already delivered on the current stream, return\n * replay metadata only. A terminal-only reasoning item (no summary\n * deltas) still delivers content exactly once.\n */\nexport function thinkingForLateReasoningItem(\n item: any,\n deliveredContentByItemId: Map\n): UnifiedAssistantThinking | undefined {\n const thinking = thinkingFromResponsesReasoningItem(item);\n if (!thinking) return undefined;\n const id =\n (typeof item?.id === \"string\" && item.id) || thinking.id;\n const alreadyDelivered = !!(id && deliveredContentByItemId.get(id));\n if (alreadyDelivered) {\n if (!thinking.encrypted_content && !thinking.id) return undefined;\n return {\n content: \"\",\n ...(thinking.encrypted_content\n ? { encrypted_content: thinking.encrypted_content }\n : {}),\n ...(thinking.id ? { id: thinking.id } : {}),\n };\n }\n if (id && thinking.content) {\n deliveredContentByItemId.set(id, thinking.content);\n }\n return thinking;\n}\n\n/**\n * Inverse of the inbound `text.format` \u2192 Chat Completions `response_format`\n * mapping in `responsesRequestToUnified`. Shared by Codex and generic\n * Responses outbound so the two reconstruct sites cannot drift.\n */\nexport function responsesTextFormatFromResponseFormat(\n responseFormat: any\n): { type: string; name?: string; schema?: any; strict?: boolean } | undefined {\n if (!responseFormat || typeof responseFormat !== \"object\") return undefined;\n if (responseFormat.type === \"json_schema\") {\n return {\n type: \"json_schema\",\n name: responseFormat.json_schema?.name,\n schema: responseFormat.json_schema?.schema,\n ...(responseFormat.json_schema?.strict !== undefined\n ? { strict: responseFormat.json_schema.strict }\n : {}),\n };\n }\n if (typeof responseFormat.type === \"string\" && responseFormat.type) {\n return { type: responseFormat.type };\n }\n return undefined;\n}\n\n/** Unified assistant.thinking \u2192 Responses `reasoning` input/output item. */\nexport function thinkingFromUnifiedAssistant(\n message: any\n): UnifiedAssistantThinking | undefined {\n if (!message || typeof message !== \"object\") return undefined;\n const fromThinking =\n typeof message.thinking?.content === \"string\" ? message.thinking.content : \"\";\n const fromReasoningContent =\n typeof message.reasoning_content === \"string\" ? message.reasoning_content : \"\";\n const fromReasoning =\n typeof message.reasoning === \"string\" ? message.reasoning : \"\";\n const content = fromThinking || fromReasoningContent || fromReasoning;\n const rawSignature =\n typeof message.thinking?.signature === \"string\" && message.thinking.signature\n ? message.thinking.signature\n : undefined;\n // Never copy thinking.signature into encrypted_content: Anthropic/Gemini\n // signatures and Responses item ids are not Codex ciphertext.\n const encrypted_content = responsesEncryptedContentFrom(\n message.thinking?.encrypted_content\n );\n const id =\n (typeof message.thinking?.id === \"string\" && message.thinking.id) ||\n (isResponsesReasoningItemId(rawSignature) ? rawSignature : undefined) ||\n (isResponsesReasoningItemId(message.thinking?.encrypted_content)\n ? message.thinking.encrypted_content\n : undefined);\n const signature =\n rawSignature && !isResponsesReasoningItemId(rawSignature)\n ? rawSignature\n : undefined;\n if (!content && !signature && !encrypted_content && !id) return undefined;\n return {\n content,\n ...(signature ? { signature } : {}),\n ...(encrypted_content ? { encrypted_content } : {}),\n ...(id ? { id } : {}),\n };\n}\n\n/**\n * Fixed assistant-turn order for every protocol:\n * thinking \u2192 text \u2192 images \u2192 tool calls.\n * Reordering here keeps cache prefixes stable across Anthropic, Chat,\n * Responses, Gemini, and Mistral.\n */\nexport interface CanonicalAssistantTurn {\n thinking?: UnifiedAssistantThinking;\n texts: Array<{ text: string; cache_control?: any }>;\n images: any[];\n toolCalls: any[];\n}\n\nexport function canonicalAssistantTurn(message: any): CanonicalAssistantTurn {\n const texts: Array<{ text: string; cache_control?: any }> = [];\n const images: any[] = [];\n if (typeof message?.content === \"string\" && message.content) {\n texts.push({ text: message.content });\n } else if (Array.isArray(message?.content)) {\n for (const part of message.content) {\n if (!part || typeof part !== \"object\") continue;\n if (\n (part.type === \"text\" ||\n part.type === \"output_text\" ||\n part.type === \"input_text\") &&\n part.text\n ) {\n texts.push({\n text: part.text,\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else if (part.type === \"image_url\" || part.type === \"input_image\" || part.type === \"output_image\") {\n images.push(part);\n }\n }\n }\n return {\n thinking: thinkingFromUnifiedAssistant(message),\n texts,\n images,\n toolCalls: Array.isArray(message?.tool_calls) ? message.tool_calls : [],\n };\n}\n\nexport function assistantTurnHasText(turn: CanonicalAssistantTurn): boolean {\n return turn.texts.some((part) => part.text.length > 0);\n}\n\n/** Placeholder CCR used to emit for ciphertext-only items; Zen rejects dupes. */\nconst REASONING_ID_PLACEHOLDER = \"rs_anon\";\n\nfunction isUsableReasoningItemId(id: unknown): id is string {\n return typeof id === \"string\" && !!id && id !== REASONING_ID_PLACEHOLDER;\n}\n\nfunction mintReasoningItemId(seed: string): string {\n return `rs_${createHash(\"sha256\").update(seed).digest(\"hex\").slice(0, 24)}`;\n}\n\nexport function responsesReasoningItemFromThinking(\n thinking:\n | {\n content?: string;\n signature?: string;\n encrypted_content?: string;\n id?: string;\n }\n | undefined,\n id?: string\n): any | null {\n if (!thinking || typeof thinking !== \"object\") return null;\n const content = typeof thinking.content === \"string\" ? thinking.content : \"\";\n const encrypted_content = responsesEncryptedContentFrom(\n thinking.encrypted_content\n );\n // Only an id carried on the thinking object itself (or real ciphertext /\n // summary text) justifies emitting a reasoning item. The optional `id`\n // argument is a preferred label for that item, not a reason to invent one\n // \u2014 otherwise skeletonResponse always minting `rs_${responseId}` would\n // prepend an empty reasoning item on every completed stream.\n const thinkingId = isUsableReasoningItemId(thinking.id)\n ? thinking.id\n : undefined;\n const preferredId = isUsableReasoningItemId(id) ? id : undefined;\n if (!content && !encrypted_content && !thinkingId) return null;\n const item: any = {\n type: \"reasoning\",\n // Date.now() ids rewrite the whole Responses/Codex prefix on every\n // turn and bust prompt cache. Prefer a carried id, then a caller\n // label, then a stable hash of ciphertext / summary. Never emit the\n // shared `rs_anon` placeholder \u2014 Zen 400s on duplicate input ids.\n id:\n thinkingId ||\n preferredId ||\n (encrypted_content\n ? mintReasoningItemId(encrypted_content)\n : content\n ? mintReasoningItemId(content)\n : mintReasoningItemId(`reasoning:${thinkingId || preferredId || \"\"}`)),\n summary: content ? [{ type: \"summary_text\", text: content }] : [],\n };\n if (encrypted_content) item.encrypted_content = encrypted_content;\n return item;\n}\n\n/**\n * Zen rejects Requests whose `input` repeats the same reasoning item id.\n * Rewrite placeholders / collisions using ciphertext (or summary) as seed.\n */\nexport function uniquifyReasoningItemIds(items: any[] | undefined): void {\n if (!Array.isArray(items)) return;\n const seen = new Set();\n for (let index = 0; index < items.length; index++) {\n const item = items[index];\n if (!item || item.type !== \"reasoning\") continue;\n let id = isUsableReasoningItemId(item.id) ? item.id : \"\";\n if (!id || seen.has(id)) {\n const summary = reasoningSummaryText(item);\n const encrypted =\n typeof item.encrypted_content === \"string\" ? item.encrypted_content : \"\";\n const seed =\n encrypted || summary || `reasoning:${index}:${id || \"missing\"}`;\n id = mintReasoningItemId(seen.has(id) ? `${seed}#${index}` : seed);\n item.id = id;\n }\n seen.add(id);\n }\n}\n\nfunction attachThinkingToAssistant(\n messages: any[],\n thinking: UnifiedAssistantThinking\n): void {\n const last = messages[messages.length - 1];\n if (last && last.role === \"assistant\") {\n last.thinking = thinking;\n return;\n }\n messages.push({\n role: \"assistant\",\n content: null,\n thinking,\n });\n}\n\nfunction appendInputItem(\n messages: any[],\n item: any,\n callIdMap: ResponsesCallIdMap\n): void {\n if (!item || typeof item !== \"object\") {\n throw createApiError(\n \"Invalid Responses input item\",\n 400,\n \"invalid_input_item\",\n \"invalid_request_error\"\n );\n }\n\n if (item.type === \"reasoning\") {\n const thinking = thinkingFromResponsesReasoningItem(item);\n if (thinking) attachThinkingToAssistant(messages, thinking);\n return;\n }\n\n if (item.type === \"function_call_output\") {\n if (typeof item.call_id !== \"string\" || !item.call_id) {\n throw createApiError(\n \"function_call_output requires call_id\",\n 400,\n \"invalid_call_id\",\n \"invalid_request_error\"\n );\n }\n messages.push({\n role: \"tool\",\n tool_call_id: mapCallId(callIdMap, item.call_id) ?? item.call_id,\n content: functionCallOutputToUnified(item.output),\n });\n return;\n }\n\n if (item.type === \"function_call\") {\n const rawCallId = item.call_id || item.id;\n if (typeof rawCallId !== \"string\" || !rawCallId) {\n throw createApiError(\n \"function_call requires call_id\",\n 400,\n \"invalid_call_id\",\n \"invalid_request_error\"\n );\n }\n if (typeof item.name !== \"string\" || !item.name) {\n throw createApiError(\n \"function_call requires name\",\n 400,\n \"invalid_function_call\",\n \"invalid_request_error\"\n );\n }\n // Chat Completions (and DeepSeek) require one assistant message carrying\n // every parallel tool_call; Responses emits them as consecutive items.\n appendAssistantToolCall(messages, {\n id: mapCallId(callIdMap, rawCallId) ?? rawCallId,\n type: \"function\",\n function: {\n name: item.name,\n arguments:\n typeof item.arguments === \"string\"\n ? item.arguments\n : JSON.stringify(item.arguments ?? {}),\n },\n });\n return;\n }\n\n if (item.type === \"custom_tool_call_output\") {\n if (typeof item.call_id !== \"string\" || !item.call_id) {\n throw createApiError(\n \"custom_tool_call_output requires call_id\",\n 400,\n \"invalid_call_id\",\n \"invalid_request_error\"\n );\n }\n messages.push({\n role: \"tool\",\n tool_call_id: mapCallId(callIdMap, item.call_id) ?? item.call_id,\n content: functionCallOutputToUnified(item.output),\n });\n return;\n }\n\n if (item.type === \"custom_tool_call\") {\n const rawCallId = item.call_id || item.id;\n if (typeof rawCallId !== \"string\" || !rawCallId) {\n throw createApiError(\n \"custom_tool_call requires call_id\",\n 400,\n \"invalid_call_id\",\n \"invalid_request_error\"\n );\n }\n if (typeof item.name !== \"string\" || !item.name) {\n throw createApiError(\n \"custom_tool_call requires name\",\n 400,\n \"invalid_function_call\",\n \"invalid_request_error\"\n );\n }\n if (typeof item.input !== \"string\") {\n throw createApiError(\n \"custom_tool_call requires string input\",\n 400,\n \"invalid_custom_tool_input\",\n \"invalid_request_error\"\n );\n }\n // Mirror the synthetic single-string-param shape normalizeResponsesTools\n // gave this tool on the way out, so replayed history round-trips.\n appendAssistantToolCall(messages, {\n id: mapCallId(callIdMap, rawCallId) ?? rawCallId,\n type: \"function\",\n function: {\n name: item.name,\n arguments: JSON.stringify({\n [CUSTOM_TOOL_INPUT_KEY]: item.input,\n }),\n },\n });\n return;\n }\n\n if (item.type === \"message\" || item.role) {\n const role =\n item.role === \"assistant\"\n ? \"assistant\"\n : item.role === \"system\" || item.role === \"developer\"\n ? \"system\"\n : item.role === \"user\"\n ? \"user\"\n : undefined;\n if (!role) {\n throw createApiError(\n `Unsupported Responses message role '${item.role}'`,\n 400,\n \"unsupported_role\",\n \"invalid_request_error\"\n );\n }\n let rawContent = item.content;\n if (\n typeof rawContent !== \"string\" &&\n !Array.isArray(rawContent)\n ) {\n if (shouldLogResponsesPassthrough()) {\n try {\n console.debug(\n `[responses passthrough] message ${role} with non-string/array content ${String(typeof rawContent)} ${JSON.stringify(rawContent)?.slice(0, 400) ?? \"\"}`\n );\n } catch {}\n }\n if (rawContent == null) {\n rawContent = \"\";\n } else if (typeof rawContent === \"object\" && !Array.isArray(rawContent)) {\n rawContent = [rawContent as any];\n } else {\n rawContent = String(rawContent);\n }\n }\n const content = flattenResponsesContent(rawContent);\n if (role === \"assistant\" && appendAssistantContent(messages, content)) {\n return;\n }\n messages.push({\n role,\n content,\n });\n return;\n }\n\n if (item.type === \"input_text\" || item.type === \"output_text\") {\n const content = String(item.text ?? \"\");\n const role = item.type === \"output_text\" ? \"assistant\" : \"user\";\n if (role === \"assistant\" && appendAssistantContent(messages, content)) {\n return;\n }\n messages.push({\n role,\n content,\n });\n return;\n }\n\n if (item.type === \"input_image\") {\n if (item.file_id) {\n throw createApiError(\n \"Provider-bound file_id inputs are not supported\",\n 400,\n \"unsupported_file_id\",\n \"invalid_request_error\"\n );\n }\n const imageUrl = item.image_url || item.url;\n if (typeof imageUrl !== \"string\" || !imageUrl) {\n throw createApiError(\n \"input_image requires image_url\",\n 400,\n \"invalid_image\",\n \"invalid_request_error\"\n );\n }\n messages.push({\n role: \"user\",\n content: [\n {\n type: \"image_url\",\n image_url: {\n url: imageUrl,\n ...(item.detail ? { detail: item.detail } : {}),\n },\n },\n ],\n });\n return;\n }\n\n if (item.type === \"input_file\") {\n if (item.file_id) {\n throw createApiError(\n \"Provider-bound file_id inputs are not supported\",\n 400,\n \"unsupported_file_id\",\n \"invalid_request_error\"\n );\n }\n const fileData = item.file_data;\n const fileUrl = item.file_url;\n if (typeof fileData !== \"string\" && typeof fileUrl !== \"string\") {\n throw createApiError(\n \"input_file requires file_data or file_url\",\n 400,\n \"invalid_file\",\n \"invalid_request_error\"\n );\n }\n messages.push({\n role: \"user\",\n content: [\n {\n type: \"file\",\n ...(typeof item.filename === \"string\"\n ? { filename: item.filename }\n : {}),\n ...(typeof fileData === \"string\" ? { file_data: fileData } : {}),\n ...(typeof fileUrl === \"string\" ? { file_url: fileUrl } : {}),\n ...(typeof item.mime_type === \"string\"\n ? { media_type: item.mime_type }\n : {}),\n },\n ],\n });\n return;\n }\n\n // Hosted calls (web_search_call, file_search_call, etc.) are ChatGPT-backend\n // state. With store:false Codex replays them verbatim like reasoning\n // encrypted_content. Keep forwards the original input[] unchanged, but this\n // Unified projection is only for routing \u2014 so passthrough (drop from Unified)\n // and log rather than 400 or synthesizing an assistant artifact.\n if (\n item.type === \"web_search_call\" ||\n (typeof item.type === \"string\" &&\n item.type.endsWith(\"_call\") &&\n item.type !== \"function_call\" &&\n item.type !== \"custom_tool_call\")\n ) {\n const action = (item as any).action;\n const hint =\n (typeof action?.query === \"string\" && action.query) ||\n (Array.isArray(action?.queries) && action.queries[0]) ||\n (typeof action?.url === \"string\" && action.url) ||\n \"\";\n // Only when explicitly enabled via config/env \u2014 avoids noise on every\n // Codex turn with web_search. Keep wire already logs the full input[]\n // when body part capture is on.\n if (shouldLogResponsesPassthrough()) {\n try {\n const id = (item as any).id || (item as any).call_id || \"\";\n console.debug(\n `[responses passthrough] ${item.type}${id ? ` ${id}` : \"\"}${hint ? ` \u2014 ${String(hint).slice(0, 200)}` : \"\"}`\n );\n } catch {\n // ignore logging failures\n }\n }\n return;\n }\n\n throw createApiError(\n `Unsupported Responses input item type '${item.type || \"unknown\"}'`,\n 400,\n \"unsupported_input_item\",\n \"invalid_request_error\"\n );\n}\n\n/**\n * Responses `function_call_output.output` / `custom_tool_call_output.output`\n * may be a plain string or an OutputContentList (text + images + files).\n * OpenCode / @ai-sdk/openai put webfetch image attachments in that list.\n * JSON.stringifying the list destroys `input_image` and Zen/Meta reject the\n * replayed string as invalid parameters \u2014 keep structured parts as Unified\n * `text` / `image_url` so Responses outbound can re-emit `input_image`.\n */\nfunction functionCallOutputToUnified(output: unknown): string | any[] {\n if (typeof output === \"string\") return output;\n if (Array.isArray(output)) return flattenResponsesContent(output);\n return JSON.stringify(output ?? \"\");\n}\n\nfunction flattenResponsesContent(content: unknown): any {\n if (typeof content === \"string\") return content;\n if (!Array.isArray(content)) {\n return content == null ? \"\" : JSON.stringify(content);\n }\n\n const parts: any[] = [];\n for (const part of content) {\n if (typeof part === \"string\") {\n parts.push({ type: \"text\", text: part });\n continue;\n }\n if (!part || typeof part !== \"object\") continue;\n if (part.type === \"input_text\" || part.type === \"output_text\" || part.type === \"text\") {\n parts.push({ type: \"text\", text: String(part.text ?? \"\") });\n } else if (part.type === \"input_image\" || part.type === \"image_url\") {\n if ((part as any).file_id) {\n throw createApiError(\n \"Provider-bound file_id inputs are not supported\",\n 400,\n \"unsupported_file_id\",\n \"invalid_request_error\"\n );\n }\n const imageUrl = part.image_url?.url || part.image_url || part.url;\n if (typeof imageUrl !== \"string\" || !imageUrl) {\n throw createApiError(\n \"input_image requires image_url\",\n 400,\n \"invalid_image\",\n \"invalid_request_error\"\n );\n }\n parts.push({\n type: \"image_url\",\n image_url: {\n url: imageUrl,\n ...((part as any).detail\n ? { detail: (part as any).detail }\n : {}),\n },\n });\n } else if (part.type === \"input_file\") {\n if ((part as any).file_id) {\n throw createApiError(\n \"Provider-bound file_id inputs are not supported\",\n 400,\n \"unsupported_file_id\",\n \"invalid_request_error\"\n );\n }\n const fileData = part.file_data;\n const fileUrl = part.file_url;\n if (typeof fileData !== \"string\" && typeof fileUrl !== \"string\") {\n throw createApiError(\n \"input_file requires file_data or file_url\",\n 400,\n \"invalid_file\",\n \"invalid_request_error\"\n );\n }\n parts.push({\n type: \"file\",\n ...(typeof part.filename === \"string\" ? { filename: part.filename } : {}),\n ...(typeof fileData === \"string\" ? { file_data: fileData } : {}),\n ...(typeof fileUrl === \"string\" ? { file_url: fileUrl } : {}),\n ...(typeof part.mime_type === \"string\"\n ? { media_type: part.mime_type }\n : {}),\n });\n } else {\n throw createApiError(\n `Unsupported Responses content part '${part.type || \"unknown\"}'`,\n 400,\n \"unsupported_content_part\",\n \"invalid_request_error\"\n );\n }\n }\n\n if (parts.length === 1 && parts[0].type === \"text\") {\n return parts[0].text;\n }\n return parts.length > 0 ? parts : \"\";\n}\n\n/** Synthetic argument key used to carry a `custom` tool's freeform text\n * through the Unified/Chat Completions function-call shape. */\nexport const CUSTOM_TOOL_INPUT_KEY = \"input\";\n\n/**\n * Custom/freeform tools have no native concept on models that were never\n * trained on OpenAI's Responses `type: \"custom\"` grammar tool (only OpenAI's\n * own backend and a handful of Responses-compatible hosts support it \u2014 see\n * openai/codex#19416, where Codex itself falls back to a plain function tool\n * for Bedrock-hosted models for the same reason). Proxying through a single\n * JSON string parameter (CUSTOM_TOOL_INPUT_KEY) works, but a model\n * unfamiliar with the convention sometimes reaches for the nearest thing it\n * does know: invoking the tool as if it were a shell command, wrapping its\n * freeform text in a bash heredoc. Unwrap that here so the client (Codex\n * CLI's own apply_patch parser, etc.) receives clean freeform text instead\n * of a heredoc-wrapped shell fragment. Mirrors opencode's stripHeredoc\n * (packages/opencode/src/patch/index.ts) \u2014 purely syntactic: only fires when\n * the *entire* input matches the wrapper pattern, so genuine patch/tool\n * content is never touched.\n */\nfunction stripHeredocWrapper(text: string): string {\n const match = text.match(/^(?:cat\\s+)?<<['\"]?(\\w+)['\"]?\\s*\\n([\\s\\S]*?)\\n\\1\\s*$/);\n return match ? match[2] : text;\n}\n\n/**\n * Codex's apply_patch/apply_update grammar accepts only the exact markers\n * `*** Begin Patch` and `*** End Patch` (no trailing asterisk triplet) as the\n * first/last patch lines \u2014 anything else is rejected with \"The first line of\n * the patch must be '*** Begin Patch'\". Models not trained on that grammar\n * (e.g. Grok reaches for Claude's trailing-asterisk variant) emit\n * `*** Begin Patch ***` / `*** End Patch ***`. Normalize those to the Codex\n * form on the client-facing emission, scoped by the marker token itself so a\n * rewrite can only ever hit an apply_patch-style payload regardless of the\n * declared tool name.\n */\nexport function normalizeCodexPatchMarkers(text: string): string {\n if (!text.includes(\"*** Begin Patch ***\") && !text.includes(\"*** End Patch ***\")) {\n return text;\n }\n return text\n .split(\"*** Begin Patch ***\").join(\"*** Begin Patch\")\n .split(\"*** End Patch ***\").join(\"*** End Patch\");\n}\n\n/**\n * Codex's `exec` tool runs raw JavaScript in a V8 isolate; a model that was\n * never trained on that convention (Grok) sometimes fills the freeform input\n * with a JSON shell-envelope instead \u2014 e.g. `{\"cmd\": \"ls -la /tmp\"}`. That is\n * not valid JS (`{\"cmd\":\u2026}` parses as a block with a string label \u2192\n * `SyntaxError: Unexpected token ':'`), so the shell call fails and the model\n * wastes a turn retrying as `await tools.exec_command({cmd: \u2026})`.\n * Rewrite the envelope into exactly that retry shape on the client-facing\n * emission. Scoped by the tool name and the whole-input-is-a-shell-object\n * shape so a freeform tool that legitimately takes a JSON blob is never\n * touched. Grok also alternates the key between `cmd` and `command`, and\n * `exec_command` only accepts `cmd`, so normalize either to `cmd`.\n */\nexport function normalizeExecCommandEnvelope(\n name: string | undefined,\n text: string\n): string {\n if (name !== \"exec\") return text;\n const trimmed = text.trim();\n if (!trimmed.startsWith(\"{\") || !trimmed.endsWith(\"}\")) return text;\n let parsed: any;\n try {\n parsed = JSON.parse(trimmed);\n } catch {\n return text;\n }\n if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n return text;\n }\n const commandKey = \"cmd\" in parsed ? \"cmd\" : \"command\" in parsed ? \"command\" : null;\n if (!commandKey) return text;\n const command = parsed[commandKey];\n if (typeof command !== \"string\" || !command) return text;\n delete parsed[commandKey];\n parsed.cmd = command;\n return `await tools.exec_command(${JSON.stringify(parsed)});`;\n}\n\n/**\n * A model that reaches for the patch tool through a shell hereditary habit\n * wraps the patch in a heredoc instead of JS:\n * apply_patch << 'PATCH'\\n*** Begin Patch \u2026 *** End Patch\\nPATCH\n * That is a shell command, not the raw JS `exec` runs, so it fails with a\n * syntax error and the model wastes a turn retrying as\n * `await tools.apply_patch(\u2026)`. Normalize the heredoc invocation into the JS\n * call form. Whole-value heredoc match only; anything else passes through.\n */\nexport function normalizeExecApplyPatchHeredoc(\n name: string | undefined,\n text: string\n): string {\n if (name !== \"exec\") return text;\n const match = text.match(\n /^apply_patch\\s*<<\\s*['\"]?(\\w+)['\"]?\\s*\\n([\\s\\S]*?)\\n\\1\\s*$/\n );\n if (!match) return text;\n return `await tools.apply_patch(${JSON.stringify(match[2])});`;\n}\n\n/**\n * `exec` may cross the wire as a plain function tool (arguments stay the JSON\n * wrapper `{\"input\":\"\u2026\"}`) rather than a custom tool (whose freeform input was\n * unwrapped already). The envelope/heredoc normalizers above operate on the\n * unwrapped inner text, so when only the wrapper is available, descend into it\n * and normalize its inner `input` value with the same rules.\n */\nexport function normalizeExecFunctionArguments(\n name: string | undefined,\n rawArguments: string,\n options?: CodexIsolateConventionsOptions\n): string {\n if (!applyCodexIsolateConventions(options)) return rawArguments;\n if (name !== \"exec\") return rawArguments;\n try {\n const parsed = JSON.parse(rawArguments);\n if (parsed && typeof parsed === \"object\" && typeof parsed.input === \"string\") {\n parsed.input = normalizeExecApplyPatchHeredoc(\n name,\n normalizeExecCommandEnvelope(name, parsed.input)\n );\n return JSON.stringify(parsed);\n }\n } catch {\n // Not the {\"input\": \u2026} wrapper; leave untouched.\n }\n return rawArguments;\n}\n\n/** Undo the CUSTOM_TOOL_INPUT_KEY wrapping applied in normalizeResponsesTools.\n * Falls back to the raw text so a malformed/empty call still round-trips\n * instead of vanishing. Also strips a whole-value shell heredoc wrapper\n * (see stripHeredocWrapper). That strip is intentional on both paths this\n * helper serves: client emission (so the Responses client sees clean\n * freeform text) and CodexTransformer history replay (so the backend is\n * not re-fed a wrapper the client never kept). Replay is therefore\n * normalized, not byte-faithful to the model's original heredoc. */\nexport function unwrapCustomToolInput(rawArguments: string): string {\n if (!rawArguments) return \"\";\n try {\n const parsed = JSON.parse(rawArguments);\n const value = parsed?.[CUSTOM_TOOL_INPUT_KEY];\n if (typeof value === \"string\") return stripHeredocWrapper(value);\n } catch {\n // Fall through to the raw text below.\n }\n return stripHeredocWrapper(rawArguments);\n}\n\n/**\n * Codex V8 isolate calling conventions (`await tools.exec_command` /\n * `await tools.apply_patch`). Default on: CCR's `/v1/responses` inbound\n * is the Codex CLI path, and Grok-via-Chat recovery depends on it.\n * Pass `false` for a generic Responses destination whose `exec` tool\n * legitimately accepts `{\"cmd\": \u2026}` JSON.\n */\nexport interface CodexIsolateConventionsOptions {\n codexIsolateConventions?: boolean;\n}\n\nfunction applyCodexIsolateConventions(\n options?: CodexIsolateConventionsOptions\n): boolean {\n return options?.codexIsolateConventions !== false;\n}\n\n/** Client-facing custom-tool input: unwrap the Unified JSON wrapper, then\n * apply the exec/patch normalizers in one place so stream finalize, the\n * completed skeleton, and the non-stream JSON path cannot drift. */\nexport function normalizeClientCustomToolInput(\n name: string | undefined,\n rawArguments: string,\n options?: CodexIsolateConventionsOptions\n): string {\n let text = unwrapCustomToolInput(rawArguments);\n if (applyCodexIsolateConventions(options)) {\n text = normalizeExecApplyPatchHeredoc(\n name,\n normalizeExecCommandEnvelope(name, text)\n );\n }\n return normalizeCodexPatchMarkers(text);\n}\n\nfunction normalizeResponsesTools(\n tools: any,\n customToolNames?: Set\n): UnifiedChatRequest[\"tools\"] | undefined {\n if (tools == null) return undefined;\n if (!Array.isArray(tools)) {\n throw createApiError(\n \"Responses tools must be an array\",\n 400,\n \"invalid_tools\",\n \"invalid_request_error\"\n );\n }\n // Unified is OpenAI Chat Completions: only `function` tools are valid.\n // Project every inbound Responses tool (function, custom/MCP, web_search,\n // and any other hosted type) onto a function so Chat Completions backends\n // never see Responses-only hosted-tool variants.\n return tools.map((t: any) => {\n const type = typeof t?.type === \"string\" ? t.type : \"\";\n // function / custom always need an explicit client name \u2014 do not fall\n // back to the type string (\"custom\") or the tool is silently unusable.\n let name: string | undefined = t?.name || t?.function?.name;\n if (type === \"web_search\" || type === \"web_search_preview\") {\n // Stable name so hasWebSearchTool / provider routing still match.\n name = \"web_search\";\n } else if (!name && type && type !== \"function\" && type !== \"custom\") {\n // Other hosted tools (file_search, computer_use, \u2026) use type as name.\n name = type;\n }\n if (typeof name !== \"string\" || !name) {\n throw createApiError(\n \"Responses function tools require a name\",\n 400,\n \"invalid_tool\",\n \"invalid_request_error\"\n );\n }\n\n if (type === \"custom\") {\n // `custom` tools take unconstrained freeform text (no JSON schema \u2014\n // see CustomToolParam), unlike `function` tools. Chat Completions has\n // no freeform-tool concept, so proxy it through a single required\n // string parameter instead of an empty object schema: an empty schema\n // gives the model no signal about what to put where, so it hallucinates\n // JSON-shaped arguments the tool never asked for. The response side\n // (unifiedChunkToResponsesEvents/unifiedResponseToResponses) unwraps\n // this key and re-emits a genuine `custom_tool_call` item.\n //\n // A model that was never trained on this convention (anything but\n // OpenAI's own \u2014 see the codex/Bedrock precedent in\n // stripHeredocWrapper's comment above) has to solve two problems at\n // once: get the tool's own freeform grammar right, *and* figure out\n // this JSON-wrapping detour. The property/function descriptions below\n // spell out the wrapping explicitly so the model only has to solve the\n // first problem \u2014 this is prompt guidance, not a content rewrite, so\n // it's as safe as the heredoc strip: it only changes what the model is\n // told, never what a well-formed call's content means.\n customToolNames?.add(name);\n const baseDescription = t.description || t.function?.description || \"\";\n // Provider-neutral contract only. Codex V8 calling conventions\n // (`await tools.exec_command`, `await tools.apply_patch`) stay off\n // this description so Anthropic and Chat Completions backends are\n // not prompted as if they were Codex's isolate. Recovery of\n // `{cmd:\u2026}` / heredoc / trailing-asterisk markers happens on the\n // Responses client emission (normalizeClientCustomToolInput).\n return {\n type: \"function\" as const,\n function: {\n name,\n description: baseDescription\n ? `${baseDescription}\\n\\nNote: this tool takes freeform text, not JSON. Call it with a single \"${CUSTOM_TOOL_INPUT_KEY}\" argument whose value is the complete text described above, as a plain string \u2014 do not add markdown code fences, a shell heredoc (e.g. \"<;\n codexIsolateConventions?: boolean;\n }\n): any {\n const callIdMap = options?.callIdMap ?? createCallIdMap();\n const isolate: CodexIsolateConventionsOptions = {\n codexIsolateConventions: options?.codexIsolateConventions,\n };\n const choice = chat?.choices?.[0];\n const message = choice?.message || {};\n const output: any[] = [];\n\n const reasoningItem = responsesReasoningItemFromThinking(\n thinkingFromUnifiedAssistant(message),\n chat?.id ? `rs_${chat.id}` : undefined\n );\n if (reasoningItem) output.push(reasoningItem);\n\n const text =\n typeof message.content === \"string\"\n ? message.content\n : Array.isArray(message.content)\n ? message.content\n .filter((p: any) => p?.type === \"text\")\n .map((p: any) => p.text)\n .join(\"\")\n : \"\";\n\n if (text || !message.tool_calls?.length) {\n const itemId = `msg_${chat.id || Date.now()}`;\n output.push({\n type: \"message\",\n id: itemId,\n status: \"completed\",\n role: \"assistant\",\n content: [\n {\n type: \"output_text\",\n text: text || \"\",\n annotations: [],\n logprobs: message?.logprobs?.content || [],\n },\n ],\n });\n }\n\n if (Array.isArray(message.tool_calls)) {\n for (const tc of message.tool_calls) {\n if (!tc?.function) continue;\n const callId =\n mapCallId(callIdMap, tc.id, \"unified_to_client\") ?? tc.id;\n const rawArguments =\n typeof tc.function.arguments === \"string\"\n ? tc.function.arguments\n : JSON.stringify(tc.function.arguments ?? {});\n if (options?.customToolNames?.has(tc.function.name)) {\n output.push({\n type: \"custom_tool_call\",\n id: callId,\n call_id: callId,\n name: tc.function.name,\n input: normalizeClientCustomToolInput(\n tc.function.name,\n rawArguments,\n isolate\n ),\n });\n continue;\n }\n output.push({\n type: \"function_call\",\n id: callId,\n call_id: callId,\n name: tc.function.name,\n arguments: normalizeCodexPatchMarkers(\n normalizeExecFunctionArguments(tc.function.name, rawArguments, isolate)\n ),\n status: \"completed\",\n });\n }\n }\n\n const usage = responsesUsageFromChat(chat?.usage);\n\n return {\n id: chat?.id || `resp_${Date.now()}`,\n object: \"response\",\n created_at: chat?.created || Math.floor(Date.now() / 1000),\n status: \"completed\",\n model: options?.originalModel || chat?.model,\n output,\n usage,\n };\n}\n\nexport interface ResponsesStreamState {\n responseId: string;\n model?: string;\n textItemId: string;\n textStarted: boolean;\n textClosed: boolean;\n textOutputIndex?: number;\n textContent: string;\n closedTextItems: Array<{\n id: string;\n outputIndex: number;\n content: string;\n }>;\n toolCalls: Map<\n number,\n {\n id: string;\n name: string;\n arguments: string;\n added: boolean;\n outputIndex: number;\n emittedArgumentsLength: number;\n isCustom: boolean;\n }\n >;\n nextOutputIndex: number;\n finished: boolean;\n created: boolean;\n sequenceNumber: number;\n finishReasonSeen: boolean;\n usage?: any;\n callIdMap: ResponsesCallIdMap;\n customToolNames: Set;\n thinkingContent: string;\n thinkingEncryptedContent?: string;\n thinkingId?: string;\n thinkingStarted: boolean;\n thinkingClosed: boolean;\n thinkingOutputIndex?: number;\n codexIsolateConventions: boolean;\n}\n\nexport function createResponsesStreamState(\n options?: {\n model?: string;\n callIdMap?: ResponsesCallIdMap;\n customToolNames?: Set;\n codexIsolateConventions?: boolean;\n }\n): ResponsesStreamState {\n const id = `resp_${Date.now()}`;\n return {\n responseId: id,\n model: options?.model,\n textItemId: `msg_${id}`,\n textStarted: false,\n textClosed: false,\n textContent: \"\",\n closedTextItems: [],\n toolCalls: new Map(),\n nextOutputIndex: 0,\n finished: false,\n created: false,\n sequenceNumber: 0,\n finishReasonSeen: false,\n callIdMap: options?.callIdMap ?? createCallIdMap(),\n customToolNames: options?.customToolNames ?? new Set(),\n thinkingContent: \"\",\n thinkingStarted: false,\n thinkingClosed: false,\n codexIsolateConventions: options?.codexIsolateConventions !== false,\n };\n}\n\nfunction sequenceEvents(state: ResponsesStreamState, events: any[]): any[] {\n return events.map((event) => ({\n ...event,\n sequence_number: state.sequenceNumber++,\n }));\n}\n\nfunction appendCreatedEvent(\n state: ResponsesStreamState,\n events: any[]\n): void {\n if (state.created) return;\n state.created = true;\n events.push({\n type: \"response.created\",\n response: skeletonResponse(state, \"in_progress\"),\n });\n}\n\n/**\n * Close the text (message) item's Responses lifecycle \u2014 idempotent via\n * textClosed. Must run before a tool call's `output_item.added` whenever a\n * text preamble preceded it: Responses items are an ordered array by\n * output_index, and a client (e.g. the Codex/ChatGPT UI) that renders items\n * as they complete expects item N to close before item N+1 opens. Previously\n * this only ran at finalizeResponsesStream (end of stream), so a tool call\n * arriving after a text preamble got its `added` event emitted live while\n * the text item was still open, and the text item's `.done` events only\n * followed at the very end, after the tool call's own added/delta/done\n * sequence had already interleaved with it \u2014 a real client can silently\n * fail to render the tool call as a distinct block when items close out of\n * their own start order.\n */\n/**\n * Open the Responses reasoning item lifecycle. OpenCode / @ai-sdk/openai only\n * materialize thinking from streamed `reasoning_summary_*` events (plus\n * `output_item.added` for reasoning) \u2014 landing the summary solely on\n * `response.completed.output` leaves the client with no thinking parts.\n */\nfunction ensureThinkingItem(state: ResponsesStreamState, events: any[]): void {\n if (state.thinkingStarted || state.thinkingClosed) return;\n state.thinkingStarted = true;\n state.thinkingOutputIndex = state.nextOutputIndex++;\n if (!state.thinkingId) {\n state.thinkingId = `rs_${state.responseId}`;\n }\n events.push({\n type: \"response.output_item.added\",\n output_index: state.thinkingOutputIndex,\n item: {\n type: \"reasoning\",\n id: state.thinkingId,\n status: \"in_progress\",\n summary: [],\n },\n });\n events.push({\n type: \"response.reasoning_summary_part.added\",\n item_id: state.thinkingId,\n output_index: state.thinkingOutputIndex,\n summary_index: 0,\n part: { type: \"summary_text\", text: \"\" },\n });\n}\n\nfunction closeThinkingItem(state: ResponsesStreamState, events: any[]): void {\n if (!state.thinkingStarted || state.thinkingClosed) return;\n state.thinkingClosed = true;\n const id = state.thinkingId || `rs_${state.responseId}`;\n const item = responsesReasoningItemFromThinking(\n {\n content: state.thinkingContent,\n encrypted_content: state.thinkingEncryptedContent,\n id,\n },\n id\n );\n events.push({\n type: \"response.reasoning_summary_text.done\",\n item_id: id,\n output_index: state.thinkingOutputIndex,\n summary_index: 0,\n text: state.thinkingContent,\n });\n events.push({\n type: \"response.reasoning_summary_part.done\",\n item_id: id,\n output_index: state.thinkingOutputIndex,\n summary_index: 0,\n part: { type: \"summary_text\", text: state.thinkingContent },\n });\n events.push({\n type: \"response.output_item.done\",\n output_index: state.thinkingOutputIndex,\n item: item\n ? { ...item, status: \"completed\" }\n : {\n type: \"reasoning\",\n id,\n status: \"completed\",\n summary: state.thinkingContent\n ? [{ type: \"summary_text\", text: state.thinkingContent }]\n : [],\n },\n });\n}\n\nfunction closeTextItem(state: ResponsesStreamState, events: any[]): void {\n if (!state.textStarted || state.textClosed) return;\n state.textClosed = true;\n events.push({\n type: \"response.output_text.done\",\n item_id: state.textItemId,\n output_index: state.textOutputIndex,\n content_index: 0,\n text: state.textContent,\n logprobs: [],\n });\n events.push({\n type: \"response.content_part.done\",\n item_id: state.textItemId,\n output_index: state.textOutputIndex,\n content_index: 0,\n part: {\n type: \"output_text\",\n text: state.textContent,\n annotations: [],\n logprobs: [],\n },\n });\n events.push({\n type: \"response.output_item.done\",\n output_index: state.textOutputIndex,\n item: {\n type: \"message\",\n id: state.textItemId,\n status: \"completed\",\n role: \"assistant\",\n content: [\n {\n type: \"output_text\",\n text: state.textContent,\n annotations: [],\n logprobs: [],\n },\n ],\n },\n });\n state.closedTextItems.push({\n id: state.textItemId,\n outputIndex: state.textOutputIndex ?? 0,\n content: state.textContent,\n });\n}\n\n/**\n * Convert one Unified Chat Completions chunk into zero or more Responses\n * stream events, including the mandatory content_part lifecycle for Codex.\n */\nexport function unifiedChunkToResponsesEvents(\n chunk: any,\n state: ResponsesStreamState\n): any[] {\n if (!chunk || typeof chunk !== \"object\") return [];\n if (state.finished) return [];\n\n const events: any[] = [];\n const choice = chunk.choices?.[0];\n const delta = choice?.delta || {};\n\n if (!state.model && chunk.model) {\n state.model = chunk.model;\n }\n if (chunk.id) {\n state.responseId = chunk.id.startsWith(\"resp_\")\n ? chunk.id\n : `resp_${chunk.id}`;\n }\n if (chunk.usage) {\n state.usage = chunk.usage;\n }\n\n // Chat providers emit reasoning_content; Unified thinking is the same\n // history. Prefer thinkingFromUnifiedAssistant so a Responses client of a\n // Chat Completions upstream still sees a reasoning item.\n const thinking = thinkingFromUnifiedAssistant(delta);\n\n // Preserve upstream lifecycle starts instead of waiting for generated content.\n if (\n !state.textStarted &&\n state.toolCalls.size === 0 &&\n (delta.role === \"assistant\" ||\n typeof delta.content === \"string\" ||\n Array.isArray(delta.tool_calls) ||\n thinking?.content ||\n thinking?.encrypted_content ||\n thinking?.id ||\n choice?.finish_reason)\n ) {\n appendCreatedEvent(state, events);\n }\n\n if (thinking?.content) {\n state.thinkingContent += thinking.content;\n }\n const encrypted_content = responsesEncryptedContentFrom(\n thinking?.encrypted_content\n );\n if (encrypted_content) {\n state.thinkingEncryptedContent = encrypted_content;\n }\n // Lock the reasoning item id on first sight \u2014 rewriting after\n // output_item.added desyncs @ai-sdk/openai's activeReasoning map.\n // Reject the legacy `rs_anon` placeholder so we mint a unique id instead.\n if (!state.thinkingId) {\n if (\n typeof thinking?.id === \"string\" &&\n thinking.id &&\n thinking.id !== \"rs_anon\"\n ) {\n state.thinkingId = thinking.id;\n } else if (isResponsesReasoningItemId(delta.thinking?.signature)) {\n state.thinkingId = delta.thinking.signature;\n }\n }\n\n // Stream reasoning the way OpenAI / Zen do: clients (OpenCode via\n // @ai-sdk/openai) ignore summaries that only appear on response.completed.\n if (\n thinking?.content ||\n encrypted_content ||\n (typeof thinking?.id === \"string\" && thinking.id)\n ) {\n ensureThinkingItem(state, events);\n if (thinking?.content) {\n events.push({\n type: \"response.reasoning_summary_text.delta\",\n item_id: state.thinkingId,\n output_index: state.thinkingOutputIndex,\n summary_index: 0,\n delta: thinking.content,\n });\n }\n }\n\n if (typeof delta.content === \"string\" && delta.content.length > 0) {\n closeThinkingItem(state, events);\n if (state.textClosed) {\n // The previous message item already completed (a tool call opened\n // after the preamble). Trailing text is a new output item \u2014 emitting\n // more output_text.delta against the closed item leaves a live\n // lifecycle the Codex/ChatGPT UI never sees.\n state.textStarted = false;\n state.textClosed = false;\n state.textContent = \"\";\n state.textItemId = `msg_${state.responseId}_${state.nextOutputIndex}`;\n state.textOutputIndex = undefined;\n }\n if (!state.textStarted) {\n state.textStarted = true;\n state.textOutputIndex = state.nextOutputIndex++;\n events.push({\n type: \"response.output_item.added\",\n output_index: state.textOutputIndex,\n item: {\n type: \"message\",\n id: state.textItemId,\n status: \"in_progress\",\n role: \"assistant\",\n content: [],\n },\n });\n events.push({\n type: \"response.content_part.added\",\n item_id: state.textItemId,\n output_index: state.textOutputIndex,\n content_index: 0,\n part: { type: \"output_text\", text: \"\", annotations: [] },\n });\n }\n state.textContent += delta.content;\n events.push({\n type: \"response.output_text.delta\",\n item_id: state.textItemId,\n output_index: state.textOutputIndex,\n content_index: 0,\n delta: delta.content,\n logprobs: [],\n });\n }\n\n if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {\n // Reasoning and text must fully close (in item-index order) before a\n // tool call's own added/delta/done sequence begins \u2014 see closeTextItem.\n closeThinkingItem(state, events);\n closeTextItem(state, events);\n }\n\n if (Array.isArray(delta.tool_calls)) {\n for (const tc of delta.tool_calls) {\n const index = typeof tc.index === \"number\" ? tc.index : 0;\n let entry = state.toolCalls.get(index);\n if (!entry) {\n const callId =\n mapCallId(\n state.callIdMap,\n tc.id || `call_${state.responseId}_${index}`,\n \"unified_to_client\"\n ) || `call_${index}`;\n const name = tc.function?.name || \"\";\n entry = {\n id: callId,\n name,\n arguments: \"\",\n added: false,\n outputIndex: state.nextOutputIndex++,\n emittedArgumentsLength: 0,\n isCustom: state.customToolNames.has(name),\n };\n state.toolCalls.set(index, entry);\n }\n if (tc.id && !entry.added) {\n entry.id =\n mapCallId(state.callIdMap, tc.id, \"unified_to_client\") || entry.id;\n }\n if (tc.function?.name) {\n entry.name = tc.function.name;\n entry.isCustom = state.customToolNames.has(entry.name);\n }\n if (typeof tc.function?.arguments === \"string\") {\n entry.arguments += tc.function.arguments;\n }\n\n if (!entry.added && entry.name) {\n entry.added = true;\n events.push({\n type: \"response.output_item.added\",\n output_index: entry.outputIndex,\n item: entry.isCustom\n ? {\n type: \"custom_tool_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n input: \"\",\n }\n : {\n type: \"function_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n arguments: \"\",\n status: \"in_progress\",\n },\n });\n }\n\n if (\n entry.added &&\n entry.arguments.length > entry.emittedArgumentsLength\n ) {\n // Function arguments arrive incrementally as JSON. For custom tools the\n // client expects deltas of the unwrapped freeform input, not JSON\n // fragments. Wait until finalization to emit the complete custom input;\n // function tools keep their normal streaming deltas.\n if (!entry.isCustom) {\n const unreported = entry.arguments.slice(entry.emittedArgumentsLength);\n events.push({\n type: \"response.function_call_arguments.delta\",\n item_id: entry.id,\n output_index: entry.outputIndex,\n delta: unreported,\n });\n }\n entry.emittedArgumentsLength = entry.arguments.length;\n }\n }\n }\n\n if (choice?.finish_reason) {\n // Chat Completions may report usage in a separate choices:[] chunk after\n // the finish-reason chunk. Wait for [DONE]/upstream close so the terminal\n // Responses object includes that provider-reported usage.\n state.finishReasonSeen = true;\n }\n\n return sequenceEvents(state, events);\n}\n\nexport function finalizeResponsesStream(\n state: ResponsesStreamState,\n usage?: any\n): any[] {\n if (state.finished) return [];\n state.finished = true;\n const events: any[] = [];\n appendCreatedEvent(state, events);\n const isolate: CodexIsolateConventionsOptions = {\n codexIsolateConventions: state.codexIsolateConventions,\n };\n\n closeThinkingItem(state, events);\n closeTextItem(state, events);\n\n for (const entry of state.toolCalls.values()) {\n if (entry.isCustom) {\n const input = normalizeClientCustomToolInput(\n entry.name,\n entry.arguments,\n isolate\n );\n events.push({\n type: \"response.custom_tool_call_input.delta\",\n item_id: entry.id,\n output_index: entry.outputIndex,\n delta: input,\n });\n events.push({\n type: \"response.custom_tool_call_input.done\",\n item_id: entry.id,\n output_index: entry.outputIndex,\n input,\n });\n events.push({\n type: \"response.output_item.done\",\n output_index: entry.outputIndex,\n item: {\n type: \"custom_tool_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n input,\n },\n });\n continue;\n }\n const clientArguments = normalizeCodexPatchMarkers(\n normalizeExecFunctionArguments(entry.name, entry.arguments, isolate)\n );\n events.push({\n type: \"response.function_call_arguments.done\",\n item_id: entry.id,\n output_index: entry.outputIndex,\n name: entry.name,\n arguments: clientArguments,\n });\n events.push({\n type: \"response.output_item.done\",\n output_index: entry.outputIndex,\n item: {\n type: \"function_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n arguments: clientArguments,\n status: \"completed\",\n },\n });\n }\n\n const completed = skeletonResponse(state, \"completed\", usage || state.usage);\n events.push({\n type: \"response.completed\",\n response: completed,\n });\n\n return sequenceEvents(state, events);\n}\n\nfunction skeletonResponse(\n state: ResponsesStreamState,\n status: string,\n usage?: any\n): any {\n const indexedOutput: Array<{ index: number; item: any }> = [];\n for (const closed of state.closedTextItems) {\n indexedOutput.push({\n index: closed.outputIndex,\n item: {\n type: \"message\",\n id: closed.id,\n status: status === \"completed\" ? \"completed\" : \"in_progress\",\n role: \"assistant\",\n content: [\n {\n type: \"output_text\",\n text: closed.content,\n annotations: [],\n logprobs: [],\n },\n ],\n },\n });\n }\n if (\n (state.textStarted || state.textContent) &&\n !state.closedTextItems.some((item) => item.id === state.textItemId)\n ) {\n indexedOutput.push({\n index: state.textOutputIndex ?? 0,\n item: {\n type: \"message\",\n id: state.textItemId,\n status: status === \"completed\" ? \"completed\" : \"in_progress\",\n role: \"assistant\",\n content: [\n {\n type: \"output_text\",\n text: state.textContent,\n annotations: [],\n logprobs: [],\n },\n ],\n },\n });\n }\n for (const entry of state.toolCalls.values()) {\n const isolate: CodexIsolateConventionsOptions = {\n codexIsolateConventions: state.codexIsolateConventions,\n };\n indexedOutput.push({\n index: entry.outputIndex,\n item: entry.isCustom\n ? {\n type: \"custom_tool_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n input: normalizeClientCustomToolInput(\n entry.name,\n entry.arguments,\n isolate\n ),\n }\n : {\n type: \"function_call\",\n id: entry.id,\n call_id: entry.id,\n name: entry.name,\n arguments: normalizeCodexPatchMarkers(\n normalizeExecFunctionArguments(entry.name, entry.arguments, isolate)\n ),\n status: status === \"completed\" ? \"completed\" : \"in_progress\",\n },\n });\n }\n const output = indexedOutput\n .sort((left, right) => left.index - right.index)\n .map(({ item }) => item);\n const reasoningItem = responsesReasoningItemFromThinking(\n {\n content: state.thinkingContent,\n encrypted_content: state.thinkingEncryptedContent,\n id: state.thinkingId,\n },\n state.thinkingId || `rs_${state.responseId}`\n );\n if (reasoningItem) output.unshift(reasoningItem);\n\n return {\n id: state.responseId,\n object: \"response\",\n created_at: Math.floor(Date.now() / 1000),\n status,\n model: state.model,\n output,\n usage: responsesUsageFromChat(usage),\n };\n}\n\nfunction responsesUsageFromChat(usage: any): any | undefined {\n if (!usage || typeof usage !== \"object\") return undefined;\n const result: any = {\n input_tokens: usage.prompt_tokens ?? 0,\n output_tokens: usage.completion_tokens ?? 0,\n total_tokens: usage.total_tokens ?? 0,\n };\n const details = usage.prompt_tokens_details;\n if (details && typeof details === \"object\") {\n result.input_tokens_details = {};\n if (details.cached_tokens != null) {\n result.input_tokens_details.cached_tokens = details.cached_tokens;\n }\n if (details.cache_write_tokens != null) {\n result.input_tokens_details.cache_write_tokens =\n details.cache_write_tokens;\n }\n }\n return result;\n}\n\nexport function responsesFailedEvent(\n message: string,\n state?: ResponsesStreamState\n): any {\n const event = {\n type: \"response.failed\",\n response: {\n id: state?.responseId || `resp_${Date.now()}`,\n object: \"response\",\n status: \"failed\",\n error: {\n message,\n type: \"api_error\",\n code: \"provider_response_error\",\n },\n output: [],\n },\n };\n if (state) {\n return { ...event, sequence_number: state.sequenceNumber++ };\n }\n return event;\n}\n", "import { createHash } from \"crypto\";\n\n/**\n * Anthropic validates `tool_use.id` / `tool_result.tool_use_id` against\n * `^[a-zA-Z0-9_-]+$` and rejects the whole request with a 400\n * `invalid_request_error` if any id violates it.\n *\n * The Cursor SDK supplies `SDKCustomToolContext.toolCallId` as two ids joined\n * by a newline \u2014 the upstream OpenAI-format call id and the SDK's own tracking\n * id, e.g. `call--3\\nfc__0`. That value is emitted as the\n * `tool_calls[].id`, so it lands in the assistant turn and is then echoed back\n * by the client on every later request for the life of the conversation.\n */\nconst ANTHROPIC_TOOL_ID_ALLOWED = /^[a-zA-Z0-9_-]+$/;\nconst ANTHROPIC_TOOL_ID_DISALLOWED = /[^a-zA-Z0-9_-]+/g;\n\n/** Anthropic rejects ids above this length. */\nconst MAX_TOOL_ID_LENGTH = 256;\n\nfunction isConformingId(id: string): boolean {\n return (\n id.length > 0 &&\n id.length <= MAX_TOOL_ID_LENGTH &&\n ANTHROPIC_TOOL_ID_ALLOWED.test(id)\n );\n}\n\n/**\n * Remove trailing `_` characters without a backtracking regex.\n *\n * `/_+$/` is quadratic on strings of many underscores followed by a\n * non-underscore: the engine re-scans the run for every possible start\n * position. Callers feed this client-controlled ids of unbounded length, so\n * the trim must not depend on regex backtracking.\n */\nfunction trimTrailingUnderscores(value: string): string {\n let end = value.length;\n while (end > 0 && value.charCodeAt(end - 1) === 0x5f) end--;\n return value.slice(0, end);\n}\n\nexport function isValidAnthropicToolCallId(id: unknown): id is string {\n return typeof id === \"string\" && isConformingId(id);\n}\n\n/**\n * Coerce an id into Anthropic's allowed alphabet.\n *\n * Runs of invalid characters collapse to a single `_` rather than being\n * deleted: deletion can merge two distinct ids into one (`a\\nb` and `ab` both\n * become `ab`), and a duplicate `tool_use.id` is a worse failure than a long\n * one \u2014 it silently mispairs tool results.\n *\n * Must be deterministic and idempotent. The same id arrives from two\n * independent directions \u2014 emitted on the response and echoed back by the\n * client on the next request \u2014 and both must map to the same value or the\n * `tool_use` / `tool_result` pair stops matching.\n */\nexport function sanitizeToolCallId(id: unknown): string | undefined {\n if (typeof id !== \"string\" || id.length === 0) return undefined;\n if (isConformingId(id)) return id;\n\n const cleaned = trimTrailingUnderscores(\n id\n .replace(ANTHROPIC_TOOL_ID_DISALLOWED, \"_\")\n .slice(0, MAX_TOOL_ID_LENGTH)\n );\n\n return cleaned.length ? cleaned : undefined;\n}\n\n/** OpenAI's Responses API rejects `call_id` values above this length. */\nconst MAX_RESPONSES_CALL_ID_LENGTH = 64;\nconst RESPONSES_CALL_ID_HASH_LENGTH = 20;\nconst RESPONSES_CALL_ID_PREFIX_LENGTH =\n MAX_RESPONSES_CALL_ID_LENGTH - RESPONSES_CALL_ID_HASH_LENGTH - 1;\n\nfunction isConformingResponsesCallId(id: string): boolean {\n return (\n id.length > 0 &&\n id.length <= MAX_RESPONSES_CALL_ID_LENGTH &&\n ANTHROPIC_TOOL_ID_ALLOWED.test(id)\n );\n}\n\n/**\n * Bound a Responses API call id without losing tool-call/result pairing.\n *\n * Invalid or overlong ids use a readable prefix plus a deterministic hash of\n * the original value. Hashing avoids collisions from either normalization or\n * plain truncation, while the conforming fast path makes this idempotent.\n */\nexport function sanitizeResponsesCallId(id: unknown): string | undefined {\n if (typeof id !== \"string\" || id.length === 0) return undefined;\n if (isConformingResponsesCallId(id)) return id;\n\n const normalized = trimTrailingUnderscores(\n id.replace(ANTHROPIC_TOOL_ID_DISALLOWED, \"_\")\n );\n const prefix =\n trimTrailingUnderscores(normalized.slice(0, RESPONSES_CALL_ID_PREFIX_LENGTH)) ||\n \"call\";\n const hash = createHash(\"sha256\")\n .update(id, \"utf8\")\n .digest(\"base64url\")\n .slice(0, RESPONSES_CALL_ID_HASH_LENGTH);\n\n return `${prefix}_${hash}`;\n}\n", "import type { ThinkLevel, UnifiedChatRequest } from \"@/types/llm\";\n\ntype UnifiedReasoning = UnifiedChatRequest[\"reasoning\"];\n\n/** Readable-reasoning request levels shared across Responses / Codex / config. */\nexport type ReasoningSummaryLevel = \"auto\" | \"detailed\" | \"concise\";\n\nconst REASONING_SUMMARY_LEVELS = new Set([\n \"auto\",\n \"detailed\",\n \"concise\",\n]);\n\n/** Normalize effort tokens at the protocol boundary without rejecting extensions. */\nexport function normalizeReasoningEffort(\n value: unknown\n): ThinkLevel | undefined {\n if (typeof value !== \"string\") return undefined;\n const normalized = value.trim().toLowerCase();\n return normalized ? (normalized as ThinkLevel) : undefined;\n}\n\n/**\n * Parse `REASONING_AUTO_SUMMARY` / provider `reasoningSummary`.\n * `true` \u2192 `\"detailed\"` (LiteLLM-compatible). `\"none\"` / false / unset \u2192 off.\n */\nexport function resolveReasoningAutoSummary(\n value: unknown\n): ReasoningSummaryLevel | undefined {\n if (value === true || value === 1) return \"detailed\";\n if (typeof value === \"string\") {\n const normalized = value.trim().toLowerCase();\n if (\n normalized === \"true\" ||\n normalized === \"1\" ||\n normalized === \"yes\" ||\n normalized === \"on\"\n ) {\n return \"detailed\";\n }\n if (REASONING_SUMMARY_LEVELS.has(normalized)) {\n return normalized as ReasoningSummaryLevel;\n }\n }\n return undefined;\n}\n\nfunction normalizeReasoningSummaryToken(\n value: unknown\n): ReasoningSummaryLevel | \"none\" | undefined {\n if (typeof value !== \"string\") return undefined;\n const normalized = value.trim().toLowerCase();\n if (normalized === \"none\") return \"none\";\n if (REASONING_SUMMARY_LEVELS.has(normalized)) {\n return normalized as ReasoningSummaryLevel;\n }\n return undefined;\n}\n\n/** True when reasoning is on (effort present and not none, or enabled:true). */\nexport function isReasoningActive(\n reasoning: UnifiedReasoning | undefined,\n thinking?: UnifiedChatRequest[\"thinking\"]\n): boolean {\n if (isReasoningDisabled(reasoning, thinking)) return false;\n if (!reasoning) return false;\n const effort = normalizeReasoningEffort(reasoning.effort);\n if (effort && effort !== \"none\") return true;\n return reasoning.enabled === true;\n}\n\n/**\n * Opt-in: when config asks for auto-summary and the client enabled reasoning\n * without an explicit `reasoning.summary`, stamp the Unified field so every\n * destination protocol can request readable thinking the same way.\n */\nexport function applyReasoningAutoSummary(\n request: UnifiedChatRequest,\n configValue: unknown\n): UnifiedChatRequest {\n const summary = resolveReasoningAutoSummary(configValue);\n if (!summary || !request.reasoning) return request;\n if (!isReasoningActive(request.reasoning, request.thinking)) return request;\n const existing = normalizeReasoningSummaryToken(request.reasoning.summary);\n // Explicit client value (including \"none\") wins over the config default.\n if (existing) return request;\n request.reasoning.summary = summary;\n return request;\n}\n\n/**\n * Outbound precedence: Unified `reasoning.summary` \u2192 provider.reasoningSummary.\n * `\"none\"` means do not request a readable summary.\n */\nexport function resolveOutboundReasoningSummary(\n request: Pick,\n provider?: { reasoningSummary?: unknown } | null\n): ReasoningSummaryLevel | undefined {\n if (isReasoningDisabled(request.reasoning, request.thinking)) {\n return undefined;\n }\n const fromRequest = normalizeReasoningSummaryToken(request.reasoning?.summary);\n if (fromRequest === \"none\") return undefined;\n if (fromRequest) return fromRequest;\n const fromProvider = normalizeReasoningSummaryToken(provider?.reasoningSummary);\n if (fromProvider === \"none\") return undefined;\n if (fromProvider) return fromProvider;\n return undefined;\n}\n\n/** `none` and an explicit enabled:false are the canonical off signals. */\nexport function isReasoningDisabled(\n reasoning: UnifiedReasoning | undefined,\n thinking?: UnifiedChatRequest[\"thinking\"]\n): boolean {\n return (\n thinking?.type === \"disabled\" ||\n reasoning?.enabled === false ||\n normalizeReasoningEffort(reasoning?.effort) === \"none\"\n );\n}\n\n/** Build the canonical reasoning state used by every inbound protocol. */\nexport function canonicalReasoning(\n effortValue: unknown,\n enabledWhenEffortAbsent?: boolean\n): UnifiedReasoning | undefined {\n const effort = normalizeReasoningEffort(effortValue);\n if (!effort && enabledWhenEffortAbsent === undefined) return undefined;\n return {\n ...(effort ? { effort } : {}),\n enabled: effort === \"none\" ? false : enabledWhenEffortAbsent ?? true,\n };\n}\n\n/** Serialize Unified reasoning onto the Chat Completions wire shape in place. */\nexport function applyOpenAIChatReasoning(\n request: UnifiedChatRequest\n): UnifiedChatRequest {\n if (!request.reasoning) return request;\n const effort = isReasoningDisabled(request.reasoning, request.thinking)\n ? \"none\"\n : normalizeReasoningEffort(request.reasoning.effort);\n if (effort) request.reasoning_effort = effort;\n delete request.reasoning;\n return request;\n}\n\n/** Anthropic accepts low..max, while CCR/OpenAI may additionally emit minimal/ultra/none. */\nexport function toAnthropicReasoningEffort(\n effortValue: unknown\n): Exclude | undefined {\n const effort = normalizeReasoningEffort(effortValue);\n if (!effort || effort === \"none\") return undefined;\n if (effort === \"minimal\") return \"low\";\n if (effort === \"ultra\") return \"max\";\n return effort as Exclude;\n}\n\n/**\n * GPT-6 family slugs (`gpt-6`, `gpt-6-astra`, `openai/gpt-6-astra`,\n * `codex,gpt-6-astra`). Anchored so `gpt-60` / `gpt-5.6` do not match.\n */\nexport function isGpt6FamilyModel(model: unknown): boolean {\n if (typeof model !== \"string\" || !model) return false;\n return /(?:^|[/,:])gpt-6(?:$|[.-])/i.test(model);\n}\n\n/** Astra/Sol reject `none` / `minimal`; OpenAI's migration floor is `low`. */\nexport function coerceGpt6ReasoningEffort(\n model: unknown,\n effort: ThinkLevel | undefined\n): ThinkLevel | undefined {\n if (!effort || !isGpt6FamilyModel(model)) return effort;\n if (effort === \"none\" || effort === \"minimal\") return \"low\";\n // Luna's level set tops out at `max` (no `ultra`, unlike Astra/Sol).\n if (effort === \"ultra\" && isGpt6LunaModel(model)) return \"max\";\n return effort;\n}\n\n/**\n * GPT-6 Luna slugs (`gpt-6-luna`, `openai/gpt-6-luna`, `codex,gpt-6-luna`).\n * Anchored so `gpt-6-sol` / `gpt-6-astra` do not match.\n */\nexport function isGpt6LunaModel(model: unknown): boolean {\n if (typeof model !== \"string\" || !model) return false;\n return /(?:^|[/,:])gpt-6-luna(?:$|[.-])/i.test(model);\n}\n\n/**\n * Remap unsupported GPT-6 efforts on a Responses/Unified request in place.\n * Covers convert (`openai-responses`) and same-protocol wire-keep (`codex`).\n */\nexport function applyGpt6ReasoningEffortCoercion(request: {\n model?: unknown;\n reasoning?: { effort?: unknown; enabled?: boolean } | null;\n}): void {\n if (!request.reasoning || !isGpt6FamilyModel(request.model)) return;\n const effort = normalizeReasoningEffort(request.reasoning.effort);\n const coerced = coerceGpt6ReasoningEffort(request.model, effort);\n if (!coerced || coerced === effort) return;\n request.reasoning.effort = coerced;\n if (request.reasoning.enabled === false) {\n request.reasoning.enabled = true;\n }\n}\n\n/**\n * GPT-6 Astra rejects temperature / top_p / logprobs on Responses. Strip in\n * place when the model is in the gpt-6 family.\n */\nexport function stripGpt6UnsupportedSampling(\n request: Record\n): void {\n if (!isGpt6FamilyModel(request.model)) return;\n delete request.temperature;\n delete request.top_p;\n delete request.top_logprobs;\n delete request.logprobs;\n if (!Array.isArray(request.include)) return;\n const next = request.include.filter(\n (value: unknown) => value !== \"message.output_text.logprobs\"\n );\n if (next.length === 0) delete request.include;\n else request.include = next;\n}\n", "import { createHash } from \"crypto\";\n\nconst MAX_SNAPSHOTS = 512;\nconst HASH_CHARS = 16;\nconst CHARS_PER_TOKEN = 4;\n\n/**\n * Pipeline position a snapshot was taken at. `client` is the Unified/exact-wire\n * body handed to the provider chain; `wire` is what actually left for upstream.\n * Comparing the two attributes a broken prefix to the client or to our own\n * transformer chain without a bisect.\n */\nexport type CachePrefixStage = \"client\" | \"wire\";\n\n/**\n * Routing headers that pin prompt-cache affinity. `x-client-request-id` is\n * deliberately absent: claude-auth mints a fresh one per request (as Claude\n * Code does), and Codex sets it equal to `thread-id`, which is tracked here.\n */\nexport type CacheAffinityHeaders = {\n sessionId?: string;\n threadId?: string;\n};\n\nexport type CachePrefixSegment = {\n path: string;\n role?: string;\n type?: string;\n hash: string;\n /** Rough token weight (JSON chars / 4) \u2014 enough to rank misses by cost. */\n approxTokens: number;\n breakpoints: number;\n reasoningId?: string;\n};\n\nexport type CachePrefixSnapshot = {\n createdAt: number;\n model?: string;\n prompt_cache_key?: string;\n session_id?: string;\n affinity?: CacheAffinityHeaders;\n lastAssistantBlockOrder?: string[];\n breakpointPaths: string[];\n systemHash?: string;\n toolsHash?: string;\n approxTokens: number;\n unstableIds: string[];\n segments: CachePrefixSegment[];\n};\n\nexport type CachePrefixChange = \"none\" | \"appended\" | \"modified\" | \"removed\";\n\nexport type CachePrefixIdSource =\n | \"session\"\n | \"cache_key\"\n | \"fingerprint\"\n /** Parent session id mixed with first substantive user text (Claude Code Task). */\n | \"subagent\";\n\nexport type CachePrefixDiff = {\n conversationId: string;\n conversationIdSource: CachePrefixIdSource;\n stage: CachePrefixStage;\n firstTurn: boolean;\n prefixIntact: boolean;\n change: CachePrefixChange;\n unchangedPrefixCount: number;\n previousSegmentCount: number;\n currentSegmentCount: number;\n /** Approximate tokens of prefix that stayed byte-identical. */\n unchangedPrefixApproxTokens: number;\n /** Approximate tokens the provider must re-read because the prefix moved. */\n approxPrefixTokensLost: number;\n /** Gap since the previous turn \u2014 separates a real break from TTL expiry. */\n msSinceLastTurn?: number;\n prompt_cache_keyChanged: boolean;\n affinityChanged: boolean;\n lastAssistantBlockOrderChanged: boolean;\n modelChanged: boolean;\n systemHashChanged: boolean;\n toolsHashChanged: boolean;\n breakpointsMoved: boolean;\n /** Ids carrying an embedded timestamp \u2014 they rewrite the prefix every turn. */\n unstableIds?: string[];\n firstDivergencePath?: string;\n firstDivergence?: {\n previous?: DivergenceSide;\n current?: DivergenceSide;\n };\n appendedPaths?: string[];\n removedPaths?: string[];\n prompt_cache_key?: { previous?: string; current?: string };\n affinity?: {\n previous?: CacheAffinityHeaders;\n current?: CacheAffinityHeaders;\n };\n lastAssistantBlockOrder?: {\n previous?: string[];\n current?: string[];\n };\n};\n\nexport type CachePrefixDiffOptions = {\n stage?: CachePrefixStage;\n provider?: string;\n model?: string;\n /**\n * Persist this snapshot as the baseline for the next turn. Pass false when\n * upstream rejected the request \u2014 a body that was never cached must not\n * become the baseline the following turn is judged against.\n */\n commit?: boolean;\n /** Override when `conversationId` is a derived subagent key rather than the raw session. */\n conversationIdSource?: CachePrefixIdSource;\n};\n\nconst snapshots = new Map();\n\nexport function __resetCachePrefixSnapshotsForTests(): void {\n snapshots.clear();\n}\n\nfunction digest(value: unknown): { hash: string; approxTokens: number } {\n const json = JSON.stringify(stableValue(value)) ?? \"\";\n return {\n hash: createHash(\"sha256\").update(json).digest(\"hex\").slice(0, HASH_CHARS),\n approxTokens: Math.ceil(json.length / CHARS_PER_TOKEN),\n };\n}\n\nfunction fingerprint(value: unknown): string {\n return digest(value).hash;\n}\n\n/**\n * `cache_control` marks where a cache entry ends; it is not prompt content.\n * Clients move the tail marker forward every turn, so hashing it would report\n * the previous tail as modified on every healthy append. Marker positions are\n * tracked separately via `breakpointPaths` / segment `breakpoints`.\n */\nfunction stableValue(value: unknown): unknown {\n if (value === null || typeof value !== \"object\") return value;\n if (Array.isArray(value)) return value.map(stableValue);\n const out: Record = {};\n for (const key of Object.keys(value as object).sort()) {\n if (key === \"cache_control\") continue;\n out[key] = stableValue((value as Record)[key]);\n }\n return out;\n}\n\nfunction isEphemeral(value: unknown): boolean {\n if (!value || typeof value !== \"object\") return false;\n const cc = (value as any).cache_control;\n return Boolean(cc && typeof cc === \"object\" && cc.type === \"ephemeral\");\n}\n\nfunction hasPromptBreakpoint(value: unknown): boolean {\n return Boolean(\n value &&\n typeof value === \"object\" &&\n (value as any).prompt_cache_breakpoint\n );\n}\n\nfunction countBreakpointsOn(value: unknown): number {\n if (!value || typeof value !== \"object\") return 0;\n let n = 0;\n if (isEphemeral(value) || hasPromptBreakpoint(value)) n += 1;\n if (Array.isArray(value)) {\n for (const item of value) n += countBreakpointsOn(item);\n return n;\n }\n for (const child of Object.values(value as Record)) {\n if (child && typeof child === \"object\") n += countBreakpointsOn(child);\n }\n return n;\n}\n\nfunction collectBreakpointPaths(value: unknown, path: string, out: string[]): void {\n if (!value || typeof value !== \"object\") return;\n if (isEphemeral(value) || hasPromptBreakpoint(value)) out.push(path);\n if (Array.isArray(value)) {\n value.forEach((item, index) =>\n collectBreakpointPaths(item, `${path}[${index}]`, out)\n );\n return;\n }\n for (const [key, child] of Object.entries(value as Record)) {\n if (child && typeof child === \"object\") {\n collectBreakpointPaths(child, `${path}.${key}`, out);\n }\n }\n}\n\nfunction assistantBlockOrder(content: unknown): string[] | undefined {\n if (!Array.isArray(content)) return undefined;\n const order: string[] = [];\n for (const part of content) {\n if (!part || typeof part !== \"object\") continue;\n const type = String((part as any).type || \"\");\n if (!type) continue;\n if (order[order.length - 1] !== type) order.push(type);\n }\n return order.length ? order : undefined;\n}\n\nfunction reasoningIdOf(item: any): string | undefined {\n if (!item || typeof item !== \"object\") return undefined;\n if (item.type === \"reasoning\" && typeof item.id === \"string\" && item.id) {\n return item.id;\n }\n const thinkingId = item.thinking?.id;\n return typeof thinkingId === \"string\" && thinkingId ? thinkingId : undefined;\n}\n\n/**\n * An id carrying a wall-clock timestamp (`rs_1735689600000`) is minted fresh on\n * every convert, so the prefix can never match. Hashed and provider-issued ids\n * do not look like this.\n */\nfunction looksUnstableId(value: unknown): boolean {\n return typeof value === \"string\" && /\\d{12,}/.test(value);\n}\n\nfunction collectUnstableIds(value: unknown, out: Set, depth = 0): void {\n if (!value || typeof value !== \"object\" || depth > 8) return;\n if (Array.isArray(value)) {\n for (const item of value) collectUnstableIds(item, out, depth + 1);\n return;\n }\n for (const [key, child] of Object.entries(value as Record)) {\n if ((key === \"id\" || key === \"call_id\") && looksUnstableId(child)) {\n out.add(String(child));\n } else if (child && typeof child === \"object\") {\n collectUnstableIds(child, out, depth + 1);\n }\n }\n}\n\n/**\n * String content and a single text block with the same text are the same\n * prompt to the provider. Claude Code sends its tail message as a marked text\n * block and the same message as a plain string on later turns (observed on\n * mid-conversation `role:\"system\"` and user messages), so hash both as blocks\n * or every healthy append reads as a rewrite of the previous tail.\n */\nfunction canonicalMessage(item: unknown): unknown {\n const message = item as any;\n if (!message || typeof message !== \"object\") return item;\n if (typeof message.content !== \"string\") return item;\n return { ...message, content: [{ type: \"text\", text: message.content }] };\n}\n\nfunction segment(\n path: string,\n value: unknown,\n extra?: { role?: string; type?: string }\n): CachePrefixSegment {\n const item = value as any;\n const { hash, approxTokens } = digest(value);\n return {\n path,\n ...(extra?.role ? { role: extra.role } : {}),\n ...(extra?.type ? { type: extra.type } : {}),\n ...(typeof item?.role === \"string\" && !extra?.role ? { role: item.role } : {}),\n ...(typeof item?.type === \"string\" && !extra?.type ? { type: item.type } : {}),\n hash,\n approxTokens,\n breakpoints: countBreakpointsOn(value),\n ...(reasoningIdOf(item) ? { reasoningId: reasoningIdOf(item) } : {}),\n };\n}\n\nfunction remember(key: string, snapshot: CachePrefixSnapshot): void {\n if (snapshots.has(key)) snapshots.delete(key);\n snapshots.set(key, snapshot);\n while (snapshots.size > MAX_SNAPSHOTS) {\n const oldest = snapshots.keys().next().value;\n if (oldest === undefined) break;\n snapshots.delete(oldest);\n }\n}\n\n/**\n * Compact, content-free snapshot of the outbound fields prompt caching uses.\n */\nexport function snapshotOutboundCachePrefix(\n body: Record | null | undefined,\n affinity?: CacheAffinityHeaders\n): CachePrefixSnapshot | null {\n if (!body || typeof body !== \"object\") return null;\n\n const segments: CachePrefixSegment[] = [];\n const breakpointPaths: string[] = [];\n let systemHash: string | undefined;\n let toolsHash: string | undefined;\n\n if (body.system != null) {\n const item = segment(\"system\", body.system, { type: \"system\" });\n systemHash = item.hash;\n segments.push(item);\n collectBreakpointPaths(body.system, \"system\", breakpointPaths);\n } else if (typeof body.instructions === \"string\" && body.instructions) {\n const item = segment(\"instructions\", body.instructions, {\n type: \"instructions\",\n });\n systemHash = item.hash;\n segments.push(item);\n }\n\n if (Array.isArray(body.tools)) {\n const item = segment(\"tools\", body.tools, { type: \"tools\" });\n toolsHash = item.hash;\n segments.push(item);\n collectBreakpointPaths(body.tools, \"tools\", breakpointPaths);\n }\n\n const conversation = Array.isArray(body.messages)\n ? { key: \"messages\", items: body.messages }\n : Array.isArray(body.input)\n ? { key: \"input\", items: body.input }\n : Array.isArray(body.contents)\n ? { key: \"contents\", items: body.contents }\n : undefined;\n\n let lastAssistantBlockOrder: string[] | undefined;\n if (conversation) {\n conversation.items.forEach((item: any, index: number) => {\n const path = `${conversation.key}[${index}]`;\n segments.push(segment(path, canonicalMessage(item)));\n collectBreakpointPaths(item, path, breakpointPaths);\n if (item?.role === \"assistant\" || item?.role === \"model\") {\n lastAssistantBlockOrder =\n assistantBlockOrder(item.content) ||\n assistantBlockOrder(item.parts) ||\n lastAssistantBlockOrder;\n }\n });\n }\n\n const prompt_cache_key =\n typeof body.prompt_cache_key === \"string\" && body.prompt_cache_key\n ? body.prompt_cache_key\n : typeof body.session_id === \"string\" && body.session_id\n ? body.session_id\n : undefined;\n\n const cleanedAffinity = affinity\n ? Object.fromEntries(\n Object.entries(affinity).filter(\n ([, value]) => typeof value === \"string\" && value\n )\n )\n : undefined;\n\n if (\n segments.length === 0 &&\n !prompt_cache_key &&\n !(cleanedAffinity && Object.keys(cleanedAffinity).length)\n ) {\n return null;\n }\n\n const unstable = new Set();\n collectUnstableIds(conversation?.items, unstable);\n\n return {\n createdAt: Date.now(),\n ...(typeof body.model === \"string\" ? { model: body.model } : {}),\n ...(prompt_cache_key ? { prompt_cache_key } : {}),\n ...(typeof body.session_id === \"string\" ? { session_id: body.session_id } : {}),\n ...(cleanedAffinity && Object.keys(cleanedAffinity).length\n ? { affinity: cleanedAffinity }\n : {}),\n ...(lastAssistantBlockOrder ? { lastAssistantBlockOrder } : {}),\n breakpointPaths,\n ...(systemHash ? { systemHash } : {}),\n ...(toolsHash ? { toolsHash } : {}),\n approxTokens: segments.reduce((sum, item) => sum + item.approxTokens, 0),\n unstableIds: [...unstable],\n segments,\n };\n}\n\ntype DivergenceSide = Pick<\n CachePrefixSegment,\n \"path\" | \"role\" | \"type\" | \"approxTokens\" | \"breakpoints\" | \"reasoningId\"\n>;\n\nfunction publicSegment(\n segmentValue: CachePrefixSegment | undefined\n): DivergenceSide | undefined {\n if (!segmentValue) return undefined;\n return {\n path: segmentValue.path,\n ...(segmentValue.role ? { role: segmentValue.role } : {}),\n ...(segmentValue.type ? { type: segmentValue.type } : {}),\n approxTokens: segmentValue.approxTokens,\n breakpoints: segmentValue.breakpoints,\n ...(segmentValue.reasoningId\n ? { reasoningId: segmentValue.reasoningId }\n : {}),\n };\n}\n\nfunction affinityFingerprint(affinity?: CacheAffinityHeaders): string {\n if (!affinity) return \"\";\n return fingerprint(affinity);\n}\n\nfunction sumApproxTokens(segmentList: CachePrefixSegment[]): number {\n return segmentList.reduce((sum, item) => sum + item.approxTokens, 0);\n}\n\nexport function diffCachePrefixSnapshots(\n conversationId: string,\n previous: CachePrefixSnapshot | undefined,\n current: CachePrefixSnapshot,\n meta?: { stage?: CachePrefixStage; conversationIdSource?: CachePrefixIdSource }\n): CachePrefixDiff {\n const stage = meta?.stage ?? \"wire\";\n const conversationIdSource = meta?.conversationIdSource ?? \"session\";\n const unstableIds = current.unstableIds.length\n ? { unstableIds: current.unstableIds.slice(0, 8) }\n : {};\n\n if (!previous) {\n return {\n conversationId,\n conversationIdSource,\n stage,\n firstTurn: true,\n prefixIntact: true,\n change: \"none\",\n unchangedPrefixCount: current.segments.length,\n previousSegmentCount: 0,\n currentSegmentCount: current.segments.length,\n unchangedPrefixApproxTokens: current.approxTokens,\n approxPrefixTokensLost: 0,\n prompt_cache_keyChanged: false,\n affinityChanged: false,\n lastAssistantBlockOrderChanged: false,\n modelChanged: false,\n systemHashChanged: false,\n toolsHashChanged: false,\n breakpointsMoved: false,\n ...unstableIds,\n };\n }\n\n const prompt_cache_keyChanged =\n (previous.prompt_cache_key || \"\") !== (current.prompt_cache_key || \"\");\n const affinityChanged =\n affinityFingerprint(previous.affinity) !==\n affinityFingerprint(current.affinity);\n const lastAssistantBlockOrderChanged =\n JSON.stringify(previous.lastAssistantBlockOrder || []) !==\n JSON.stringify(current.lastAssistantBlockOrder || []);\n const modelChanged = (previous.model || \"\") !== (current.model || \"\");\n const systemHashChanged = (previous.systemHash || \"\") !== (current.systemHash || \"\");\n const toolsHashChanged = (previous.toolsHash || \"\") !== (current.toolsHash || \"\");\n const breakpointsMoved =\n JSON.stringify(previous.breakpointPaths) !==\n JSON.stringify(current.breakpointPaths);\n\n const prevSegs = previous.segments;\n const currSegs = current.segments;\n const shared = Math.min(prevSegs.length, currSegs.length);\n let unchanged = 0;\n while (\n unchanged < shared &&\n prevSegs[unchanged].path === currSegs[unchanged].path &&\n prevSegs[unchanged].hash === currSegs[unchanged].hash\n ) {\n unchanged += 1;\n }\n\n const prefixIntact =\n unchanged === prevSegs.length && currSegs.length >= prevSegs.length;\n let change: CachePrefixChange = \"none\";\n let firstDivergencePath: string | undefined;\n let appendedPaths: string[] | undefined;\n let removedPaths: string[] | undefined;\n let firstDivergence: CachePrefixDiff[\"firstDivergence\"];\n\n if (unchanged < shared) {\n change = \"modified\";\n firstDivergencePath = currSegs[unchanged]?.path || prevSegs[unchanged]?.path;\n firstDivergence = {\n previous: publicSegment(prevSegs[unchanged]),\n current: publicSegment(currSegs[unchanged]),\n };\n } else if (currSegs.length > prevSegs.length) {\n change = \"appended\";\n appendedPaths = currSegs.slice(unchanged).map((item) => item.path);\n } else if (currSegs.length < prevSegs.length) {\n change = \"removed\";\n removedPaths = prevSegs.slice(unchanged).map((item) => item.path);\n firstDivergencePath = prevSegs[unchanged]?.path;\n }\n\n if (\n change === \"none\" &&\n (prompt_cache_keyChanged ||\n affinityChanged ||\n lastAssistantBlockOrderChanged ||\n modelChanged ||\n breakpointsMoved)\n ) {\n change = \"modified\";\n }\n\n if (!firstDivergencePath) {\n if (prompt_cache_keyChanged) firstDivergencePath = \"prompt_cache_key\";\n else if (affinityChanged) firstDivergencePath = \"affinity\";\n else if (modelChanged) firstDivergencePath = \"model\";\n // A healthy append moves the tail breakpoint and usually adds an assistant\n // turn with a different block layout. Those name a divergence only when\n // they are the sole change (identical segments escalated to \"modified\"\n // above); otherwise `breakpointsMoved` / `lastAssistantBlockOrderChanged`\n // remain as informational flags.\n else if (change === \"modified\" && lastAssistantBlockOrderChanged) {\n firstDivergencePath = \"lastAssistantBlockOrder\";\n } else if (change === \"modified\" && breakpointsMoved) {\n firstDivergencePath = \"breakpointPaths\";\n }\n }\n\n // A prefix break forces the provider to re-read everything from the\n // divergence onward; an append costs nothing that was already cached.\n const approxPrefixTokensLost =\n change === \"modified\" || change === \"removed\"\n ? sumApproxTokens(prevSegs.slice(unchanged))\n : 0;\n\n return {\n conversationId,\n conversationIdSource,\n stage,\n firstTurn: false,\n prefixIntact:\n prefixIntact &&\n !prompt_cache_keyChanged &&\n !affinityChanged &&\n !modelChanged,\n change,\n unchangedPrefixCount: unchanged,\n previousSegmentCount: prevSegs.length,\n currentSegmentCount: currSegs.length,\n unchangedPrefixApproxTokens: sumApproxTokens(currSegs.slice(0, unchanged)),\n approxPrefixTokensLost,\n msSinceLastTurn: Math.max(0, current.createdAt - previous.createdAt),\n prompt_cache_keyChanged,\n affinityChanged,\n lastAssistantBlockOrderChanged,\n modelChanged,\n systemHashChanged,\n toolsHashChanged,\n breakpointsMoved,\n ...unstableIds,\n ...(firstDivergencePath ? { firstDivergencePath } : {}),\n ...(firstDivergence ? { firstDivergence } : {}),\n ...(appendedPaths ? { appendedPaths } : {}),\n ...(removedPaths ? { removedPaths } : {}),\n ...(prompt_cache_keyChanged\n ? {\n prompt_cache_key: {\n previous: previous.prompt_cache_key,\n current: current.prompt_cache_key,\n },\n }\n : {}),\n ...(affinityChanged\n ? {\n affinity: {\n previous: previous.affinity,\n current: current.affinity,\n },\n }\n : {}),\n ...(lastAssistantBlockOrderChanged\n ? {\n lastAssistantBlockOrder: {\n previous: previous.lastAssistantBlockOrder,\n current: current.lastAssistantBlockOrder,\n },\n }\n : {}),\n };\n}\n\n/**\n * Structural identity for clients that send no session metadata. Keyed on the\n * system prompt plus the opening turn, both of which are fixed for the life of\n * a conversation and differ between conversations \u2014 unlike a shared literal,\n * which would make concurrent conversations diff against each other.\n */\nfunction fingerprintConversation(snapshot: CachePrefixSnapshot): string {\n const opening = snapshot.segments.find((item) =>\n /^(messages|input|contents)\\[0\\]$/.test(item.path)\n );\n return `fp_${fingerprint([\n snapshot.systemHash || \"\",\n snapshot.toolsHash || \"\",\n opening?.hash || \"\",\n ])}`;\n}\n\nfunction resolveConversationId(\n conversationId: string | undefined,\n snapshot: CachePrefixSnapshot,\n sourceOverride?: CachePrefixIdSource\n): { id: string; source: CachePrefixIdSource } {\n if (typeof conversationId === \"string\" && conversationId) {\n return {\n id: conversationId,\n source: sourceOverride ?? \"session\",\n };\n }\n if (snapshot.prompt_cache_key) {\n return { id: snapshot.prompt_cache_key, source: \"cache_key\" };\n }\n return { id: fingerprintConversation(snapshot), source: \"fingerprint\" };\n}\n\n/**\n * Snapshot key for consecutive cache-prefix diffs.\n *\n * Claude Code Tasks share the parent `session_id`. Mixing first substantive\n * user text keeps parent vs fork (and two forks) from overwriting one baseline\n * and reporting 25k-token \"modified\" misses.\n */\nexport function resolveCachePrefixConversationId(opts: {\n sessionId?: string;\n isSubagent?: boolean;\n nestedAgent?: boolean;\n firstUserText?: string;\n}): { id?: string; source?: CachePrefixIdSource } {\n const sessionId =\n typeof opts.sessionId === \"string\" && opts.sessionId\n ? opts.sessionId\n : undefined;\n if (!sessionId) return {};\n const distinct =\n typeof opts.firstUserText === \"string\" ? opts.firstUserText : \"\";\n // Any harness may share a parent session id across workers. Mix the opening\n // user text so parent vs nested transcripts do not overwrite one baseline.\n if (distinct) {\n const nested = opts.nestedAgent === true || opts.isSubagent === true;\n return {\n id: createHash(\"sha256\")\n .update(`${sessionId}\\n${distinct}`)\n .digest(\"hex\")\n .slice(0, 32),\n source: nested ? \"subagent\" : \"session\",\n };\n }\n return { id: sessionId, source: \"session\" };\n}\n\n/**\n * Compare this outbound body to the last one for the conversation, then\n * remember the current snapshot. Returns null when there is nothing cacheable.\n *\n * Snapshots are keyed per stage and per provider/model: a routed fallback to a\n * different destination is a legitimate cache miss, not prefix corruption, and\n * must not be reported as one.\n */\nexport function rememberAndDiffOutboundCachePrefix(\n conversationId: string | undefined,\n body: Record | null | undefined,\n affinity?: CacheAffinityHeaders,\n options?: CachePrefixDiffOptions\n): CachePrefixDiff | null {\n const current = snapshotOutboundCachePrefix(body, affinity);\n if (!current) return null;\n\n const stage = options?.stage ?? \"wire\";\n const { id, source } = resolveConversationId(\n conversationId,\n current,\n options?.conversationIdSource\n );\n const key = [\n stage,\n options?.provider || \"-\",\n options?.model || current.model || \"-\",\n id,\n ].join(\"|\");\n\n const previous = snapshots.get(key);\n const diff = diffCachePrefixSnapshots(id, previous, current, {\n stage,\n conversationIdSource: source,\n });\n if (options?.commit !== false) remember(key, current);\n return diff;\n}\n\n/**\n * Attribute a broken wire prefix to the stage that broke it. The client leg is\n * checked first: if Claude Code itself rewrote history there is nothing our\n * transformer chain could have preserved.\n */\nexport function attributeDivergenceStage(\n clientDiff: CachePrefixDiff | null | undefined,\n wireDiff: CachePrefixDiff | null | undefined\n): CachePrefixStage | \"none\" | undefined {\n if (!wireDiff || wireDiff.firstTurn) return undefined;\n if (wireDiff.prefixIntact) return \"none\";\n if (!clientDiff || clientDiff.firstTurn) return undefined;\n return clientDiff.prefixIntact ? \"wire\" : \"client\";\n}\n", "type MessageLike = { role?: string; content?: unknown };\n\nfunction contentFromResponsesItem(item: any): unknown {\n if (!item || typeof item !== \"object\") return undefined;\n if (item.content !== undefined) return item.content;\n return undefined;\n}\n\nfunction messagesOf(request: unknown): MessageLike[] {\n if (!request || typeof request !== \"object\") return [];\n const body = request as { messages?: unknown; input?: unknown };\n if (Array.isArray(body.messages)) return body.messages as MessageLike[];\n // Responses inbound / wire-keep uses `input[]` (EasyInput or typed message items).\n if (Array.isArray(body.input)) {\n const out: MessageLike[] = [];\n for (const item of body.input) {\n if (!item || typeof item !== \"object\") continue;\n const role = (item as MessageLike).role;\n const type = (item as { type?: string }).type;\n if (role === \"user\" || type === \"message\") {\n out.push({\n role: role || \"user\",\n content: contentFromResponsesItem(item),\n });\n }\n }\n return out;\n }\n return [];\n}\n\n/** First user-turn text only \u2014 never system (billing / harness version). */\nexport function firstUserText(request: unknown): string {\n for (const msg of messagesOf(request)) {\n if (msg.role !== \"user\") continue;\n if (typeof msg.content === \"string\") return msg.content;\n if (Array.isArray(msg.content)) {\n return msg.content\n .map((p: any) => (typeof p === \"string\" ? p : p?.text || \"\"))\n .join(\"\");\n }\n return \"\";\n }\n return \"\";\n}\n\nexport function isHarnessUserNoise(text: string): boolean {\n const trimmed = text.trimStart();\n return (\n !trimmed ||\n trimmed.startsWith(\"\") ||\n trimmed.startsWith(\"\")\n );\n}\n\nexport function userMessageTextParts(content: unknown): string[] {\n if (typeof content === \"string\") return content ? [content] : [];\n if (!Array.isArray(content)) return [];\n const parts: string[] = [];\n for (const part of content) {\n if (typeof part === \"string\") {\n if (part) parts.push(part);\n continue;\n }\n if (\n (part?.type === \"text\" || part?.type === \"input_text\") &&\n typeof part.text === \"string\" &&\n part.text\n ) {\n parts.push(part.text);\n }\n }\n return parts;\n}\n\n/**\n * First user text that distinguishes a worker transcript.\n * Shared reminder/caveat preambles are skipped so parallel Tasks do not collide.\n */\nexport function firstSubstantiveUserText(request: unknown): string {\n for (const msg of messagesOf(request)) {\n if (msg.role !== \"user\") continue;\n const texts = userMessageTextParts(msg.content).filter(\n (text) => !isHarnessUserNoise(text)\n );\n if (texts.length) return texts.join(\"\");\n }\n return firstUserText(request);\n}\n\nconst STATUSLINE_USER_RE =\n /Describe your most recent action in 3-5 words/i;\n\nfunction lastUserText(request: unknown): string {\n const messages = messagesOf(request);\n for (let i = messages.length - 1; i >= 0; i--) {\n const msg = messages[i];\n if (msg.role !== \"user\") continue;\n return userMessageTextParts(msg.content).join(\"\");\n }\n return \"\";\n}\n\n/** Statusline / spinner polls \u2014 must not supersede or become a cache baseline. */\nexport function isStatuslinePollTurn(request: unknown): boolean {\n return STATUSLINE_USER_RE.test(lastUserText(request));\n}\n\nconst FORK_OPENING_RE =\n /|You are a worker fork/i;\n\n/** Parent-lineage headers. Never used as the conversation id. */\nconst PARENT_SESSION_HEADERS = [\n \"x-parent-session-id\",\n \"x-kilocode-parent-taskid\",\n];\n\n/** Nested-agent labels (Codex and similar). */\nconst NESTED_AGENT_HEADERS = [\"x-openai-subagent\"];\n\nfunction headerValue(\n headers: unknown,\n name: string\n): string | undefined {\n if (!headers || typeof headers !== \"object\") return undefined;\n const want = name.toLowerCase();\n for (const [rawName, rawValue] of Object.entries(\n headers as Record\n )) {\n if (rawName.toLowerCase() !== want || rawValue == null) continue;\n const value = Array.isArray(rawValue)\n ? rawValue.find((item) => item != null && String(item))\n : rawValue;\n if (typeof value === \"string\" && value.trim()) return value.trim();\n }\n return undefined;\n}\n\n/**\n * Nested/worker agent on any inbound protocol.\n *\n * Claude Code: `cc_is_subagent`.\n * OpenCode / Kilocode / MiMo: child session + `x-parent-session-id`.\n * Kilocode gateway: `X-KILOCODE-PARENT-TASKID`.\n * Codex: `x-openai-subagent`.\n * Cursor/Claude forks: `` / worker-fork opening text.\n * Grok CLI: child `x-grok-session-id` (unique) plus opening-text mix.\n */\nexport function detectNestedAgent(input: {\n headers?: unknown;\n body?: unknown;\n claudeCodeSubagent?: boolean;\n}): boolean {\n if (input.claudeCodeSubagent === true) return true;\n for (const name of PARENT_SESSION_HEADERS) {\n if (headerValue(input.headers, name)) return true;\n }\n for (const name of NESTED_AGENT_HEADERS) {\n if (headerValue(input.headers, name)) return true;\n }\n const opening = firstSubstantiveUserText(input.body);\n return FORK_OPENING_RE.test(opening);\n}\n", "export class SSEParserTransform extends TransformStream {\n private buffer = '';\n private currentEvent: Record = {};\n\n constructor() {\n super({\n transform: (chunk: string, controller) => {\n this.buffer += chunk;\n const lines = this.buffer.split('\\n');\n\n // Keep last line (may be incomplete)\n this.buffer = lines.pop() || '';\n\n for (const line of lines) {\n const event = this.processLine(line);\n if (event) {\n controller.enqueue(event);\n }\n }\n },\n flush: (controller) => {\n // Process remaining content in buffer\n if (this.buffer.trim()) {\n const events: any[] = [];\n this.processLine(this.buffer.trim(), events);\n events.forEach(event => controller.enqueue(event));\n }\n\n // Push last event (if any)\n if (Object.keys(this.currentEvent).length > 0) {\n controller.enqueue(this.currentEvent);\n }\n }\n });\n }\n\n private processLine(line: string, events?: any[]): any | null {\n if (!line.trim()) {\n if (Object.keys(this.currentEvent).length > 0) {\n const event = { ...this.currentEvent };\n this.currentEvent = {};\n if (events) {\n events.push(event);\n return null;\n }\n return event;\n }\n return null;\n }\n\n if (line.startsWith('event:')) {\n this.currentEvent.event = line.slice(6).trim();\n } else if (line.startsWith('data:')) {\n const data = line.slice(5).trim();\n if (data === '[DONE]') {\n this.currentEvent.data = { type: 'done' };\n } else {\n try {\n this.currentEvent.data = JSON.parse(data);\n } catch {\n this.currentEvent.data = { raw: data, error: 'JSON parse failed' };\n }\n }\n } else if (line.startsWith('id:')) {\n this.currentEvent.id = line.slice(3).trim();\n } else if (line.startsWith('retry:')) {\n this.currentEvent.retry = parseInt(line.slice(6).trim());\n }\n return null;\n }\n}\n", "export type HeaderRecord = Record;\n\nfunction findHeaderKey(headers: HeaderRecord, name: string): string | undefined {\n const normalized = name.toLowerCase();\n return Object.keys(headers).find((key) => key.toLowerCase() === normalized);\n}\n\nexport function mergeHeadersCaseInsensitive(\n base: HeaderRecord | undefined,\n update: HeaderRecord | undefined\n): HeaderRecord {\n const merged: HeaderRecord = { ...(base || {}) };\n if (!update) return merged;\n\n for (const [name, value] of Object.entries(update)) {\n const existing = findHeaderKey(merged, name);\n if (existing) delete merged[existing];\n if (value !== undefined && value !== \"undefined\") {\n merged[name] = value;\n }\n }\n return merged;\n}\n\n/**\n * Headers that describe the previous representation (framing, length,\n * encoding) and must never survive onto a reshaped response body \u2014 the new\n * body has different framing/length than what upstream sent.\n */\nconst NON_FORWARDABLE_RESPONSE_HEADERS = new Set([\n \"content-length\",\n \"content-encoding\",\n \"transfer-encoding\",\n \"connection\",\n \"content-type\",\n \"keep-alive\",\n]);\n\n/**\n * Carry non-representational upstream response headers (rate-limit/usage\n * metadata, request ids, etc.) onto a reshaped `Response`, so overage\n * observability (`anthropic-ratelimit-unified-*`) survives SSE re-framing.\n */\nexport function preserveUpstreamResponseHeaders(\n headers: Headers | undefined\n): Record {\n const preserved: Record = {};\n if (!headers) return preserved;\n headers.forEach((value, key) => {\n if (NON_FORWARDABLE_RESPONSE_HEADERS.has(key.toLowerCase())) return;\n preserved[key] = value;\n });\n return preserved;\n}\n\n/**\n * Strict allowlist of upstream response headers that may cross the final\n * server boundary to the client: retry and observability metadata only.\n * Everything else \u2014 credentials, cookies, hop-by-hop, proxy (`server`,\n * `via`), and representation headers whose values are recomputed after body\n * conversion \u2014 is dropped by omission. Names are matched case-insensitively\n * and emitted lowercase; first value wins so duplicates cannot accumulate.\n */\nconst DOWNSTREAM_SAFE_EXACT_HEADERS = new Set([\n \"retry-after\",\n \"request-id\",\n \"x-request-id\",\n \"openai-request-id\",\n]);\n\nconst DOWNSTREAM_SAFE_HEADER_PREFIXES = [\n \"anthropic-ratelimit-\",\n \"x-ratelimit-\",\n];\n\nexport function selectSafeDownstreamHeaders(\n headers: Headers | HeaderRecord | undefined\n): Record {\n const safe: Record = {};\n if (!headers) return safe;\n\n const entries: Array<[string, unknown]> =\n typeof (headers as Headers).forEach === \"function\" &&\n typeof (headers as any).entries === \"function\"\n ? Array.from((headers as any).entries() as Iterable<[string, unknown]>)\n : Object.entries(headers as HeaderRecord);\n\n for (const [name, value] of entries) {\n if (typeof value !== \"string\" || !value) continue;\n const lower = name.toLowerCase();\n const allowed =\n DOWNSTREAM_SAFE_EXACT_HEADERS.has(lower) ||\n DOWNSTREAM_SAFE_HEADER_PREFIXES.some((prefix) =>\n lower.startsWith(prefix)\n );\n if (!allowed || safe[lower] !== undefined) continue;\n safe[lower] = value;\n }\n return safe;\n}\n\nexport function canonicalizeOutboundHeaders(\n headers: HeaderRecord | undefined,\n fallbackBearer?: string\n): Record {\n const canonical: HeaderRecord = {};\n for (const [name, value] of Object.entries(headers || {})) {\n if (value === undefined || value === \"undefined\") continue;\n const normalized = name.toLowerCase();\n const outputName =\n normalized === \"authorization\"\n ? \"Authorization\"\n : normalized === \"x-api-key\"\n ? \"x-api-key\"\n : normalized;\n const existing = findHeaderKey(canonical, outputName);\n if (existing) delete canonical[existing];\n canonical[outputName] = value;\n }\n\n if (canonical[\"x-api-key\"]) {\n delete canonical.Authorization;\n } else if (!canonical.Authorization && fallbackBearer) {\n canonical.Authorization = `Bearer ${fallbackBearer}`;\n }\n\n return Object.fromEntries(\n Object.entries(canonical).filter(\n (entry): entry is [string, string] => typeof entry[1] === \"string\"\n )\n );\n}\n", "import type { CachePrefixDiff } from \"./cache-prefix-debug\";\n\n/**\n * Provider-family-specific cache contracts. OpenAI-style message prefix +\n * prompt_cache_key is only one of several; Cursor uses conversation/lifecycle,\n * Anthropic uses ephemeral breakpoints, Gemini uses cachedContent resources.\n */\nexport type CacheFamily =\n | \"openai_prefix\"\n | \"anthropic_ephemeral\"\n | \"gemini_cached_content\"\n | \"cursor_conversation\"\n | \"deepseek_prefix\"\n | \"unknown\";\n\nexport type CacheVerdict =\n | \"cold\"\n | \"warm-start\"\n | \"hit\"\n | \"partial\"\n | \"expected-miss\"\n | \"unexpected-miss\"\n | \"unknown\";\n\nexport type CachePrediction = {\n family: CacheFamily;\n firstTurn: boolean;\n /** Provider-specific: was a hit expected this turn? */\n predictedHit: boolean;\n /** Why we predicted miss/hit (for logs). */\n reason: string;\n /** OpenAI-style prefix intactness when available (diagnostic for Cursor). */\n prefixIntact?: boolean;\n firstDivergencePath?: string;\n approxPrefixTokensLost?: number;\n conversationId?: string;\n conversationIdSource?: string;\n /** Cursor lifecycle action when family is cursor_conversation. */\n lifecycleAction?: string;\n hostPrefixIntact?: boolean;\n};\n\nexport type CursorCacheLifecycle = {\n sessionKey?: string;\n action: string;\n reason?: string;\n};\n\nexport type ResolveCacheFamilyInput = {\n provider?: string;\n model?: string;\n body?: Record | null;\n cursorLifecycle?: CursorCacheLifecycle | null;\n};\n\nconst CURSOR_PROVIDER_RE = /\\bcursor\\b/i;\nconst DEEPSEEK_PROVIDER_RE = /deepseek/i;\nconst ANTHROPIC_PROVIDER_RE = /anthropic|claude/i;\nconst GEMINI_PROVIDER_RE = /gemini|google|vertex/i;\n\nfunction hasEphemeralBreakpoint(value: unknown, depth = 0): boolean {\n if (!value || typeof value !== \"object\" || depth > 8) return false;\n const cc = (value as any).cache_control;\n if (cc && typeof cc === \"object\" && cc.type === \"ephemeral\") return true;\n if (Array.isArray(value)) {\n return value.some((item) => hasEphemeralBreakpoint(item, depth + 1));\n }\n for (const child of Object.values(value as Record)) {\n if (hasEphemeralBreakpoint(child, depth + 1)) return true;\n }\n return false;\n}\n\n/**\n * Longest ephemeral TTL on the body in ms (default 5m, `ttl: \"1h\"`), 0 when\n * there is no breakpoint. Each read refreshes an entry for its TTL, so a gap\n * longer than this since the previous turn means every entry has expired.\n */\nfunction longestEphemeralTtlMs(value: unknown, depth = 0): number {\n if (!value || typeof value !== \"object\" || depth > 8) return 0;\n let longest = 0;\n const cc = (value as any).cache_control;\n if (cc && typeof cc === \"object\" && cc.type === \"ephemeral\") {\n longest = cc.ttl === \"1h\" ? 3_600_000 : 300_000;\n }\n for (const child of Object.values(value as Record)) {\n longest = Math.max(longest, longestEphemeralTtlMs(child, depth + 1));\n }\n return longest;\n}\n\nfunction geminiCachedContentName(\n body: Record | null | undefined\n): string | undefined {\n if (!body || typeof body !== \"object\") return undefined;\n const name = body.cachedContent ?? body.cached_content;\n return typeof name === \"string\" && name ? name : undefined;\n}\n\n/**\n * Prefer explicit provider/transformer id; fall back to body sniffing.\n */\nexport function resolveCacheFamily(input: ResolveCacheFamilyInput): CacheFamily {\n const provider = String(input.provider || \"\");\n if (input.cursorLifecycle || CURSOR_PROVIDER_RE.test(provider)) {\n return \"cursor_conversation\";\n }\n if (DEEPSEEK_PROVIDER_RE.test(provider)) return \"deepseek_prefix\";\n if (ANTHROPIC_PROVIDER_RE.test(provider)) return \"anthropic_ephemeral\";\n if (GEMINI_PROVIDER_RE.test(provider)) return \"gemini_cached_content\";\n\n const body = input.body;\n if (body && typeof body === \"object\") {\n if (geminiCachedContentName(body)) return \"gemini_cached_content\";\n if (hasEphemeralBreakpoint(body)) return \"anthropic_ephemeral\";\n if (\n Array.isArray(body.messages) ||\n Array.isArray(body.input) ||\n typeof body.prompt_cache_key === \"string\"\n ) {\n return \"openai_prefix\";\n }\n }\n return \"unknown\";\n}\n\n/**\n * Join what we predicted against what upstream reported.\n * Labels intentionally match the historical sse-debug-tap strings.\n */\nexport function classifyCacheOutcome(\n prediction: CachePrediction | null | undefined,\n hitRatio: number | undefined\n): CacheVerdict {\n if (hitRatio === undefined) return \"unknown\";\n if (!prediction || prediction.firstTurn) {\n return hitRatio > 0 ? \"warm-start\" : \"cold\";\n }\n if (prediction.predictedHit) {\n return hitRatio > 0 ? \"hit\" : \"unexpected-miss\";\n }\n return hitRatio > 0 ? \"partial\" : \"expected-miss\";\n}\n\nfunction fromPrefixDiff(\n family: CacheFamily,\n diff: CachePrefixDiff | null | undefined,\n extras?: Partial\n): CachePrediction {\n if (!diff) {\n return {\n family,\n firstTurn: true,\n predictedHit: false,\n reason: extras?.reason || \"no-prefix-diff\",\n ...extras,\n };\n }\n const predictedHit = !diff.firstTurn && diff.prefixIntact;\n let reason: string;\n if (diff.firstTurn) reason = \"first-turn\";\n else if (diff.prefixIntact) reason = \"prefix-intact\";\n else reason = diff.firstDivergencePath || diff.change || \"prefix-broken\";\n return {\n family,\n firstTurn: diff.firstTurn,\n predictedHit,\n reason: extras?.reason || reason,\n prefixIntact: diff.prefixIntact,\n firstDivergencePath: diff.firstDivergencePath,\n approxPrefixTokensLost: diff.approxPrefixTokensLost,\n conversationId: diff.conversationId,\n conversationIdSource: diff.conversationIdSource,\n ...extras,\n };\n}\n\n/** OpenAI Chat/Responses, Codex, Zen, Cerebras, OpenRouter, Mistral, xAI. */\nexport function predictOpenAiPrefix(\n diff: CachePrefixDiff | null | undefined\n): CachePrediction {\n return fromPrefixDiff(\"openai_prefix\", diff);\n}\n\n/** DeepSeek uses the same outbound prefix contract; hit tokens are separate. */\nexport function predictDeepSeekPrefix(\n diff: CachePrefixDiff | null | undefined\n): CachePrediction {\n return fromPrefixDiff(\"deepseek_prefix\", diff);\n}\n\n/**\n * Anthropic caches only when ephemeral breakpoints exist and the covered\n * prefix stayed intact. No breakpoints \u2192 predicted miss.\n */\nexport function predictAnthropicEphemeral(\n diff: CachePrefixDiff | null | undefined,\n body?: Record | null\n): CachePrediction {\n // When body is supplied, require at least one ephemeral breakpoint.\n if (body !== undefined && body !== null && !hasEphemeralBreakpoint(body)) {\n return {\n family: \"anthropic_ephemeral\",\n firstTurn: diff?.firstTurn ?? true,\n predictedHit: false,\n reason: \"no-ephemeral-breakpoints\",\n prefixIntact: diff?.prefixIntact,\n firstDivergencePath: diff?.firstDivergencePath,\n approxPrefixTokensLost: diff?.approxPrefixTokensLost,\n conversationId: diff?.conversationId,\n conversationIdSource: diff?.conversationIdSource,\n };\n }\n\n // Expiry only explains a miss when the prefix was intact; a rewritten\n // history after a long gap keeps its divergence path.\n const ttlMs = body ? longestEphemeralTtlMs(body) : 0;\n if (\n diff &&\n !diff.firstTurn &&\n diff.prefixIntact &&\n ttlMs > 0 &&\n (diff.msSinceLastTurn ?? 0) > ttlMs\n ) {\n return fromPrefixDiff(\"anthropic_ephemeral\", diff, {\n predictedHit: false,\n reason: \"ttl-expired\",\n });\n }\n\n return fromPrefixDiff(\"anthropic_ephemeral\", diff, {\n reason: diff?.firstTurn\n ? \"first-turn\"\n : diff?.prefixIntact\n ? \"ephemeral-prefix-intact\"\n : diff?.firstDivergencePath || \"ephemeral-prefix-broken\",\n });\n}\n\n/** Track last seen Gemini cachedContent name per conversation for rotation. */\nconst geminiCachedNames = new Map();\nconst MAX_GEMINI_NAMES = 256;\n\nexport function __resetGeminiCachedContentNamesForTests(): void {\n geminiCachedNames.clear();\n}\n\nfunction rememberGeminiName(conversationId: string, name: string): string | undefined {\n const previous = geminiCachedNames.get(conversationId);\n geminiCachedNames.delete(conversationId);\n geminiCachedNames.set(conversationId, name);\n while (geminiCachedNames.size > MAX_GEMINI_NAMES) {\n const oldest = geminiCachedNames.keys().next().value;\n if (!oldest) break;\n geminiCachedNames.delete(oldest);\n }\n return previous;\n}\n\nexport function predictGeminiCachedContent(opts: {\n diff?: CachePrefixDiff | null;\n body?: Record | null;\n conversationId?: string;\n}): CachePrediction {\n const { diff, body } = opts;\n const name = geminiCachedContentName(body);\n const conversationId =\n opts.conversationId || diff?.conversationId || \"gemini-anon\";\n\n if (!name) {\n return {\n family: \"gemini_cached_content\",\n firstTurn: diff?.firstTurn ?? true,\n predictedHit: false,\n reason: \"no-cached-content\",\n prefixIntact: diff?.prefixIntact,\n conversationId,\n conversationIdSource: diff?.conversationIdSource,\n };\n }\n\n const previous = rememberGeminiName(conversationId, name);\n if (!previous) {\n return {\n family: \"gemini_cached_content\",\n firstTurn: true,\n predictedHit: false,\n reason: \"first-cached-content\",\n prefixIntact: diff?.prefixIntact,\n conversationId,\n conversationIdSource: diff?.conversationIdSource,\n };\n }\n if (previous !== name) {\n return {\n family: \"gemini_cached_content\",\n firstTurn: false,\n predictedHit: false,\n reason: \"cached-content-rotated\",\n prefixIntact: false,\n firstDivergencePath: \"cachedContent\",\n conversationId,\n conversationIdSource: diff?.conversationIdSource,\n };\n }\n // Same resource: still require host prefix intact when we have a diff.\n if (diff && !diff.firstTurn && !diff.prefixIntact) {\n return fromPrefixDiff(\"gemini_cached_content\", diff, {\n reason: \"cached-content-prefix-broken\",\n });\n }\n return {\n family: \"gemini_cached_content\",\n firstTurn: false,\n predictedHit: true,\n reason: \"cached-content-reused\",\n prefixIntact: diff?.prefixIntact ?? true,\n conversationId,\n conversationIdSource: diff?.conversationIdSource,\n };\n}\n\nconst CURSOR_HIT_ACTIONS = new Set([\"resume-parked\", \"send-incremental\"]);\nconst CURSOR_FIRST_ACTIONS = new Set([\"send-full\"]);\n\n/**\n * Cursor has no prompt_cache_key. Prediction follows lifecycle:\n * resume/incremental \u2192 hit expected; retire/replay or fresh send \u2192 miss expected.\n */\nexport function predictCursorConversation(opts: {\n lifecycle?: CursorCacheLifecycle | null;\n diff?: CachePrefixDiff | null;\n}): CachePrediction {\n const lifecycle = opts.lifecycle;\n const diff = opts.diff;\n const action = lifecycle?.action || \"\";\n const sessionKey = lifecycle?.sessionKey;\n\n if (!action) {\n // Fall back to OpenAI-style prefix if lifecycle was not stashed.\n return fromPrefixDiff(\"cursor_conversation\", diff, {\n reason: \"cursor-lifecycle-missing\",\n hostPrefixIntact: diff?.prefixIntact,\n });\n }\n\n if (CURSOR_FIRST_ACTIONS.has(action) || action === \"send-full\") {\n return {\n family: \"cursor_conversation\",\n firstTurn: true,\n predictedHit: false,\n reason: lifecycle?.reason || action,\n lifecycleAction: action,\n conversationId: sessionKey || diff?.conversationId,\n conversationIdSource: sessionKey ? \"session\" : diff?.conversationIdSource,\n hostPrefixIntact: diff?.prefixIntact,\n prefixIntact: diff?.prefixIntact,\n };\n }\n\n if (CURSOR_HIT_ACTIONS.has(action)) {\n return {\n family: \"cursor_conversation\",\n firstTurn: false,\n predictedHit: true,\n reason: lifecycle?.reason || action,\n lifecycleAction: action,\n conversationId: sessionKey || diff?.conversationId,\n conversationIdSource: sessionKey ? \"session\" : diff?.conversationIdSource,\n hostPrefixIntact: diff?.prefixIntact,\n // Do not use host message prefix as Cursor prediction; keep as diagnostic.\n prefixIntact: true,\n };\n }\n\n // retire-and-replay-full and any unknown retirement-like action\n return {\n family: \"cursor_conversation\",\n firstTurn: false,\n predictedHit: false,\n reason: lifecycle?.reason || action || \"cursor-retire\",\n lifecycleAction: action,\n conversationId: sessionKey || diff?.conversationId,\n conversationIdSource: sessionKey ? \"session\" : diff?.conversationIdSource,\n hostPrefixIntact: diff?.prefixIntact,\n prefixIntact: false,\n firstDivergencePath: diff?.firstDivergencePath,\n approxPrefixTokensLost: diff?.approxPrefixTokensLost,\n };\n}\n\n/**\n * Build the right prediction for this outbound leg.\n */\nexport function buildCachePrediction(opts: {\n provider?: string;\n model?: string;\n body?: Record | null;\n diff?: CachePrefixDiff | null;\n cursorLifecycle?: CursorCacheLifecycle | null;\n conversationId?: string;\n}): CachePrediction {\n const family = resolveCacheFamily({\n provider: opts.provider,\n model: opts.model,\n body: opts.body,\n cursorLifecycle: opts.cursorLifecycle,\n });\n\n switch (family) {\n case \"cursor_conversation\":\n return predictCursorConversation({\n lifecycle: opts.cursorLifecycle,\n diff: opts.diff,\n });\n case \"anthropic_ephemeral\":\n return predictAnthropicEphemeral(opts.diff, opts.body);\n case \"gemini_cached_content\":\n return predictGeminiCachedContent({\n diff: opts.diff,\n body: opts.body,\n conversationId: opts.conversationId || opts.diff?.conversationId,\n });\n case \"deepseek_prefix\":\n return predictDeepSeekPrefix(opts.diff);\n case \"openai_prefix\":\n return predictOpenAiPrefix(opts.diff);\n default:\n return fromPrefixDiff(\"unknown\", opts.diff, { reason: \"unknown-family\" });\n }\n}\n", "/**\n * Sniff a response body as JSON vs SSE without Response.clone().\n *\n * Cloudflare (Codex) often strips Content-Type from SSE. The first\n * non-whitespace byte is `{`/`[` for a JSON object/array and anything\n * else (typically `d` from `data:`) for SSE. JSON drains into text;\n * SSE returns a new Response that replays the peeked chunk then\n * continues from the same reader.\n */\nexport type PeekedResponseBody =\n | { kind: \"json\"; firstChar: string; text: string }\n | { kind: \"sse\"; response: Response }\n | { kind: \"empty\" };\n\nexport async function peekResponseBody(\n response: Response\n): Promise {\n const body = response.body;\n if (!body) return { kind: \"empty\" };\n\n const reader = body.getReader();\n const decoder = new TextDecoder();\n const cancelReader = async () => {\n try {\n await reader.cancel();\n } catch {\n // ignore\n }\n try {\n reader.releaseLock();\n } catch {\n // already released\n }\n };\n\n let firstRead: { done: boolean; value?: Uint8Array };\n try {\n firstRead = await reader.read();\n } catch (err) {\n await cancelReader();\n throw err;\n }\n\n if (firstRead.done || !firstRead.value) {\n try {\n reader.releaseLock();\n } catch {\n // ignore\n }\n return { kind: \"empty\" };\n }\n\n const firstChunk = firstRead.value;\n const firstText = decoder.decode(firstChunk, { stream: true });\n const firstChar = firstText.trimStart().charAt(0) || \"\";\n\n if (firstChar === \"{\" || firstChar === \"[\") {\n let buffer = firstText;\n try {\n while (true) {\n const r = await reader.read();\n if (r.done) break;\n buffer += decoder.decode(r.value, { stream: true });\n }\n buffer += decoder.decode();\n } catch (err) {\n await cancelReader();\n throw err;\n } finally {\n try {\n reader.releaseLock();\n } catch {\n // ignore\n }\n }\n return { kind: \"json\", firstChar, text: buffer };\n }\n\n const replayed = new ReadableStream({\n start(controller) {\n controller.enqueue(firstChunk);\n },\n async pull(controller) {\n try {\n const r = await reader.read();\n if (r.done) {\n controller.close();\n try {\n reader.releaseLock();\n } catch {\n // ignore\n }\n return;\n }\n controller.enqueue(r.value!);\n } catch (err) {\n try {\n await reader.cancel();\n } catch {\n // ignore\n }\n try {\n reader.releaseLock();\n } catch {\n // ignore\n }\n controller.error(err);\n }\n },\n async cancel(reason) {\n try {\n await reader.cancel(reason);\n } catch {\n // ignore\n }\n try {\n reader.releaseLock();\n } catch {\n // ignore\n }\n },\n });\n\n const headers = new Headers(response.headers);\n if (!headers.has(\"Content-Type\")) {\n headers.set(\"Content-Type\", \"text/event-stream\");\n }\n\n return {\n kind: \"sse\",\n response: new Response(replayed, {\n status: response.status,\n statusText: response.statusText,\n headers,\n }),\n };\n}\n", "import { SSEParserTransform } from \"./sse/SSEParser.transform\";\nimport { preserveUpstreamResponseHeaders } from \"./headers\";\nimport {\n DEFAULT_LOG_BODY_MAX_BYTES,\n sanitizeBodyForLog,\n sanitizeUpstreamErrorBody,\n} from \"./redact\";\nimport {\n attributeDivergenceStage,\n rememberAndDiffOutboundCachePrefix,\n type CacheAffinityHeaders,\n type CachePrefixDiff,\n type CachePrefixIdSource,\n type CachePrefixStage,\n} from \"./cache-prefix-debug\";\nimport {\n buildCachePrediction,\n classifyCacheOutcome,\n type CachePrediction,\n type CursorCacheLifecycle,\n} from \"./cache-outcome\";\nimport type { MessageDebugDirection } from \"./message-debug\";\nimport { peekResponseBody } from \"./stream-peek\";\n\nexport type UpstreamSSEDebugOptions = {\n logger?: any;\n reqId?: string | number;\n provider?: string;\n /** Routed model \u2014 snapshots are keyed per destination. */\n model?: string;\n /** Conversation / Claude session id used to pair consecutive cache snapshots. */\n conversationId?: string;\n conversationIdSource?: CachePrefixIdSource;\n /** When false, diff against the last baseline but do not replace it. */\n commitCachePrefix?: boolean;\n /** Pipeline position this body was captured at. Defaults to `wire`. */\n stage?: CachePrefixStage;\n /** Codex (and similar) routing headers that pin prompt-cache affinity. */\n cacheAffinity?: CacheAffinityHeaders;\n /** Upstream status. Non-2xx bodies are diffed but never become the baseline. */\n responseStatus?: number;\n /** Client-leg diff, used to attribute a broken wire prefix to a stage. */\n clientStageDiff?: CachePrefixDiff | null;\n /** Outbound diff for this request, joined with the observed cache usage. */\n cacheDiff?: CachePrefixDiff | null;\n /** Outbound body used to resolve Anthropic/Gemini family signals. */\n outboundBody?: Record | null;\n /** Precomputed prediction; built from cacheDiff + family when absent. */\n cachePrediction?: CachePrediction | null;\n /** Cursor lifecycle plan for conversation-cache prediction. */\n cursorLifecycle?: CursorCacheLifecycle | null;\n /** Cap for a single logged payload string (raw `data` field). */\n maxBytes?: number;\n /**\n * Opt-in raw per-event SSE logging. Independent of LOG_LEVEL=debug.\n * When false (default), the debug tap still computes terminal cache outcome\n * summaries but does not log every delta.\n */\n rawEvents?: boolean;\n /**\n * Which wire leg produced these bytes. Defaults to `provider\u2192ccr` for the\n * upstream tap and `ccr\u2192client` for the client tap.\n */\n direction?: MessageDebugDirection;\n /**\n * When true, only emit raw SSE/JSON event logs (no cache outcome summary).\n * Used for the client-bound leg where cache usage was already observed upstream.\n */\n eventsOnly?: boolean;\n};\n\nexport type ClientSSEDebugOptions = {\n logger?: any;\n reqId?: string | number;\n provider?: string;\n model?: string;\n protocol?: string;\n maxBytes?: number;\n rawEvents?: boolean;\n};\n\nfunction isDebugEnabled(logger: any): boolean {\n if (!logger || typeof logger.debug !== \"function\") return false;\n if (typeof logger.isLevelEnabled === \"function\") {\n try {\n return logger.isLevelEnabled(\"debug\") === true;\n } catch {\n return false;\n }\n }\n const level = typeof logger.level === \"string\" ? logger.level.toLowerCase() : \"\";\n if (level === \"debug\" || level === \"trace\") return true;\n // Pino numeric levels: trace=10, debug=20\n if (typeof logger.levelVal === \"number\") return logger.levelVal <= 20;\n // Minimal test loggers often expose only debug(); treat that as enabled.\n return !(\"level\" in logger) && !(\"levelVal\" in logger);\n}\n\nfunction isRawSSETraceEnabled(opts: UpstreamSSEDebugOptions): boolean {\n if (opts.rawEvents === true) return true;\n if (opts.rawEvents === false) return false;\n // Explicit config / env opt-in (not implied by LOG_LEVEL=debug).\n const env = process.env.LOG_SSE_EVENTS || process.env.CCR_LOG_SSE_EVENTS;\n if (env === \"1\" || env === \"true\") return true;\n return false;\n}\n\nfunction cloneResponseHeaders(\n headers: Headers,\n contentTypeFallback?: string\n): Record {\n const out = preserveUpstreamResponseHeaders(headers);\n const contentType = headers.get(\"Content-Type\") || contentTypeFallback;\n if (contentType) out[\"Content-Type\"] = contentType;\n return out;\n}\n\nfunction contentTypeOf(response: Response): string {\n return (response.headers.get(\"Content-Type\") || \"\").toLowerCase();\n}\n\nfunction logReceived(\n opts: UpstreamSSEDebugOptions,\n data: string,\n parsed?: unknown\n): void {\n if (!isRawSSETraceEnabled(opts)) return;\n const logger = opts.logger;\n if (!logger?.debug) return;\n const maxBytes = opts.maxBytes ?? DEFAULT_LOG_BODY_MAX_BYTES;\n const base = {\n reqId: opts.reqId,\n provider: opts.provider,\n model: opts.model,\n direction: opts.direction ?? \"provider\u2192ccr\",\n };\n\n logger.debug({\n ...base,\n type: \"received data\",\n data: sanitizeBodyForLog(data, maxBytes),\n });\n\n if (parsed !== undefined) {\n logger.debug({\n ...base,\n response: sanitizeUpstreamErrorBody(parsed),\n // Keep the historical typo so existing log greps keep working.\n tppe: \"Original Response\",\n });\n }\n}\n\ntype CacheUsage = {\n /** True when cached tokens are reported outside the prompt total (Anthropic). */\n cachedExcludedFromPrompt: boolean;\n promptTokens?: number;\n cachedTokens?: number;\n cacheWriteTokens?: number;\n outputTokens?: number;\n};\n\nfunction num(value: unknown): number | undefined {\n return typeof value === \"number\" && Number.isFinite(value) ? value : undefined;\n}\n\nfunction pickMax(a: number | undefined, b: number | undefined) {\n if (a === undefined) return b;\n if (b === undefined) return a;\n return Math.max(a, b);\n}\n\n/**\n * Every provider reports prompt-cache hits under a different name. Collect the\n * usage objects each protocol can emit and normalize them onto one shape.\n */\nfunction mergeCacheUsage(acc: CacheUsage, event: unknown): CacheUsage {\n if (!event || typeof event !== \"object\") return acc;\n const node = event as any;\n const candidates = [\n node.usage,\n node.message?.usage,\n node.response?.usage,\n node.usageMetadata,\n ].filter((value) => value && typeof value === \"object\");\n\n let next = acc;\n for (const usage of candidates) {\n const cached = pickMax(\n pickMax(\n num(usage.cache_read_input_tokens),\n num(usage.prompt_tokens_details?.cached_tokens)\n ),\n pickMax(\n pickMax(\n num(usage.input_tokens_details?.cached_tokens),\n num(usage.cachedContentTokenCount)\n ),\n num(usage.prompt_cache_hit_tokens)\n )\n );\n next = {\n // Anthropic's input_tokens counts only the uncached remainder; the\n // OpenAI/Gemini families fold cached tokens into the prompt total.\n cachedExcludedFromPrompt:\n next.cachedExcludedFromPrompt ||\n num(usage.cache_read_input_tokens) !== undefined ||\n num(usage.cache_creation_input_tokens) !== undefined,\n promptTokens: pickMax(\n next.promptTokens,\n pickMax(\n pickMax(num(usage.input_tokens), num(usage.prompt_tokens)),\n num(usage.promptTokenCount)\n )\n ),\n cachedTokens: pickMax(next.cachedTokens, cached),\n cacheWriteTokens: pickMax(\n next.cacheWriteTokens,\n pickMax(\n num(usage.cache_creation_input_tokens),\n // Cursor accurate usage projects write onto this diagnostic field.\n num(usage._cacheWriteTokens)\n )\n ),\n outputTokens: pickMax(\n next.outputTokens,\n pickMax(\n pickMax(num(usage.output_tokens), num(usage.completion_tokens)),\n num(usage.candidatesTokenCount)\n )\n ),\n };\n }\n return next;\n}\n\nfunction resolvePrediction(opts: UpstreamSSEDebugOptions): CachePrediction {\n if (opts.cachePrediction) return opts.cachePrediction;\n return buildCachePrediction({\n provider: opts.provider,\n model: opts.model,\n body: opts.outboundBody,\n diff: opts.cacheDiff,\n cursorLifecycle: opts.cursorLifecycle,\n conversationId: opts.conversationId,\n });\n}\n\nfunction logCacheOutcome(opts: UpstreamSSEDebugOptions, usage: CacheUsage): void {\n if (!isDebugEnabled(opts.logger)) return;\n const diff = opts.cacheDiff;\n const prediction = resolvePrediction(opts);\n const cached = usage.cachedTokens;\n const prompt = usage.promptTokens;\n // Anthropic reports the uncached remainder, so the billable prompt is the sum.\n const promptTotal =\n prompt === undefined\n ? undefined\n : usage.cachedExcludedFromPrompt\n ? prompt + (cached || 0) + (usage.cacheWriteTokens || 0)\n : prompt;\n const hitRatio =\n cached === undefined || !promptTotal\n ? undefined\n : Math.round((cached / promptTotal) * 1000) / 1000;\n\n if (cached === undefined && prompt === undefined && !diff && !opts.cursorLifecycle) {\n return;\n }\n\n const divergenceStage = diff\n ? attributeDivergenceStage(opts.clientStageDiff, diff)\n : undefined;\n\n opts.logger.debug({\n reqId: opts.reqId,\n provider: opts.provider,\n type: \"cache outcome\",\n verdict: classifyCacheOutcome(prediction, hitRatio),\n cacheFamily: prediction.family,\n predictedHit: prediction.predictedHit,\n predictionReason: prediction.reason,\n ...(opts.model ? { model: opts.model } : {}),\n ...(opts.responseStatus ? { status: opts.responseStatus } : {}),\n ...(prediction.lifecycleAction\n ? { lifecycleAction: prediction.lifecycleAction }\n : {}),\n ...(prediction.hostPrefixIntact !== undefined\n ? { hostPrefixIntact: prediction.hostPrefixIntact }\n : {}),\n ...(diff\n ? {\n conversationId: prediction.conversationId || diff.conversationId,\n conversationIdSource:\n prediction.conversationIdSource || diff.conversationIdSource,\n predictedChange: diff.change,\n prefixIntact:\n prediction.prefixIntact !== undefined\n ? prediction.prefixIntact\n : diff.prefixIntact,\n ...(prediction.firstDivergencePath || diff.firstDivergencePath\n ? {\n firstDivergencePath:\n prediction.firstDivergencePath || diff.firstDivergencePath,\n }\n : {}),\n approxPrefixTokensLost:\n prediction.approxPrefixTokensLost ?? diff.approxPrefixTokensLost,\n ...(diff.msSinceLastTurn !== undefined\n ? { msSinceLastTurn: diff.msSinceLastTurn }\n : {}),\n ...(divergenceStage ? { divergenceStage } : {}),\n }\n : prediction.conversationId\n ? {\n conversationId: prediction.conversationId,\n conversationIdSource: prediction.conversationIdSource,\n }\n : {}),\n ...(promptTotal !== undefined ? { promptTokens: promptTotal } : {}),\n ...(cached !== undefined ? { cachedTokens: cached } : {}),\n ...(usage.cacheWriteTokens !== undefined\n ? { cacheWriteTokens: usage.cacheWriteTokens }\n : {}),\n ...(usage.outputTokens !== undefined\n ? { outputTokens: usage.outputTokens }\n : {}),\n ...(hitRatio !== undefined ? { cacheHitRatio: hitRatio } : {}),\n });\n}\n\nfunction consumeSSEDebugBranch(\n debugBranch: ReadableStream,\n opts: UpstreamSSEDebugOptions\n): void {\n const run = async () => {\n // Cast avoids DOM lib ArrayBuffer/ArrayBufferLike mismatch on TextDecoderStream.\n const reader = (debugBranch as ReadableStream)\n .pipeThrough(new TextDecoderStream())\n .pipeThrough(new SSEParserTransform())\n .getReader();\n\n let usage: CacheUsage = { cachedExcludedFromPrompt: false };\n const rawEvents = isRawSSETraceEnabled(opts);\n\n // Yield so a sync-heavy logger.debug (pino file I/O) cannot monopolize the\n // event loop and starve the client TransformStream on the same thread.\n const yieldToClient = () =>\n new Promise((resolve) => setImmediate(resolve));\n\n try {\n while (true) {\n const { done, value } = await reader.read();\n if (done) break;\n if (!value || typeof value !== \"object\") continue;\n\n const event = value as { data?: unknown; event?: string };\n if (event.data == null) continue;\n\n if (\n typeof event.data === \"object\" &&\n (event.data as any).type === \"done\"\n ) {\n if (rawEvents) {\n logReceived(opts, \"[DONE]\");\n await yieldToClient();\n }\n continue;\n }\n\n if (typeof event.data === \"object\" && (event.data as any).raw != null) {\n if (rawEvents) {\n logReceived(opts, String((event.data as any).raw));\n await yieldToClient();\n }\n continue;\n }\n\n usage = mergeCacheUsage(usage, event.data);\n\n if (rawEvents) {\n let dataStr: string;\n try {\n dataStr = JSON.stringify(event.data);\n } catch {\n dataStr = String(event.data);\n }\n logReceived(opts, dataStr, event.data);\n await yieldToClient();\n }\n }\n } finally {\n if (!opts.eventsOnly) {\n logCacheOutcome(opts, usage);\n }\n try {\n reader.releaseLock();\n } catch {\n // already released\n }\n }\n };\n\n void run().catch(() => {});\n}\n\nasync function tapJsonBody(\n response: Response,\n opts: UpstreamSSEDebugOptions\n): Promise {\n const text = await response.text();\n let parsed: unknown;\n try {\n parsed = JSON.parse(text);\n } catch {\n parsed = undefined;\n }\n logReceived(opts, text, parsed);\n if (!opts.eventsOnly) {\n logCacheOutcome(\n opts,\n mergeCacheUsage({ cachedExcludedFromPrompt: false }, parsed)\n );\n }\n return new Response(text, {\n status: response.status,\n statusText: response.statusText,\n headers: cloneResponseHeaders(response.headers, \"application/json\"),\n });\n}\n\n/**\n * Byte-preserving upstream response debug tap.\n *\n * For SSE: mirrors bytes to a background consumer that emits Codex-parity\n * `received data` / `Original Response` logs (including Anthropic usage /\n * cache fields on message_start / message_delta).\n *\n * Important: do **not** use `ReadableStream.tee()` here. Tee couples\n * backpressure across both branches \u2014 a slow debug logger (pino file I/O on\n * every thinking delta) stalls the client branch. Claude Code then idles long\n * enough to surface \"Waiting for API response \u00B7 check your network\" and retry\n * while CCR eventually still finishes the upstream as HTTP 200.\n *\n * Instead, a TransformStream forwards each chunk to the client immediately and\n * copies into a debug tunnel whose writable side has an infinite high-water\n * mark, so debug I/O can never delay the client. The debug consumer drains the\n * buffered copy at its own pace (memory-bound to the stream size).\n *\n * Exact-wire passthrough never enters transformer stream loggers; this tap is\n * the single shared place that covers every outbound provider.\n */\nexport async function tapUpstreamSSEDebug(\n response: Response,\n opts: UpstreamSSEDebugOptions\n): Promise {\n if (!isDebugEnabled(opts.logger) || !response.body) {\n return response;\n }\n\n const withDirection: UpstreamSSEDebugOptions = {\n ...opts,\n direction: opts.direction ?? \"provider\u2192ccr\",\n };\n\n const contentType = contentTypeOf(response);\n\n if (contentType.includes(\"application/json\")) {\n try {\n return await tapJsonBody(response, withDirection);\n } catch {\n return response;\n }\n }\n\n let sseResponse = response;\n if (!contentType.includes(\"text/event-stream\")) {\n if (contentType) {\n // Declared non-SSE (text/plain, octet-stream, \u2026): no usage to read.\n if (!withDirection.eventsOnly) {\n logCacheOutcome(withDirection, { cachedExcludedFromPrompt: false });\n }\n return response;\n }\n // Missing Content-Type: Cloudflare (Codex) strips it from SSE. Sniff the\n // first byte so cache outcome and provider\u2192ccr logs still run.\n try {\n const peek = await peekResponseBody(response);\n if (peek.kind === \"json\") {\n const headers = new Headers(response.headers);\n headers.set(\"Content-Type\", \"application/json\");\n return await tapJsonBody(\n new Response(peek.text, {\n status: response.status,\n statusText: response.statusText,\n headers,\n }),\n withDirection\n );\n }\n if (peek.kind === \"empty\") {\n if (!withDirection.eventsOnly) {\n logCacheOutcome(withDirection, { cachedExcludedFromPrompt: false });\n }\n return new Response(null, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n }\n sseResponse = peek.response;\n } catch {\n return response;\n }\n }\n\n if (!sseResponse.body) {\n return sseResponse;\n }\n\n try {\n const clientBranch = pipeSSEWithNonblockingDebugTap(\n sseResponse.body,\n withDirection\n );\n return new Response(clientBranch, {\n status: sseResponse.status,\n statusText: sseResponse.statusText,\n headers: cloneResponseHeaders(sseResponse.headers, \"text/event-stream\"),\n });\n } catch {\n return sseResponse;\n }\n}\n\n/**\n * Byte-preserving tap for the SSE body CCR sends back to the client after\n * response transformers. Same non-blocking tunnel as the upstream tap; events\n * are tagged `direction: \"ccr\u2192client\"` so greps can split the two legs.\n */\nexport function tapClientSSEDebug(\n body: ReadableStream,\n opts: ClientSSEDebugOptions\n): ReadableStream {\n if (!body || !opts.rawEvents || !isDebugEnabled(opts.logger)) {\n return body;\n }\n try {\n return pipeSSEWithNonblockingDebugTap(body, {\n logger: opts.logger,\n reqId: opts.reqId,\n provider: opts.provider,\n model: opts.model,\n maxBytes: opts.maxBytes,\n rawEvents: true,\n direction: \"ccr\u2192client\",\n eventsOnly: true,\n });\n } catch {\n return body;\n }\n}\n\n/**\n * Forward upstream SSE bytes to the client without waiting on debug I/O.\n *\n * The debug tunnel writable uses `highWaterMark: Infinity` so `write()` always\n * accepts immediately and queues in memory. That preserves full debug logs\n * (including terminal usage frames for cache outcome) without the tee()\n * backpressure footgun and without dropping mid-stream chunks (which would\n * tear the SSE parser and lose usage anyway).\n */\nfunction pipeSSEWithNonblockingDebugTap(\n body: ReadableStream,\n opts: UpstreamSSEDebugOptions\n): ReadableStream {\n const debugTunnel = new TransformStream(\n undefined,\n // Writable strategy: never apply backpressure toward the client tap.\n { highWaterMark: Infinity },\n // Readable strategy: let the debug consumer pull at its own pace.\n { highWaterMark: 1 }\n );\n const debugWriter = debugTunnel.writable.getWriter();\n consumeSSEDebugBranch(debugTunnel.readable, opts);\n\n let debugAlive = true;\n const abandonDebug = () => {\n if (!debugAlive) return;\n debugAlive = false;\n void debugWriter.close().catch(() => {});\n };\n\n return body.pipeThrough(\n // `cancel` is part of the Transformer contract at runtime but missing from\n // the bundled DOM lib types.\n new TransformStream({\n transform(chunk, controller) {\n controller.enqueue(chunk);\n if (!debugAlive) return;\n // Infinite writable HWM: write() queues synchronously and resolves\n // without waiting on the debug consumer / pino I/O.\n void debugWriter.write(chunk.slice()).catch(() => {\n abandonDebug();\n });\n },\n flush() {\n abandonDebug();\n },\n cancel() {\n abandonDebug();\n },\n } as Transformer)\n );\n}\n\nexport type CacheStructureSummary = {\n systemBreakpoints: number;\n messageBreakpoints: number;\n toolBreakpoints: number;\n prompt_cache_key?: string;\n lastAssistantBlockOrder?: string[];\n};\n\nfunction countEphemeralOnValue(value: unknown): number {\n if (!value || typeof value !== \"object\") return 0;\n const cc = (value as any).cache_control;\n return cc && typeof cc === \"object\" && cc.type === \"ephemeral\" ? 1 : 0;\n}\n\nfunction countEphemeralInContent(content: unknown): number {\n if (!Array.isArray(content)) return 0;\n return content.reduce(\n (sum: number, part: unknown) => sum + countEphemeralOnValue(part),\n 0\n );\n}\n\nfunction assistantBlockOrder(content: unknown): string[] | undefined {\n if (!Array.isArray(content)) return undefined;\n const order: string[] = [];\n for (const part of content) {\n if (!part || typeof part !== \"object\") continue;\n const type = String((part as any).type || \"\");\n if (!type) continue;\n if (order[order.length - 1] !== type) order.push(type);\n }\n return order.length ? order : undefined;\n}\n\n/**\n * Summarize outbound Anthropic/OpenAI cache-oriented request structure for\n * debug verification (breakpoints / prompt_cache_key / assistant block order).\n */\nexport function summarizeOutboundCacheStructure(\n body: Record | null | undefined\n): CacheStructureSummary | null {\n if (!body || typeof body !== \"object\") return null;\n\n let systemBreakpoints = 0;\n if (Array.isArray(body.system)) {\n for (const block of body.system) {\n systemBreakpoints += countEphemeralOnValue(block);\n }\n } else if (body.system && typeof body.system === \"object\") {\n systemBreakpoints += countEphemeralOnValue(body.system);\n }\n\n let messageBreakpoints = 0;\n let lastAssistantBlockOrder: string[] | undefined;\n if (Array.isArray(body.messages)) {\n for (const message of body.messages) {\n if (!message || typeof message !== \"object\") continue;\n messageBreakpoints += countEphemeralOnValue(message);\n messageBreakpoints += countEphemeralInContent(message.content);\n if (message.role === \"assistant\") {\n lastAssistantBlockOrder = assistantBlockOrder(message.content);\n }\n }\n }\n\n let toolBreakpoints = 0;\n if (Array.isArray(body.tools)) {\n for (const tool of body.tools) {\n toolBreakpoints += countEphemeralOnValue(tool);\n }\n }\n\n const prompt_cache_key =\n typeof body.prompt_cache_key === \"string\" && body.prompt_cache_key\n ? body.prompt_cache_key\n : undefined;\n\n if (\n systemBreakpoints === 0 &&\n messageBreakpoints === 0 &&\n toolBreakpoints === 0 &&\n !prompt_cache_key &&\n !lastAssistantBlockOrder\n ) {\n return null;\n }\n\n return {\n systemBreakpoints,\n messageBreakpoints,\n toolBreakpoints,\n ...(prompt_cache_key ? { prompt_cache_key } : {}),\n ...(lastAssistantBlockOrder\n ? { lastAssistantBlockOrder }\n : {}),\n };\n}\n\n/**\n * Snapshot the outbound body, diff it against the previous turn, and log both.\n * Returns the diff so the caller can join it with the observed cache usage\n * once upstream responds.\n */\nexport function logOutboundCacheStructure(\n body: Record | null | undefined,\n opts: UpstreamSSEDebugOptions\n): CachePrefixDiff | null {\n if (!isDebugEnabled(opts.logger)) return null;\n const summary = summarizeOutboundCacheStructure(body);\n if (summary) {\n opts.logger.debug({\n reqId: opts.reqId,\n provider: opts.provider,\n type: \"cache structure\",\n stage: opts.stage ?? \"wire\",\n ...summary,\n });\n }\n\n const status = opts.responseStatus;\n const accepted =\n status === undefined || (status >= 200 && status < 300);\n const diff = rememberAndDiffOutboundCachePrefix(\n opts.conversationId,\n body,\n opts.cacheAffinity,\n {\n stage: opts.stage ?? \"wire\",\n provider: opts.provider,\n model: opts.model,\n conversationIdSource: opts.conversationIdSource,\n // A rejected request was never cached upstream; keeping it as the\n // baseline would report the next turn as a phantom prefix break.\n commit: opts.commitCachePrefix !== false && accepted,\n }\n );\n if (!diff) return null;\n\n const divergenceStage = attributeDivergenceStage(opts.clientStageDiff, diff);\n opts.logger.debug({\n reqId: opts.reqId,\n provider: opts.provider,\n type: \"cache prefix diff\",\n ...diff,\n ...(divergenceStage ? { divergenceStage } : {}),\n });\n return diff;\n}\n", "import { createHash } from \"crypto\";\nimport { existsSync, mkdirSync, writeFileSync } from \"fs\";\nimport { homedir } from \"os\";\nimport { join } from \"path\";\nimport {\n DEFAULT_LOG_BODY_MAX_BYTES,\n sanitizeBodyForLog,\n} from \"./redact\";\n\n/** Wire direction for request/response body and SSE message debug logs. */\nexport type MessageDebugDirection =\n | \"client\u2192ccr\"\n | \"ccr\u2192provider\"\n | \"provider\u2192ccr\"\n | \"ccr\u2192client\";\n\nexport function isTruthyConfigFlag(value: unknown): boolean {\n return value === true || value === \"true\" || value === \"1\";\n}\n\nexport function resolveLogBodyMaxBytes(configService: {\n get?: (key: string) => unknown;\n} | null | undefined): number {\n const raw = configService?.get?.(\"LOG_REQUEST_BODY_MAX_BYTES\");\n return typeof raw === \"number\" && Number.isFinite(raw) && raw > 0\n ? raw\n : DEFAULT_LOG_BODY_MAX_BYTES;\n}\n\n/**\n * Body capture selector (`LOG_REQUEST_BODY_PARTS`): comma-separated top-level\n * body fields (`system,tools`), or `full` for the whole body. Unset/empty\n * disables capture. Unknown names are kept and reported as not-found at write\n * time so typos stay visible.\n */\nexport type LogBodySelection = \"full\" | string[];\n\nexport function resolveLogBodySelection(configService: {\n get?: (key: string) => unknown;\n} | null | undefined): LogBodySelection | undefined {\n const raw = configService?.get?.(\"LOG_REQUEST_BODY_PARTS\");\n if (typeof raw !== \"string\") return undefined;\n const parts = raw\n .split(\",\")\n .map((part) => part.trim().toLowerCase())\n .filter(Boolean)\n .filter((part, index, all) => all.indexOf(part) === index);\n if (parts.length === 0) return undefined;\n if (parts.includes(\"full\") || parts.includes(\"*\")) return \"full\";\n return parts;\n}\n\n/** Capture files live next to the rotated server logs. */\nexport function defaultLogBodyDir(): string {\n return join(homedir(), \".claude-code-router\", \"logs\");\n}\n\nfunction directionSlug(direction: MessageDebugDirection): string {\n switch (direction) {\n case \"client\u2192ccr\":\n return \"client-ccr\";\n case \"ccr\u2192provider\":\n return \"ccr-provider\";\n case \"provider\u2192ccr\":\n return \"provider-ccr\";\n case \"ccr\u2192client\":\n return \"ccr-client\";\n }\n}\n\nfunction filenameSegment(value: unknown, fallback: string): string {\n const text = typeof value === \"string\" && value ? value : fallback;\n // Dots excluded: a \"..\" segment would traverse out of the bodies dir.\n const clean = text.replace(/[^A-Za-z0-9_-]+/g, \"_\").slice(0, 80);\n return clean || fallback;\n}\n\nfunction sha16Hex(value: string): string {\n return createHash(\"sha256\").update(value, \"utf8\").digest(\"hex\").slice(0, 16);\n}\n\n/** Directories already created by this process (mkdir once per dir). */\nconst ensuredBodyDirs = new Set();\n\nexport function shouldLogSSEEvents(configService: {\n get?: (key: string) => unknown;\n} | null | undefined): boolean {\n if (isTruthyConfigFlag(configService?.get?.(\"LOG_SSE_EVENTS\"))) return true;\n const env = process.env.LOG_SSE_EVENTS || process.env.CCR_LOG_SSE_EVENTS;\n return env === \"1\" || env === \"true\";\n}\n\n/** Serialize a request/response body for sanitizeBodyForLog. */\nexport function bodyToLogString(body: unknown): string {\n if (body == null) return \"\";\n if (typeof body === \"string\") return body;\n try {\n return JSON.stringify(body);\n } catch {\n return String(body);\n }\n}\n\nexport type MessageBodyLogOptions = {\n logger: { debug?: (...args: any[]) => void; info?: (...args: any[]) => void };\n direction: MessageDebugDirection;\n /** Prefer debug; info kept for the legacy Anthropic-only inbound path. */\n level?: \"debug\" | \"info\";\n reqId?: string | number;\n protocol?: string;\n provider?: string;\n model?: string;\n maxBytes?: number;\n /** Override the historical `type` field when needed. */\n type?: string;\n /**\n * Resolved `LOG_REQUEST_BODY_PARTS` (see resolveLogBodySelection).\n * `\"full\"` stores the whole body; a list stores one file per named\n * top-level field. The log carries one manifest line per part (with sha256)\n * instead of the body. Undefined keeps the legacy inline whole-body dump.\n */\n selection?: LogBodySelection | undefined;\n /** Code-level directory override (tests); defaults to the logs folder. */\n bodiesDir?: string;\n};\n\n/**\n * Opt-in full message-body capture with a stable direction tag so operators\n * can grep client\u2194CCR and CCR\u2194provider legs independently.\n */\nfunction itemType(item: unknown): string {\n if (!item || typeof item !== \"object\") return \"unknown\";\n const rec = item as Record;\n if (typeof rec.type === \"string\" && rec.type) return rec.type;\n if (typeof rec.role === \"string\" && rec.role) return rec.role;\n return \"unknown\";\n}\n\nfunction encryptedLen(item: unknown): number {\n if (!item || typeof item !== \"object\") return 0;\n const value = (item as { encrypted_content?: unknown }).encrypted_content;\n return typeof value === \"string\" ? value.length : 0;\n}\n\n/**\n * Compact keep-wire snapshot for debug logs. Full transcripts stay behind\n * LOG_REQUEST_BODY; this is how keep (Responses/Chat) shows encrypted\n * replay on `ccr\u2192provider` without a 200k-token dump.\n */\nexport function summarizeKeepWire(body: unknown): Record {\n if (!body || typeof body !== \"object\") {\n return { empty: true };\n }\n const rec = body as Record;\n const inputTypes: Record = {};\n const reasoning: Array> = [];\n let encryptedItems = 0;\n\n const tally = (item: unknown) => {\n const type = itemType(item);\n inputTypes[type] = (inputTypes[type] || 0) + 1;\n const enc = encryptedLen(item);\n if (enc > 0) encryptedItems += 1;\n if (type === \"reasoning\" || enc > 0) {\n const entry: Record = { type, encrypted_len: enc };\n if (item && typeof item === \"object\") {\n const id = (item as { id?: unknown }).id;\n if (typeof id === \"string\" && id) entry.id = id;\n const summary = (item as { summary?: unknown }).summary;\n if (Array.isArray(summary)) entry.summary_n = summary.length;\n }\n reasoning.push(entry);\n }\n };\n\n if (Array.isArray(rec.input)) {\n for (const item of rec.input) tally(item);\n } else if (Array.isArray(rec.messages)) {\n for (const item of rec.messages) {\n tally(item);\n const thinking =\n item && typeof item === \"object\"\n ? (item as { thinking?: unknown }).thinking\n : undefined;\n if (thinking && typeof thinking === \"object\") {\n const enc = encryptedLen(thinking);\n if (enc > 0) {\n encryptedItems += 1;\n reasoning.push({ type: \"thinking\", encrypted_len: enc });\n }\n }\n }\n }\n\n return {\n ...(rec.store !== undefined ? { store: rec.store } : {}),\n ...(rec.stream !== undefined ? { stream: rec.stream } : {}),\n ...(Array.isArray(rec.include) ? { include: rec.include } : {}),\n ...(typeof rec.prompt_cache_key === \"string\" && rec.prompt_cache_key\n ? { prompt_cache_key: rec.prompt_cache_key }\n : {}),\n ...(Array.isArray(rec.input) ? { input_n: rec.input.length } : {}),\n ...(Array.isArray(rec.messages) ? { messages_n: rec.messages.length } : {}),\n ...(Object.keys(inputTypes).length ? { input_types: inputTypes } : {}),\n encrypted_content_items: encryptedItems,\n ...(reasoning.length ? { reasoning } : {}),\n ...(Array.isArray(rec.tools) ? { tools_n: rec.tools.length } : {}),\n };\n}\n\nexport function logKeepWire(\n body: unknown,\n opts: {\n logger?: { debug?: (...args: any[]) => void };\n reqId?: string | number;\n provider?: string;\n model?: string;\n }\n): void {\n const write = opts.logger?.debug;\n if (typeof write !== \"function\") return;\n write.call(opts.logger, {\n type: \"keep wire\",\n direction: \"ccr\u2192provider\" as MessageDebugDirection,\n reqId: opts.reqId,\n provider: opts.provider,\n model: opts.model,\n ...summarizeKeepWire(body),\n });\n}\n\nexport function logMessageBody(\n body: unknown,\n opts: MessageBodyLogOptions\n): void {\n const level = opts.level ?? \"debug\";\n const write = opts.logger?.[level];\n if (typeof write !== \"function\") return;\n\n const maxBytes = opts.maxBytes ?? DEFAULT_LOG_BODY_MAX_BYTES;\n if (opts.selection !== undefined) {\n logMessageBodyParts(body, opts, opts.selection, maxBytes, write);\n return;\n }\n write.call(opts.logger, {\n type: opts.type ?? \"message body\",\n direction: opts.direction,\n reqId: opts.reqId,\n protocol: opts.protocol,\n provider: opts.provider,\n model: opts.model,\n data: sanitizeBodyForLog(bodyToLogString(body), maxBytes),\n });\n}\n\n/**\n * Selective capture: one file per requested top-level field plus a manifest\n * line carrying the sha256 of the stored bytes, so components can be compared\n * across turns (`rg '\"part\":\"tools\"'` then diff hashes) without opening files.\n * Best-effort: filesystem failures degrade to a single warning line, never to\n * a request-path error.\n */\nfunction logMessageBodyParts(\n body: unknown,\n opts: MessageBodyLogOptions,\n selection: LogBodySelection,\n maxBytes: number,\n write: (...args: any[]) => void\n): void {\n const base = {\n direction: opts.direction,\n reqId: opts.reqId,\n protocol: opts.protocol,\n provider: opts.provider,\n model: opts.model,\n };\n const dir = opts.bodiesDir ?? defaultLogBodyDir();\n const slug = directionSlug(opts.direction);\n const req = filenameSegment(opts.reqId, \"noreq\");\n const names = selection === \"full\" ? [\"full\"] : selection;\n\n for (const part of names) {\n const value =\n part === \"full\"\n ? { found: true as const, value: body }\n : body !== null && typeof body === \"object\" &&\n Object.prototype.hasOwnProperty.call(body, part)\n ? {\n found: true as const,\n value: (body as Record)[part],\n }\n : { found: false as const, value: undefined };\n if (!value.found) {\n write.call(opts.logger, {\n ...base,\n type: \"message body part\",\n part,\n found: false,\n });\n continue;\n }\n const stored = sanitizeBodyForLog(\n bodyToLogString(value.value),\n maxBytes\n );\n const hash = sha16Hex(stored);\n const safePart = filenameSegment(part, \"part\");\n const path = join(dir, `${req}.${slug}.${safePart}.${hash}.json`);\n try {\n if (!ensuredBodyDirs.has(dir)) {\n mkdirSync(dir, { recursive: true });\n ensuredBodyDirs.add(dir);\n } else if (!existsSync(dir)) {\n // Removed between requests (log rotation, operator cleanup).\n mkdirSync(dir, { recursive: true });\n }\n writeFileSync(path, stored, \"utf-8\");\n } catch (error: any) {\n write.call(opts.logger, {\n ...base,\n type: \"message body part\",\n part,\n sha256: hash,\n bytes: stored.length,\n path,\n error: String(error?.message || error),\n });\n continue;\n }\n write.call(opts.logger, {\n ...base,\n type: \"message body part\",\n part,\n found: true,\n sha256: hash,\n bytes: stored.length,\n truncated: /\u2026\\[truncated \\d+ bytes\\]$/.test(stored),\n path,\n });\n }\n}\n", "/**\n * Client-facing SSE keepalive.\n *\n * Claude Code shows \"Waiting for API response \u00B7 will retry in \u2026 \u00B7 check your\n * network\" when no bytes arrive on the response stream for 20s (advisor: 90s),\n * even before any retry has started \u2014 see Claude Code error docs. Anthropic's\n * own `ping` events often arrive only every ~25\u201330s during long thinking /\n * tool-argument streams, so a transparent proxy that only forwards upstream\n * bytes trips that spinner on every slow Opus turn.\n *\n * Inject SSE comment frames (`: \u2026\\n\\n`) after `idleMs` of silence. Comments are\n * transport keepalives: EventSource / Anthropic SSE parsers ignore them, but\n * they reset Claude Code's byte-idle timer. Default 10s is half the 20s warning.\n */\n\nconst DEFAULT_IDLE_MS = 10_000;\nconst KEEPALIVE_BYTES = new TextEncoder().encode(\": keepalive\\n\\n\");\n\nexport type SSEClientKeepaliveOptions = {\n /** Silence before emitting a comment frame. Default 10_000. */\n idleMs?: number;\n};\n\nexport function withSSEClientKeepalive(\n body: ReadableStream,\n options?: SSEClientKeepaliveOptions\n): ReadableStream {\n const idleMs = options?.idleMs ?? DEFAULT_IDLE_MS;\n if (!(idleMs > 0)) return body;\n\n let timer: ReturnType | null = null;\n let reader: ReadableStreamDefaultReader | null = null;\n let cancelled = false;\n\n const clear = () => {\n if (timer) {\n clearTimeout(timer);\n timer = null;\n }\n };\n\n return new ReadableStream({\n async start(controller) {\n reader = body.getReader();\n\n const arm = () => {\n clear();\n if (cancelled) return;\n timer = setTimeout(() => {\n timer = null;\n if (cancelled) return;\n try {\n controller.enqueue(KEEPALIVE_BYTES);\n } catch {\n // Controller already closed/errored \u2014 stop arming.\n cancelled = true;\n return;\n }\n arm();\n }, idleMs);\n };\n\n arm();\n\n try {\n while (!cancelled) {\n const { done, value } = await reader.read();\n if (done) break;\n if (value && value.byteLength > 0) {\n controller.enqueue(value);\n arm();\n }\n }\n clear();\n if (!cancelled) controller.close();\n } catch (err) {\n clear();\n if (!cancelled) {\n try {\n controller.error(err);\n } catch {\n // ignore\n }\n }\n } finally {\n clear();\n try {\n reader?.releaseLock();\n } catch {\n // ignore\n }\n }\n },\n cancel(reason) {\n cancelled = true;\n clear();\n const r = reader;\n reader = null;\n if (r) {\n return r.cancel(reason).catch(() => {});\n }\n return body.cancel(reason).catch(() => {});\n },\n });\n}\n", "/**\n * OpenCode Zen (DeepSeek flash, etc.) glues extra SSE `data:` fields onto the\n * Chat Completions terminator without a blank event separator:\n *\n * data: [DONE]\n * data: {\"choices\":[],\"cost\":\"0\"}\n *\n * data: [DONE] {\"choices\":[],\"cost\":\"0\"}\n *\n * data: {\"choices\":[],\"usage\":{...}}\n * data: [DONE]\n *\n * EventSource / AI SDK concatenate those fields with `\\n` and JSON.parse the\n * result (`[DONE]\\n{\u2026}` or `{\u2026}\\n[DONE]`). Close `[DONE]` as its own event and\n * drop anything after it \u2014 Chat Completions streams end there.\n */\nexport function splitChatCompletionsDoneLine(line: string): string[] {\n if (/^\\s*\\[DONE\\]/.test(line) && !line.includes(\"data:\")) {\n return [\"data: [DONE]\", \"\"];\n }\n const idx = line.indexOf(\"data:\");\n if (idx < 0) return [line];\n const prefix = line.slice(0, idx);\n const payload = line.slice(idx + 5).trim();\n if (!payload) return [line];\n if (payload.startsWith(\"[DONE]\")) {\n return [`${prefix}data: [DONE]`, \"\"];\n }\n const doneAt = doneTrailerIndex(payload);\n if (doneAt < 0) return [line];\n const json = payload.slice(0, doneAt).trimEnd();\n if (!json) return [`${prefix}data: [DONE]`, \"\"];\n return [`${prefix}data: ${json}`, \"\", `${prefix}data: [DONE]`, \"\"];\n}\n\nfunction doneTrailerIndex(payload: string): number {\n const marker = \"[DONE]\";\n let from = 0;\n while (from < payload.length) {\n const i = payload.indexOf(marker, from);\n if (i < 0) return -1;\n const before = payload.slice(0, i).trimEnd();\n if (!before) return i;\n try {\n JSON.parse(before);\n return i;\n } catch {\n from = i + marker.length;\n }\n }\n return -1;\n}\n\nexport function isChatCompletionsDoneLine(line: string): boolean {\n return /^data:\\s*\\[DONE\\]\\s*$/.test(line) || /^\\s*\\[DONE\\]\\s*$/.test(line);\n}\n\n/** Always close the previous SSE event before emitting the terminator. */\nexport function pushChatCompletionsDone(out: string[]): void {\n out.push(\"\");\n out.push(\"data: [DONE]\");\n out.push(\"\");\n}\n\n/**\n * Rewrite a Chat Completions SSE body so `[DONE]` always closes its event and\n * nothing follows it. Idempotent on an already-clean stream.\n */\nexport function withChatCompletionsDoneBoundary(\n body: ReadableStream\n): ReadableStream {\n const decoder = new TextDecoder();\n const encoder = new TextEncoder();\n let buffer = \"\";\n let sawDone = false;\n let reader: ReadableStreamDefaultReader | null = null;\n\n const emitText = (text: string, flush = false): string => {\n if (sawDone) return \"\";\n buffer += text;\n const lines = buffer.split(/\\r?\\n/);\n buffer = flush ? \"\" : lines.pop() || \"\";\n const out: string[] = [];\n const pushLine = (line: string) => {\n if (sawDone) return;\n for (const piece of splitChatCompletionsDoneLine(line)) {\n if (sawDone) return;\n if (isChatCompletionsDoneLine(piece)) {\n pushChatCompletionsDone(out);\n sawDone = true;\n return;\n }\n out.push(piece);\n }\n };\n for (const line of lines) pushLine(line);\n if (flush && buffer) {\n pushLine(buffer);\n buffer = \"\";\n }\n return out.length ? `${out.join(\"\\n\")}\\n` : \"\";\n };\n\n return new ReadableStream({\n async start(controller) {\n reader = body.getReader();\n try {\n while (!sawDone) {\n const { done, value } = await reader.read();\n if (done) {\n const tail = emitText(decoder.decode(), true);\n if (tail) controller.enqueue(encoder.encode(tail));\n controller.close();\n return;\n }\n const rewritten = emitText(decoder.decode(value, { stream: true }));\n if (rewritten) controller.enqueue(encoder.encode(rewritten));\n }\n await reader.cancel();\n controller.close();\n } catch (err) {\n try {\n controller.error(err);\n } catch {\n // Controller already closed.\n }\n } finally {\n try {\n reader?.releaseLock();\n } catch {\n // ignore\n }\n }\n },\n cancel(reason) {\n const r = reader;\n reader = null;\n if (r) return r.cancel(reason).catch(() => {});\n return body.cancel(reason).catch(() => {});\n },\n });\n}\n", "export type UnauthorizedAuthRecovery = () => Promise<\n Record | null\n>;\n\nexport async function sendWithUnauthorizedAuthRecovery(\n send: (headers: Record) => Promise,\n requestHeaders: Record,\n recover?: UnauthorizedAuthRecovery\n): Promise {\n const response = await send(requestHeaders);\n if (response.status !== 401 || typeof recover !== \"function\") {\n return response;\n }\n\n const recoveredHeaders = await recover();\n if (!recoveredHeaders) return response;\n\n try {\n await response.body?.cancel();\n } catch {\n // The unauthorized response may already be fully consumed.\n }\n Object.assign(requestHeaders, recoveredHeaders);\n return send(requestHeaders);\n}\n", "import type { RouterScenarioType } from \"@/utils/router\";\nimport type {\n AnthropicClientKind,\n AnthropicProviderMode,\n} from \"@/utils/anthropic-client-policy\";\nimport type { ResponsesCallIdMap } from \"@/utils/openai.responses.util\";\n\n/**\n * Inbound client protocols supported by CCR's gateway lifecycle.\n */\nexport type ClientProtocol =\n | \"anthropic_messages\"\n | \"openai_chat_completions\"\n | \"openai_responses\"\n | \"openai_fim_completions\";\n\nexport interface AnthropicSourceRequestFields {\n metadata?: Record;\n thinking?: Record;\n outputConfig?: Record;\n stopSequences?: string[];\n}\n\nexport interface ClientProtocolContext {\n protocol: ClientProtocol;\n pathname: string;\n /** Canonical Fastify route path (without preset prefix), e.g. /v1/responses */\n canonicalPath: string;\n /** Alias path that matched, if different from canonical */\n matchedPath: string;\n originalModel?: string;\n /** Client selected the gateway's trailing `[1m]` context variant. */\n requestedOneMillion?: boolean;\n stream: boolean;\n scenarioType?: RouterScenarioType;\n /** Source-only Anthropic semantics retained before destination routing. */\n anthropicSource?: AnthropicSourceRequestFields;\n /** Client fingerprint captured before Anthropic normalization. */\n anthropicClientKind?: AnthropicClientKind;\n /** In-scope Anthropic destination/auth variant selected after routing. */\n anthropicProviderMode?: AnthropicProviderMode;\n anthropicDestinationInScope?: boolean;\n /** Native Desktop/CLI requests must bypass body and response conversion. */\n anthropicNativeWire?: boolean;\n /** Third-party emulation has already modified the Unified projection. */\n anthropicPolicyApplied?: boolean;\n anthropicSystemTransformed?: boolean;\n claudeAuthToolNameMap?: Map;\n /** Per-request Responses call/result correlation across both pipeline legs. */\n responsesCallIdMap?: ResponsesCallIdMap;\n responsesCustomToolNames?: Set;\n /** Claude Code routing metadata extracted without mutating the source billing block. */\n claudeCodeSubagent?: boolean;\n /**\n * Nested/worker agent on any inbound protocol (Claude Code Task, OpenCode\n * child session, Codex x-openai-subagent, Cursor fork boilerplate).\n */\n nestedAgent?: boolean;\n taggedSubagentModel?: string;\n /** Transformer that owns this client protocol */\n ownerTransformerName: string;\n /**\n * Client conversation id captured from the original wire (never harness\n * version or system text). Used for prompt-cache affinity and Codex headers.\n */\n sessionId?: string;\n}\n\nexport interface ProtocolRouteMatch {\n protocol: ClientProtocol;\n canonicalPath: string;\n matchedPath: string;\n ownerTransformerName: string;\n /** True when matchedPath is an alias of canonicalPath */\n isAlias: boolean;\n stream: boolean;\n /** Preset namespace prefix without trailing slash, e.g. /preset/foo */\n presetPrefix?: string;\n}\n\ninterface ProtocolRouteSpec {\n protocol: ClientProtocol;\n canonicalPath: string;\n aliases: string[];\n ownerTransformerName: string;\n /** Default stream intent when not encoded in the path */\n defaultStream?: boolean;\n}\n\n/**\n * Client-facing route table. Aliases are first-class; registration must not\n * rely on transformer endPoint first-wins.\n */\nexport const PROTOCOL_ROUTE_SPECS: ProtocolRouteSpec[] = [\n {\n protocol: \"anthropic_messages\",\n canonicalPath: \"/v1/messages\",\n aliases: [],\n ownerTransformerName: \"Anthropic\",\n },\n {\n protocol: \"openai_chat_completions\",\n canonicalPath: \"/v1/chat/completions\",\n aliases: [\"/chat/completions\"],\n ownerTransformerName: \"OpenAI\",\n },\n {\n protocol: \"openai_responses\",\n canonicalPath: \"/v1/responses\",\n aliases: [\"/responses\"],\n ownerTransformerName: \"openai-responses\",\n },\n {\n protocol: \"openai_fim_completions\",\n canonicalPath: \"/v1/fim/completions\",\n aliases: [\"/fim/completions\"],\n ownerTransformerName: \"Fim\",\n },\n];\n\n/** Paths that must never be classified as routed LLM posts. */\nconst EXCLUDED_PATH_SUFFIXES = [\n \"/v1/completions\",\n \"/completions\",\n \"/v1beta/interactions\",\n \"/v1/interactions\",\n];\n\nconst PRESET_PREFIX_RE = /^\\/preset\\/[^/]+/;\n\nfunction stripQueryAndNormalize(pathname: string): string {\n const withoutQuery = pathname.split(\"?\")[0] || \"/\";\n if (withoutQuery.length > 1 && withoutQuery.endsWith(\"/\")) {\n return withoutQuery.slice(0, -1);\n }\n return withoutQuery || \"/\";\n}\n\nfunction stripPresetPrefix(pathname: string): {\n suffix: string;\n presetPrefix?: string;\n} {\n const match = pathname.match(PRESET_PREFIX_RE);\n if (!match) {\n return { suffix: pathname };\n }\n const presetPrefix = match[0];\n const suffix = pathname.slice(presetPrefix.length) || \"/\";\n return { suffix, presetPrefix };\n}\n\nfunction isExcludedSuffix(suffix: string): boolean {\n // Exact match only. endsWith(\"/completions\") would falsely exclude\n // \"/v1/chat/completions\".\n return EXCLUDED_PATH_SUFFIXES.some((excluded) => suffix === excluded);\n}\n\nfunction matchStaticProtocol(suffix: string): ProtocolRouteMatch | null {\n for (const spec of PROTOCOL_ROUTE_SPECS) {\n const paths = [spec.canonicalPath, ...spec.aliases];\n for (const path of paths) {\n if (suffix === path) {\n return {\n protocol: spec.protocol,\n canonicalPath: spec.canonicalPath,\n matchedPath: path,\n ownerTransformerName: spec.ownerTransformerName,\n isAlias: path !== spec.canonicalPath,\n stream: Boolean(spec.defaultStream),\n };\n }\n }\n }\n return null;\n}\n\n/**\n * Match a client LLM POST path to a protocol. Works with preset prefixes,\n * trailing-slash normalization, and query stripping.\n */\nexport function matchClientProtocol(\n method: string,\n pathnameOrUrl: string\n): ProtocolRouteMatch | null {\n if (method.toUpperCase() !== \"POST\") {\n return null;\n }\n\n const normalized = stripQueryAndNormalize(pathnameOrUrl);\n const { suffix, presetPrefix } = stripPresetPrefix(normalized);\n\n if (isExcludedSuffix(suffix)) {\n return null;\n }\n\n const staticMatch = matchStaticProtocol(suffix);\n if (!staticMatch) {\n return null;\n }\n\n return { ...staticMatch, presetPrefix };\n}\n\n/** True when method+path is an in-scope routed LLM POST. */\nexport function isRoutedLlmPost(method: string, pathnameOrUrl: string): boolean {\n return matchClientProtocol(method, pathnameOrUrl) !== null;\n}\n\n/** All Fastify paths that should be registered for a protocol (canonical + aliases). */\nexport function getRegisteredPathsForProtocol(\n protocol: ClientProtocol\n): string[] {\n const spec = PROTOCOL_ROUTE_SPECS.find((s) => s.protocol === protocol);\n if (!spec) return [];\n return [spec.canonicalPath, ...spec.aliases];\n}\n\n/** Flat list of registered client routes and their owner transformers. */\nexport function listClientRouteRegistrations(): Array<{\n path: string;\n protocol: ClientProtocol;\n ownerTransformerName: string;\n isCanonical: boolean;\n}> {\n const result: Array<{\n path: string;\n protocol: ClientProtocol;\n ownerTransformerName: string;\n isCanonical: boolean;\n }> = [];\n\n for (const spec of PROTOCOL_ROUTE_SPECS) {\n result.push({\n path: spec.canonicalPath,\n protocol: spec.protocol,\n ownerTransformerName: spec.ownerTransformerName,\n isCanonical: true,\n });\n for (const alias of spec.aliases) {\n result.push({\n path: alias,\n protocol: spec.protocol,\n ownerTransformerName: spec.ownerTransformerName,\n isCanonical: false,\n });\n }\n }\n\n return result;\n}\n\nexport function createClientProtocolContext(\n match: ProtocolRouteMatch,\n options?: {\n originalModel?: string;\n stream?: boolean;\n scenarioType?: RouterScenarioType;\n }\n): ClientProtocolContext {\n return {\n protocol: match.protocol,\n pathname: match.matchedPath,\n canonicalPath: match.canonicalPath,\n matchedPath: match.matchedPath,\n originalModel: options?.originalModel,\n stream: options?.stream ?? match.stream,\n scenarioType: options?.scenarioType,\n ownerTransformerName: match.ownerTransformerName,\n };\n}\n", "import type { UnifiedChatRequest } from \"@/types/llm\";\nimport type { Transformer } from \"@/types/transformer\";\nimport {\n ClientProtocolContext,\n ProtocolRouteMatch,\n createClientProtocolContext,\n} from \"./protocol-endpoints\";\nimport { createApiError } from \"@/api/middleware\";\nimport { responsesRequestToUnified } from \"../utils/openai.responses.util\";\n\nexport interface ProtocolAdaptResult {\n /** Cloned client body used as normalization input (never the live req.body). */\n normalizationInput: any;\n context: ClientProtocolContext;\n}\n\n/**\n * Adapt path/query fields into a cloned normalization input and build the\n * initial ClientProtocolContext. Does not mutate the caller's body object.\n */\nexport function adaptClientRequest(\n match: ProtocolRouteMatch,\n rawBody: any,\n _query?: Record\n): ProtocolAdaptResult {\n const body =\n rawBody && typeof rawBody === \"object\" ? cloneProtocolBody(rawBody) : {};\n\n let stream = match.stream;\n const originalModel: string | undefined =\n typeof body.model === \"string\" ? body.model : undefined;\n\n if (match.protocol === \"openai_chat_completions\") {\n stream = body.stream === true;\n } else if (match.protocol === \"openai_responses\") {\n stream = body.stream === true;\n } else if (match.protocol === \"anthropic_messages\") {\n stream = body.stream === true;\n }\n\n const context = createClientProtocolContext(match, {\n originalModel,\n stream,\n });\n\n return { normalizationInput: body, context };\n}\n\n/**\n * Normalize client wire \u2192 Unified once via the endpoint transformer's\n * transformRequestOut when present. Chat Completions bodies are already\n * Unified-shaped; until Phase 2/3 add full converters, fall back to a\n * lightweight projection sufficient for routing.\n */\nexport async function normalizeClientToUnified(\n protocol: ClientProtocolContext[\"protocol\"],\n normalizationInput: any,\n endpointTransformer: Transformer,\n context: any\n): Promise {\n if (typeof endpointTransformer.transformRequestOut === \"function\") {\n const out = await endpointTransformer.transformRequestOut(\n normalizationInput,\n context\n );\n // Some transformers return { body, config }; prefer body when present.\n if (out && typeof out === \"object\" && \"body\" in (out as any) && (out as any).body) {\n return (out as any).body as UnifiedChatRequest;\n }\n return out as UnifiedChatRequest;\n }\n\n if (protocol === \"openai_chat_completions\") {\n return chatBodyAsUnified(normalizationInput);\n }\n\n if (protocol === \"openai_responses\") {\n return responsesRequestToUnified(normalizationInput);\n }\n\n if (protocol === \"anthropic_messages\") {\n // Anthropic endpoint transformer always defines transformRequestOut;\n // reaching here is unexpected.\n throw createApiError(\n \"Anthropic transformRequestOut is required\",\n 500,\n \"transformer_misconfigured\"\n );\n }\n\n throw createApiError(\n `Client protocol '${protocol}' normalization is not implemented yet`,\n 501,\n \"protocol_not_implemented\"\n );\n}\n\nfunction chatBodyAsUnified(body: any): UnifiedChatRequest {\n if (!body || typeof body !== \"object\") {\n throw createApiError(\"Invalid Chat Completions body\", 400, \"invalid_body\");\n }\n if (!Array.isArray(body.messages)) {\n throw createApiError(\n \"Chat Completions requires messages[]\",\n 400,\n \"invalid_body\",\n \"invalid_request_error\"\n );\n }\n if (typeof body.model !== \"string\" || !body.model) {\n throw createApiError(\n \"Chat Completions requires model\",\n 400,\n \"invalid_body\",\n \"invalid_request_error\"\n );\n }\n return body as UnifiedChatRequest;\n}\n\n/**\n * Provider transformers are allowed to mutate their input. Every primary and\n * fallback attempt therefore needs an independent copy of the normalized body.\n * Prefers structuredClone when available; falls back to JSON round-trip for\n * environments without it.\n */\nexport function cloneProtocolBody(value: T): T {\n if (typeof structuredClone === \"function\") {\n return structuredClone(value);\n }\n return JSON.parse(JSON.stringify(value)) as T;\n}\n\nconst PASSTHROUGH_HEADER_DENYLIST = new Set([\n \"authorization\",\n \"proxy-authorization\",\n \"x-api-key\",\n \"cookie\",\n \"set-cookie\",\n \"host\",\n \"content-length\",\n \"content-encoding\",\n \"accept-encoding\",\n \"connection\",\n \"keep-alive\",\n \"transfer-encoding\",\n \"upgrade\",\n \"te\",\n \"trailer\",\n \"expect\",\n \"via\",\n \"proxy-authenticate\",\n \"proxy-authentication-info\",\n \"x-auth-token\",\n \"openai-secret\",\n \"x-claude-desktop-no-iap-inject\",\n]);\n\nconst PASSTHROUGH_HEADER_DENY_PREFIXES = [\n \"proxy-\",\n \"x-forwarded-\",\n \"x-real-ip\",\n];\n\n/**\n * Preserve all end-to-end application headers for a native client. Only\n * credentials, cookies, CCR/proxy routing metadata and hop-by-hop transport\n * headers are removed; provider authentication is generated independently.\n */\nexport function sanitizePassthroughHeaders(\n headers: Headers | Record | undefined\n): Record {\n const safe: Record = {};\n if (!headers) return safe;\n\n const entries: Array<[string, unknown]> =\n headers instanceof Headers\n ? Array.from(headers.entries())\n : Object.entries(headers);\n\n for (const [rawName, rawValue] of entries) {\n const name = rawName.toLowerCase();\n if (\n PASSTHROUGH_HEADER_DENYLIST.has(name) ||\n PASSTHROUGH_HEADER_DENY_PREFIXES.some((prefix) => name.startsWith(prefix))\n ) continue;\n const value = Array.isArray(rawValue)\n ? rawValue.filter((item) => item != null).map(String).join(\", \")\n : rawValue;\n if (typeof value === \"string\" && value) {\n safe[name] = value;\n }\n }\n return safe;\n}\n\n/**\n * Protocol-aware passthrough: only bypass when the provider speaks the same\n * client protocol (matching transformer name) and the request is same-protocol.\n */\nexport function shouldBypassTransformersProtocolAware(\n provider: any,\n endpointTransformer: Transformer,\n protocol: ClientProtocolContext[\"protocol\"],\n bodyModel: string | undefined\n): boolean {\n const use = provider.transformer?.use;\n if (!Array.isArray(use) || use.length !== 1) {\n return false;\n }\n if (use[0]?.name !== endpointTransformer.name) {\n return false;\n }\n\n const modelUse = bodyModel\n ? provider.transformer?.[bodyModel]?.use\n : undefined;\n if (Array.isArray(modelUse) && modelUse.length > 0) {\n if (\n modelUse.length !== 1 ||\n modelUse[0]?.name !== endpointTransformer.name\n ) {\n return false;\n }\n }\n\n // Cross-protocol: never bypass client normalization.\n // Same name means the provider transformer is the endpoint owner.\n const ownerByProtocol: Record = {\n anthropic_messages: \"Anthropic\",\n openai_chat_completions: \"OpenAI\",\n openai_responses: \"openai-responses\",\n };\n return endpointTransformer.name === ownerByProtocol[protocol];\n}\n", "import { get_encoding } from \"tiktoken\";\nimport { sessionUsageCache, Usage } from \"./cache\";\nimport { readFile } from \"fs/promises\";\nimport { opendir, stat } from \"fs/promises\";\nimport { join, resolve, relative, basename } from \"path\";\nimport { createHash } from \"crypto\";\nimport { CLAUDE_PROJECTS_DIR, HOME_DIR } from \"@caeliq/ccr-shared\";\nimport { LRUCache } from \"lru-cache\";\nimport { ConfigService } from \"../services/config\";\nimport { TokenizerService } from \"../services/tokenizer\";\nimport { isReasoningDisabled } from \"./reasoning-effort\";\nimport {\n estimateTokenizePayloadChars,\n estimateTokensFromChars,\n countTokensInWorker,\n TOKEN_COUNT_WORKER_THRESHOLD_CHARS,\n} from \"./token-count-worker\";\nimport { attachLatencyMeta, ensureRequestLatency, markLatency } from \"./request-latency\";\n\n// Types from @anthropic-ai/sdk\ninterface Tool {\n name: string;\n description?: string;\n input_schema: object;\n}\n\ninterface ContentBlockParam {\n type: string;\n [key: string]: any;\n}\n\ninterface MessageParam {\n role: string;\n content: string | ContentBlockParam[];\n}\n\ninterface MessageCreateParamsBase {\n messages?: MessageParam[];\n system?: string | any[];\n tools?: Tool[];\n [key: string]: any;\n}\n\nconst enc = get_encoding(\"cl100k_base\");\n\n// disallowed_special: [] treats literal special-token-like substrings\n// (e.g. \"<|fim_prefix|>\") in arbitrary message/tool content as plain\n// text instead of throwing, since this is just counting tokens, not\n// feeding the result back into the model.\nconst encodeSafe = (text: string) => enc.encode(text, undefined, []);\n\nconst CCR_SUBAGENT_MODEL_OPEN_TAG = \"\";\nconst CCR_SUBAGENT_MODEL_CLOSE_TAG = \"\";\nexport const CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX =\n \"x-anthropic-billing-header\";\n\nconst isRecord = (value: unknown): value is Record =>\n Boolean(value) && typeof value === \"object\" && !Array.isArray(value);\n\n/** Normalize `provider/model` or `provider,model` into our `provider,model` form. */\nexport function normalizeModelSelector(\n value: string | undefined | null\n): string | undefined {\n const trimmed = value?.trim();\n if (!trimmed) return undefined;\n if (trimmed.includes(\",\")) return trimmed;\n const slash = trimmed.indexOf(\"/\");\n if (slash > 0) {\n return `${trimmed.slice(0, slash)},${trimmed.slice(slash + 1)}`;\n }\n return trimmed;\n}\n\nexport function claudeCodeBillingMetadataIsSubagent(text: string): boolean {\n const prefix = `${CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX}:`;\n if (!text.startsWith(prefix)) return false;\n const payload = text.slice(prefix.length).trim();\n if (!payload) return false;\n\n if (payload.startsWith(\"{\")) {\n try {\n const metadata = JSON.parse(payload) as unknown;\n return isRecord(metadata) && metadata.cc_is_subagent === true;\n } catch {\n return false;\n }\n }\n\n const values = payload\n .split(\";\")\n .map((part) => part.trim())\n .filter(Boolean)\n .flatMap((part) => {\n const separator = part.indexOf(\"=\");\n if (\n separator < 0 ||\n part.slice(0, separator).trim() !== \"cc_is_subagent\"\n ) {\n return [];\n }\n return [part.slice(separator + 1).trim()];\n });\n return values.length === 1 && values[0] === \"true\";\n}\n\n/**\n * Strip Claude Code's billing helper system block.\n * Returns true when that block marks the request as a subagent.\n */\nexport function removeClaudeCodeBillingSystemHeader(body: any): boolean {\n const system = body?.system;\n if (!Array.isArray(system) || system.length === 0) return false;\n\n const firstBlock = system[0];\n const firstText =\n typeof firstBlock === \"string\"\n ? firstBlock\n : isRecord(firstBlock) &&\n firstBlock.type === \"text\" &&\n typeof firstBlock.text === \"string\"\n ? firstBlock.text\n : undefined;\n\n if (!firstText?.startsWith(CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX)) {\n return false;\n }\n\n const isSubagent = claudeCodeBillingMetadataIsSubagent(firstText);\n system.shift();\n if (system.length === 0) {\n delete body.system;\n }\n return isSubagent;\n}\n\nfunction extractAndRemoveSubagentModelTagFromText(\n text: string,\n replace: (next: string) => void\n): string | undefined {\n const openIndex = text.indexOf(CCR_SUBAGENT_MODEL_OPEN_TAG);\n if (openIndex < 0) return undefined;\n const modelStart = openIndex + CCR_SUBAGENT_MODEL_OPEN_TAG.length;\n const closeIndex = text.indexOf(CCR_SUBAGENT_MODEL_CLOSE_TAG, modelStart);\n if (closeIndex < 0) return undefined;\n\n const model = normalizeModelSelector(text.slice(modelStart, closeIndex));\n if (!model) return undefined;\n\n replace(\n `${text.slice(0, openIndex)}${text.slice(\n closeIndex + CCR_SUBAGENT_MODEL_CLOSE_TAG.length\n )}`\n );\n return model;\n}\n\nfunction extractAndRemoveSubagentModelTagFromContentBlock(\n block: unknown,\n replace: (next: string) => void\n): string | undefined {\n if (typeof block === \"string\") {\n return extractAndRemoveSubagentModelTagFromText(block, replace);\n }\n if (!isRecord(block) || typeof block.text !== \"string\") {\n return undefined;\n }\n return extractAndRemoveSubagentModelTagFromText(block.text, replace);\n}\n\nfunction extractAndRemoveSystemSubagentModelTag(\n body: any\n): string | undefined {\n const system = body?.system;\n if (typeof system === \"string\") {\n return extractAndRemoveSubagentModelTagFromText(system, (text) => {\n body.system = text;\n });\n }\n if (!Array.isArray(system)) return undefined;\n\n for (let index = 0; index < system.length; index += 1) {\n const block = system[index];\n const model = extractAndRemoveSubagentModelTagFromContentBlock(\n block,\n (text) => {\n if (typeof block === \"string\") {\n system[index] = text;\n } else if (isRecord(block)) {\n block.text = text;\n }\n }\n );\n if (model) return model;\n }\n return undefined;\n}\n\nfunction extractAndRemoveSubagentModelTagFromMessage(\n message: Record\n): string | undefined {\n if (typeof message.content === \"string\") {\n return extractAndRemoveSubagentModelTagFromText(\n message.content,\n (text) => {\n message.content = text;\n }\n );\n }\n if (!Array.isArray(message.content)) return undefined;\n\n const content = message.content;\n for (let index = 0; index < content.length; index += 1) {\n const block = content[index];\n const model = extractAndRemoveSubagentModelTagFromContentBlock(\n block,\n (text) => {\n if (typeof block === \"string\") {\n content[index] = text;\n } else if (isRecord(block)) {\n block.text = text;\n }\n }\n );\n if (model) return model;\n }\n return undefined;\n}\n\nfunction extractAndRemoveMessageSubagentModelTag(\n body: any\n): string | undefined {\n if (!Array.isArray(body?.messages)) return undefined;\n const limit = Math.min(body.messages.length, 2);\n for (let index = 0; index < limit; index += 1) {\n const message = body.messages[index];\n if (!isRecord(message) || message.role !== \"user\") continue;\n const model = extractAndRemoveSubagentModelTagFromMessage(message);\n if (model) return model;\n }\n return undefined;\n}\n\n/** Prefer system tag, then early user-message tag; strip whichever matched. */\nexport function extractAndRemoveClaudeCodeSubagentModelTag(\n body: any\n): string | undefined {\n return (\n extractAndRemoveSystemSubagentModelTag(body) ||\n extractAndRemoveMessageSubagentModelTag(body)\n );\n}\n\n/** Read Claude Code's billing/subagent marker without mutating the source body. */\nexport function inspectClaudeCodeBillingSystemHeader(body: any): {\n present: boolean;\n isSubagent: boolean;\n} {\n const system = body?.system;\n if (!Array.isArray(system) || system.length === 0) {\n return { present: false, isSubagent: false };\n }\n const firstBlock = system[0];\n const firstText =\n typeof firstBlock === \"string\"\n ? firstBlock\n : isRecord(firstBlock) &&\n firstBlock.type === \"text\" &&\n typeof firstBlock.text === \"string\"\n ? firstBlock.text\n : undefined;\n if (!firstText?.startsWith(CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX)) {\n return { present: false, isSubagent: false };\n }\n return {\n present: true,\n isSubagent: claudeCodeBillingMetadataIsSubagent(firstText),\n };\n}\n\n\nexport const calculateTokenCount = (\n messages: MessageParam[],\n system: any,\n tools: Tool[]\n) => {\n let tokenCount = 0;\n if (Array.isArray(messages)) {\n messages.forEach((message) => {\n if (typeof message.content === \"string\") {\n tokenCount += encodeSafe(message.content).length;\n } else if (Array.isArray(message.content)) {\n message.content.forEach((contentPart: any) => {\n if (contentPart.type === \"text\") {\n tokenCount += encodeSafe(contentPart.text).length;\n } else if (contentPart.type === \"tool_use\") {\n tokenCount += encodeSafe(JSON.stringify(contentPart.input)).length;\n } else if (contentPart.type === \"tool_result\") {\n tokenCount += encodeSafe(\n typeof contentPart.content === \"string\"\n ? contentPart.content\n : JSON.stringify(contentPart.content)\n ).length;\n }\n });\n }\n });\n }\n if (typeof system === \"string\") {\n tokenCount += encodeSafe(system).length;\n } else if (Array.isArray(system)) {\n system.forEach((item: any) => {\n if (item.type !== \"text\") return;\n if (typeof item.text === \"string\") {\n tokenCount += encodeSafe(item.text).length;\n } else if (Array.isArray(item.text)) {\n item.text.forEach((textPart: any) => {\n tokenCount += encodeSafe(textPart || \"\").length;\n });\n }\n });\n }\n if (tools) {\n tools.forEach((tool: Tool) => {\n if (tool.description) {\n tokenCount += encodeSafe(tool.name + tool.description).length;\n }\n if (tool.input_schema) {\n tokenCount += encodeSafe(JSON.stringify(tool.input_schema)).length;\n }\n });\n }\n return tokenCount;\n};\n\nconst getProjectSpecificRouter = async (\n req: any,\n _configService: ConfigService\n) => {\n // Check if there is project-specific configuration\n if (req.sessionId) {\n const project = await searchProjectBySession(req.sessionId);\n if (project) {\n const homeRoot = resolve(HOME_DIR);\n const projectDir = resolve(homeRoot, basename(project));\n const projectRel = relative(homeRoot, projectDir);\n if (!projectRel || projectRel.startsWith(\"..\")) {\n return undefined;\n }\n const sessionName = `${basename(String(req.sessionId))}.json`;\n const projectConfigPath = join(projectDir, \"config.json\");\n const sessionConfigPath = join(projectDir, sessionName);\n\n // First try to read sessionConfig file\n try {\n const sessionConfig = JSON.parse(await readFile(sessionConfigPath, \"utf8\"));\n if (sessionConfig && sessionConfig.Router) {\n return sessionConfig.Router;\n }\n } catch {}\n try {\n const projectConfig = JSON.parse(await readFile(projectConfigPath, \"utf8\"));\n if (projectConfig && projectConfig.Router) {\n return projectConfig.Router;\n }\n } catch {}\n }\n }\n return undefined; // Return undefined to use original configuration\n};\n\n/**\n * Routing body: prefer Unified projection when present so scenario detection\n * does not interpret Responses wire shapes as Anthropic bodies.\n */\nfunction routingBody(req: any): any {\n return req.unifiedBody && typeof req.unifiedBody === \"object\"\n ? req.unifiedBody\n : req.body;\n}\n\nfunction isAnthropicClient(req: any): boolean {\n return (\n !req.clientProtocol || req.clientProtocol === \"anthropic_messages\"\n );\n}\n\nfunction hasWebSearchTool(tools: any[] | undefined): boolean {\n if (!Array.isArray(tools)) return false;\n return tools.some((tool: any) => {\n if (!tool || typeof tool !== \"object\") return false;\n if (\n typeof tool.type === \"string\" &&\n (tool.type === \"web_search\" || tool.type.startsWith(\"web_search\"))\n ) {\n return true;\n }\n const name =\n tool.function?.name || tool.name || tool.function?.function?.name;\n return (\n typeof name === \"string\" &&\n (name === \"web_search\" || name.toLowerCase() === \"websearch\")\n );\n });\n}\n\nfunction hasThinkSignal(body: any): boolean {\n if (isReasoningDisabled(body?.reasoning, body?.thinking)) return false;\n if (body?.thinking) return true;\n const reasoning = body?.reasoning;\n if (reasoning && typeof reasoning === \"object\") {\n if (reasoning.enabled === true) return true;\n if (\n typeof reasoning.effort === \"string\" &&\n reasoning.effort.trim().length > 0\n ) {\n return true;\n }\n }\n return false;\n}\n\nconst getUseModel = async (\n req: any,\n tokenCount: number,\n configService: ConfigService,\n lastUsage?: Usage | undefined\n): Promise<{ model: string; scenarioType: RouterScenarioType }> => {\n const projectSpecificRouter = await getProjectSpecificRouter(req, configService);\n const providers = configService.get(\"providers\") || [];\n const Router = projectSpecificRouter || configService.get(\"Router\");\n const body = routingBody(req);\n const modelValue =\n typeof body?.model === \"string\" ? body.model : String(body?.model ?? \"\");\n\n if (modelValue.includes(\",\")) {\n const [provider, model] = modelValue.split(\",\");\n const finalProvider = providers.find(\n (p: any) => p.name.toLowerCase() === provider.toLowerCase()\n );\n const finalModel = finalProvider?.models?.find(\n (m: any) => m.toLowerCase() === model.toLowerCase()\n );\n if (finalProvider && finalModel) {\n return { model: `${finalProvider.name},${finalModel}`, scenarioType: 'default' };\n }\n return { model: modelValue, scenarioType: 'default' };\n }\n\n // Scenario precedence: explicit provider,model (above) \u2192 subagent \u2192\n // background \u2192 webSearch \u2192 think \u2192 longContext \u2192 default. The long-context\n // check intentionally runs after the higher-priority scenarios so a large\n // subagent/background/web-search/thinking request keeps its scenario route.\n const longContextThreshold = Router?.longContextThreshold || 60000;\n const lastUsageThreshold =\n lastUsage &&\n lastUsage.input_tokens > longContextThreshold &&\n tokenCount > 20000;\n const tokenCountThreshold = tokenCount > longContextThreshold;\n\n // subagent / background: Anthropic Messages clients only (Claude Code signals).\n if (isAnthropicClient(req)) {\n const taggedSubagentModel = req.protocolContext?.taggedSubagentModel;\n const isClaudeCodeSubagent =\n req.protocolContext?.claudeCodeSubagent === true;\n if (taggedSubagentModel) {\n req.log.info(`Using CCR subagent tag model: ${taggedSubagentModel}`);\n return { model: taggedSubagentModel, scenarioType: 'subagent' };\n }\n if (isClaudeCodeSubagent) {\n const envModel = normalizeModelSelector(\n process.env.CLAUDE_CODE_SUBAGENT_MODEL\n );\n if (envModel) {\n req.log.info(\n `Using CLAUDE_CODE_SUBAGENT_MODEL for Claude Code subagent: ${envModel}`\n );\n return { model: envModel, scenarioType: 'subagent' };\n }\n }\n\n const globalRouter = configService.get(\"Router\");\n if (\n modelValue?.includes(\"claude\") &&\n modelValue?.includes(\"haiku\") &&\n globalRouter?.background\n ) {\n req.log.info(`Using background model for ${modelValue}`);\n return { model: globalRouter.background, scenarioType: 'background' };\n }\n }\n\n // The priority of websearch must be higher than thinking.\n if (hasWebSearchTool(body?.tools) && Router?.webSearch) {\n return { model: Router.webSearch, scenarioType: 'webSearch' };\n }\n if (hasThinkSignal(body) && Router?.think) {\n req.log.info(`Using think model for reasoning/thinking request`);\n return { model: Router.think, scenarioType: 'think' };\n }\n\n // if tokenCount is greater than the configured threshold, use the long context model\n if ((lastUsageThreshold || tokenCountThreshold) && Router?.longContext) {\n req.log.info(\n `Using long context model due to token count: ${tokenCount}, threshold: ${longContextThreshold}`\n );\n return { model: Router.longContext, scenarioType: 'longContext' };\n }\n\n // No scenario matched and no default route is configured: keep the\n // caller's original model instead of wiping it out.\n return { model: Router?.default || modelValue, scenarioType: 'default' };\n};\n\nexport interface RouterContext {\n configService: ConfigService;\n tokenizerService?: TokenizerService;\n event?: any;\n}\n\nexport type RouterScenarioType =\n | 'default'\n | 'background'\n | 'think'\n | 'longContext'\n | 'webSearch'\n | 'subagent'\n | 'fim';\n\nexport interface RouterFallbackConfig {\n default?: string[];\n background?: string[];\n think?: string[];\n longContext?: string[];\n webSearch?: string[];\n subagent?: string[];\n fim?: string[];\n}\n\nconst parseSessionId = (userId: unknown): string | undefined => {\n if (typeof userId !== \"string\" || !userId) {\n return undefined;\n }\n\n const parts = userId.split(\"_session_\");\n if (parts.length > 1 && parts[1]) {\n return parts[1];\n }\n\n try {\n const parsed = JSON.parse(userId);\n if (parsed && typeof parsed.session_id === \"string\" && parsed.session_id) {\n return parsed.session_id;\n }\n } catch {\n // Ignore non-JSON user_id formats.\n }\n\n return undefined;\n};\n\nconst sessionTokenPrefixCache = new LRUCache<\n string,\n { fingerprint: string; tokenCount: number }\n>({ max: 500 });\n\nfunction fingerprintMessagePrefix(messages: MessageParam[]): string {\n if (!messages.length) return \"0\";\n const prefix = messages.slice(0, -1);\n const head = JSON.stringify(prefix.slice(0, 2));\n const tail = JSON.stringify(prefix.slice(-1));\n return createHash(\"sha256\")\n .update(`${prefix.length}|${head}|${tail}`)\n .digest(\"hex\")\n .slice(0, 24);\n}\n\nfunction routerNeedsExactTokenCount(\n routerConfig: any,\n customRouterPath: unknown\n): boolean {\n if (customRouterPath) return true;\n if (routerConfig?.longContext) return true;\n return false;\n}\n\nasync function resolveExactTokenCount(options: {\n messages: MessageParam[];\n system: any;\n tools: Tool[];\n tokenizerService?: TokenizerService;\n tokenizerConfig?: any;\n sessionId?: string;\n lastUsage?: Usage;\n longContextThreshold: number;\n latency?: ReturnType;\n}): Promise {\n const {\n messages,\n system,\n tools,\n tokenizerService,\n tokenizerConfig,\n sessionId,\n lastUsage,\n longContextThreshold,\n latency,\n } = options;\n\n markLatency(latency, \"tokenizeStart\");\n\n const charCount = estimateTokenizePayloadChars(messages, system, tools);\n // One char can be one BPE token in pathological cases. If charCount is\n // strictly below the threshold, exact tokens cannot reach it.\n if (charCount < longContextThreshold) {\n const estimated = estimateTokensFromChars(charCount);\n markLatency(latency, \"tokenizeEnd\");\n return estimated;\n }\n\n // Incremental: stable transcript prefix + provider-reported prior usage.\n if (sessionId && lastUsage && messages.length > 1) {\n const fingerprint = fingerprintMessagePrefix(messages);\n const cached = sessionTokenPrefixCache.get(sessionId);\n if (cached && cached.fingerprint === fingerprint) {\n const appended = messages.slice(-1);\n const delta = calculateTokenCount(appended, [], []);\n const combined = lastUsage.input_tokens + delta;\n markLatency(latency, \"tokenizeEnd\");\n return combined;\n }\n }\n\n let tokenCount: number;\n const useWorker = charCount >= TOKEN_COUNT_WORKER_THRESHOLD_CHARS;\n if (useWorker) {\n try {\n tokenCount = await countTokensInWorker({ messages, system, tools });\n } catch {\n tokenCount = calculateTokenCount(messages, system, tools);\n }\n } else if (tokenizerService) {\n const result = await tokenizerService.countTokens(\n { messages, system, tools },\n tokenizerConfig\n );\n tokenCount = result.tokenCount;\n } else {\n tokenCount = calculateTokenCount(messages, system, tools);\n }\n\n if (sessionId && messages.length > 1) {\n sessionTokenPrefixCache.set(sessionId, {\n fingerprint: fingerprintMessagePrefix(messages),\n tokenCount,\n });\n }\n\n markLatency(latency, \"tokenizeEnd\");\n return tokenCount;\n}\n\nexport const router = async (req: any, _res: any, context: RouterContext) => {\n const { configService, event } = context;\n const body = routingBody(req);\n const latency = ensureRequestLatency(req);\n\n // Prefer the inbound-captured client session (original wire). Unified has no\n // Anthropic metadata, so do not re-parse req.body after the protocol swap.\n if (!req.sessionId) {\n const sessionSource =\n req.protocolContext?.sessionId ||\n req.body?.metadata?.user_id ||\n body?.metadata?.user_id;\n req.sessionId =\n typeof sessionSource === \"string\" && !sessionSource.includes(\"{\")\n ? sessionSource\n : parseSessionId(sessionSource);\n }\n const lastMessageUsage = sessionUsageCache.get(req.sessionId);\n\n // Token counting always uses the Unified projection when available.\n const messages = (body.messages || []) as MessageParam[];\n const system = body.system ?? [];\n const tools = (body.tools || []) as Tool[];\n\n try {\n const modelForTokenizer =\n typeof body.model === \"string\" ? body.model : String(body.model ?? \"\");\n const customRouterPath = configService.get(\"CUSTOM_ROUTER_PATH\");\n const providers = configService.get(\"providers\") || [];\n const globalRouter = configService.get(\"Router\");\n markLatency(latency, \"projectLookup\");\n const projectRouter = await getProjectSpecificRouter(req, configService);\n const activeRouter = projectRouter || globalRouter;\n const longContextThreshold = activeRouter?.longContextThreshold || 60000;\n\n // Explicit provider,model routes skip exact tokenize (getUseModel returns\n // before longContext). Still stamp a cheap char estimate so latency records\n // are not stuck at tokenCount: 0 on 180k-token turns.\n if (!customRouterPath && modelForTokenizer.includes(\",\")) {\n const [provider, model] = modelForTokenizer.split(\",\");\n const finalProvider = providers.find(\n (p: any) => p.name.toLowerCase() === provider.toLowerCase()\n );\n const finalModel = finalProvider?.models?.find(\n (m: any) => m.toLowerCase() === model.toLowerCase()\n );\n const estimated = estimateTokensFromChars(\n estimateTokenizePayloadChars(messages, system, tools)\n );\n req.tokenCount = estimated;\n attachLatencyMeta(latency, {\n tokenCount: estimated,\n tokenCountSource: \"estimate\",\n });\n body.model =\n finalProvider && finalModel\n ? `${finalProvider.name},${finalModel}`\n : modelForTokenizer;\n if (req.unifiedBody && typeof req.unifiedBody === \"object\") {\n req.unifiedBody.model = body.model;\n }\n req.scenarioType = \"default\";\n markLatency(latency, \"routeSelected\");\n return;\n }\n\n let tokenCount = 0;\n if (routerNeedsExactTokenCount(activeRouter, customRouterPath)) {\n const [providerName, modelName] = modelForTokenizer.split(\",\");\n const tokenizerConfig =\n context.tokenizerService?.getTokenizerConfigForModel(\n providerName,\n modelName\n );\n tokenCount = await resolveExactTokenCount({\n messages,\n system,\n tools,\n tokenizerService: context.tokenizerService,\n tokenizerConfig,\n sessionId: req.sessionId,\n lastUsage: lastMessageUsage,\n longContextThreshold,\n latency,\n });\n }\n\n req.tokenCount = tokenCount;\n attachLatencyMeta(latency, {\n tokenCount,\n tokenCountSource: routerNeedsExactTokenCount(activeRouter, customRouterPath)\n ? \"exact\"\n : \"skipped\",\n });\n\n let model;\n if (customRouterPath) {\n try {\n const customRouter = require(customRouterPath);\n // Anthropic custom routers continue to receive original Anthropic req.body.\n // Multi-protocol routers can read req.clientProtocol / req.unifiedBody.\n model = await customRouter(req, configService.getAll(), {\n event,\n });\n } catch (e: any) {\n req.log.error(`failed to load custom router: ${e.message}`);\n }\n }\n if (!model) {\n const result = await getUseModel(\n req,\n tokenCount,\n configService,\n lastMessageUsage\n );\n model = result.model;\n req.scenarioType = result.scenarioType;\n } else {\n req.scenarioType = \"default\";\n }\n markLatency(latency, \"routeSelected\");\n\n // Apply selected model to canonical Unified. Do not mutate immutable client wire provenance.\n body.model = model;\n if (req.unifiedBody && typeof req.unifiedBody === \"object\") {\n req.unifiedBody.model = model;\n }\n } catch (error: any) {\n req.log.error(`Error in router middleware: ${error.message}`);\n const Router = configService.get(\"Router\");\n const fallbackModel = Router?.default || body.model;\n body.model = fallbackModel;\n if (req.unifiedBody && typeof req.unifiedBody === \"object\") {\n req.unifiedBody.model = fallbackModel;\n }\n req.scenarioType = \"default\";\n }\n return;\n};\n\n// Memory cache for sessionId to project name mapping\n// null value indicates previously searched but not found\n// Uses LRU cache with max 1000 entries\nconst sessionProjectCache = new LRUCache({\n max: 1000,\n});\n\nexport const searchProjectBySession = async (\n sessionId: string,\n logger?: any\n): Promise => {\n // Check cache first\n if (sessionProjectCache.has(sessionId)) {\n const result = sessionProjectCache.get(sessionId);\n if (!result || result === '') {\n return null;\n }\n return result;\n }\n\n try {\n const projectsDirStat = await stat(CLAUDE_PROJECTS_DIR);\n if (!projectsDirStat.isDirectory()) {\n sessionProjectCache.set(sessionId, '');\n return null;\n }\n } catch (error: any) {\n if (error?.code === \"ENOENT\") {\n sessionProjectCache.set(sessionId, '');\n return null;\n }\n (logger?.error ?? console.error)(\"Error checking Claude projects directory:\", error);\n sessionProjectCache.set(sessionId, '');\n return null;\n }\n\n try {\n const dir = await opendir(CLAUDE_PROJECTS_DIR);\n const folderNames: string[] = [];\n\n // Collect all folder names\n for await (const dirent of dir) {\n if (dirent.isDirectory()) {\n folderNames.push(dirent.name);\n }\n }\n\n // Concurrently check each project folder for sessionId.jsonl file\n const projectsRoot = resolve(CLAUDE_PROJECTS_DIR);\n const safeSessionFile = `${basename(String(sessionId))}.jsonl`;\n const checkPromises = folderNames.map(async (folderName) => {\n const projectDir = resolve(projectsRoot, basename(folderName));\n const projectRel = relative(projectsRoot, projectDir);\n if (!projectRel || projectRel.startsWith(\"..\")) {\n return null;\n }\n const sessionFilePath = join(projectDir, safeSessionFile);\n try {\n const fileStat = await stat(sessionFilePath);\n return fileStat.isFile() ? folderName : null;\n } catch {\n // File does not exist, continue checking next\n return null;\n }\n });\n\n const results = await Promise.all(checkPromises);\n\n // Return the first existing project directory name\n for (const result of results) {\n if (result) {\n // Cache the found result\n sessionProjectCache.set(sessionId, result);\n return result;\n }\n }\n\n // Cache not found result (null value means previously searched but not found)\n sessionProjectCache.set(sessionId, '');\n return null; // No matching project found\n } catch (error) {\n (logger?.error ?? console.error)(\"Error searching for project by session:\", error);\n // Cache null result on error to avoid repeated errors\n sessionProjectCache.set(sessionId, '');\n return null;\n }\n};\n", "// LRU cache for session usage\n\nexport interface Usage {\n input_tokens: number;\n output_tokens: number;\n}\n\nclass LRUCache {\n private capacity: number;\n private cache: Map;\n\n constructor(capacity: number) {\n this.capacity = capacity;\n this.cache = new Map();\n }\n\n get(key: K): V | undefined {\n if (!this.cache.has(key)) {\n return undefined;\n }\n const value = this.cache.get(key) as V;\n // Move to end to mark as recently used\n this.cache.delete(key);\n this.cache.set(key, value);\n return value;\n }\n\n put(key: K, value: V): void {\n if (this.cache.has(key)) {\n // If key exists, delete it to update its position\n this.cache.delete(key);\n } else if (this.cache.size >= this.capacity) {\n // If cache is full, delete the least recently used item\n const leastRecentlyUsedKey = this.cache.keys().next().value;\n if (leastRecentlyUsedKey !== undefined) {\n this.cache.delete(leastRecentlyUsedKey);\n }\n }\n this.cache.set(key, value);\n }\n\n values(): V[] {\n return Array.from(this.cache.values());\n }\n}\n\nexport const sessionUsageCache = new LRUCache(100);\n", "/**\n * Off-main-thread token counting for large prompts so one request cannot\n * starve concurrent SSE streams on the event loop.\n */\nimport { Worker } from \"node:worker_threads\";\nimport { cpus } from \"node:os\";\n\nexport type TokenCountWorkerRequest = {\n messages: unknown;\n system: unknown;\n tools: unknown;\n};\n\ntype Pending = {\n resolve: (n: number) => void;\n reject: (err: Error) => void;\n};\n\n/** Offload when serialized payload exceeds this many characters. */\nexport const TOKEN_COUNT_WORKER_THRESHOLD_CHARS = 200_000;\n\nconst MAX_WORKERS = Math.max(1, Math.min(2, (cpus().length || 2) - 1));\n\nlet nextId = 1;\nconst pending = new Map();\nconst workers: Worker[] = [];\nlet rr = 0;\n\nconst WORKER_SOURCE = `\nconst { parentPort } = require(\"worker_threads\");\nconst { get_encoding } = require(\"tiktoken\");\nconst enc = get_encoding(\"cl100k_base\");\nfunction encodeSafe(text) {\n try { return enc.encode(text); }\n catch { return enc.encode(String(text).replace(/[^\\\\u0000-\\\\uFFFF]/g, \"\")); }\n}\nfunction countTokens(messages, system, tools) {\n let tokenCount = 0;\n if (Array.isArray(messages)) {\n for (const message of messages) {\n if (typeof message?.content === \"string\") {\n tokenCount += encodeSafe(message.content).length;\n } else if (Array.isArray(message?.content)) {\n for (const part of message.content) {\n if (part?.type === \"text\") tokenCount += encodeSafe(part.text || \"\").length;\n else if (part?.type === \"tool_use\") tokenCount += encodeSafe(JSON.stringify(part.input)).length;\n else if (part?.type === \"tool_result\") {\n tokenCount += encodeSafe(typeof part.content === \"string\" ? part.content : JSON.stringify(part.content)).length;\n }\n }\n }\n }\n }\n if (typeof system === \"string\") tokenCount += encodeSafe(system).length;\n else if (Array.isArray(system)) {\n for (const item of system) {\n if (item?.type !== \"text\") continue;\n if (typeof item.text === \"string\") tokenCount += encodeSafe(item.text).length;\n else if (Array.isArray(item.text)) {\n for (const textPart of item.text) tokenCount += encodeSafe(textPart || \"\").length;\n }\n }\n }\n if (Array.isArray(tools)) {\n for (const tool of tools) {\n if (tool?.description) tokenCount += encodeSafe(String(tool.name || \"\") + String(tool.description)).length;\n if (tool?.input_schema) tokenCount += encodeSafe(JSON.stringify(tool.input_schema)).length;\n }\n }\n return tokenCount;\n}\nparentPort.on(\"message\", (msg) => {\n try {\n parentPort.postMessage({ id: msg.id, tokenCount: countTokens(msg.messages, msg.system, msg.tools) });\n } catch (error) {\n parentPort.postMessage({ id: msg.id, error: error?.message || String(error) });\n }\n});\n`;\n\nfunction ensureWorker(): Worker {\n if (workers.length < MAX_WORKERS) {\n const worker = new Worker(WORKER_SOURCE, { eval: true });\n worker.on(\n \"message\",\n (msg: { id: number; tokenCount?: number; error?: string }) => {\n const slot = pending.get(msg.id);\n if (!slot) return;\n pending.delete(msg.id);\n if (msg.error) slot.reject(new Error(msg.error));\n else slot.resolve(msg.tokenCount ?? 0);\n }\n );\n worker.on(\"error\", (err) => {\n for (const [id, slot] of pending) {\n pending.delete(id);\n slot.reject(err instanceof Error ? err : new Error(String(err)));\n }\n });\n workers.push(worker);\n return worker;\n }\n const worker = workers[rr % workers.length]!;\n rr += 1;\n return worker;\n}\n\nexport function estimateTokenizePayloadChars(\n messages: unknown,\n system: unknown,\n tools: unknown\n): number {\n let n = 0;\n const add = (v: unknown) => {\n if (typeof v === \"string\") n += v.length;\n else if (Array.isArray(v)) {\n for (const item of v) add(item);\n } else if (v && typeof v === \"object\") {\n for (const val of Object.values(v as Record)) add(val);\n }\n };\n add(messages);\n add(system);\n add(tools);\n return n;\n}\n\n/** Conservative under-estimate: ~4 chars/token. Safe for \"below threshold\" skips. */\nexport function estimateTokensFromChars(charCount: number): number {\n return Math.ceil(charCount / 4);\n}\n\nexport function countTokensInWorker(\n request: TokenCountWorkerRequest\n): Promise {\n const id = nextId++;\n const worker = ensureWorker();\n return new Promise((resolve, reject) => {\n pending.set(id, { resolve, reject });\n worker.postMessage({ id, ...request });\n });\n}\n\nexport async function closeTokenCountWorkers(): Promise {\n const closing = workers.splice(0, workers.length);\n await Promise.all(\n closing.map((w) =>\n w.terminate().catch(() => {\n /* ignore */\n })\n )\n );\n pending.clear();\n}\n", "import { readFile } from \"fs/promises\";\nimport { TextContent, UnifiedChatRequest } from \"@/types/llm\";\nimport {\n applyClaudeSystemIdentity,\n fillClaudeBillingSystemBlock,\n normalizeSystemToArray,\n prefixClaudeToolNames,\n relocateForeignSystemContent,\n reserveClaudeBillingSystemBlock,\n} from \"./claude-billing\";\nimport { unifiedUserPartToAnthropic } from \"./tool-content\";\n\nexport type AnthropicClientKind = \"claude_desktop\" | \"claude_code\" | \"other\";\nexport type AnthropicProviderMode = \"api_key\" | \"claude_oauth\" | \"out_of_scope\";\n\nexport interface AnthropicClientFingerprintSignals {\n desktopMarker: boolean;\n desktopUserAgent: boolean;\n desktopAgentSdkUserAgent: boolean;\n cliUserAgent: boolean;\n cliApp: boolean;\n cliSession: boolean;\n stainlessPackage: boolean;\n billingSystem: boolean;\n identitySystem: boolean;\n}\n\nexport interface AnthropicClientPolicyContext {\n anthropicClientKind?: AnthropicClientKind;\n anthropicProviderMode?: AnthropicProviderMode;\n anthropicDestinationInScope?: boolean;\n anthropicNativeWire?: boolean;\n anthropicPolicyApplied?: boolean;\n anthropicSystemTransformed?: boolean;\n claudeAuthToolNameMap?: Map;\n}\n\nexport function readHeaderValue(\n headers: Record | undefined,\n name: string\n): string | undefined {\n if (!headers) return undefined;\n const expected = name.toLowerCase();\n for (const [rawName, rawValue] of Object.entries(headers)) {\n if (rawName.toLowerCase() !== expected || rawValue == null) continue;\n if (Array.isArray(rawValue)) {\n const values = rawValue.filter((value) => value != null && String(value));\n return values.length ? values.map(String).join(\", \") : undefined;\n }\n const value = String(rawValue);\n return value || undefined;\n }\n return undefined;\n}\n\nfunction hasNativeClaudeBillingBody(body: any): boolean {\n const system = Array.isArray(body?.system) ? body.system : [];\n return system.some(\n (block: any) =>\n typeof block?.text === \"string\" &&\n block.text.startsWith(\"x-anthropic-billing-header\")\n );\n}\n\nfunction hasClaudeCodeIdentityBody(body: any): boolean {\n const system = Array.isArray(body?.system) ? body.system : [];\n return system.some(\n (block: any) =>\n typeof block?.text === \"string\" &&\n (block.text.startsWith(\n \"You are Claude Code, Anthropic's official CLI for Claude.\"\n ) ||\n block.text.startsWith(\n \"You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.\"\n ) ||\n block.text.startsWith(\n \"You are a Claude agent, built on Anthropic's Claude Agent SDK.\"\n ))\n );\n}\n\n/**\n * Classify the original Anthropic wire request. A generic SDK UA is never\n * enough to grant native pass-through; incomplete fingerprints fail closed to\n * the third-party emulation path.\n */\nexport function classifyAnthropicClient(\n headers: Record | undefined,\n body: any\n): AnthropicClientKind {\n const signals = inspectAnthropicClientFingerprint(headers, body);\n const desktopTopbarCandidate =\n signals.desktopMarker &&\n signals.desktopUserAgent &&\n Array.isArray(body?.messages);\n const nativeCliShape =\n signals.cliUserAgent &&\n signals.cliApp &&\n signals.cliSession &&\n signals.stainlessPackage &&\n signals.billingSystem &&\n signals.identitySystem &&\n Array.isArray(body?.messages);\n const conflictingCliMarkers =\n signals.cliUserAgent ||\n signals.cliApp ||\n signals.cliSession;\n if (desktopTopbarCandidate && conflictingCliMarkers) {\n return \"other\";\n }\n if (desktopTopbarCandidate) {\n return \"claude_desktop\";\n }\n\n // Current Desktop 3P inference runs through the bundled Agent SDK and\n // Claude Code binary. Its wire request intentionally has the complete CLI\n // shape, but the UA's entrypoint identifies Desktop as the host client.\n if (signals.desktopAgentSdkUserAgent && nativeCliShape) {\n return \"claude_desktop\";\n }\n\n return nativeCliShape ? \"claude_code\" : \"other\";\n}\n\n/** Return only non-sensitive boolean fingerprint signals for debug logging. */\nexport function inspectAnthropicClientFingerprint(\n headers: Record | undefined,\n body: any\n): AnthropicClientFingerprintSignals {\n const userAgent = readHeaderValue(headers, \"user-agent\") || \"\";\n const desktopMarker = readHeaderValue(headers, \"anthropic-desktop-topbar\");\n const cliUserAgentMatch = /^claude-cli\\/[^\\s()]+\\s+\\(([^)]*)\\)$/i.exec(\n userAgent\n );\n const cliUserAgentParts = (cliUserAgentMatch?.[1] || \"\")\n .split(\",\")\n .map((part) => part.trim().toLowerCase());\n const desktopAgentSdkUserAgent =\n cliUserAgentParts.some((part) =>\n [\"claude-desktop\", \"claude-desktop-3p\"].includes(part)\n ) && cliUserAgentParts.some((part) => /^agent-sdk\\/[^\\s,]+$/.test(part));\n return {\n desktopMarker: desktopMarker === \"1\",\n desktopUserAgent: /^Anthropic\\/JS\\s+/i.test(userAgent),\n desktopAgentSdkUserAgent,\n cliUserAgent: /^claude-cli\\//i.test(userAgent),\n cliApp: [\"cli\", \"cli-bg\"].includes(\n readHeaderValue(headers, \"x-app\") || \"\"\n ),\n cliSession: Boolean(readHeaderValue(headers, \"x-claude-code-session-id\")),\n stainlessPackage: Boolean(\n readHeaderValue(headers, \"x-stainless-package-version\")\n ),\n billingSystem: hasNativeClaudeBillingBody(body),\n identitySystem: hasClaudeCodeIdentityBody(body),\n };\n}\n\n/**\n * The feature is intentionally scoped to CCR's real Anthropic provider, with\n * either the exact Anthropic API-key chain or the exact claude-auth + Anthropic\n * OAuth chain. Adjacent middleware makes a provider out of scope.\n */\nexport function getAnthropicProviderMode(\n provider: any,\n endpointTransformerName = \"Anthropic\"\n): AnthropicProviderMode {\n const use = Array.isArray(provider?.transformer?.use)\n ? provider.transformer.use\n : [];\n const names = use.map((transformer: any) => transformer?.name);\n if (names.length === 1 && names[0] === endpointTransformerName) {\n return \"api_key\";\n }\n if (\n names.length === 2 &&\n names[0] === \"claude-auth\" &&\n names[1] === endpointTransformerName\n ) {\n return \"claude_oauth\";\n }\n return \"out_of_scope\";\n}\n\nexport function isNativeAnthropicClient(kind: AnthropicClientKind): boolean {\n return kind === \"claude_desktop\" || kind === \"claude_code\";\n}\n\n/**\n * Owners of ephemeral breakpoints at the places the Messages API accepts them:\n * top level, tool definitions, system blocks, message content blocks and\n * tool_result content blocks. Tool inputs and other payloads are user data and\n * are never scanned.\n */\nfunction ephemeralMarkerOwners(body: any): any[] {\n const owners: any[] = [];\n const add = (owner: any) => {\n const cc = owner?.cache_control;\n if (cc && typeof cc === \"object\" && cc.type === \"ephemeral\") owners.push(owner);\n };\n const blocks = (value: unknown) => (Array.isArray(value) ? value : []);\n add(body);\n blocks(body.tools).forEach(add);\n blocks(body.system).forEach(add);\n for (const message of blocks(body.messages)) {\n for (const block of blocks(message?.content)) {\n add(block);\n if (block?.type === \"tool_result\") blocks(block.content).forEach(add);\n }\n }\n return owners;\n}\n\n/** `CLAUDE_AUTH_NATIVE_CACHE_TTL` values: `1h` (default) or `client`. */\nexport type NativeClaudeOAuthCacheTtlMode = \"1h\" | \"client\";\n\nexport function resolveNativeClaudeOAuthCacheTtlMode(\n value: unknown\n): NativeClaudeOAuthCacheTtlMode {\n return typeof value === \"string\" && value.trim().toLowerCase() === \"client\"\n ? \"client\"\n : \"1h\";\n}\n\n/**\n * Native Desktop/CLI on claude-auth OAuth: extend the client's default-TTL\n * (5m) ephemeral breakpoints to 1h, the TTL the third-party profile already\n * uses on this route. Breakpoint placement is untouched. A body that already\n * sets a TTL on any breakpoint is left exactly as sent (an explicit client\n * choice), as is every body when the mode is `client`. Returns whether the\n * body changed.\n */\nexport function applyNativeClaudeOAuthCacheTtl(\n body: any,\n context: AnthropicClientPolicyContext | undefined,\n mode: NativeClaudeOAuthCacheTtlMode = \"1h\"\n): boolean {\n if (\n mode !== \"1h\" ||\n !context?.anthropicNativeWire ||\n context.anthropicProviderMode !== \"claude_oauth\" ||\n !body ||\n typeof body !== \"object\"\n ) {\n return false;\n }\n const markers = ephemeralMarkerOwners(body);\n if (!markers.length || markers.some((owner) => owner.cache_control.ttl !== undefined)) {\n return false;\n }\n for (const owner of markers) {\n owner.cache_control = { ...owner.cache_control, ttl: \"1h\" };\n }\n return true;\n}\n\n/**\n * Apply the one and only system transformation allowed by the gateway policy.\n * This runs after routing has identified an in-scope Anthropic destination and\n * before the provider's Anthropic body builder runs.\n */\nexport async function applyThirdPartyAnthropicPolicy(\n request: UnifiedChatRequest,\n context: AnthropicClientPolicyContext,\n configService: any\n): Promise {\n if (\n context.anthropicClientKind !== \"other\" ||\n context.anthropicDestinationInScope !== true\n ) {\n return;\n }\n const system = normalizeSystemToArray(request);\n const billingBlock = reserveClaudeBillingSystemBlock(system);\n applyClaudeSystemIdentity(system);\n\n const rewritePrompt = configService?.get?.(\"REWRITE_SYSTEM_PROMPT\");\n if (rewritePrompt && Array.isArray(request.system)) {\n for (const block of request.system as any[]) {\n if (typeof block?.text !== \"string\" || !block.text.includes(\"\")) {\n continue;\n }\n const prompt = await readFile(rewritePrompt, \"utf-8\");\n block.text = `${prompt}${block.text.split(\"\").pop()}`;\n }\n }\n\n // Give user/assistant text one block shape regardless of position: the\n // relocated prompt then stays a standalone block that can carry its own\n // breakpoint, and the tail breakpoint no longer flips a string into a block\n // array only while that message is last (which read as a rewritten history\n // in the client-stage cache diff). The Anthropic wire is identical.\n for (const message of request.messages) {\n if (\n (message.role === \"user\" || message.role === \"assistant\") &&\n typeof message.content === \"string\" &&\n message.content\n ) {\n message.content = [{ type: \"text\", text: message.content }];\n }\n }\n const relocatedSystemBlock = relocateForeignSystemContent(\n system,\n request.messages\n );\n // The billing suffix samples the first user text, so compute it from the\n // body actually sent: after relocation that text is the caller's stable\n // prompt, and system[0] survives clients dropping or summarizing early turns.\n fillClaudeBillingSystemBlock(system, billingBlock, request.messages);\n const toolNameMap = new Map();\n prefixClaudeToolNames(request, toolNameMap);\n applyClaudeCodeCacheProfile(\n request,\n context.anthropicProviderMode,\n relocatedSystemBlock\n );\n context.claudeAuthToolNameMap = toolNameMap;\n context.anthropicPolicyApplied = true;\n context.anthropicSystemTransformed = true;\n}\n\nfunction applyClaudeCodeCacheProfile(\n request: UnifiedChatRequest,\n providerMode: AnthropicProviderMode | undefined,\n relocatedSystemBlock: TextContent | undefined\n): void {\n const cacheControl: { type: \"ephemeral\"; ttl?: \"1h\" } = {\n type: \"ephemeral\",\n ...(providerMode === \"claude_oauth\" ? { ttl: \"1h\" } : {}),\n };\n\n delete (request as any).cache_control;\n for (const tool of request.tools || []) delete (tool as any).cache_control;\n\n // Normally system[] is billing + identity. Without a user message to relocate\n // into, the caller's blocks stay here too; mark only the first and last\n // cacheable block so identity + system + tail stay within Anthropic's 4.\n const systemBlocks = ((request.system as any[]) || []).filter(Boolean);\n const cacheable = systemBlocks.filter(\n (block) =>\n typeof block.text === \"string\" &&\n !block.text.startsWith(\"x-anthropic-billing-header\")\n );\n for (const block of systemBlocks) {\n if (block === cacheable[0] || block === cacheable.at(-1)) {\n block.cache_control = { ...cacheControl };\n } else {\n delete block.cache_control;\n }\n }\n\n for (const message of request.messages || []) {\n delete (message as any).cache_control;\n for (const toolCall of message.tool_calls || []) {\n delete (toolCall as any).cache_control;\n }\n if (Array.isArray(message.content)) {\n for (const part of message.content as any[]) delete part.cache_control;\n }\n }\n\n // Claude Code caches its system prompt as a system block. Relocation moves\n // the caller's prompt into the first user message, so mark it there: tools +\n // system + instructions stay cached even when the client later rewrites its\n // history (memory windows, summarization). Identity + this + tail = 3 of 4.\n if (relocatedSystemBlock) {\n (relocatedSystemBlock as any).cache_control = { ...cacheControl };\n }\n\n // The body builder omits a turn with nothing to send, so a tail that cannot\n // take the marker hands it to the previous eligible message.\n const messages = request.messages || [];\n for (let i = messages.length - 1; i >= 0; i -= 1) {\n if (markCacheTail(messages[i], cacheControl)) return;\n }\n}\n\nconst ASSISTANT_REASONING_PARTS = [\"thinking\", \"redacted_thinking\", \"fallback\"];\n\n/** Place the tail breakpoint on `message`; false when it cannot carry one. */\nfunction markCacheTail(\n message: UnifiedChatRequest[\"messages\"][number],\n cacheControl: { type: \"ephemeral\"; ttl?: \"1h\" }\n): boolean {\n if (message.role === \"tool\") {\n // A Unified tool message becomes one Anthropic tool_result block, and the\n // body builder only carries the message-level marker onto that block.\n // Claude Code marks the tool_result itself; a marker on a content part is\n // lost when single-text tool content collapses to a string.\n (message as any).cache_control = { ...cacheControl };\n return true;\n }\n if (typeof message.content === \"string\") {\n // The body builder drops empty text blocks, and a marker with them.\n if (!message.content) return false;\n message.content = [{\n type: \"text\",\n text: message.content,\n cache_control: { ...cacheControl },\n }];\n return true;\n }\n if (!Array.isArray(message.content)) return false;\n // An assistant turn ending in reasoning is skipped as a whole, as in Claude\n // Code's current `a8b`/`zGb` path.\n if (\n message.role === \"assistant\" &&\n ASSISTANT_REASONING_PARTS.includes((message.content.at(-1) as any)?.type)\n ) {\n return false;\n }\n for (let i = message.content.length - 1; i >= 0; i -= 1) {\n const part = message.content[i] as any;\n // Claude Code marks the last eligible content block, not necessarily a\n // text block: user tool results and assistant tool_use blocks can be the\n // cache breakpoint. Parts the body builder does not send (empty text,\n // image without URL, ...) would drop the marker with them, so skip those.\n if (\n message.role === \"assistant\" &&\n ASSISTANT_REASONING_PARTS.includes(part?.type)\n ) {\n continue;\n }\n if (\n message.role === \"user\"\n ? unifiedUserPartToAnthropic(part).length === 0\n : part?.type === \"text\" && !part.text\n ) {\n continue;\n }\n if (part && typeof part === \"object\") {\n part.cache_control = { ...cacheControl };\n return true;\n }\n }\n return false;\n}\n", "import { createHash } from \"crypto\";\nimport { TextContent, UnifiedChatRequest, UnifiedMessage } from \"@/types/llm\";\nimport { CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX } from \"./router\";\n\n/** Salt used in Claude Code's `cc_version` suffix hash (`RYn()`). */\nexport const BILLING_SALT = \"59cf53e54c78\";\n// Frozen current Claude Code reference used by third-party emulation. Update\n// intentionally with a new golden profile when the CLI reference changes.\nexport const CC_VERSION = process.env.ANTHROPIC_CLI_VERSION || \"2.1.280\";\n// Claude Code uses different fallbacks for the HTTP user agent and billing\n// attribution marker in the current 2.1.280 build.\nexport const CC_ENTRYPOINT = process.env.CLAUDE_CODE_ENTRYPOINT ?? \"unknown\";\nexport const CC_USER_AGENT_ENTRYPOINT =\n process.env.CLAUDE_CODE_ENTRYPOINT ?? \"cli\";\nexport const SYSTEM_IDENTITY =\n \"You are Claude Code, Anthropic's official CLI for Claude.\";\n\nfunction textOfContent(content: UnifiedMessage[\"content\"]): string {\n if (typeof content === \"string\") return content;\n if (Array.isArray(content)) {\n const firstText = content.find(\n (part): part is TextContent => part.type === \"text\"\n );\n return firstText?.text ?? \"\";\n }\n return \"\";\n}\n\nexport function extractFirstUserMessageText(\n messages: UnifiedMessage[] | undefined\n): string {\n const firstUser = messages?.find((msg) => msg.role === \"user\");\n return firstUser ? textOfContent(firstUser.content) : \"\";\n}\n\nexport function computeVersionSuffix(text: string, version: string): string {\n const sample = [4, 7, 20].map((i) => text[i] || \"0\").join(\"\");\n return createHash(\"sha256\")\n .update(BILLING_SALT + sample + version)\n .digest(\"hex\")\n .slice(0, 3);\n}\n\n/**\n * Current first-party Anthropic requests use the literal cch marker. Older\n * captures showed a random session value; the current 2.1.280 decompilation\n * gates this field to first-party/Vertex and emits `00000`.\n */\nexport function sessionCch(): string {\n return \"00000\";\n}\n\nexport function __resetClaudeBillingStateForTests(): void {\n // Kept as a test compatibility hook; the current marker is stateless.\n}\n\nexport function buildClaudeBillingHeaderValue(\n messages: UnifiedMessage[] | undefined,\n version: string = CC_VERSION,\n entrypoint: string = CC_ENTRYPOINT\n): string {\n const attributionSetting = process.env.CLAUDE_CODE_ATTRIBUTION_HEADER\n ?.trim()\n .toLowerCase();\n if ([\"0\", \"false\", \"no\", \"off\"].includes(attributionSetting || \"\")) {\n return \"\";\n }\n\n const suffix = computeVersionSuffix(\n extractFirstUserMessageText(messages),\n version\n );\n return (\n `${CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX}: cc_version=${version}.${suffix}; ` +\n `cc_entrypoint=${entrypoint}; cch=${sessionCch()};`\n );\n}\n\n/**\n * Normalize `request.system` to an array as a complete ordered fold:\n * top-level `request.system` blocks first, then every `role:\"system\"` /\n * `role:\"developer\"` message's text blocks in source order. Consumed messages\n * are removed from `request.messages` so no downstream builder can drop or\n * double-emit them. Block-level `cache_control` is preserved.\n */\nexport function normalizeSystemToArray(\n request: UnifiedChatRequest\n): TextContent[] {\n const blocks: TextContent[] = [];\n\n const pushContent = (content: UnifiedMessage[\"content\"] | undefined) => {\n if (typeof content === \"string\") {\n if (content) blocks.push({ type: \"text\", text: content });\n return;\n }\n if (!Array.isArray(content)) return;\n for (const part of content) {\n if (part?.type === \"text\" && part.text) {\n const block: TextContent = { type: \"text\", text: part.text };\n if (part.cache_control !== undefined) {\n block.cache_control = part.cache_control;\n }\n blocks.push(block);\n }\n }\n };\n\n if (typeof request.system === \"string\" || Array.isArray(request.system)) {\n pushContent(request.system as UnifiedMessage[\"content\"]);\n }\n\n if (Array.isArray(request.messages)) {\n const remaining: UnifiedMessage[] = [];\n for (const message of request.messages) {\n if (\n message.role === \"system\" ||\n (message.role as string) === \"developer\"\n ) {\n pushContent(message.content);\n } else {\n remaining.push(message);\n }\n }\n request.messages = remaining;\n }\n\n request.system = blocks;\n return blocks;\n}\n\n/** Drop any existing billing entry (dedupe) and prepend a fresh one at system[0]. */\nexport function applyClaudeBillingSystemBlock(\n system: TextContent[],\n messages: UnifiedMessage[] | undefined\n): void {\n fillClaudeBillingSystemBlock(\n system,\n reserveClaudeBillingSystemBlock(system),\n messages\n );\n}\n\n/**\n * Drop any existing billing entry (dedupe) and reserve system[0] for a fresh\n * one, so applyClaudeSystemIdentity places identity right after it. The value\n * samples the first user text as sent, which relocation may still change, so\n * fill it afterwards with fillClaudeBillingSystemBlock.\n */\nexport function reserveClaudeBillingSystemBlock(\n system: TextContent[]\n): TextContent {\n for (let i = system.length - 1; i >= 0; i--) {\n if (system[i].text.startsWith(CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX)) {\n system.splice(i, 1);\n }\n }\n const block: TextContent = {\n type: \"text\",\n text: CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX,\n };\n system.unshift(block);\n return block;\n}\n\n/** Fill a reserved billing block; remove it when attribution is disabled. */\nexport function fillClaudeBillingSystemBlock(\n system: TextContent[],\n block: TextContent,\n messages: UnifiedMessage[] | undefined\n): void {\n const index = system.indexOf(block);\n if (index < 0) return;\n const billing = buildClaudeBillingHeaderValue(messages);\n if (billing) block.text = billing;\n else system.splice(index, 1);\n}\n\n/**\n * Insert SYSTEM_IDENTITY after the billing block (normally system[1], or\n * system[0] when attribution is disabled). Any remaining caller system\n * content is left in place here \u2014 relocateForeignSystemContent (called\n * separately, afterwards) is what moves it out of system[].\n */\nexport function applyClaudeSystemIdentity(system: TextContent[]): void {\n const billingIndex = system.findIndex((block) =>\n block.text.startsWith(CLAUDE_CODE_BILLING_SYSTEM_HEADER_PREFIX)\n );\n const candidateIndex = billingIndex >= 0 ? billingIndex + 1 : 0;\n const candidate = system[candidateIndex];\n\n if (candidate?.text === SYSTEM_IDENTITY) return;\n\n if (\n candidate?.text.startsWith(SYSTEM_IDENTITY) &&\n candidate.text.length > SYSTEM_IDENTITY.length\n ) {\n const remainder: TextContent = {\n type: \"text\",\n text: candidate.text.slice(SYSTEM_IDENTITY.length),\n };\n if (candidate.cache_control !== undefined) {\n remainder.cache_control = candidate.cache_control;\n }\n system.splice(\n candidateIndex,\n 1,\n { type: \"text\", text: SYSTEM_IDENTITY },\n remainder\n );\n return;\n }\n\n system.splice(candidateIndex, 0, { type: \"text\", text: SYSTEM_IDENTITY });\n}\n\n/**\n * Move everything in `system[]` past the identity block into the first user\n * message instead. Anthropic's OAuth billing validator appears to\n * inspect `system[]` content beyond the identity prefix and reject requests\n * whose system array carries a foreign harness prompt with an \"out of extra\n * usage\" 400 \u2014 the same approach used by third-party Claude Code OAuth\n * clients (e.g. opencode-claude-auth). The relocated text still reaches the\n * model, just as part of the first user turn rather than\n * `system[]`.\n *\n * A no-op when there is no user message to attach the content to, so nothing\n * is silently dropped \u2014 the caller's system content stays in `system[]`\n * instead.\n *\n * Returns the inserted block unless the first user message has non-empty\n * string content (the relocated text is then a standalone block a cache\n * breakpoint can end on); non-empty string content is prefixed in place and\n * returns undefined.\n */\nexport function relocateForeignSystemContent(\n system: TextContent[],\n messages: UnifiedMessage[] | undefined\n): TextContent | undefined {\n const identityIndex = system.findIndex(\n (block) => block.text === SYSTEM_IDENTITY\n );\n if (identityIndex < 0 || system.length <= identityIndex + 1 || !Array.isArray(messages)) {\n return undefined;\n }\n\n const firstUser = messages.find((msg) => msg.role === \"user\");\n if (!firstUser) return undefined;\n\n const foreign = system.splice(identityIndex + 1);\n const text = foreign\n .map((block) => block.text)\n .filter((t) => t.length > 0)\n .join(\"\\n\\n\");\n if (!text) return undefined;\n\n if (typeof firstUser.content === \"string\" && firstUser.content) {\n firstUser.content = `${text}\\n\\n${firstUser.content}`;\n return undefined;\n }\n const block: TextContent = { type: \"text\", text };\n if (Array.isArray(firstUser.content)) {\n firstUser.content.unshift(block);\n } else {\n // Empty or non-text content carries nothing to prefix; the relocated\n // prompt becomes the sole block so it can still take a breakpoint.\n firstUser.content = [block];\n }\n return block;\n}\n\n/**\n * Claude Code's OAuth validator expects tool names in the mcp_PascalCase\n * spelling used by the official CLI. Non-Claude-Code clients commonly send\n * ordinary names such as `bash` or `read`, so normalize them before the\n * Anthropic body is built. The prefix check keeps this operation idempotent.\n */\nexport function prefixClaudeToolName(name: string): string {\n if (/^mcp_[A-Z]/.test(name)) return name;\n return `mcp_${name.charAt(0).toUpperCase()}${name.slice(1)}`;\n}\n\n/** Restore a Claude Code tool name to the caller's original spelling. */\nexport function unprefixClaudeToolName(name: string): string {\n if (!name.startsWith(\"mcp_\") || name.length <= 4) return name;\n return `${name.charAt(4).toLowerCase()}${name.slice(5)}`;\n}\n\n/** Rewrite tool names in a Unified request in place for the OAuth wire path. */\nexport function prefixClaudeToolNames(\n request: UnifiedChatRequest,\n nameMap?: Map\n): void {\n const prefix = (name: string): string => {\n const wireName = prefixClaudeToolName(name);\n nameMap?.set(wireName, name);\n return wireName;\n };\n\n if (Array.isArray(request.tools)) {\n for (const tool of request.tools) {\n if (tool?.function?.name) tool.function.name = prefix(tool.function.name);\n }\n }\n\n if (Array.isArray(request.messages)) {\n for (const message of request.messages) {\n for (const toolCall of message.tool_calls ?? []) {\n if (toolCall?.function?.name) {\n toolCall.function.name = prefix(toolCall.function.name);\n }\n }\n }\n }\n\n if (typeof request.tool_choice === \"string\") {\n if (![\"auto\", \"none\", \"required\"].includes(request.tool_choice)) {\n request.tool_choice = prefix(request.tool_choice);\n }\n } else if (\n request.tool_choice?.type === \"function\" &&\n request.tool_choice.function?.name\n ) {\n request.tool_choice.function.name = prefix(request.tool_choice.function.name);\n }\n}\n\n/** Rewrite tool names in a Unified/OpenAI-shaped response in place. */\nexport function unprefixClaudeToolNames(\n value: any,\n nameMap?: Map\n): void {\n const rewriteToolCall = (toolCall: any) => {\n const name = toolCall?.function?.name;\n if (typeof name !== \"string\") return;\n toolCall.function.name = nameMap?.get(name) ?? unprefixClaudeToolName(name);\n };\n\n for (const choice of value?.choices ?? []) {\n for (const toolCall of choice?.message?.tool_calls ?? []) rewriteToolCall(toolCall);\n for (const toolCall of choice?.delta?.tool_calls ?? []) rewriteToolCall(toolCall);\n }\n}\n\n/** Rewrite one OpenAI SSE data payload's tool names. */\nexport function unprefixClaudeToolNamesInSseData(\n value: any,\n nameMap?: Map\n): void {\n unprefixClaudeToolNames(value, nameMap);\n}\n", "/**\n * Multimodal tool-result helpers.\n *\n * Responses / OpenCode attach images (and files) on function_call_output as\n * structured parts. Unified carries them as text / image_url / file parts on\n * role:\"tool\". Destinations differ:\n * - Responses/Codex: re-emit input_image / input_file in output[]\n * - Anthropic: image / document blocks inside tool_result.content\n * - Gemini: text in functionResponse + sibling inlineData parts\n * - Chat Completions / Mistral: string tool content only \u2014 extract media\n * into a follow-up user message (OpenCode's pattern for non-supporting APIs)\n */\n\nexport type UnifiedToolPart =\n | {\n type: \"text\";\n text: string;\n cache_control?: any;\n }\n | {\n type: \"image_url\";\n image_url: { url: string; detail?: string };\n media_type?: string;\n cache_control?: any;\n }\n | {\n type: \"file\";\n filename?: string;\n file_data?: string;\n file_url?: string;\n media_type?: string;\n cache_control?: any;\n };\n\nconst SYNTHETIC_TOOL_MEDIA_PROMPT =\n \"The previous tool result included the following media attachment(s).\";\n\nexport function isUnifiedToolMediaPart(\n part: any\n): part is Extract {\n return (\n !!part &&\n typeof part === \"object\" &&\n (part.type === \"image_url\" || part.type === \"file\")\n );\n}\n\n/** Normalize string | part[] tool content into a part list. */\nexport function normalizeUnifiedToolParts(content: unknown): UnifiedToolPart[] {\n if (typeof content === \"string\") {\n return content ? [{ type: \"text\", text: content }] : [];\n }\n if (!Array.isArray(content)) {\n if (content == null) return [];\n return [{ type: \"text\", text: JSON.stringify(content) }];\n }\n const parts: UnifiedToolPart[] = [];\n for (const part of content) {\n if (!part || typeof part !== \"object\") continue;\n if (part.type === \"text\") {\n parts.push({\n type: \"text\",\n text: String(part.text ?? \"\"),\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else if (part.type === \"image_url\" && part.image_url?.url) {\n parts.push({\n type: \"image_url\",\n image_url: {\n url: String(part.image_url.url),\n ...(typeof part.image_url.detail === \"string\" && part.image_url.detail\n ? { detail: part.image_url.detail }\n : {}),\n },\n ...(part.media_type ? { media_type: part.media_type } : {}),\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else if (part.type === \"file\") {\n parts.push({\n type: \"file\",\n ...(part.filename ? { filename: String(part.filename) } : {}),\n ...(part.file_data ? { file_data: String(part.file_data) } : {}),\n ...(part.file_url ? { file_url: String(part.file_url) } : {}),\n ...(part.media_type ? { media_type: String(part.media_type) } : {}),\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n }\n }\n return parts;\n}\n\nexport function unifiedToolTextOnly(content: unknown): string {\n const texts = normalizeUnifiedToolParts(content)\n .filter((p): p is Extract => p.type === \"text\")\n .map((p) => p.text)\n .filter(Boolean);\n return texts.join(\"\\n\");\n}\n\nexport function unifiedToolHasMedia(content: unknown): boolean {\n return normalizeUnifiedToolParts(content).some(isUnifiedToolMediaPart);\n}\n\n/** Anthropic tool_result.content: string or (text|image|document)[]. */\nexport function unifiedToolContentToAnthropic(content: unknown): string | any[] {\n const parts = normalizeUnifiedToolParts(content);\n if (parts.length === 0) return \"\";\n const blocks: any[] = [];\n for (const part of parts) {\n if (part.type === \"text\") {\n blocks.push({\n type: \"text\",\n text: part.text,\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n continue;\n }\n if (part.type === \"image_url\") {\n const url = part.image_url.url;\n if (url.startsWith(\"data:\")) {\n const [meta, data] = url.split(\",\");\n const mediaType =\n part.media_type ||\n meta.split(\":\")[1]?.split(\";\")[0] ||\n \"image/jpeg\";\n blocks.push({\n type: \"image\",\n source: { type: \"base64\", media_type: mediaType, data },\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else {\n blocks.push({\n type: \"image\",\n source: { type: \"url\", url },\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n }\n continue;\n }\n // file \u2192 Anthropic document (PDF) or image when media is image/*\n const mediaType =\n part.media_type ||\n mediaTypeFromDataUrl(part.file_data) ||\n \"application/pdf\";\n if (mediaType.startsWith(\"image/\") && part.file_data) {\n const data = part.file_data.includes(\",\")\n ? part.file_data.split(\",\").pop()!\n : part.file_data;\n blocks.push({\n type: \"image\",\n source: { type: \"base64\", media_type: mediaType, data },\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else if (part.file_url) {\n blocks.push({\n type: \"document\",\n source: { type: \"url\", url: part.file_url },\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n } else if (part.file_data) {\n const data = part.file_data.includes(\",\")\n ? part.file_data.split(\",\").pop()!\n : part.file_data;\n blocks.push({\n type: \"document\",\n source: {\n type: \"base64\",\n media_type: mediaType,\n data,\n },\n ...(part.filename ? { title: part.filename } : {}),\n ...(part.cache_control ? { cache_control: part.cache_control } : {}),\n });\n }\n }\n // The string form cannot carry a cache breakpoint; keep the block form then.\n return blocks.length === 1 &&\n blocks[0].type === \"text\" &&\n !blocks[0].cache_control\n ? blocks[0].text\n : blocks.length > 0\n ? blocks\n : \"\";\n}\n\n/**\n * Anthropic blocks for one Unified user content part. Empty when the part is\n * not sent (empty text, image without URL, file without data or URL, unknown\n * type), so callers placing cache breakpoints can skip it.\n */\nexport function unifiedUserPartToAnthropic(part: any): any[] {\n if (!part || typeof part !== \"object\") return [];\n const cacheControl = part.cache_control\n ? { cache_control: part.cache_control }\n : {};\n if (part.type === \"text\") {\n return part.text\n ? [{ type: \"text\", text: part.text, ...cacheControl }]\n : [];\n }\n if (part.type === \"image_url\" || part.type === \"file\") {\n // Same image/document mapping as tool results (honours part.media_type).\n const blocks = unifiedToolContentToAnthropic([part]);\n return Array.isArray(blocks) ? blocks : [];\n }\n return [];\n}\n\n/**\n * Anthropic inbound tool_result.content \u2192 Unified tool content\n * (string or text/image_url/file parts).\n */\nexport function anthropicToolResultToUnified(content: unknown): string | any[] {\n if (typeof content === \"string\") return content;\n if (!Array.isArray(content)) {\n return content == null ? \"\" : JSON.stringify(content);\n }\n const parts: any[] = [];\n for (const block of content) {\n if (!block || typeof block !== \"object\") continue;\n if (block.type === \"text\" && block.text) {\n parts.push({\n type: \"text\",\n text: block.text,\n ...(block.cache_control ? { cache_control: block.cache_control } : {}),\n });\n } else if (block.type === \"image\" && block.source) {\n const url =\n block.source.type === \"base64\"\n ? `data:${block.source.media_type || \"image/jpeg\"};base64,${block.source.data}`\n : block.source.url;\n if (typeof url === \"string\" && url) {\n parts.push({\n type: \"image_url\",\n image_url: { url },\n media_type: block.source.media_type,\n ...(block.cache_control ? { cache_control: block.cache_control } : {}),\n });\n }\n } else if (block.type === \"document\" && block.source) {\n if (block.source.type === \"base64\" && block.source.data) {\n const mediaType = block.source.media_type || \"application/pdf\";\n parts.push({\n type: \"file\",\n filename: block.title || block.source.media_type || \"document\",\n file_data: `data:${mediaType};base64,${block.source.data}`,\n media_type: mediaType,\n ...(block.cache_control ? { cache_control: block.cache_control } : {}),\n });\n } else if (block.source.type === \"url\" && block.source.url) {\n parts.push({\n type: \"file\",\n filename: block.title || \"document\",\n file_url: block.source.url,\n media_type: block.source.media_type || \"application/pdf\",\n ...(block.cache_control ? { cache_control: block.cache_control } : {}),\n });\n }\n }\n }\n if (parts.length === 1 && parts[0].type === \"text\") return parts[0].text;\n return parts.length > 0 ? parts : \"\";\n}\n\n/** Gemini sibling inlineData / fileData parts for tool media. */\nexport function unifiedToolMediaToGeminiParts(content: unknown): any[] {\n const parts: any[] = [];\n for (const part of normalizeUnifiedToolParts(content)) {\n if (part.type === \"image_url\") {\n const url = part.image_url.url;\n const mediaType =\n part.media_type ||\n mediaTypeFromDataUrl(url) ||\n \"image/jpeg\";\n if (url.startsWith(\"data:\")) {\n parts.push({\n inlineData: {\n mimeType: mediaType,\n data: url.split(\",\").pop() || url,\n },\n });\n } else {\n parts.push({\n fileData: { mimeType: mediaType, fileUri: url },\n });\n }\n } else if (part.type === \"file\") {\n const mediaType =\n part.media_type ||\n mediaTypeFromDataUrl(part.file_data) ||\n \"application/pdf\";\n if (part.file_data) {\n parts.push({\n inlineData: {\n mimeType: mediaType,\n data: part.file_data.includes(\",\")\n ? part.file_data.split(\",\").pop()!\n : part.file_data,\n },\n });\n } else if (part.file_url) {\n parts.push({\n fileData: { mimeType: mediaType, fileUri: part.file_url },\n });\n }\n }\n }\n return parts;\n}\n\n/**\n * Chat Completions / Mistral: string-only tool content. Pull media out of\n * tool messages and insert a synthetic user message after each contiguous\n * tool-result group so vision still reaches the model.\n */\nexport function extractToolMediaForStringToolApis(messages: any[]): any[] {\n if (!Array.isArray(messages) || messages.length === 0) return messages;\n\n const out: any[] = [];\n let pendingMedia: any[] = [];\n\n const flushMedia = () => {\n if (pendingMedia.length === 0) return;\n out.push({\n role: \"user\",\n content: [\n { type: \"text\", text: SYNTHETIC_TOOL_MEDIA_PROMPT },\n ...pendingMedia,\n ],\n });\n pendingMedia = [];\n };\n\n for (const msg of messages) {\n if (msg?.role !== \"tool\") {\n flushMedia();\n out.push(msg);\n continue;\n }\n\n if (!unifiedToolHasMedia(msg.content)) {\n out.push(msg);\n continue;\n }\n\n const parts = normalizeUnifiedToolParts(msg.content);\n const text = parts\n .filter((p): p is Extract => p.type === \"text\")\n .map((p) => p.text)\n .filter(Boolean)\n .join(\"\\n\");\n out.push({ ...msg, content: text });\n\n for (const part of parts) {\n if (part.type === \"image_url\") {\n pendingMedia.push({\n type: \"image_url\",\n image_url: part.image_url,\n ...(part.media_type ? { media_type: part.media_type } : {}),\n });\n } else if (part.type === \"file\") {\n // Chat Completions has no portable file part. Image data-URLs can ride\n // as image_url; other files become a short notice (PDF bytes stay on\n // Responses/Anthropic/Gemini paths that understand documents).\n if (\n part.file_data?.startsWith(\"data:image/\") ||\n (part.media_type?.startsWith(\"image/\") && part.file_data)\n ) {\n pendingMedia.push({\n type: \"image_url\",\n image_url: { url: part.file_data! },\n media_type: part.media_type,\n });\n } else {\n pendingMedia.push({\n type: \"text\",\n text: `[Attached file${part.filename ? `: ${part.filename}` : \"\"}${\n part.media_type ? ` (${part.media_type})` : \"\"\n }${part.file_url ? `: ${part.file_url}` : \"\"}]`,\n });\n }\n }\n }\n }\n flushMedia();\n return out;\n}\n\nfunction mediaTypeFromDataUrl(dataUrl?: string): string | undefined {\n if (!dataUrl || !dataUrl.startsWith(\"data:\")) return undefined;\n return dataUrl.slice(5).split(\";\")[0] || undefined;\n}\n", "/**\n * Claude Code's bundled model capability catalog, revalidated against the\n * installed v2.1.280 CLI decompilation.\n *\n * Every model-dependent decision in the claude-auth impersonation path (beta\n * flags, effort support, thinking shape, max_tokens ceiling) is driven by\n * `capabilities` membership here, never by matching on the model name.\n */\nexport interface ClaudeModelCatalogEntry {\n /** Context window in tokens, or undefined when the model predates 1M-context routing. */\n window?: number;\n /** Router carries a native (unconditional) 1M-token context window. */\n nativeOneMillion: boolean;\n /** Model can opt into a 1M-token window via the context-1m-2025-08-07 beta. */\n supportsOneMillionBeta: boolean;\n /** Model id accepts an explicit \"[1m]\" wire suffix. */\n supportsOneMillionSuffix: boolean;\n maxOutputTokens: { default: number; upper: number };\n defaultEffort?: string;\n capabilities: string[];\n /**\n * CCR-owned Messages API request constraints. Not part of Claude Code's\n * catalog (Claude Code simply never sends these shapes); sourced from\n * Anthropic's per-model API documentation. Each flag names a request shape\n * the model rejects with HTTP 400, so third-party emulation must normalize\n * it away before sending.\n */\n apiConstraints?: {\n /** `thinking: {type: \"disabled\"}` is rejected; thinking is always on. */\n thinkingAlwaysOn?: boolean;\n /** Forced `tool_choice` (`any` / `tool`) is rejected. */\n noForcedToolChoice?: boolean;\n /** `temperature` / `top_p` / `top_k` are rejected. */\n noSamplingParams?: boolean;\n };\n}\n\nexport const CLAUDE_MODEL_CATALOG: Record = {\n \"claude-3-5-haiku\": {\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 8192, upper: 8192 },\n capabilities: [],\n },\n \"claude-haiku-4-5\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 64000 },\n capabilities: [\"context_management\"],\n },\n \"claude-3-5-sonnet\": {\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 8192, upper: 8192 },\n capabilities: [],\n },\n \"claude-3-7-sonnet\": {\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 32000, upper: 64000 },\n capabilities: [],\n },\n \"claude-sonnet-4-0\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 64000 },\n capabilities: [\"context_management\"],\n },\n \"claude-sonnet-4-5\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 64000 },\n capabilities: [\"context_management\"],\n },\n \"claude-sonnet-4-6\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 128000 },\n capabilities: [\"effort\", \"max_effort\", \"adaptive_thinking\", \"context_management\"],\n },\n \"claude-sonnet-5\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"mid_conv_system\",\n \"context_management\",\n ],\n apiConstraints: { noSamplingParams: true },\n },\n \"claude-opus-4-0\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 32000 },\n capabilities: [\"context_management\"],\n },\n \"claude-opus-4-1\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 32000 },\n capabilities: [\"context_management\"],\n },\n \"claude-opus-4-5\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: false,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 32000, upper: 64000 },\n capabilities: [\"context_management\"],\n },\n \"claude-opus-4-6\": {\n window: 200000,\n nativeOneMillion: false,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 64000, upper: 128000 },\n capabilities: [\"effort\", \"max_effort\", \"adaptive_thinking\", \"context_management\"],\n },\n \"claude-opus-4-7\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"xhigh\",\n capabilities: [\"effort\", \"max_effort\", \"xhigh_effort\", \"adaptive_thinking\", \"context_management\"],\n apiConstraints: { noSamplingParams: true },\n },\n \"claude-opus-4-8\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"context_management\",\n \"fast_mode\",\n \"lean_prompt\",\n ],\n apiConstraints: { noSamplingParams: true },\n },\n \"claude-opus-5\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"context_management\",\n \"thinking_disabled_effort_cap\",\n \"fast_mode\",\n \"lean_prompt\",\n \"refusal_fallback\",\n \"opus_5_prompt_bundle\",\n ],\n apiConstraints: { noSamplingParams: true },\n },\n \"claude-opus-5-5\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: true,\n maxOutputTokens: { default: 128000, upper: 128000 },\n defaultEffort: \"medium\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"rejects_disabled_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"per_turn_effort\",\n \"per_turn_timing\",\n \"context_management\",\n \"fast_mode\",\n \"lean_prompt\",\n \"refusal_fallback\",\n \"opus_5_5_prompt_bundle\",\n ],\n apiConstraints: {\n thinkingAlwaysOn: true,\n noForcedToolChoice: true,\n noSamplingParams: true,\n },\n },\n \"claude-fable-5-1\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"rejects_disabled_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"per_turn_effort\",\n \"per_turn_timing\",\n \"context_management\",\n \"lean_prompt\",\n \"fable_5_mitigations\",\n \"refusal_fallback\",\n \"fable_5_1_prompt_bundle\",\n ],\n apiConstraints: {\n thinkingAlwaysOn: true,\n noForcedToolChoice: true,\n noSamplingParams: true,\n },\n },\n \"claude-fable-5\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"rejects_disabled_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"context_management\",\n \"lean_prompt\",\n \"fable_5_mitigations\",\n \"refusal_fallback\",\n ],\n apiConstraints: { thinkingAlwaysOn: true, noSamplingParams: true },\n },\n \"claude-mythos-5\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 64000, upper: 128000 },\n capabilities: [],\n },\n \"claude-mythos-5-1\": {\n window: 1e6,\n nativeOneMillion: true,\n supportsOneMillionBeta: true,\n supportsOneMillionSuffix: false,\n maxOutputTokens: { default: 64000, upper: 128000 },\n defaultEffort: \"high\",\n capabilities: [\n \"effort\",\n \"max_effort\",\n \"xhigh_effort\",\n \"adaptive_thinking\",\n \"rejects_disabled_thinking\",\n \"mid_conv_system\",\n \"mid_conv_tool_change\",\n \"per_turn_timing\",\n \"context_management\",\n \"lean_prompt\",\n \"fable_5_mitigations\",\n \"fable_5_1_prompt_bundle\",\n ],\n apiConstraints: {\n thinkingAlwaysOn: true,\n noForcedToolChoice: true,\n noSamplingParams: true,\n },\n },\n};\n\n/** The literal wire marker CCR/Claude Code use to request a model's 1M-token context window. */\nconst ONE_MILLION_CONTEXT_MARKER = /\\[1m\\]$/i;\n\n/** Strip the \"[1m]\" wire marker, reporting whether it was present. */\nexport function stripOneMillionContextMarker(modelId: string | undefined): {\n modelId: string;\n requestedOneMillion: boolean;\n} {\n const raw = modelId || \"\";\n const requestedOneMillion = ONE_MILLION_CONTEXT_MARKER.test(raw);\n return { modelId: raw.replace(ONE_MILLION_CONTEXT_MARKER, \"\"), requestedOneMillion };\n}\n\n/**\n * Normalize a routed model id (CCR \"provider,model\" selector, an optional\n * \"[1m]\" marker, and Anthropic's dated model-id suffix) down to a catalog\n * key, e.g. \"anthropic,claude-opus-5-20260101[1m]\" -> \"claude-opus-5\".\n */\nexport function normalizeModelIdForCatalog(modelId: string | undefined): string {\n if (!modelId) return \"\";\n let id = modelId.trim();\n const commaIndex = id.indexOf(\",\");\n if (commaIndex >= 0) id = id.slice(commaIndex + 1);\n id = stripOneMillionContextMarker(id).modelId.trim();\n // Anthropic model ids carry a dated or \"@YYYYMMDD\" revision suffix that is\n // not part of the catalog's family key.\n id = id.replace(/[-@]\\d{8}$/, \"\");\n return id.toLowerCase();\n}\n\n/** Look up a model's catalog entry. Unknown models resolve to undefined (minimal capability set). */\nexport function lookupClaudeModelCatalogEntry(\n modelId: string | undefined\n): ClaudeModelCatalogEntry | undefined {\n const key = normalizeModelIdForCatalog(modelId);\n if (!key) return undefined;\n return CLAUDE_MODEL_CATALOG[key];\n}\n\nexport function catalogEntryHasCapability(\n entry: ClaudeModelCatalogEntry | undefined,\n capability: string\n): boolean {\n return entry?.capabilities.includes(capability) ?? false;\n}\n\n/**\n * Whether extended-thinking betas apply to this model. The catalog has no\n * dedicated \"supports_thinking\" column, but every entry that predates the\n * Claude 4 thinking generation (claude-3-5-haiku, claude-3-5-sonnet,\n * claude-3-7-sonnet) \u2014 plus the not-yet-classified claude-mythos-5 \u2014 carries\n * an empty capability set; every thinking-capable model carries at least\n * \"context_management\". A non-empty capability set is therefore a reliable,\n * self-documenting proxy that also degrades unknown models to \"no thinking\"\n * rather than guessing.\n */\nexport function catalogEntrySupportsThinking(\n entry: ClaudeModelCatalogEntry | undefined\n): boolean {\n return (entry?.capabilities.length ?? 0) > 0;\n}\n", "import { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport { createApiError } from \"@/api/middleware\";\nimport { Transformer } from \"@/types/transformer\";\nimport { UnifiedChatRequest } from \"@/types/llm\";\nimport {\n extractAndRemoveClaudeCodeSubagentModelTag,\n inspectClaudeCodeBillingSystemHeader,\n router,\n} from \"@/utils/router\";\nimport {\n applyThirdPartyAnthropicPolicy,\n classifyAnthropicClient,\n getAnthropicProviderMode,\n inspectAnthropicClientFingerprint,\n isNativeAnthropicClient,\n} from \"@/utils/anthropic-client-policy\";\nimport {\n adaptClientRequest,\n cloneProtocolBody,\n normalizeClientToUnified,\n shouldBypassTransformersProtocolAware,\n} from \"./protocol-adapter\";\nimport {\n ClientProtocolContext,\n matchClientProtocol,\n ProtocolRouteMatch,\n} from \"./protocol-endpoints\";\nimport { protocolErrorBody } from \"./protocol-errors\";\nimport { stripOneMillionContextMarker } from \"@/utils/claude-model-catalog\";\nimport { decodeClaudeModelAlias } from \"@caeliq/ccr-shared\";\nimport { ensureRequestLatency, markLatency } from \"@/utils/request-latency\";\nimport { applyReasoningAutoSummary } from \"@/utils/reasoning-effort\";\nimport { extractClientSessionId } from \"@/utils/cacheControl\";\nimport { detectNestedAgent } from \"@/utils/nested-agent\";\n\nexport interface PreparedInboundRequest {\n match: ProtocolRouteMatch;\n protocolContext: ClientProtocolContext;\n /** Original client wire body (preserved for Anthropic custom routers). */\n originalBody: any;\n /** Client wire body after protocol adaptation and CCR-only cleanup. */\n clientWireBody: any;\n /** Normalized Unified body used for routing and provider conversion. */\n unifiedBody: UnifiedChatRequest;\n /**\n * Unified projection before destination-specific Anthropic emulation.\n * Only cloned when global fallback is configured; otherwise undefined so\n * fallback can fall back to `unifiedBody`.\n */\n prePolicyUnifiedBody?: UnifiedChatRequest;\n providerName: string;\n modelName: string;\n}\n\n/**\n * Stages 1\u20137 of the canonical inbound lifecycle:\n * detect \u2192 adapt \u2192 normalize \u2192 route \u2192 validate destination.\n */\nexport async function prepareInboundRequest(\n req: FastifyRequest,\n reply: FastifyReply,\n fastify: FastifyInstance,\n endpointTransformer: Transformer,\n routePath: string\n): Promise {\n const pathname =\n (req as any).pathname ||\n String(req.url || routePath).split(\"?\")[0] ||\n routePath;\n\n const match =\n (req as any).protocolMatch ||\n matchClientProtocol(req.method, pathname) ||\n matchClientProtocol(\"POST\", routePath);\n\n if (!match) {\n throw createApiError(\n `No inbound protocol match for ${pathname}`,\n 404,\n \"protocol_not_found\"\n );\n }\n\n // Set protocol identity before adaptation/normalization. Those stages can\n // throw validation errors, and the global error handler needs this value to\n // serialize the client protocol's envelope.\n (req as any).protocolMatch = match;\n (req as any).clientProtocol = match.protocol;\n\n if (match.ownerTransformerName !== endpointTransformer.name) {\n req.log?.warn?.(\n {\n expected: match.ownerTransformerName,\n actual: endpointTransformer.name,\n path: pathname,\n },\n \"endpoint transformer name differs from protocol owner\"\n );\n }\n\n const originalBody = req.body;\n const query = (req.query || {}) as Record;\n const { normalizationInput, context } = adaptClientRequest(\n match,\n originalBody,\n query\n );\n\n // Capture conversation id from the original client wire before Unified drops\n // Anthropic metadata. Never use harness version / system text.\n (req as any).protocolContext = context;\n const sessionId = extractClientSessionId({\n body: originalBody,\n headers: req.headers,\n });\n if (sessionId) {\n context.sessionId = sessionId;\n (req as any).sessionId = sessionId;\n }\n\n if (match.protocol === \"anthropic_messages\") {\n context.anthropicClientKind = classifyAnthropicClient(\n req.headers as Record,\n normalizationInput\n );\n req.log?.debug?.(\n {\n anthropicClientKind: context.anthropicClientKind,\n anthropicClientSignals: inspectAnthropicClientFingerprint(\n req.headers as Record,\n normalizationInput\n ),\n },\n \"classified Anthropic client\"\n );\n await prepareAnthropicNormalizationInput(\n normalizationInput,\n context\n );\n } else {\n // OpenAI protocols have no native Anthropic wire identity. If routed to an\n // in-scope Anthropic destination they must use the third-party emulation\n // profile, never native pass-through.\n context.anthropicClientKind = \"other\";\n }\n\n context.nestedAgent = detectNestedAgent({\n headers: req.headers,\n body: originalBody,\n claudeCodeSubagent: context.claudeCodeSubagent,\n });\n\n const transformerContext = {\n req,\n signal: undefined,\n clientProtocol: match.protocol,\n protocolContext: context,\n };\n\n const unifiedBody = await normalizeClientToUnified(\n match.protocol,\n normalizationInput,\n endpointTransformer,\n transformerContext\n );\n markLatency(ensureRequestLatency(req as any), \"normalized\");\n\n\n // Opt-in readable thinking for every client \u2192 provider direction: stamp\n // Unified reasoning.summary so Responses/Codex/Anthropic/Gemini outbound\n // can request visible thought text when the client only sent effort.\n applyReasoningAutoSummary(\n unifiedBody,\n fastify.configService.get(\"REASONING_AUTO_SUMMARY\")\n );\n\n unifiedBody.model = resolveConfiguredClaudeModelAlias(\n unifiedBody.model,\n (canonicalId) =>\n fastify.providerService.resolveModelRoute(canonicalId) !== null,\n match.protocol\n ) || \"\";\n\n const routingReq = req as any;\n (req as any).protocolContext = context;\n (req as any).unifiedBody = unifiedBody;\n (req as any).originalClientBody = originalBody;\n\n // Built-in routing consumes canonical Unified. Legacy Anthropic custom routers\n // still observe the immutable original wire body and can read req.unifiedBody.\n const customRouterPath = fastify.configService.get(\"CUSTOM_ROUTER_PATH\");\n const previousBody = routingReq.body;\n routingReq.body =\n match.protocol === \"anthropic_messages\" && customRouterPath\n ? originalBody\n : unifiedBody;\n\n try {\n await router(routingReq, reply, {\n configService: fastify.configService,\n tokenizerService: fastify.tokenizerService,\n });\n } finally {\n routingReq.body = previousBody ?? originalBody;\n }\n\n const routedModel =\n typeof unifiedBody.model === \"string\"\n ? unifiedBody.model\n : context.originalModel;\n unifiedBody.model =\n resolveConfiguredClaudeModelAlias(\n routedModel,\n (canonicalId) =>\n fastify.providerService.resolveModelRoute(canonicalId) !== null,\n match.protocol\n ) || \"\";\n context.scenarioType = routingReq.scenarioType;\n context.originalModel =\n context.originalModel ??\n (typeof (originalBody as any)?.model === \"string\"\n ? (originalBody as any).model\n : undefined);\n\n routingReq.unifiedBody = unifiedBody;\n routingReq.protocolContext = context;\n\n const destination = resolveDestination(unifiedBody.model, match.protocol);\n const normalizedContextModel = stripOneMillionContextMarker(\n destination.modelName\n );\n destination.modelName = normalizedContextModel.modelId;\n context.requestedOneMillion = normalizedContextModel.requestedOneMillion;\n const provider = fastify.providerService.getProvider(destination.providerName);\n if (!provider) {\n throwProtocolError(\n match.protocol,\n `Provider '${destination.providerName}' not found`,\n 404,\n \"provider_not_found\"\n );\n }\n\n unifiedBody.model = destination.modelName;\n routingReq.provider = destination.providerName;\n routingReq.model = destination.modelName;\n // Clone only when fallback may need an unmutated pre-policy snapshot.\n const prePolicyUnifiedBody = hasConfiguredFallback(fastify)\n ? cloneProtocolBody(unifiedBody)\n : undefined;\n const providerMode = getAnthropicProviderMode(provider);\n context.anthropicProviderMode = providerMode;\n context.anthropicDestinationInScope =\n providerMode !== \"out_of_scope\";\n context.anthropicNativeWire =\n match.protocol === \"anthropic_messages\" &&\n context.anthropicDestinationInScope &&\n isNativeAnthropicClient(context.anthropicClientKind || \"other\");\n\n if (\n context.anthropicDestinationInScope &&\n context.anthropicClientKind === \"other\"\n ) {\n await applyThirdPartyAnthropicPolicy(\n unifiedBody,\n context,\n fastify.configService\n );\n }\n\n context.stream =\n context.stream ||\n unifiedBody.stream === true ||\n (originalBody as any)?.stream === true;\n\n return {\n match,\n protocolContext: context,\n originalBody,\n clientWireBody: normalizationInput,\n unifiedBody,\n prePolicyUnifiedBody,\n providerName: destination.providerName,\n modelName: destination.modelName,\n };\n}\n\nasync function prepareAnthropicNormalizationInput(\n body: any,\n context: ClientProtocolContext\n): Promise {\n const billing = inspectClaudeCodeBillingSystemHeader(body);\n context.claudeCodeSubagent = billing.isSubagent;\n context.taggedSubagentModel =\n extractAndRemoveClaudeCodeSubagentModelTag(body);\n}\n\nexport function resolveDestination(\n model: string | undefined,\n protocol?: ClientProtocolContext[\"protocol\"]\n): { providerName: string; modelName: string } {\n const trimmed = typeof model === \"string\" ? model.trim() : \"\";\n if (!trimmed) {\n throwProtocolError(\n protocol,\n \"Missing model. Configure Router.default or send provider,model.\",\n 400,\n \"missing_model\",\n \"invalid_request_error\"\n );\n }\n if (!trimmed.includes(\",\")) {\n throwProtocolError(\n protocol,\n `Unresolved bare model '${trimmed}'. Configure Router.default or send provider,model.`,\n 400,\n \"unresolved_model\",\n \"invalid_request_error\"\n );\n }\n const [providerName, ...modelParts] = trimmed.split(\",\");\n const modelName = modelParts.join(\",\");\n if (!providerName || !modelName) {\n throwProtocolError(\n protocol,\n `Invalid model '${trimmed}'. Expected provider,model.`,\n 400,\n \"invalid_model\",\n \"invalid_request_error\"\n );\n }\n return { providerName, modelName };\n}\n\n/**\n * Decode a discovery alias before scenario routing. Aliases are constrained to\n * configured canonical routes; ordinary `provider,model` ids are unchanged.\n */\nexport function resolveConfiguredClaudeModelAlias(\n model: string | undefined,\n isConfigured: (canonicalId: string) => boolean,\n protocol?: ClientProtocolContext[\"protocol\"]\n): string | undefined {\n if (typeof model !== \"string\") return model;\n const decoded = decodeClaudeModelAlias(model);\n if (!decoded) return model;\n\n const canonicalId = stripOneMillionContextMarker(decoded).modelId;\n if (!isConfigured(canonicalId)) {\n throwProtocolError(\n protocol,\n `Encoded model alias resolves to an unconfigured model '${canonicalId}'.`,\n 404,\n \"model_not_found\",\n \"invalid_request_error\"\n );\n }\n return decoded;\n}\n\nexport function throwProtocolError(\n protocol: ClientProtocolContext[\"protocol\"] | undefined,\n message: string,\n statusCode: number,\n code: string,\n type: string = \"api_error\"\n): never {\n const shaped = protocolErrorBody(protocol, message, statusCode, code, type);\n const err = createApiError(message, shaped.statusCode, code, type);\n (err as any).protocolBody = shaped.body;\n throw err;\n}\n\nexport function protocolAwareBypass(\n provider: any,\n transformer: Transformer,\n protocolContext: ClientProtocolContext | undefined,\n modelName: string | undefined\n): boolean {\n if (!protocolContext) {\n return (\n provider.transformer?.use?.length === 1 &&\n provider.transformer.use[0].name === transformer.name &&\n (!provider.transformer?.[modelName || \"\"]?.use?.length ||\n (provider.transformer?.[modelName || \"\"]?.use.length === 1 &&\n provider.transformer?.[modelName || \"\"]?.use[0].name ===\n transformer.name))\n );\n }\n return shouldBypassTransformersProtocolAware(\n provider,\n transformer,\n protocolContext.protocol,\n modelName\n );\n}\n\n/** True when any Router/top-level fallback scenario has a non-empty model list. */\nfunction hasConfiguredFallback(fastify: FastifyInstance): boolean {\n const router = fastify.configService.get(\"Router\") as\n | { fallback?: Record }\n | undefined;\n const fallback =\n (router?.fallback as Record | undefined) ??\n (fastify.configService.get(\"fallback\") as\n | Record\n | undefined);\n if (!fallback || typeof fallback !== \"object\") return false;\n return Object.values(fallback).some(\n (value) => Array.isArray(value) && value.length > 0\n );\n}\n", "import type { FastifyInstance, FastifyReply, FastifyRequest } from \"fastify\";\nimport { Readable } from \"stream\";\nimport { createApiError } from \"@/api/middleware\";\nimport { sendUnifiedRequest } from \"@/utils/request\";\nimport {\n CLIENT_DISCONNECT_REASON,\n createClientDisconnectSignal,\n isClientAbortError,\n isFallbackEligibleError,\n isResponseSocketGone,\n retryDelayAfterFailure,\n selectFallbackModels,\n toClientAbortError,\n delay,\n} from \"@/utils/retry\";\nimport {\n attachLatencyMeta,\n emitLatencyRecord,\n ensureRequestLatency,\n markLatency,\n} from \"@/utils/request-latency\";\nimport { withSSEClientKeepalive } from \"@/utils/sse/client-keepalive\";\nimport { withChatCompletionsDoneBoundary } from \"@/utils/sse/done-boundary\";\nimport {\n canonicalizeOutboundHeaders,\n mergeHeadersCaseInsensitive,\n selectSafeDownstreamHeaders,\n} from \"@/utils/headers\";\nimport { resolveDestination } from \"@/routing/inbound-pipeline\";\nimport {\n createClientProtocolContext,\n matchClientProtocol,\n type ProtocolRouteMatch,\n} from \"@/routing/protocol-endpoints\";\nimport { normalizeModelSelector } from \"@/utils/router\";\nimport {\n V1_FIM_INBOUND_KIND,\n inboundToUnifiedFim,\n isFimProviderTransformerName,\n normalizeFimSseDataPayload,\n encodeFimResponseForInbound,\n outboundFamilyFromTransformerName,\n type UnifiedFimRequest,\n type FimInboundKind,\n} from \"@/utils/fim\";\nimport type { Transformer } from \"@/types/transformer\";\n\nfunction resolveFimRouteModel(\n clientModel: string,\n configService: { get: (key: string) => any }\n): { model: string; scenarioType: \"fim\" } {\n const trimmed =\n typeof clientModel === \"string\" ? clientModel.trim() : \"\";\n const normalized = normalizeModelSelector(trimmed) || trimmed;\n\n if (normalized.includes(\",\")) {\n return { model: normalized, scenarioType: \"fim\" };\n }\n\n const Router = configService.get(\"Router\") || {};\n const destination =\n (typeof Router.fim === \"string\" && Router.fim.trim()) ||\n (typeof Router.default === \"string\" && Router.default.trim()) ||\n \"\";\n\n if (!destination) {\n throw createApiError(\n \"Missing FIM model. Configure Router.fim or send provider,model.\",\n 400,\n \"missing_model\",\n \"invalid_request_error\"\n );\n }\n\n const destNorm = normalizeModelSelector(destination) || destination;\n if (!destNorm.includes(\",\")) {\n throw createApiError(\n `Router.fim must be provider,model (got '${destination}').`,\n 400,\n \"invalid_model\",\n \"invalid_request_error\"\n );\n }\n return { model: destNorm, scenarioType: \"fim\" };\n}\n\nfunction findFimOutboundTransformer(provider: any): {\n transformer: Transformer;\n family: NonNullable>;\n} {\n const use = provider?.transformer?.use;\n if (!Array.isArray(use) || use.length === 0) {\n throw createApiError(\n `Provider '${provider?.name}' has no fim.* transformer. Configure transformer.use with fim.mistral, fim.deepseek, or fim.qwen.`,\n 400,\n \"fim_transformer_required\",\n \"invalid_request_error\"\n );\n }\n\n const nonFim = use.filter(\n (t: Transformer) => !isFimProviderTransformerName(t?.name)\n );\n if (nonFim.length > 0) {\n const names = nonFim.map((t: Transformer) => t?.name || \"\").join(\", \");\n throw createApiError(\n `FIM provider '${provider?.name}' must not stack chat transformers with fim.* (found: ${names}). Use a dedicated FIM provider entry.`,\n 400,\n \"fim_transformer_conflict\",\n \"invalid_request_error\"\n );\n }\n\n const fimTransforms = use.filter((t: Transformer) =>\n isFimProviderTransformerName(t?.name)\n );\n if (fimTransforms.length === 0) {\n throw createApiError(\n `Provider '${provider?.name}' has no fim.* transformer.`,\n 400,\n \"fim_transformer_required\",\n \"invalid_request_error\"\n );\n }\n\n const primary = fimTransforms[0];\n const family = outboundFamilyFromTransformerName(primary.name);\n if (!family) {\n throw createApiError(\n `Unknown FIM transformer '${primary.name}'.`,\n 400,\n \"fim_transformer_unknown\",\n \"invalid_request_error\"\n );\n }\n return { transformer: primary, family };\n}\n\nasync function reshapeFimResponseForClient(\n response: Response,\n inboundKind: FimInboundKind,\n passthrough: boolean\n): Promise {\n // Same-kind: upstream already speaks inbound wire \u2014 leave body alone.\n if (!response.ok || passthrough) {\n return response;\n }\n\n // Cross-family: encode upstream \u2192 inbound client wire (v1: mistral).\n const contentType = response.headers.get(\"Content-Type\") || \"\";\n if (contentType.includes(\"text/event-stream\") && response.body) {\n const reader = response.body.getReader();\n const decoder = new TextDecoder();\n const encoder = new TextEncoder();\n let buffer = \"\";\n const stream = new ReadableStream({\n async pull(controller) {\n const { done, value } = await reader.read();\n if (done) {\n if (buffer.trim().length) {\n const trailing = buffer.startsWith(\"data: \")\n ? `data: ${normalizeFimSseDataPayload(buffer.slice(6), inboundKind)}\\n`\n : buffer;\n controller.enqueue(encoder.encode(trailing));\n }\n controller.close();\n return;\n }\n buffer += decoder.decode(value, { stream: true });\n const lines = buffer.split(\"\\n\");\n buffer = lines.pop() || \"\";\n for (const line of lines) {\n if (line.startsWith(\"data: \")) {\n const data = line.slice(6);\n const normalized = normalizeFimSseDataPayload(data, inboundKind);\n controller.enqueue(encoder.encode(`data: ${normalized}\\n`));\n } else {\n controller.enqueue(encoder.encode(`${line}\\n`));\n }\n }\n },\n cancel() {\n reader.cancel().catch(() => {});\n },\n });\n return new Response(stream, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n }\n\n const raw = await response.text();\n try {\n const json = JSON.parse(raw);\n const normalized = encodeFimResponseForInbound(json, inboundKind);\n return new Response(JSON.stringify(normalized), {\n status: response.status,\n statusText: response.statusText,\n headers: { \"Content-Type\": \"application/json\" },\n });\n } catch {\n return new Response(raw, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n }\n}\n\nasync function formatFimResponse(\n response: Response,\n reply: FastifyReply,\n stream: boolean,\n clientSignal?: AbortSignal\n) {\n if (!response.ok) {\n reply.code(response.status);\n }\n\n for (const [name, value] of Object.entries(\n selectSafeDownstreamHeaders(response.headers)\n )) {\n reply.header(name, value);\n }\n\n if (stream && response.ok && response.body) {\n const framed = withChatCompletionsDoneBoundary(response.body);\n const keptAlive = withSSEClientKeepalive(framed);\n const nodeStream = Readable.fromWeb(keptAlive as any);\n const socketGone = isResponseSocketGone(reply);\n let cleanedUp = false;\n const cleanup = () => {\n if (cleanedUp) return;\n cleanedUp = true;\n try {\n if (!nodeStream.destroyed) nodeStream.destroy();\n } catch {\n // ignore\n }\n };\n if (clientSignal) {\n clientSignal.addEventListener(\"abort\", cleanup, { once: true });\n }\n if (socketGone) {\n cleanup();\n if (!reply.sent) {\n return reply.code(499).send({\n error: {\n message: \"Client closed request\",\n type: \"api_error\",\n code: \"client_aborted\",\n },\n });\n }\n return;\n }\n reply.header(\"Content-Type\", \"text/event-stream\");\n reply.header(\"Cache-Control\", \"no-cache\");\n reply.header(\"Connection\", \"keep-alive\");\n return reply.send(nodeStream);\n }\n\n const text = await response.text();\n const ct = response.headers.get(\"Content-Type\") || \"application/json\";\n reply.type(ct);\n try {\n return reply.send(JSON.parse(text));\n } catch {\n return reply.send(text);\n }\n}\n\nasync function dispatchFimOnce(\n req: FastifyRequest,\n fastify: FastifyInstance,\n provider: any,\n unified: UnifiedFimRequest,\n clientBody: any,\n clientSignal: AbortSignal,\n inboundKind: FimInboundKind = V1_FIM_INBOUND_KIND\n): Promise<{ response: Response; passthrough: boolean }> {\n const { transformer } = findFimOutboundTransformer(provider);\n const context = {\n req,\n provider,\n signal: clientSignal,\n fimInboundKind: inboundKind,\n fimClientBody: clientBody,\n unifiedFim: unified,\n clientProtocol: \"openai_fim_completions\",\n };\n\n if (typeof transformer.transformRequestIn !== \"function\") {\n throw createApiError(\n `FIM transformer '${transformer.name}' missing transformRequestIn`,\n 500,\n \"transformer_misconfigured\"\n );\n }\n\n const out = await transformer.transformRequestIn(\n unified as any,\n provider,\n context as any\n );\n\n let requestBody = out;\n let config: Record = {};\n if (out && typeof out === \"object\" && \"body\" in out) {\n requestBody = (out as any).body;\n config = { ...((out as any).config || {}) };\n }\n\n const passthrough = Boolean(config.__fimPassthrough);\n delete config.__fimPassthrough;\n\n const url = config.url || provider.baseUrl;\n const headers = canonicalizeOutboundHeaders(\n mergeHeadersCaseInsensitive(\n {\n \"Content-Type\": \"application/json\",\n },\n config.headers || {}\n )\n );\n\n const httpsProxy =\n fastify.configService.get(\"HTTPS_PROXY\") ||\n process.env.HTTPS_PROXY ||\n process.env.https_proxy;\n\n const response = await sendUnifiedRequest(\n url,\n requestBody as any,\n {\n ...config,\n headers,\n signal: clientSignal,\n httpsProxy,\n TIMEOUT: fastify.configService.get(\"TIMEOUT\"),\n },\n { req }\n );\n\n if (typeof transformer.transformResponseOut === \"function\") {\n const shaped = await transformer.transformResponseOut(response, context as any);\n return {\n response: await reshapeFimResponseForClient(\n shaped,\n inboundKind,\n passthrough\n ),\n passthrough,\n };\n }\n\n return {\n response: await reshapeFimResponseForClient(\n response,\n inboundKind,\n passthrough\n ),\n passthrough,\n };\n}\n\n/**\n * Dedicated FIM pipeline \u2014 does not call prepareInboundRequest / chat Unified.\n */\nexport async function handleFimEndpoint(\n req: FastifyRequest,\n reply: FastifyReply,\n fastify: FastifyInstance,\n _ownerTransformer: Transformer,\n routePath: string\n) {\n const disconnect = createClientDisconnectSignal(req, reply);\n const clientSignal = disconnect.signal;\n disconnect.arm();\n const latency = ensureRequestLatency(req as any);\n markLatency(latency, \"bodyParsed\");\n\n const pathname = (req as any).pathname || routePath;\n const match: ProtocolRouteMatch | null =\n (req as any).protocolMatch ||\n matchClientProtocol(req.method, pathname);\n\n if (!match || match.protocol !== \"openai_fim_completions\") {\n throw createApiError(\n \"Not a FIM protocol route\",\n 500,\n \"protocol_mismatch\"\n );\n }\n\n const originalBody = req.body;\n const inboundKind: FimInboundKind = V1_FIM_INBOUND_KIND;\n let unified: UnifiedFimRequest;\n try {\n unified = inboundToUnifiedFim(originalBody, inboundKind);\n } catch (error: any) {\n attachLatencyMeta(latency, { error: error?.message || String(error) });\n emitLatencyRecord(req.log, latency);\n throw error;\n }\n\n const routed = resolveFimRouteModel(\n unified.model,\n fastify.configService\n );\n (req as any).scenarioType = routed.scenarioType;\n\n const { providerName, modelName } = resolveDestination(\n routed.model,\n \"openai_fim_completions\"\n );\n unified = { ...unified, model: modelName };\n\n const protocolContext = createClientProtocolContext(match, {\n originalModel:\n typeof (originalBody as any)?.model === \"string\"\n ? (originalBody as any).model\n : undefined,\n stream: unified.stream === true,\n scenarioType: \"fim\",\n });\n (req as any).protocolContext = protocolContext;\n (req as any).clientProtocol = \"openai_fim_completions\";\n\n markLatency(latency, \"destinationPolicy\");\n\n const tryProviders: Array<{ providerName: string; modelName: string }> = [\n { providerName, modelName },\n ];\n\n const fallbackConfig = fastify.configService.get(\"fallback\");\n const fallbackList = selectFallbackModels(fallbackConfig, \"fim\");\n if (Array.isArray(fallbackList)) {\n for (const entry of fallbackList) {\n const norm = normalizeModelSelector(String(entry)) || String(entry);\n if (!norm.includes(\",\")) continue;\n const [p, ...rest] = norm.split(\",\");\n const m = rest.join(\",\");\n if (p && m && !(p === providerName && m === modelName)) {\n tryProviders.push({ providerName: p, modelName: m });\n }\n }\n }\n\n let lastError: any;\n for (let i = 0; i < tryProviders.length; i++) {\n const dest = tryProviders[i];\n const provider = fastify.providerService.getProvider(dest.providerName);\n if (!provider) {\n lastError = createApiError(\n `Provider '${dest.providerName}' not found`,\n 404,\n \"provider_not_found\"\n );\n continue;\n }\n\n const attemptUnified: UnifiedFimRequest = {\n ...unified,\n model: dest.modelName,\n };\n\n attachLatencyMeta(latency, {\n protocol: \"openai_fim_completions\",\n provider: dest.providerName,\n model: dest.modelName,\n scenario: \"fim\",\n });\n\n try {\n const { response } = await dispatchFimOnce(\n req,\n fastify,\n provider,\n attemptUnified,\n originalBody,\n clientSignal,\n inboundKind\n );\n markLatency(latency, \"requestTransformers\");\n emitLatencyRecord(req.log, latency);\n return await formatFimResponse(\n response,\n reply,\n attemptUnified.stream === true,\n clientSignal\n );\n } catch (error: any) {\n lastError = error;\n if (isClientAbortError(error) || clientSignal.aborted) {\n throw typeof error === \"string\"\n ? toClientAbortError(error)\n : toClientAbortError(clientSignal.reason ?? error);\n }\n if (\n i < tryProviders.length - 1 &&\n isFallbackEligibleError(error)\n ) {\n await delay(retryDelayAfterFailure(i));\n continue;\n }\n attachLatencyMeta(latency, {\n error: error?.message || String(error),\n cancelled: clientSignal.aborted,\n });\n emitLatencyRecord(req.log, latency);\n throw error;\n }\n }\n\n attachLatencyMeta(latency, {\n error: lastError?.message || String(lastError),\n });\n emitLatencyRecord(req.log, latency);\n throw lastError || createApiError(\"FIM request failed\", 500, \"fim_failed\");\n}\n\n// Silence unused import warning if CLIENT_DISCONNECT_REASON unused\nvoid CLIENT_DISCONNECT_REASON;\n", "/**\n * FIM inbound/outbound family kinds. v1 only implements mistral/codestral\n * inbound; deepseek/qwen inbound adapters are reserved for later.\n */\n\nexport type FimInboundKind = \"mistral\" | \"deepseek\" | \"qwen\";\nexport type FimOutboundFamily = \"mistral\" | \"deepseek\" | \"qwen\";\n\n/** v1 hard-wired inbound kind (Codestral/Mistral-shaped client wire). */\nexport const V1_FIM_INBOUND_KIND: FimInboundKind = \"mistral\";\n\nexport function isFimProviderTransformerName(name: string | undefined): boolean {\n return typeof name === \"string\" && name.startsWith(\"fim.\");\n}\n\nexport function outboundFamilyFromTransformerName(\n name: string | undefined\n): FimOutboundFamily | null {\n if (name === \"fim.mistral\") return \"mistral\";\n if (name === \"fim.deepseek\") return \"deepseek\";\n if (name === \"fim.qwen\") return \"qwen\";\n return null;\n}\n\n/**\n * Same-kind passthrough: no request or response shape translation \u2014\n * auth/URL only. Kept generic so future DeepSeek\u2192DeepSeek / Qwen\u2192Qwen\n * inbound works the same.\n */\nexport function shouldFimPassthrough(\n inboundKind: FimInboundKind,\n outboundFamily: FimOutboundFamily\n): boolean {\n return inboundKind === outboundFamily;\n}\n", "import { createApiError } from \"@/api/middleware\";\nimport type { FimInboundKind } from \"./kinds\";\nimport { V1_FIM_INBOUND_KIND } from \"./kinds\";\nimport type { UnifiedFimRequest } from \"./types\";\n\n/**\n * Inbound \u2192 Unified FIM seam.\n * v1: only Codestral/Mistral kind. Future: inboundKind selects an adapter.\n */\nexport function inboundToUnifiedFim(\n body: unknown,\n inboundKind: FimInboundKind = V1_FIM_INBOUND_KIND\n): UnifiedFimRequest {\n if (inboundKind !== \"mistral\") {\n throw createApiError(\n `FIM inbound kind '${inboundKind}' is not implemented yet`,\n 501,\n \"fim_inbound_not_implemented\"\n );\n }\n return parseMistralCodestralInbound(body);\n}\n\nfunction parseMistralCodestralInbound(body: unknown): UnifiedFimRequest {\n if (!body || typeof body !== \"object\") {\n throw createApiError(\"Invalid FIM body\", 400, \"invalid_body\");\n }\n const raw = body as Record;\n if (typeof raw.prompt !== \"string\") {\n throw createApiError(\n \"FIM requires prompt (string)\",\n 400,\n \"invalid_body\",\n \"invalid_request_error\"\n );\n }\n if (typeof raw.model !== \"string\" || !raw.model.trim()) {\n throw createApiError(\n \"FIM requires model\",\n 400,\n \"invalid_body\",\n \"invalid_request_error\"\n );\n }\n\n const unified: UnifiedFimRequest = {\n model: raw.model.trim(),\n prompt: raw.prompt,\n };\n\n if (typeof raw.suffix === \"string\") {\n unified.suffix = raw.suffix;\n }\n if (typeof raw.max_tokens === \"number\") {\n unified.max_tokens = raw.max_tokens;\n }\n if (typeof raw.temperature === \"number\") {\n unified.temperature = raw.temperature;\n }\n if (typeof raw.top_p === \"number\") {\n unified.top_p = raw.top_p;\n }\n if (typeof raw.stream === \"boolean\") {\n unified.stream = raw.stream;\n }\n if (typeof raw.min_tokens === \"number\") {\n unified.min_tokens = raw.min_tokens;\n }\n if (typeof raw.random_seed === \"number\") {\n unified.random_seed = raw.random_seed;\n }\n if (typeof raw.stop === \"string\" || Array.isArray(raw.stop)) {\n unified.stop = raw.stop as string | string[];\n }\n\n return unified;\n}\n\n/** Clone client body for same-kind passthrough (preserve unknown fields). */\nexport function cloneFimClientBody(\n body: unknown,\n modelName: string\n): Record {\n const base =\n body && typeof body === \"object\"\n ? { ...(body as Record) }\n : {};\n base.model = modelName;\n return base;\n}\n", "/** Resolve Codestral/Mistral native FIM URL from provider base. */\nexport function resolveFimMistralUrl(baseUrl: string): URL {\n const url = new URL(baseUrl);\n const path = url.pathname.replace(/\\/$/, \"\") || \"\";\n if (path.endsWith(\"/fim/completions\")) {\n return url;\n }\n return new URL(\"/v1/fim/completions\", baseUrl);\n}\n\n/**\n * DeepSeek hosted FIM uses beta completions.\n * Prefer explicit \u2026/beta/completions; otherwise derive from host.\n */\nexport function resolveFimDeepseekUrl(baseUrl: string): URL {\n const url = new URL(baseUrl);\n const path = url.pathname.replace(/\\/$/, \"\") || \"\";\n if (path.endsWith(\"/completions\") && path.includes(\"/beta\")) {\n return url;\n }\n if (path.endsWith(\"/beta\") || path === \"/beta\") {\n url.pathname = `${path}/completions`.replace(/\\/+/g, \"/\");\n return url;\n }\n // Chat or bare origin \u2192 force beta completions on same host.\n return new URL(\"/beta/completions\", `${url.protocol}//${url.host}`);\n}\n\n/**\n * Qwen / LM Studio / DashScope: OpenAI legacy completions.\n * Trust api_base_url when it already ends with /completions.\n */\nexport function resolveFimQwenCompletionsUrl(baseUrl: string): URL {\n const url = new URL(baseUrl);\n const path = url.pathname.replace(/\\/$/, \"\") || \"\";\n if (path.endsWith(\"/completions\") && !path.endsWith(\"/chat/completions\")) {\n return url;\n }\n if (\n path.endsWith(\"/v1\") ||\n path.endsWith(\"/compatible-mode/v1\") ||\n /\\/compatible-mode\\/v1$/.test(path)\n ) {\n url.pathname = `${path}/completions`.replace(/\\/+/g, \"/\");\n return url;\n }\n return new URL(\"/v1/completions\", baseUrl);\n}\n\nexport function bearerAuthHeaders(\n apiKey: string | undefined\n): Record {\n if (!apiKey) return {};\n return { Authorization: `Bearer ${apiKey}` };\n}\n", "import type { UnifiedFimRequest } from \"./types\";\n\nconst DEEPSEEK_FIM_MAX_TOKENS = 4096;\n\n/** Qwen / HF FIM markers for completions prompt. */\nexport function buildQwenFimPrompt(prompt: string, suffix?: string): string {\n if (typeof suffix === \"string\") {\n return `<|fim_prefix|>${prompt}<|fim_suffix|>${suffix}<|fim_middle|>`;\n }\n return `<|fim_prefix|>${prompt}<|fim_suffix|>`;\n}\n\n/** Sampling fields shared across FIM outbound bodies. */\nexport function pickFimSamplingFields(\n unified: UnifiedFimRequest\n): Record {\n const out: Record