octoflow-core 1.0.0

package/dist/adapters/transport/push-notifications.js

@@ -0,0 +1,103 @@
+import { RpcFailure } from "./jsonrpc-wire.js";
+import { A2A_RPC_ERROR_CODES } from "./rpc-errors.js";
+import { toA2ATask } from "./wire.js";
+const CHECKPOINT_PREFIX = "a2a:push-notification:";
+const DEFAULT_CONFIG_ID = "default";
+function pushNotificationConfigId(config) {
+  return config.id ?? DEFAULT_CONFIG_ID;
+}
+async function setTaskPushNotificationConfig(store, config) {
+  const normalized = normalizeTaskPushNotificationConfig(config);
+  await store.putCheckpoint(
+    checkpointKey(
+      normalized.taskId,
+      pushNotificationConfigId(normalized.pushNotificationConfig)
+    ),
+    JSON.stringify(normalized)
+  );
+  return normalized;
+}
+async function getTaskPushNotificationConfig(store, params) {
+  const taskId = params.taskId ?? params.id;
+  if (!taskId) {
+    throw new RpcFailure(400, -32602, "taskId is required");
+  }
+  const configId = params.taskId ? params.id ?? params.configId : params.configId;
+  const data = await store.getCheckpoint(
+    checkpointKey(taskId, configId ?? DEFAULT_CONFIG_ID)
+  );
+  if (!data) {
+    throw new RpcFailure(
+      404,
+      A2A_RPC_ERROR_CODES.TASK_NOT_FOUND,
+      "Push notification config not found"
+    );
+  }
+  return JSON.parse(data);
+}
+async function notifyTaskPushNotifications(store, task, options = {}) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") return;
+  const keys = await store.listCheckpoints(`${CHECKPOINT_PREFIX}${task.id}:`);
+  await Promise.all(
+    keys.map(async (key) => {
+      const data = await store.getCheckpoint(key);
+      if (!data) return;
+      const config = JSON.parse(data);
+      await postTaskNotification(fetchImpl, config, task);
+    })
+  );
+}
+function normalizeTaskPushNotificationConfig(input) {
+  if (!input.taskId) {
+    throw new RpcFailure(400, -32602, "taskId is required");
+  }
+  if (!input.pushNotificationConfig?.url) {
+    throw new RpcFailure(400, -32602, "pushNotificationConfig.url is required");
+  }
+  return {
+    taskId: input.taskId,
+    pushNotificationConfig: {
+      ...input.pushNotificationConfig,
+      id: pushNotificationConfigId(input.pushNotificationConfig)
+    }
+  };
+}
+function checkpointKey(taskId, configId) {
+  return `${CHECKPOINT_PREFIX}${taskId}:${configId}`;
+}
+async function postTaskNotification(fetchImpl, config, task) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.pushNotificationConfig.token) {
+    headers["X-A2A-Notification-Token"] = config.pushNotificationConfig.token;
+  }
+  const auth = config.pushNotificationConfig.authentication;
+  if (auth?.credentials && auth.schemes.some((scheme) => scheme.toLowerCase() === "bearer")) {
+    headers.Authorization = `Bearer ${auth.credentials}`;
+  }
+  const response = await fetchImpl(config.pushNotificationConfig.url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      task: toA2ATask(task),
+      taskId: task.id,
+      pushNotificationConfigId: pushNotificationConfigId(
+        config.pushNotificationConfig
+      )
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `A2A push notification failed: ${response.status} ${response.statusText}`
+    );
+  }
+}
+export {
+  getTaskPushNotificationConfig,
+  notifyTaskPushNotifications,
+  pushNotificationConfigId,
+  setTaskPushNotificationConfig
+};
+//# sourceMappingURL=push-notifications.js.map

