recoder-a2a-sdk 1.0.0

package/dist/chunk-MAA7JZ2Q.mjs

@@ -0,0 +1,142 @@
+import {
+  TaskStateEnum,
+  isTerminalState,
+  isValidTransition
+} from "./chunk-WLNW7Y2H.mjs";
+
+// src/state-mapping.ts
+var CODEX_TO_CANONICAL = {
+  queued: TaskStateEnum.Submitted,
+  running: TaskStateEnum.Working,
+  waiting_for_input: TaskStateEnum.InputRequired,
+  completed: TaskStateEnum.Completed,
+  failed: TaskStateEnum.Failed,
+  error: TaskStateEnum.Failed,
+  cancelled: TaskStateEnum.Cancelled,
+  timeout: TaskStateEnum.Failed
+};
+var CANONICAL_TO_CODEX = {
+  [TaskStateEnum.Submitted]: "queued",
+  [TaskStateEnum.Working]: "running",
+  [TaskStateEnum.InputRequired]: "waiting_for_input",
+  [TaskStateEnum.Completed]: "completed",
+  [TaskStateEnum.Failed]: "failed",
+  [TaskStateEnum.Cancelled]: "cancelled"
+};
+function mapCodexState(nativeState) {
+  return CODEX_TO_CANONICAL[nativeState];
+}
+function mapCodexStateStrict(nativeState) {
+  const mapped = mapCodexState(nativeState);
+  if (mapped === void 0) {
+    throw new Error(`Unknown Codex state: "${nativeState}"`);
+  }
+  return mapped;
+}
+function canonicalToCodexState(canonicalState) {
+  return CANONICAL_TO_CODEX[canonicalState];
+}
+var CLAUDE_TO_CANONICAL = {
+  pending: TaskStateEnum.Submitted,
+  streaming: TaskStateEnum.Working,
+  processing: TaskStateEnum.Working,
+  waiting_for_approval: TaskStateEnum.InputRequired,
+  waiting_for_input: TaskStateEnum.InputRequired,
+  done: TaskStateEnum.Completed,
+  completed: TaskStateEnum.Completed,
+  error: TaskStateEnum.Failed,
+  failed: TaskStateEnum.Failed,
+  aborted: TaskStateEnum.Cancelled,
+  cancelled: TaskStateEnum.Cancelled,
+  timeout: TaskStateEnum.Failed
+};
+var CANONICAL_TO_CLAUDE = {
+  [TaskStateEnum.Submitted]: "pending",
+  [TaskStateEnum.Working]: "streaming",
+  [TaskStateEnum.InputRequired]: "waiting_for_input",
+  [TaskStateEnum.Completed]: "done",
+  [TaskStateEnum.Failed]: "error",
+  [TaskStateEnum.Cancelled]: "aborted"
+};
+function mapClaudeState(nativeState) {
+  return CLAUDE_TO_CANONICAL[nativeState];
+}
+function mapClaudeStateStrict(nativeState) {
+  const mapped = mapClaudeState(nativeState);
+  if (mapped === void 0) {
+    throw new Error(`Unknown Claude Code state: "${nativeState}"`);
+  }
+  return mapped;
+}
+function canonicalToClaudeState(canonicalState) {
+  return CANONICAL_TO_CLAUDE[canonicalState];
+}
+function mapConnectorState(platform, nativeState) {
+  switch (platform) {
+    case "codex":
+      return mapCodexState(nativeState);
+    case "claude_code":
+      return mapClaudeState(nativeState);
+    default:
+      return void 0;
+  }
+}
+function mapConnectorStateStrict(platform, nativeState) {
+  const mapped = mapConnectorState(platform, nativeState);
+  if (mapped === void 0) {
+    throw new Error(
+      `Cannot map state "${nativeState}" for platform "${platform}"`
+    );
+  }
+  return mapped;
+}
+function canonicalToConnectorState(platform, canonicalState) {
+  switch (platform) {
+    case "codex":
+      return canonicalToCodexState(canonicalState);
+    case "claude_code":
+      return canonicalToClaudeState(canonicalState);
+    default:
+      return void 0;
+  }
+}
+function checkConnectorTransition(currentCanonical, platform, newNativeState) {
+  const mappedState = mapConnectorState(platform, newNativeState);
+  if (mappedState === void 0) {
+    return {
+      valid: false,
+      mappedState: void 0,
+      error: `Unknown ${platform} state: "${newNativeState}"`
+    };
+  }
+  if (mappedState === currentCanonical) {
+    return { valid: true, mappedState };
+  }
+  if (!isValidTransition(currentCanonical, mappedState)) {
+    return {
+      valid: false,
+      mappedState,
+      error: `Invalid transition: ${currentCanonical} -> ${mappedState} (from ${platform} state "${newNativeState}")`
+    };
+  }
+  return { valid: true, mappedState };
+}
+function isConnectorTerminalState(platform, nativeState) {
+  const mapped = mapConnectorState(platform, nativeState);
+  return mapped !== void 0 && isTerminalState(mapped);
+}
+
+export {
+  mapCodexState,
+  mapCodexStateStrict,
+  canonicalToCodexState,
+  mapClaudeState,
+  mapClaudeStateStrict,
+  canonicalToClaudeState,
+  mapConnectorState,
+  mapConnectorStateStrict,
+  canonicalToConnectorState,
+  checkConnectorTransition,
+  isConnectorTerminalState
+};
+//# sourceMappingURL=chunk-MAA7JZ2Q.mjs.map

