{"version":3,"file":"error_translation-Bkz-bl27.mjs","names":[],"sources":["../node_modules/.pnpm/@anthropic-ai+sdk@0.115.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/internal/errors.mjs","../node_modules/.pnpm/@anthropic-ai+sdk@0.115.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/core/error.mjs","../src/batteries/llm/anthropic_messages/error_translation.ts"],"sourcesContent":["// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.\nexport function isAbortError(err) {\n    return (typeof err === 'object' &&\n        err !== null &&\n        // Spec-compliant fetch implementations\n        (('name' in err && err.name === 'AbortError') ||\n            // Expo fetch\n            ('message' in err && String(err.message).includes('FetchRequestCanceledException'))));\n}\nexport const castToError = (err) => {\n    if (err instanceof Error)\n        return err;\n    if (typeof err === 'object' && err !== null) {\n        try {\n            if (Object.prototype.toString.call(err) === '[object Error]') {\n                // @ts-ignore - not all envs have native support for cause yet\n                const error = new Error(err.message, err.cause ? { cause: err.cause } : {});\n                if (err.stack)\n                    error.stack = err.stack;\n                // @ts-ignore - not all envs have native support for cause yet\n                if (err.cause && !error.cause)\n                    error.cause = err.cause;\n                if (err.name)\n                    error.name = err.name;\n                return error;\n            }\n        }\n        catch { }\n        try {\n            return new Error(JSON.stringify(err));\n        }\n        catch { }\n    }\n    return new Error(err);\n};\n//# sourceMappingURL=errors.mjs.map","// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.\nimport { castToError } from \"../internal/errors.mjs\";\nexport class AnthropicError extends Error {\n}\nexport class APIError extends AnthropicError {\n    constructor(status, error, message, headers, type) {\n        super(`${APIError.makeMessage(status, error, message)}`);\n        this.status = status;\n        this.headers = headers;\n        this.requestID = headers?.get('request-id');\n        this.error = error;\n        this.type = type ?? null;\n    }\n    static makeMessage(status, error, message) {\n        const msg = error?.message ?\n            typeof error.message === 'string' ?\n                error.message\n                : JSON.stringify(error.message)\n            : error ? JSON.stringify(error)\n                : message;\n        if (status && msg) {\n            return `${status} ${msg}`;\n        }\n        if (status) {\n            return `${status} status code (no body)`;\n        }\n        if (msg) {\n            return msg;\n        }\n        return '(no status code or body)';\n    }\n    static generate(status, errorResponse, message, headers) {\n        if (!status || !headers) {\n            return new APIConnectionError({ message, cause: castToError(errorResponse) });\n        }\n        const error = errorResponse;\n        const type = error?.['error']?.['type'];\n        if (status === 400) {\n            return new BadRequestError(status, error, message, headers, type);\n        }\n        if (status === 401) {\n            return new AuthenticationError(status, error, message, headers, type);\n        }\n        if (status === 403) {\n            return new PermissionDeniedError(status, error, message, headers, type);\n        }\n        if (status === 404) {\n            return new NotFoundError(status, error, message, headers, type);\n        }\n        if (status === 409) {\n            return new ConflictError(status, error, message, headers, type);\n        }\n        if (status === 422) {\n            return new UnprocessableEntityError(status, error, message, headers, type);\n        }\n        if (status === 429) {\n            return new RateLimitError(status, error, message, headers, type);\n        }\n        if (status >= 500) {\n            return new InternalServerError(status, error, message, headers, type);\n        }\n        return new APIError(status, error, message, headers, type);\n    }\n}\nexport class APIUserAbortError extends APIError {\n    constructor({ message } = {}) {\n        super(undefined, undefined, message || 'Request was aborted.', undefined);\n    }\n}\nexport class APIConnectionError extends APIError {\n    constructor({ message, cause }) {\n        super(undefined, undefined, message || 'Connection error.', undefined);\n        // in some environments the 'cause' property is already declared\n        // @ts-ignore\n        if (cause)\n            this.cause = cause;\n    }\n}\nexport class APIConnectionTimeoutError extends APIConnectionError {\n    constructor({ message } = {}) {\n        super({ message: message ?? 'Request timed out.' });\n    }\n}\n/**\n * An error that opts into the SDK's retry policy: throw it (e.g. from\n * middleware) to have the attempt retried.\n *\n * Note that the request will only be retried when `maxRetries` has not been exhausted.\n */\nexport class RetryableError extends AnthropicError {\n    constructor(message, { cause } = {}) {\n        super(message ?? 'Retryable error.');\n        // in some environments the 'cause' property is already declared\n        // @ts-ignore\n        if (cause !== undefined)\n            this.cause = cause;\n    }\n}\nexport class BadRequestError extends APIError {\n}\nexport class AuthenticationError extends APIError {\n}\nexport class PermissionDeniedError extends APIError {\n}\nexport class NotFoundError extends APIError {\n}\nexport class ConflictError extends APIError {\n}\nexport class UnprocessableEntityError extends APIError {\n}\nexport class RateLimitError extends APIError {\n}\nexport class InternalServerError extends APIError {\n}\n//# sourceMappingURL=error.mjs.map","/**\n * SDK error → ADK classification for the Anthropic Messages battery.\n *\n * @remarks\n * Extracted so the dispatch path (`adapter.ts`) and the token-count path (`count_tokens.ts`) share\n * ONE classifier. They previously carried byte-identical private copies, which meant a fix to one\n * silently left the other wrong — exactly what happened with the statusless-`APIError` bug this\n * module's {@link AnthropicMessagesErrorStatusResolver} seam addresses.\n *\n * @module @nhtio/adk/batteries/llm/anthropic_messages/error_translation\n */\n\nimport { isObject, isError, isInstanceOf } from '@nhtio/adk/guards'\nimport {\n  APIError,\n  AnthropicError,\n  APIConnectionError,\n  APIUserAbortError,\n  APIConnectionTimeoutError,\n} from '@anthropic-ai/sdk/core/error'\nimport type { AnthropicMessagesErrorStatusResolver } from './types'\n\n/**\n * Body-text marker identifying an Anthropic context-overflow rejection.\n *\n * @remarks\n * Context overflow arrives as a 400 `BadRequestError` and is detected from body TEXT, not status —\n * the status alone cannot distinguish it from any other bad request.\n */\nexport const CONTEXT_OVERFLOW_PHRASE = 'prompt is too long'\n\n/**\n * The outcome of classifying an SDK error.\n */\nexport type AnthropicErrorClassification =\n  | { kind: 'abort' }\n  | { kind: 'timeout' }\n  | { kind: 'context-overflow'; message: string }\n  | { kind: 'retriable'; status: number; message: string }\n  | { kind: 'fatal'; status: number; message: string }\n\n/**\n * Apply a consumer-supplied status resolver, defending against every way it can misbehave.\n *\n * @param resolver - The consumer hook, or `undefined` when none was configured.\n * @param input - The error, its body text, and the SDK-reported status.\n * @param warn - Optional sink for a one-line diagnostic when the resolver misbehaves.\n * @returns The resolved status, or `undefined` to leave the SDK status in force.\n */\nconst applyStatusResolver = (\n  resolver: AnthropicMessagesErrorStatusResolver | undefined,\n  input: { error: unknown; bodyText: string; sdkStatus: number },\n  warn?: (msg: string) => void\n): number | undefined => {\n  if (resolver === undefined) return undefined\n  // The warn SINK is consumer-supplied too, so it can throw just like the resolver. Every\n  // diagnostic emitted from this helper goes through here: a logger fault must never become the\n  // failure the caller sees, which would replace a real, reportable upstream error with an\n  // unrelated one from the diagnostic path.\n  const safeWarn = (msg: string): void => {\n    try {\n      warn?.(msg)\n    } catch {\n      // Nothing useful to do — the channel for reporting problems is itself the problem.\n    }\n  }\n  let resolved: number | undefined\n  try {\n    resolved = resolver(input)\n  } catch (err) {\n    // `String(err)` can throw in its own right (a hostile `toString`/`Symbol.toPrimitive`), so the\n    // message is built inside this catch rather than passed out of it.\n    let detail: string\n    try {\n      detail = isError(err) ? err.message : String(err)\n    } catch {\n      detail = '<uncoercible thrown value>'\n    }\n    safeWarn(`resolveErrorStatus threw and was ignored: ${detail}`)\n    return undefined\n  }\n  if (resolved === undefined) return undefined\n  if (typeof resolved !== 'number' || !Number.isInteger(resolved)) {\n    let shown: string\n    try {\n      shown = String(resolved)\n    } catch {\n      shown = '<uncoercible>'\n    }\n    safeWarn(`resolveErrorStatus returned a non-integer (${shown}); ignoring it.`)\n    return undefined\n  }\n  if (resolved < 100 || resolved > 599) {\n    safeWarn(`resolveErrorStatus returned ${resolved}, outside 100-599; ignoring it.`)\n    return undefined\n  }\n  return resolved\n}\n\n/**\n * Classify an error thrown by the Anthropic SDK into an ADK disposition.\n *\n * @remarks\n * Ordering is deliberate. Abort and timeout are checked first because they are control-flow\n * outcomes rather than failures. `APIConnectionError` is retriable at status `0` — a transport\n * fault has no HTTP status and never will, and that branch establishes the convention that a\n * statusless error can still be retriable.\n *\n * For an `APIError`, the consumer's `resolveErrorStatus` hook (when configured) runs BEFORE both\n * the context-overflow check and retriable classification, so a recovered status participates in\n * every downstream decision and is what gets reported — a recovered `529` surfaces as `529`, not\n * `0`. Without a resolver the behaviour is unchanged from before the hook existed: a statusless\n * `APIError` coerces to `0`, matches no retriable status, and is fatal.\n *\n * @param err - The thrown value.\n * @param retriableStatuses - Status codes configured as retriable.\n * @param opts - Optional status resolver and warning sink.\n * @returns The classification.\n */\nexport const translateAnthropicError = (\n  err: unknown,\n  retriableStatuses: ReadonlyArray<number>,\n  opts?: {\n    resolveErrorStatus?: AnthropicMessagesErrorStatusResolver\n    warn?: (msg: string) => void\n  }\n): AnthropicErrorClassification => {\n  if (isInstanceOf(err, 'APIUserAbortError', APIUserAbortError)) return { kind: 'abort' }\n  if (isInstanceOf(err, 'APIConnectionTimeoutError', APIConnectionTimeoutError)) {\n    return { kind: 'timeout' }\n  }\n  if (isInstanceOf(err, 'APIConnectionError', APIConnectionError)) {\n    return { kind: 'retriable', status: 0, message: err.message }\n  }\n  if (isInstanceOf(err, 'APIError', APIError)) {\n    const sdkStatus = typeof err.status === 'number' ? err.status : 0\n    const bodyText = isObject(err.error) ? JSON.stringify(err.error) : String(err.error ?? '')\n    const status =\n      applyStatusResolver(\n        opts?.resolveErrorStatus,\n        { error: err, bodyText, sdkStatus },\n        opts?.warn\n      ) ?? sdkStatus\n    if (status === 400 && bodyText.toLowerCase().includes(CONTEXT_OVERFLOW_PHRASE)) {\n      return { kind: 'context-overflow', message: bodyText }\n    }\n    if (retriableStatuses.includes(status)) {\n      return { kind: 'retriable', status, message: bodyText || err.message }\n    }\n    return { kind: 'fatal', status, message: bodyText || err.message }\n  }\n  const message = isError(err) ? err.message : String(err)\n  if (isInstanceOf(err, 'AnthropicError', AnthropicError)) {\n    return { kind: 'fatal', status: 0, message }\n  }\n  return { kind: 'fatal', status: 0, message }\n}\n"],"x_google_ignoreList":[0,1],"mappings":"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"}