package/dist/adapters/transport/push-notifications.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/adapters/transport/push-notifications.ts"],
+  "sourcesContent": ["import type { Task } from '../../domain/core-task.js';\nimport type { TaskStore } from '../data/task-store/index.js';\nimport { RpcFailure } from './jsonrpc-wire.js';\nimport { A2A_RPC_ERROR_CODES } from './rpc-errors.js';\nimport { toA2ATask } from './wire.js';\nimport type {\n  A2APushNotificationConfig,\n  A2ATaskPushNotificationConfig,\n} from './wire-types.js';\n\nexport interface A2APushNotificationDeliveryOptions {\n  fetch?: typeof globalThis.fetch;\n}\n\nconst CHECKPOINT_PREFIX = 'a2a:push-notification:';\nconst DEFAULT_CONFIG_ID = 'default';\n\nexport function pushNotificationConfigId(\n  config: A2APushNotificationConfig\n): string {\n  return config.id ?? DEFAULT_CONFIG_ID;\n}\n\nexport async function setTaskPushNotificationConfig(\n  store: TaskStore,\n  config: A2ATaskPushNotificationConfig\n): Promise<A2ATaskPushNotificationConfig> {\n  const normalized = normalizeTaskPushNotificationConfig(config);\n  await store.putCheckpoint(\n    checkpointKey(\n      normalized.taskId,\n      pushNotificationConfigId(normalized.pushNotificationConfig)\n    ),\n    JSON.stringify(normalized)\n  );\n  return normalized;\n}\n\nexport async function getTaskPushNotificationConfig(\n  store: TaskStore,\n  params: { configId?: string; id?: string; taskId?: string }\n): Promise<A2ATaskPushNotificationConfig> {\n  const taskId = params.taskId ?? params.id;\n  if (!taskId) {\n    throw new RpcFailure(400, -32602, 'taskId is required');\n  }\n  const configId = params.taskId\n    ? (params.id ?? params.configId)\n    : params.configId;\n  const data = await store.getCheckpoint(\n    checkpointKey(taskId, configId ?? DEFAULT_CONFIG_ID)\n  );\n  if (!data) {\n    throw new RpcFailure(\n      404,\n      A2A_RPC_ERROR_CODES.TASK_NOT_FOUND,\n      'Push notification config not found'\n    );\n  }\n  return JSON.parse(data) as A2ATaskPushNotificationConfig;\n}\n\nexport async function notifyTaskPushNotifications(\n  store: TaskStore,\n  task: Task,\n  options: A2APushNotificationDeliveryOptions = {}\n): Promise<void> {\n  const fetchImpl = options.fetch ?? globalThis.fetch;\n  if (typeof fetchImpl !== 'function') return;\n\n  const keys = await store.listCheckpoints(`${CHECKPOINT_PREFIX}${task.id}:`);\n  await Promise.all(\n    keys.map(async (key) => {\n      const data = await store.getCheckpoint(key);\n      if (!data) return;\n      const config = JSON.parse(data) as A2ATaskPushNotificationConfig;\n      await postTaskNotification(fetchImpl, config, task);\n    })\n  );\n}\n\nfunction normalizeTaskPushNotificationConfig(\n  input: A2ATaskPushNotificationConfig\n): A2ATaskPushNotificationConfig {\n  if (!input.taskId) {\n    throw new RpcFailure(400, -32602, 'taskId is required');\n  }\n  if (!input.pushNotificationConfig?.url) {\n    throw new RpcFailure(400, -32602, 'pushNotificationConfig.url is required');\n  }\n  return {\n    taskId: input.taskId,\n    pushNotificationConfig: {\n      ...input.pushNotificationConfig,\n      id: pushNotificationConfigId(input.pushNotificationConfig),\n    },\n  };\n}\n\nfunction checkpointKey(taskId: string, configId: string): string {\n  return `${CHECKPOINT_PREFIX}${taskId}:${configId}`;\n}\n\nasync function postTaskNotification(\n  fetchImpl: typeof globalThis.fetch,\n  config: A2ATaskPushNotificationConfig,\n  task: Task\n): Promise<void> {\n  const headers: Record<string, string> = {\n    'Content-Type': 'application/json',\n  };\n  if (config.pushNotificationConfig.token) {\n    headers['X-A2A-Notification-Token'] = config.pushNotificationConfig.token;\n  }\n  const auth = config.pushNotificationConfig.authentication;\n  if (\n    auth?.credentials &&\n    auth.schemes.some((scheme) => scheme.toLowerCase() === 'bearer')\n  ) {\n    headers.Authorization = `Bearer ${auth.credentials}`;\n  }\n  const response = await fetchImpl(config.pushNotificationConfig.url, {\n    method: 'POST',\n    headers,\n    body: JSON.stringify({\n      task: toA2ATask(task),\n      taskId: task.id,\n      pushNotificationConfigId: pushNotificationConfigId(\n        config.pushNotificationConfig\n      ),\n    }),\n  });\n  if (!response.ok) {\n    throw new Error(\n      `A2A push notification failed: ${response.status} ${response.statusText}`\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/adapters/transport/rpc-errors.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Centralized JSON-RPC 2.0 error codes used by the A2A server + client
+ * ( /).
+ *
+ * JSON-RPC 2.0 reserves `-32768..-32000` for protocol errors, with the range
+ * `-32099..-32000` available for implementation-defined server errors. All
+ * custom codes live inside that server-error band so strict clients accept
+ * them as valid server errors; we only reuse the protocol pre-defined codes
+ * (`-32700`/`-32600`/`-32601`/`-32603`) for their canonical meanings.
+ *
+ * Centralizing the table (instead of ad-hoc literals per call site) means:
+ *  - every typed error is mapped exactly once
+ *  - consumers can build an `errorClass → code` registry at module load
+ *  - A2A clients can reverse-map `code → exception class`
+ */
+import type { OctoFlowError } from '../../domain/errors/index.js';
+/** JSON-RPC 2.0 predefined protocol errors — re-exported for one-stop consumption. */
+export declare const JSON_RPC_PREDEFINED: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+};
+/**
+ * A2A-specific error codes. Every entry must live inside the implementation-
+ * defined server-error range `-32099..-32000`.
+ */
+export declare const A2A_RPC_ERROR_CODES: {
+    /** Generic rate-limit-exceeded response. */
+    readonly RATE_LIMITED: -32000;
+    readonly TASK_NOT_FOUND: -32001;
+    readonly TASK_TERMINAL: -32002;
+    readonly BUDGET_EXHAUSTED: -32003;
+    readonly BACKEND_UNAVAILABLE: -32004;
+    readonly APPROVAL_REQUIRED: -32005;
+    readonly AUTH_REQUIRED: -32006;
+    readonly UNSAFE_COMMAND: -32007;
+    readonly QUEUE_FULL: -32008;
+    readonly UNSUPPORTED_VERSION: -32009;
+    readonly SESSION_NOT_FOUND: -32010;
+    readonly CONTEXT_OVERFLOW: -32011;
+    readonly BACKEND_SWITCH_REJECTED: -32012;
+    readonly BACKEND_SWITCH_LIMIT: -32013;
+    readonly BACKEND_SWITCH_UNSUPPORTED: -32014;
+    readonly APPROVAL_NOT_FOUND: -32015;
+    readonly APPROVAL_STATE_ERROR: -32016;
+    readonly API_KEY_ERROR: -32017;
+    readonly API_HTTP_ERROR: -32018;
+    readonly API_STREAM_ERROR: -32019;
+    readonly SSH_CONNECTION_ERROR: -32020;
+    /** Thrown when every configured backend is unavailable — distinct from a single BACKEND_UNAVAILABLE. */
+    readonly NO_BACKEND_AVAILABLE: -32021;
+    readonly POLICY_DENIED: -32022;
+};
+export type A2ARpcErrorCode = (typeof A2A_RPC_ERROR_CODES)[keyof typeof A2A_RPC_ERROR_CODES];
+/**
+ * Maps every typed {@link OctoFlowError} subclass to its wire code.
+ * Missing an entry produces a CI-visible completeness failure in
+ * `__tests__/a2a-error-codes.test.ts` — no runtime silent defaults.
+ */
+type AnyErrorClass = new (...args: never[]) => OctoFlowError;
+export declare const ERR_CODE_MAP: ReadonlyMap<AnyErrorClass, A2ARpcErrorCode>;
+/** Reverse lookup: wire code → class, for A2A client mapping. */
+export declare const ERROR_CLASS_BY_CODE: ReadonlyMap<A2ARpcErrorCode, AnyErrorClass>;
+/**
+ * Map an {@link OctoFlowError} instance to its RPC code. Returns
+ * `undefined` when the class has no registered mapping — the caller decides
+ * whether that is an internal error or a programmer error.
+ */
+export declare function rpcCodeForError(error: OctoFlowError): A2ARpcErrorCode | undefined;
+export {};
+//# sourceMappingURL=rpc-errors.d.ts.map