package/dist/chunk-MAA7JZ2Q.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/state-mapping.ts"],"sourcesContent":["/**\n * @module state-mapping\n *\n * Task state mapping helpers for connector adapters.\n *\n * Each external connector (Codex, Claude Code, etc.) has its own native state\n * vocabulary. This module provides bidirectional mapping functions that\n * translate between connector-specific states and the canonical\n * `TaskState` enum defined in `@recoder/shared/a2a/schemas`.\n *\n * Adapter authors should use these mappers at the boundary where connector\n * events enter (or leave) the Recoder A2A control plane, ensuring that all\n * internal logic operates exclusively on canonical states.\n *\n * @example\n * ```ts\n * import { mapCodexState, mapClaudeState } from '@recoder/a2a-sdk/state-mapping';\n *\n * const canonical = mapCodexState('running');   // => 'working'\n * const claude    = mapClaudeState('streaming'); // => 'working'\n * ```\n */\n\nimport {\n  type TaskState,\n  TaskStateEnum,\n  isValidTransition,\n  isTerminalState,\n} from '@recoder/shared/a2a/schemas';\n\n// ---------------------------------------------------------------------------\n// Connector platform identifier\n// ---------------------------------------------------------------------------\n\n/** Supported connector platforms for state mapping. */\nexport type ConnectorPlatform = 'codex' | 'claude_code';\n\n// ---------------------------------------------------------------------------\n// Codex state mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Native states reported by the OpenAI Codex CLI / API adapter.\n * These are the raw status strings that appear in Codex task events.\n */\nexport type CodexNativeState =\n  | 'queued'\n  | 'running'\n  | 'waiting_for_input'\n  | 'completed'\n  | 'failed'\n  | 'error'\n  | 'cancelled'\n  | 'timeout';\n\n/**\n * Map from Codex native states to canonical TaskState values.\n * Every known Codex state must appear exactly once as a key.\n */\nconst CODEX_TO_CANONICAL: Readonly<Record<CodexNativeState, TaskState>> = {\n  queued: TaskStateEnum.Submitted,\n  running: TaskStateEnum.Working,\n  waiting_for_input: TaskStateEnum.InputRequired,\n  completed: TaskStateEnum.Completed,\n  failed: TaskStateEnum.Failed,\n  error: TaskStateEnum.Failed,\n  cancelled: TaskStateEnum.Cancelled,\n  timeout: TaskStateEnum.Failed,\n};\n\n/**\n * Reverse map from canonical TaskState to the \"primary\" Codex native state.\n * When multiple Codex states map to the same canonical state, the most\n * common / expected one is chosen as the primary reverse mapping.\n */\nconst CANONICAL_TO_CODEX: Readonly<Record<TaskState, CodexNativeState>> = {\n  [TaskStateEnum.Submitted]: 'queued',\n  [TaskStateEnum.Working]: 'running',\n  [TaskStateEnum.InputRequired]: 'waiting_for_input',\n  [TaskStateEnum.Completed]: 'completed',\n  [TaskStateEnum.Failed]: 'failed',\n  [TaskStateEnum.Cancelled]: 'cancelled',\n};\n\n/**\n * Map a Codex native state string to the canonical `TaskState`.\n *\n * @param nativeState - The raw state string from a Codex event.\n * @returns The canonical `TaskState`, or `undefined` if the state is unknown.\n */\nexport function mapCodexState(nativeState: string): TaskState | undefined {\n  return CODEX_TO_CANONICAL[nativeState as CodexNativeState];\n}\n\n/**\n * Map a Codex native state to canonical, throwing if the state is unknown.\n *\n * @param nativeState - The raw state string from a Codex event.\n * @returns The canonical `TaskState`.\n * @throws {Error} If the state cannot be mapped.\n */\nexport function mapCodexStateStrict(nativeState: string): TaskState {\n  const mapped = mapCodexState(nativeState);\n  if (mapped === undefined) {\n    throw new Error(`Unknown Codex state: \"${nativeState}\"`);\n  }\n  return mapped;\n}\n\n/**\n * Map a canonical `TaskState` back to the primary Codex native state.\n *\n * @param canonicalState - The canonical task state.\n * @returns The Codex native state string.\n */\nexport function canonicalToCodexState(canonicalState: TaskState): CodexNativeState {\n  return CANONICAL_TO_CODEX[canonicalState];\n}\n\n// ---------------------------------------------------------------------------\n// Claude Code state mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Native states reported by the Claude Code CLI / API adapter.\n * These are the raw status strings that appear in Claude Code events.\n */\nexport type ClaudeNativeState =\n  | 'pending'\n  | 'streaming'\n  | 'processing'\n  | 'waiting_for_approval'\n  | 'waiting_for_input'\n  | 'done'\n  | 'completed'\n  | 'error'\n  | 'failed'\n  | 'aborted'\n  | 'cancelled'\n  | 'timeout';\n\n/**\n * Map from Claude Code native states to canonical TaskState values.\n */\nconst CLAUDE_TO_CANONICAL: Readonly<Record<ClaudeNativeState, TaskState>> = {\n  pending: TaskStateEnum.Submitted,\n  streaming: TaskStateEnum.Working,\n  processing: TaskStateEnum.Working,\n  waiting_for_approval: TaskStateEnum.InputRequired,\n  waiting_for_input: TaskStateEnum.InputRequired,\n  done: TaskStateEnum.Completed,\n  completed: TaskStateEnum.Completed,\n  error: TaskStateEnum.Failed,\n  failed: TaskStateEnum.Failed,\n  aborted: TaskStateEnum.Cancelled,\n  cancelled: TaskStateEnum.Cancelled,\n  timeout: TaskStateEnum.Failed,\n};\n\n/**\n * Reverse map from canonical TaskState to the primary Claude Code native state.\n */\nconst CANONICAL_TO_CLAUDE: Readonly<Record<TaskState, ClaudeNativeState>> = {\n  [TaskStateEnum.Submitted]: 'pending',\n  [TaskStateEnum.Working]: 'streaming',\n  [TaskStateEnum.InputRequired]: 'waiting_for_input',\n  [TaskStateEnum.Completed]: 'done',\n  [TaskStateEnum.Failed]: 'error',\n  [TaskStateEnum.Cancelled]: 'aborted',\n};\n\n/**\n * Map a Claude Code native state string to the canonical `TaskState`.\n *\n * @param nativeState - The raw state string from a Claude Code event.\n * @returns The canonical `TaskState`, or `undefined` if the state is unknown.\n */\nexport function mapClaudeState(nativeState: string): TaskState | undefined {\n  return CLAUDE_TO_CANONICAL[nativeState as ClaudeNativeState];\n}\n\n/**\n * Map a Claude Code native state to canonical, throwing if the state is unknown.\n *\n * @param nativeState - The raw state string from a Claude Code event.\n * @returns The canonical `TaskState`.\n * @throws {Error} If the state cannot be mapped.\n */\nexport function mapClaudeStateStrict(nativeState: string): TaskState {\n  const mapped = mapClaudeState(nativeState);\n  if (mapped === undefined) {\n    throw new Error(`Unknown Claude Code state: \"${nativeState}\"`);\n  }\n  return mapped;\n}\n\n/**\n * Map a canonical `TaskState` back to the primary Claude Code native state.\n *\n * @param canonicalState - The canonical task state.\n * @returns The Claude Code native state string.\n */\nexport function canonicalToClaudeState(canonicalState: TaskState): ClaudeNativeState {\n  return CANONICAL_TO_CLAUDE[canonicalState];\n}\n\n// ---------------------------------------------------------------------------\n// Generic / platform-agnostic mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Map a native state from any supported connector to canonical `TaskState`.\n *\n * @param platform - The connector platform identifier.\n * @param nativeState - The raw state string from the connector.\n * @returns The canonical `TaskState`, or `undefined` if unmappable.\n */\nexport function mapConnectorState(\n  platform: ConnectorPlatform,\n  nativeState: string,\n): TaskState | undefined {\n  switch (platform) {\n    case 'codex':\n      return mapCodexState(nativeState);\n    case 'claude_code':\n      return mapClaudeState(nativeState);\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Map a native state from any supported connector to canonical `TaskState`,\n * throwing if the mapping fails.\n *\n * @param platform - The connector platform identifier.\n * @param nativeState - The raw state string from the connector.\n * @returns The canonical `TaskState`.\n * @throws {Error} If the platform or state is unknown.\n */\nexport function mapConnectorStateStrict(\n  platform: ConnectorPlatform,\n  nativeState: string,\n): TaskState {\n  const mapped = mapConnectorState(platform, nativeState);\n  if (mapped === undefined) {\n    throw new Error(\n      `Cannot map state \"${nativeState}\" for platform \"${platform}\"`,\n    );\n  }\n  return mapped;\n}\n\n/**\n * Map a canonical `TaskState` back to the primary native state for a given\n * connector platform.\n *\n * @param platform - The connector platform identifier.\n * @param canonicalState - The canonical task state.\n * @returns The native state string, or `undefined` if the platform is unknown.\n */\nexport function canonicalToConnectorState(\n  platform: ConnectorPlatform,\n  canonicalState: TaskState,\n): string | undefined {\n  switch (platform) {\n    case 'codex':\n      return canonicalToCodexState(canonicalState);\n    case 'claude_code':\n      return canonicalToClaudeState(canonicalState);\n    default:\n      return undefined;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Transition safety helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Given the current canonical state and a new native state from a connector,\n * determine whether the implied transition is valid according to the\n * canonical lifecycle rules.\n *\n * This is the main \"guard\" function that adapters should call before\n * applying a state update from a connector event.\n *\n * @param currentCanonical - The current canonical task state.\n * @param platform - The connector platform identifier.\n * @param newNativeState - The new native state reported by the connector.\n * @returns An object indicating whether the transition is valid, the mapped\n *          canonical state, and an error message if invalid.\n */\nexport function checkConnectorTransition(\n  currentCanonical: TaskState,\n  platform: ConnectorPlatform,\n  newNativeState: string,\n): {\n  valid: boolean;\n  mappedState: TaskState | undefined;\n  error?: string;\n} {\n  const mappedState = mapConnectorState(platform, newNativeState);\n\n  if (mappedState === undefined) {\n    return {\n      valid: false,\n      mappedState: undefined,\n      error: `Unknown ${platform} state: \"${newNativeState}\"`,\n    };\n  }\n\n  // Same state is a no-op, always valid\n  if (mappedState === currentCanonical) {\n    return { valid: true, mappedState };\n  }\n\n  if (!isValidTransition(currentCanonical, mappedState)) {\n    return {\n      valid: false,\n      mappedState,\n      error: `Invalid transition: ${currentCanonical} -> ${mappedState} (from ${platform} state \"${newNativeState}\")`,\n    };\n  }\n\n  return { valid: true, mappedState };\n}\n\n/**\n * Check whether a connector-reported native state maps to a terminal\n * canonical state.\n *\n * @param platform - The connector platform identifier.\n * @param nativeState - The native state to check.\n * @returns `true` if the mapped canonical state is terminal; `false` if\n *          non-terminal or unmappable.\n */\nexport function isConnectorTerminalState(\n  platform: ConnectorPlatform,\n  nativeState: string,\n): boolean {\n  const mapped = mapConnectorState(platform, nativeState);\n  return mapped !== undefined && isTerminalState(mapped);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-QVOOBAUA.mjs

@@ -0,0 +1,140 @@
+// src/error-mapping.ts
+import {
+  A2AErrorCodeEnum,
+  buildA2AError
+} from "@recoder/shared/a2a/schemas";
+var CODEX_ERROR_MAP = {
+  timeout: A2AErrorCodeEnum.ConnectorTimeout,
+  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,
+  quota_exceeded: A2AErrorCodeEnum.QuotaExceeded,
+  auth_error: A2AErrorCodeEnum.AuthenticationFailed,
+  connection_error: A2AErrorCodeEnum.NetworkError,
+  invalid_request: A2AErrorCodeEnum.InvalidPayload,
+  execution_error: A2AErrorCodeEnum.TaskExecutionFailed,
+  model_error: A2AErrorCodeEnum.ConnectorError,
+  internal_error: A2AErrorCodeEnum.InternalError,
+  cancelled: A2AErrorCodeEnum.TaskCancelled
+};
+function mapCodexError(input) {
+  const code = CODEX_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;
+  return buildA2AError({
+    code,
+    message: input.message,
+    details: {
+      ...input.details,
+      connector_platform: "codex",
+      original_error_type: input.type,
+      ...input.statusCode !== void 0 ? { status_code: input.statusCode } : {}
+    },
+    trace_id: input.traceId
+  });
+}
+var CLAUDE_ERROR_MAP = {
+  overloaded: A2AErrorCodeEnum.ConnectorUnavailable,
+  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,
+  authentication_error: A2AErrorCodeEnum.AuthenticationFailed,
+  permission_error: A2AErrorCodeEnum.AuthorizationDenied,
+  invalid_request: A2AErrorCodeEnum.InvalidPayload,
+  api_error: A2AErrorCodeEnum.ConnectorError,
+  timeout: A2AErrorCodeEnum.ConnectorTimeout,
+  connection_error: A2AErrorCodeEnum.NetworkError,
+  tool_execution_error: A2AErrorCodeEnum.TaskExecutionFailed,
+  context_length_exceeded: A2AErrorCodeEnum.QuotaExceeded,
+  cancelled: A2AErrorCodeEnum.TaskCancelled,
+  aborted: A2AErrorCodeEnum.TaskCancelled
+};
+function mapClaudeError(input) {
+  const code = CLAUDE_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;
+  return buildA2AError({
+    code,
+    message: input.message,
+    details: {
+      ...input.details,
+      connector_platform: "claude_code",
+      original_error_type: input.type,
+      ...input.statusCode !== void 0 ? { status_code: input.statusCode } : {}
+    },
+    trace_id: input.traceId
+  });
+}
+var HTTP_STATUS_MAP = {
+  400: A2AErrorCodeEnum.InvalidPayload,
+  401: A2AErrorCodeEnum.AuthenticationFailed,
+  403: A2AErrorCodeEnum.AuthorizationDenied,
+  404: A2AErrorCodeEnum.ConnectorNotFound,
+  408: A2AErrorCodeEnum.ConnectorTimeout,
+  409: A2AErrorCodeEnum.InvalidStateTransition,
+  422: A2AErrorCodeEnum.InvalidEnvelope,
+  429: A2AErrorCodeEnum.RateLimitExceeded,
+  500: A2AErrorCodeEnum.InternalError,
+  502: A2AErrorCodeEnum.NetworkError,
+  503: A2AErrorCodeEnum.ConnectorUnavailable,
+  504: A2AErrorCodeEnum.ConnectorTimeout
+};
+function mapHttpError(statusCode, message, options) {
+  const code = HTTP_STATUS_MAP[statusCode] ?? A2AErrorCodeEnum.UnexpectedStatus;
+  return buildA2AError({
+    code,
+    message,
+    details: {
+      ...options?.details,
+      http_status: statusCode,
+      ...options?.platform ? { connector_platform: options.platform } : {}
+    },
+    trace_id: options?.traceId
+  });
+}
+function mapConnectorError(input) {
+  switch (input.platform) {
+    case "codex":
+      return mapCodexError(input);
+    case "claude_code":
+      return mapClaudeError(input);
+    default:
+      if (input.statusCode !== void 0) {
+        return mapHttpError(input.statusCode, input.message, {
+          traceId: input.traceId,
+          details: { ...input.details, original_error_type: input.type },
+          platform: input.platform
+        });
+      }
+      return buildA2AError({
+        code: A2AErrorCodeEnum.ConnectorError,
+        message: input.message,
+        details: {
+          ...input.details,
+          connector_platform: input.platform,
+          original_error_type: input.type
+        },
+        trace_id: input.traceId
+      });
+  }
+}
+function wrapUnknownError(err, options) {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+  const details = {};
+  if (options?.platform) {
+    details.connector_platform = options.platform;
+  }
+  if (err instanceof Error) {
+    details.error_name = err.name;
+    if (err.stack) {
+      details.stack_preview = err.stack.split("\n").slice(0, 3).join("\n");
+    }
+  }
+  return buildA2AError({
+    code: A2AErrorCodeEnum.InternalError,
+    message,
+    details,
+    trace_id: options?.traceId
+  });
+}
+
+export {
+  mapCodexError,
+  mapClaudeError,
+  mapHttpError,
+  mapConnectorError,
+  wrapUnknownError
+};
+//# sourceMappingURL=chunk-QVOOBAUA.mjs.map