package/dist/adapters/transport/rpc-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-errors.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/rpc-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAsBlE,sFAAsF;AACtF,eAAO,MAAM,mBAAmB;;;;;;CAMtB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,mBAAmB;IAC9B,4CAA4C;;;;;;;;;;;;;;;;;;;;;;IAsB5C,wGAAwG;;;CAGhG,CAAC;AAEX,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEjE;;;;GAIG;AACH,KAAK,aAAa,GAAG,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,aAAa,CAAC;AAE7D,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,aAAa,EAAE,eAAe,CAuBjE,CAAC;AAEL,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,eAAe,EAAE,aAAa,CAKzE,CAAC;AAEJ;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,GACnB,eAAe,GAAG,SAAS,CAU7B"}

package/dist/adapters/transport/rpc-errors.js

@@ -0,0 +1,100 @@
+import {
+  ApiHttpError,
+  ApiKeyError,
+  ApiStreamError,
+  ApprovalNotFoundError,
+  ApprovalStateError,
+  BackendNotAvailableError,
+  BackendSwitchLimitError,
+  BackendSwitchRejectedError,
+  BackendSwitchUnsupportedError,
+  BudgetExhaustedError,
+  NoBackendAvailableError,
+  PolicyDeniedError,
+  QueueFullError,
+  SessionNotFoundError,
+  SshConnectionError,
+  TaskNotFoundError,
+  TaskTerminalError,
+  UnsafeCommandError
+} from "../../domain/errors/index.js";
+const JSON_RPC_PREDEFINED = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+const A2A_RPC_ERROR_CODES = {
+  /** Generic rate-limit-exceeded response. */
+  RATE_LIMITED: -32e3,
+  TASK_NOT_FOUND: -32001,
+  TASK_TERMINAL: -32002,
+  BUDGET_EXHAUSTED: -32003,
+  BACKEND_UNAVAILABLE: -32004,
+  APPROVAL_REQUIRED: -32005,
+  AUTH_REQUIRED: -32006,
+  UNSAFE_COMMAND: -32007,
+  QUEUE_FULL: -32008,
+  UNSUPPORTED_VERSION: -32009,
+  SESSION_NOT_FOUND: -32010,
+  CONTEXT_OVERFLOW: -32011,
+  BACKEND_SWITCH_REJECTED: -32012,
+  BACKEND_SWITCH_LIMIT: -32013,
+  BACKEND_SWITCH_UNSUPPORTED: -32014,
+  APPROVAL_NOT_FOUND: -32015,
+  APPROVAL_STATE_ERROR: -32016,
+  API_KEY_ERROR: -32017,
+  API_HTTP_ERROR: -32018,
+  API_STREAM_ERROR: -32019,
+  SSH_CONNECTION_ERROR: -32020,
+  /** Thrown when every configured backend is unavailable — distinct from a single BACKEND_UNAVAILABLE. */
+  NO_BACKEND_AVAILABLE: -32021,
+  POLICY_DENIED: -32022
+};
+const ERR_CODE_MAP = /* @__PURE__ */ new Map([
+  [TaskNotFoundError, A2A_RPC_ERROR_CODES.TASK_NOT_FOUND],
+  [TaskTerminalError, A2A_RPC_ERROR_CODES.TASK_TERMINAL],
+  [BudgetExhaustedError, A2A_RPC_ERROR_CODES.BUDGET_EXHAUSTED],
+  [BackendNotAvailableError, A2A_RPC_ERROR_CODES.BACKEND_UNAVAILABLE],
+  [NoBackendAvailableError, A2A_RPC_ERROR_CODES.NO_BACKEND_AVAILABLE],
+  [PolicyDeniedError, A2A_RPC_ERROR_CODES.POLICY_DENIED],
+  [UnsafeCommandError, A2A_RPC_ERROR_CODES.UNSAFE_COMMAND],
+  [QueueFullError, A2A_RPC_ERROR_CODES.QUEUE_FULL],
+  [SessionNotFoundError, A2A_RPC_ERROR_CODES.SESSION_NOT_FOUND],
+  [BackendSwitchRejectedError, A2A_RPC_ERROR_CODES.BACKEND_SWITCH_REJECTED],
+  [BackendSwitchLimitError, A2A_RPC_ERROR_CODES.BACKEND_SWITCH_LIMIT],
+  [
+    BackendSwitchUnsupportedError,
+    A2A_RPC_ERROR_CODES.BACKEND_SWITCH_UNSUPPORTED
+  ],
+  [ApprovalNotFoundError, A2A_RPC_ERROR_CODES.APPROVAL_NOT_FOUND],
+  [ApprovalStateError, A2A_RPC_ERROR_CODES.APPROVAL_STATE_ERROR],
+  [ApiKeyError, A2A_RPC_ERROR_CODES.API_KEY_ERROR],
+  [ApiHttpError, A2A_RPC_ERROR_CODES.API_HTTP_ERROR],
+  [ApiStreamError, A2A_RPC_ERROR_CODES.API_STREAM_ERROR],
+  [SshConnectionError, A2A_RPC_ERROR_CODES.SSH_CONNECTION_ERROR]
+]);
+const ERROR_CLASS_BY_CODE = new Map(
+  Array.from(ERR_CODE_MAP.entries()).map(
+    ([cls, code]) => [code, cls]
+  )
+);
+function rpcCodeForError(error) {
+  let ctor = error.constructor;
+  while (ctor) {
+    const code = ERR_CODE_MAP.get(ctor);
+    if (code !== void 0) return code;
+    const proto = Object.getPrototypeOf(ctor);
+    ctor = typeof proto === "function" ? proto : void 0;
+  }
+  return void 0;
+}
+export {
+  A2A_RPC_ERROR_CODES,
+  ERROR_CLASS_BY_CODE,
+  ERR_CODE_MAP,
+  JSON_RPC_PREDEFINED,
+  rpcCodeForError
+};
+//# sourceMappingURL=rpc-errors.js.map

package/dist/adapters/transport/rpc-errors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/adapters/transport/rpc-errors.ts"],
+  "sourcesContent": ["/**\n * Centralized JSON-RPC 2.0 error codes used by the A2A server + client\n * ( /).\n *\n * JSON-RPC 2.0 reserves `-32768..-32000` for protocol errors, with the range\n * `-32099..-32000` available for implementation-defined server errors. All\n * custom codes live inside that server-error band so strict clients accept\n * them as valid server errors; we only reuse the protocol pre-defined codes\n * (`-32700`/`-32600`/`-32601`/`-32603`) for their canonical meanings.\n *\n * Centralizing the table (instead of ad-hoc literals per call site) means:\n *  - every typed error is mapped exactly once\n *  - consumers can build an `errorClass \u2192 code` registry at module load\n *  - A2A clients can reverse-map `code \u2192 exception class`\n */\n\nimport type { OctoFlowError } from '../../domain/errors/index.js';\nimport {\n  ApiHttpError,\n  ApiKeyError,\n  ApiStreamError,\n  ApprovalNotFoundError,\n  ApprovalStateError,\n  BackendNotAvailableError,\n  BackendSwitchLimitError,\n  BackendSwitchRejectedError,\n  BackendSwitchUnsupportedError,\n  BudgetExhaustedError,\n  NoBackendAvailableError,\n  PolicyDeniedError,\n  QueueFullError,\n  SessionNotFoundError,\n  SshConnectionError,\n  TaskNotFoundError,\n  TaskTerminalError,\n  UnsafeCommandError,\n} from '../../domain/errors/index.js';\n\n/** JSON-RPC 2.0 predefined protocol errors \u2014 re-exported for one-stop consumption. */\nexport const JSON_RPC_PREDEFINED = {\n  PARSE_ERROR: -32700,\n  INVALID_REQUEST: -32600,\n  METHOD_NOT_FOUND: -32601,\n  INVALID_PARAMS: -32602,\n  INTERNAL_ERROR: -32603,\n} as const;\n\n/**\n * A2A-specific error codes. Every entry must live inside the implementation-\n * defined server-error range `-32099..-32000`.\n */\nexport const A2A_RPC_ERROR_CODES = {\n  /** Generic rate-limit-exceeded response. */\n  RATE_LIMITED: -32000,\n  TASK_NOT_FOUND: -32001,\n  TASK_TERMINAL: -32002,\n  BUDGET_EXHAUSTED: -32003,\n  BACKEND_UNAVAILABLE: -32004,\n  APPROVAL_REQUIRED: -32005,\n  AUTH_REQUIRED: -32006,\n  UNSAFE_COMMAND: -32007,\n  QUEUE_FULL: -32008,\n  UNSUPPORTED_VERSION: -32009,\n  SESSION_NOT_FOUND: -32010,\n  CONTEXT_OVERFLOW: -32011,\n  BACKEND_SWITCH_REJECTED: -32012,\n  BACKEND_SWITCH_LIMIT: -32013,\n  BACKEND_SWITCH_UNSUPPORTED: -32014,\n  APPROVAL_NOT_FOUND: -32015,\n  APPROVAL_STATE_ERROR: -32016,\n  API_KEY_ERROR: -32017,\n  API_HTTP_ERROR: -32018,\n  API_STREAM_ERROR: -32019,\n  SSH_CONNECTION_ERROR: -32020,\n  /** Thrown when every configured backend is unavailable \u2014 distinct from a single BACKEND_UNAVAILABLE. */\n  NO_BACKEND_AVAILABLE: -32021,\n  POLICY_DENIED: -32022,\n} as const;\n\nexport type A2ARpcErrorCode =\n  (typeof A2A_RPC_ERROR_CODES)[keyof typeof A2A_RPC_ERROR_CODES];\n\n/**\n * Maps every typed {@link OctoFlowError} subclass to its wire code.\n * Missing an entry produces a CI-visible completeness failure in\n * `__tests__/a2a-error-codes.test.ts` \u2014 no runtime silent defaults.\n */\ntype AnyErrorClass = new (...args: never[]) => OctoFlowError;\n\nexport const ERR_CODE_MAP: ReadonlyMap<AnyErrorClass, A2ARpcErrorCode> =\n  new Map<AnyErrorClass, A2ARpcErrorCode>([\n    [TaskNotFoundError, A2A_RPC_ERROR_CODES.TASK_NOT_FOUND],\n    [TaskTerminalError, A2A_RPC_ERROR_CODES.TASK_TERMINAL],\n    [BudgetExhaustedError, A2A_RPC_ERROR_CODES.BUDGET_EXHAUSTED],\n    [BackendNotAvailableError, A2A_RPC_ERROR_CODES.BACKEND_UNAVAILABLE],\n    [NoBackendAvailableError, A2A_RPC_ERROR_CODES.NO_BACKEND_AVAILABLE],\n    [PolicyDeniedError, A2A_RPC_ERROR_CODES.POLICY_DENIED],\n    [UnsafeCommandError, A2A_RPC_ERROR_CODES.UNSAFE_COMMAND],\n    [QueueFullError, A2A_RPC_ERROR_CODES.QUEUE_FULL],\n    [SessionNotFoundError, A2A_RPC_ERROR_CODES.SESSION_NOT_FOUND],\n    [BackendSwitchRejectedError, A2A_RPC_ERROR_CODES.BACKEND_SWITCH_REJECTED],\n    [BackendSwitchLimitError, A2A_RPC_ERROR_CODES.BACKEND_SWITCH_LIMIT],\n    [\n      BackendSwitchUnsupportedError,\n      A2A_RPC_ERROR_CODES.BACKEND_SWITCH_UNSUPPORTED,\n    ],\n    [ApprovalNotFoundError, A2A_RPC_ERROR_CODES.APPROVAL_NOT_FOUND],\n    [ApprovalStateError, A2A_RPC_ERROR_CODES.APPROVAL_STATE_ERROR],\n    [ApiKeyError, A2A_RPC_ERROR_CODES.API_KEY_ERROR],\n    [ApiHttpError, A2A_RPC_ERROR_CODES.API_HTTP_ERROR],\n    [ApiStreamError, A2A_RPC_ERROR_CODES.API_STREAM_ERROR],\n    [SshConnectionError, A2A_RPC_ERROR_CODES.SSH_CONNECTION_ERROR],\n  ]);\n\n/** Reverse lookup: wire code \u2192 class, for A2A client mapping. */\nexport const ERROR_CLASS_BY_CODE: ReadonlyMap<A2ARpcErrorCode, AnyErrorClass> =\n  new Map(\n    Array.from(ERR_CODE_MAP.entries()).map(\n      ([cls, code]) => [code, cls] as const\n    )\n  );\n\n/**\n * Map an {@link OctoFlowError} instance to its RPC code. Returns\n * `undefined` when the class has no registered mapping \u2014 the caller decides\n * whether that is an internal error or a programmer error.\n */\nexport function rpcCodeForError(\n  error: OctoFlowError\n): A2ARpcErrorCode | undefined {\n  // Walk the prototype chain so subclasses of registered classes still map.\n  let ctor: AnyErrorClass | undefined = error.constructor as AnyErrorClass;\n  while (ctor) {\n    const code = ERR_CODE_MAP.get(ctor);\n    if (code !== undefined) return code;\n    const proto: unknown = Object.getPrototypeOf(ctor);\n    ctor = typeof proto === 'function' ? (proto as AnyErrorClass) : undefined;\n  }\n  return undefined;\n}\n"],
+  "mappings": "AAiBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGA,MAAM,sBAAsB;AAAA,EACjC,aAAa;AAAA,EACb,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,gBAAgB;AAClB;AAMO,MAAM,sBAAsB;AAAA;AAAA,EAEjC,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,kBAAkB;AAAA,EAClB,yBAAyB;AAAA,EACzB,sBAAsB;AAAA,EACtB,4BAA4B;AAAA,EAC5B,oBAAoB;AAAA,EACpB,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAClB,sBAAsB;AAAA;AAAA,EAEtB,sBAAsB;AAAA,EACtB,eAAe;AACjB;AAYO,MAAM,eACX,oBAAI,IAAoC;AAAA,EACtC,CAAC,mBAAmB,oBAAoB,cAAc;AAAA,EACtD,CAAC,mBAAmB,oBAAoB,aAAa;AAAA,EACrD,CAAC,sBAAsB,oBAAoB,gBAAgB;AAAA,EAC3D,CAAC,0BAA0B,oBAAoB,mBAAmB;AAAA,EAClE,CAAC,yBAAyB,oBAAoB,oBAAoB;AAAA,EAClE,CAAC,mBAAmB,oBAAoB,aAAa;AAAA,EACrD,CAAC,oBAAoB,oBAAoB,cAAc;AAAA,EACvD,CAAC,gBAAgB,oBAAoB,UAAU;AAAA,EAC/C,CAAC,sBAAsB,oBAAoB,iBAAiB;AAAA,EAC5D,CAAC,4BAA4B,oBAAoB,uBAAuB;AAAA,EACxE,CAAC,yBAAyB,oBAAoB,oBAAoB;AAAA,EAClE;AAAA,IACE;AAAA,IACA,oBAAoB;AAAA,EACtB;AAAA,EACA,CAAC,uBAAuB,oBAAoB,kBAAkB;AAAA,EAC9D,CAAC,oBAAoB,oBAAoB,oBAAoB;AAAA,EAC7D,CAAC,aAAa,oBAAoB,aAAa;AAAA,EAC/C,CAAC,cAAc,oBAAoB,cAAc;AAAA,EACjD,CAAC,gBAAgB,oBAAoB,gBAAgB;AAAA,EACrD,CAAC,oBAAoB,oBAAoB,oBAAoB;AAC/D,CAAC;AAGI,MAAM,sBACX,IAAI;AAAA,EACF,MAAM,KAAK,aAAa,QAAQ,CAAC,EAAE;AAAA,IACjC,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,GAAG;AAAA,EAC7B;AACF;AAOK,SAAS,gBACd,OAC6B;AAE7B,MAAI,OAAkC,MAAM;AAC5C,SAAO,MAAM;AACX,UAAM,OAAO,aAAa,IAAI,IAAI;AAClC,QAAI,SAAS,OAAW,QAAO;AAC/B,UAAM,QAAiB,OAAO,eAAe,IAAI;AACjD,WAAO,OAAO,UAAU,aAAc,QAA0B;AAAA,EAClE;AACA,SAAO;AACT;",
+  "names": []
+}