package/dist/chunk-QVOOBAUA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/error-mapping.ts"],"sourcesContent":["/**\n * @module error-mapping\n *\n * Error mapping helpers for connector adapters.\n *\n * Each connector may report errors in its own format (HTTP status codes,\n * vendor-specific error objects, raw exceptions). This module provides\n * functions that normalize those heterogeneous error shapes into canonical\n * `A2AError` instances using the error taxonomy from\n * `@recoder/shared/a2a/schemas`.\n *\n * Adapter authors should call these mappers at the boundary where connector\n * errors are caught, so that all upstream logic can operate on a uniform\n * error type.\n *\n * @example\n * ```ts\n * import { mapCodexError, mapClaudeError, mapHttpError } from '@recoder/a2a-sdk/error-mapping';\n *\n * const a2aError = mapCodexError({ type: 'timeout', message: 'Codex timed out' });\n * const httpError = mapHttpError(503, 'Service Unavailable');\n * ```\n */\n\nimport {\n  type A2AError,\n  type A2AErrorCode,\n  A2AErrorCodeEnum,\n  buildA2AError,\n} from '@recoder/shared/a2a/schemas';\n\nimport type { ConnectorPlatform } from './state-mapping';\n\n// ---------------------------------------------------------------------------\n// Codex error mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Shape of an error object emitted by the Codex adapter.\n * This is a normalized representation -- the actual wire format may vary,\n * and adapter code should transform the raw error into this shape before\n * calling `mapCodexError`.\n */\nexport interface CodexErrorInput {\n  /** Codex-specific error type string. */\n  type:\n    | 'timeout'\n    | 'rate_limit'\n    | 'quota_exceeded'\n    | 'auth_error'\n    | 'connection_error'\n    | 'invalid_request'\n    | 'execution_error'\n    | 'model_error'\n    | 'internal_error'\n    | 'cancelled'\n    | string;\n  /** Human-readable error message from Codex. */\n  message: string;\n  /** Optional HTTP status code (if the error originated from an HTTP call). */\n  statusCode?: number;\n  /** Optional raw details from the Codex API response. */\n  details?: Record<string, unknown>;\n  /** Optional trace ID for correlation. */\n  traceId?: string;\n}\n\n/**\n * Map from Codex error type strings to canonical A2A error codes.\n */\nconst CODEX_ERROR_MAP: Readonly<Record<string, A2AErrorCode>> = {\n  timeout: A2AErrorCodeEnum.ConnectorTimeout,\n  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,\n  quota_exceeded: A2AErrorCodeEnum.QuotaExceeded,\n  auth_error: A2AErrorCodeEnum.AuthenticationFailed,\n  connection_error: A2AErrorCodeEnum.NetworkError,\n  invalid_request: A2AErrorCodeEnum.InvalidPayload,\n  execution_error: A2AErrorCodeEnum.TaskExecutionFailed,\n  model_error: A2AErrorCodeEnum.ConnectorError,\n  internal_error: A2AErrorCodeEnum.InternalError,\n  cancelled: A2AErrorCodeEnum.TaskCancelled,\n};\n\n/**\n * Map a Codex adapter error to a canonical `A2AError`.\n *\n * @param input - The normalized Codex error.\n * @returns A canonical `A2AError`.\n */\nexport function mapCodexError(input: CodexErrorInput): A2AError {\n  const code = CODEX_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;\n  return buildA2AError({\n    code,\n    message: input.message,\n    details: {\n      ...input.details,\n      connector_platform: 'codex' as const,\n      original_error_type: input.type,\n      ...(input.statusCode !== undefined ? { status_code: input.statusCode } : {}),\n    },\n    trace_id: input.traceId,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Claude Code error mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Shape of an error object emitted by the Claude Code adapter.\n */\nexport interface ClaudeErrorInput {\n  /** Claude-specific error type string. */\n  type:\n    | 'overloaded'\n    | 'rate_limit'\n    | 'authentication_error'\n    | 'permission_error'\n    | 'invalid_request'\n    | 'api_error'\n    | 'timeout'\n    | 'connection_error'\n    | 'tool_execution_error'\n    | 'context_length_exceeded'\n    | 'cancelled'\n    | 'aborted'\n    | string;\n  /** Human-readable error message from Claude. */\n  message: string;\n  /** Optional HTTP status code. */\n  statusCode?: number;\n  /** Optional raw details from the Claude API response. */\n  details?: Record<string, unknown>;\n  /** Optional trace ID for correlation. */\n  traceId?: string;\n}\n\n/**\n * Map from Claude Code error type strings to canonical A2A error codes.\n */\nconst CLAUDE_ERROR_MAP: Readonly<Record<string, A2AErrorCode>> = {\n  overloaded: A2AErrorCodeEnum.ConnectorUnavailable,\n  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,\n  authentication_error: A2AErrorCodeEnum.AuthenticationFailed,\n  permission_error: A2AErrorCodeEnum.AuthorizationDenied,\n  invalid_request: A2AErrorCodeEnum.InvalidPayload,\n  api_error: A2AErrorCodeEnum.ConnectorError,\n  timeout: A2AErrorCodeEnum.ConnectorTimeout,\n  connection_error: A2AErrorCodeEnum.NetworkError,\n  tool_execution_error: A2AErrorCodeEnum.TaskExecutionFailed,\n  context_length_exceeded: A2AErrorCodeEnum.QuotaExceeded,\n  cancelled: A2AErrorCodeEnum.TaskCancelled,\n  aborted: A2AErrorCodeEnum.TaskCancelled,\n};\n\n/**\n * Map a Claude Code adapter error to a canonical `A2AError`.\n *\n * @param input - The normalized Claude Code error.\n * @returns A canonical `A2AError`.\n */\nexport function mapClaudeError(input: ClaudeErrorInput): A2AError {\n  const code = CLAUDE_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;\n  return buildA2AError({\n    code,\n    message: input.message,\n    details: {\n      ...input.details,\n      connector_platform: 'claude_code' as const,\n      original_error_type: input.type,\n      ...(input.statusCode !== undefined ? { status_code: input.statusCode } : {}),\n    },\n    trace_id: input.traceId,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// HTTP error mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Map from common HTTP status codes to canonical A2A error codes.\n */\nconst HTTP_STATUS_MAP: Readonly<Record<number, A2AErrorCode>> = {\n  400: A2AErrorCodeEnum.InvalidPayload,\n  401: A2AErrorCodeEnum.AuthenticationFailed,\n  403: A2AErrorCodeEnum.AuthorizationDenied,\n  404: A2AErrorCodeEnum.ConnectorNotFound,\n  408: A2AErrorCodeEnum.ConnectorTimeout,\n  409: A2AErrorCodeEnum.InvalidStateTransition,\n  422: A2AErrorCodeEnum.InvalidEnvelope,\n  429: A2AErrorCodeEnum.RateLimitExceeded,\n  500: A2AErrorCodeEnum.InternalError,\n  502: A2AErrorCodeEnum.NetworkError,\n  503: A2AErrorCodeEnum.ConnectorUnavailable,\n  504: A2AErrorCodeEnum.ConnectorTimeout,\n};\n\n/**\n * Map an HTTP status code and message to a canonical `A2AError`.\n *\n * Useful for connector adapters that communicate with external services\n * over HTTP/REST and need to normalize HTTP error responses.\n *\n * @param statusCode - The HTTP response status code.\n * @param message - Human-readable error message (e.g. from the response body).\n * @param options - Optional trace ID and additional details.\n * @returns A canonical `A2AError`.\n */\nexport function mapHttpError(\n  statusCode: number,\n  message: string,\n  options?: {\n    traceId?: string;\n    details?: Record<string, unknown>;\n    platform?: ConnectorPlatform;\n  },\n): A2AError {\n  const code = HTTP_STATUS_MAP[statusCode] ?? A2AErrorCodeEnum.UnexpectedStatus;\n  return buildA2AError({\n    code,\n    message,\n    details: {\n      ...options?.details,\n      http_status: statusCode,\n      ...(options?.platform ? { connector_platform: options.platform } : {}),\n    },\n    trace_id: options?.traceId,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Generic connector error mapping\n// ---------------------------------------------------------------------------\n\n/**\n * Generic connector error input that works with any platform.\n */\nexport interface ConnectorErrorInput {\n  /** The connector platform. */\n  platform: ConnectorPlatform;\n  /** Connector-specific error type string. */\n  type: string;\n  /** Human-readable error message. */\n  message: string;\n  /** Optional HTTP status code. */\n  statusCode?: number;\n  /** Optional raw details. */\n  details?: Record<string, unknown>;\n  /** Optional trace ID. */\n  traceId?: string;\n}\n\n/**\n * Map a generic connector error to a canonical `A2AError`, dispatching\n * to the appropriate platform-specific mapper.\n *\n * @param input - The connector error input.\n * @returns A canonical `A2AError`.\n */\nexport function mapConnectorError(input: ConnectorErrorInput): A2AError {\n  switch (input.platform) {\n    case 'codex':\n      return mapCodexError(input);\n    case 'claude_code':\n      return mapClaudeError(input);\n    default:\n      // Fallback: use the HTTP mapper if we have a status code, otherwise generic\n      if (input.statusCode !== undefined) {\n        return mapHttpError(input.statusCode, input.message, {\n          traceId: input.traceId,\n          details: { ...input.details, original_error_type: input.type },\n          platform: input.platform,\n        });\n      }\n      return buildA2AError({\n        code: A2AErrorCodeEnum.ConnectorError,\n        message: input.message,\n        details: {\n          ...input.details,\n          connector_platform: input.platform,\n          original_error_type: input.type,\n        },\n        trace_id: input.traceId,\n      });\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Exception wrapping\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap a caught JavaScript Error (or unknown) into a canonical `A2AError`.\n *\n * This is a last-resort mapper for unstructured exceptions that escape\n * the connector adapter. Prefer using the typed mappers above whenever\n * possible.\n *\n * @param err - The caught error.\n * @param options - Optional context: platform, trace ID.\n * @returns A canonical `A2AError`.\n */\nexport function wrapUnknownError(\n  err: unknown,\n  options?: {\n    platform?: ConnectorPlatform;\n    traceId?: string;\n  },\n): A2AError {\n  const message =\n    err instanceof Error ? err.message : typeof err === 'string' ? err : 'Unknown error';\n\n  const details: Record<string, unknown> = {};\n  if (options?.platform) {\n    details.connector_platform = options.platform;\n  }\n  if (err instanceof Error) {\n    details.error_name = err.name;\n    if (err.stack) {\n      details.stack_preview = err.stack.split('\\n').slice(0, 3).join('\\n');\n    }\n  }\n\n  return buildA2AError({\n    code: A2AErrorCodeEnum.InternalError,\n    message,\n    details,\n    trace_id: options?.traceId,\n  });\n}\n"],"mappings":"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","names":[]}