octoflow-core 1.0.0

package/dist/adapters/transport/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AA2B5D,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3C,CAAC;AAEH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;EAQlD,CAAC;AAEL,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC;AAEH,iDAAiD;AACjD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AAEH,wCAAwC;AACxC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAAsB,CAAC;AAE1D,yBAAyB;AACzB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUxB,CAAC;AAEX,uFAAuF;AACvF,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAWvE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,OAAO,GACd,OAAO,CAeT"}

package/dist/adapters/transport/schemas.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { OctoFlowError } from "../../domain/errors/base.js";
+const A2APartSchema = z.object({
+  data: z.unknown().optional(),
+  filename: z.string().optional(),
+  mediaType: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  raw: z.string().optional(),
+  text: z.string().optional(),
+  url: z.string().optional()
+});
+const A2ARoleSchema = z.enum(["ROLE_USER", "ROLE_AGENT"]);
+const PushNotificationAuthenticationSchema = z.object({
+  credentials: z.string().optional(),
+  schemes: z.array(z.string())
+});
+const PushNotificationConfigSchema = z.object({
+  authentication: PushNotificationAuthenticationSchema.optional(),
+  id: z.string().optional(),
+  token: z.string().optional(),
+  url: z.string().url()
+});
+const TaskPushNotificationConfigSchema = z.object({
+  pushNotificationConfig: PushNotificationConfigSchema,
+  taskId: z.string()
+});
+const GetTaskPushNotificationConfigParamsSchema = z.object({
+  configId: z.string().optional(),
+  id: z.string().optional(),
+  taskId: z.string().optional()
+}).refine((value) => value.taskId || value.id, {
+  message: "taskId is required"
+});
+const A2AMessageSchema = z.object({
+  contextId: z.string().optional(),
+  extensions: z.array(z.string()).optional(),
+  messageId: z.string(),
+  metadata: z.record(z.unknown()).optional(),
+  parts: z.array(A2APartSchema),
+  referenceTaskIds: z.array(z.string()).optional(),
+  role: A2ARoleSchema,
+  taskId: z.string().optional()
+});
+const SendMessageParamsSchema = z.object({
+  message: A2AMessageSchema,
+  contextId: z.string().optional(),
+  taskId: z.string().optional(),
+  configuration: z.record(z.unknown()).optional(),
+  metadata: z.record(z.unknown()).optional(),
+  taskPushNotificationConfig: TaskPushNotificationConfigSchema.optional()
+});
+const GetTaskParamsSchema = z.object({
+  id: z.string(),
+  historyLength: z.number().int().nonnegative().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+const CancelTaskParamsSchema = GetTaskParamsSchema;
+const ListTasksParamsSchema = z.object({
+  contextId: z.string().optional(),
+  pageSize: z.number().int().positive().optional(),
+  pageToken: z.string().optional(),
+  state: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+const INBOUND_PARAMS_SCHEMA = {
+  SendMessage: SendMessageParamsSchema,
+  SendStreamingMessage: SendMessageParamsSchema,
+  GetTask: GetTaskParamsSchema,
+  CancelTask: CancelTaskParamsSchema,
+  ListTasks: ListTasksParamsSchema,
+  SubscribeToTask: GetTaskParamsSchema,
+  SetTaskPushNotificationConfig: TaskPushNotificationConfigSchema,
+  GetTaskPushNotificationConfig: GetTaskPushNotificationConfigParamsSchema
+  // GetExtendedAgentCard takes no params.
+};
+class SchemaValidationError extends OctoFlowError {
+  issues;
+  boundary;
+  schemaPath;
+  constructor(boundary, schemaPath, issues) {
+    super(
+      "SCHEMA_VALIDATION",
+      `validation failed at ${boundary} (${schemaPath}): ${issues.map((i) => i.message).join("; ")}`,
+      { boundary, schemaPath, issueCount: issues.length }
+    );
+    this.name = "SchemaValidationError";
+    this.boundary = boundary;
+    this.schemaPath = schemaPath;
+    this.issues = issues;
+  }
+}
+function validateA2AInbound(canonicalMethod, params) {
+  const schema = INBOUND_PARAMS_SCHEMA[canonicalMethod];
+  if (!schema) return params;
+  const result = schema.safeParse(params);
+  if (!result.success) {
+    throw new SchemaValidationError(
+      "a2a-inbound",
+      canonicalMethod,
+      result.error.issues
+    );
+  }
+  return result.data;
+}
+export {
+  A2AMessageSchema,
+  CancelTaskParamsSchema,
+  GetTaskParamsSchema,
+  GetTaskPushNotificationConfigParamsSchema,
+  INBOUND_PARAMS_SCHEMA,
+  ListTasksParamsSchema,
+  SchemaValidationError,
+  SendMessageParamsSchema,
+  TaskPushNotificationConfigSchema,
+  validateA2AInbound
+};
+//# sourceMappingURL=schemas.js.map

package/dist/adapters/transport/schemas.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/adapters/transport/schemas.ts"],
+  "sourcesContent": ["/**\n * Zod schemas for inbound A2A requests.\n *\n * Validation is scoped to **protocol boundaries** \u2014 the A2A server's JSON-RPC\n * body and the A2A client's response parser. Internal callers stay typed\n * by the TS compiler alone; the runtime cost is paid only where untrusted\n * bytes first enter the process.\n */\n\nimport { z } from 'zod';\n\nimport { OctoFlowError } from '../../domain/errors/base.js';\n\n/** Parts of an A2A message body \u2014 text, file, or data. */\nconst A2APartSchema = z.object({\n  data: z.unknown().optional(),\n  filename: z.string().optional(),\n  mediaType: z.string().optional(),\n  metadata: z.record(z.unknown()).optional(),\n  raw: z.string().optional(),\n  text: z.string().optional(),\n  url: z.string().optional(),\n});\n\nconst A2ARoleSchema = z.enum(['ROLE_USER', 'ROLE_AGENT']);\n\nconst PushNotificationAuthenticationSchema = z.object({\n  credentials: z.string().optional(),\n  schemes: z.array(z.string()),\n});\n\nconst PushNotificationConfigSchema = z.object({\n  authentication: PushNotificationAuthenticationSchema.optional(),\n  id: z.string().optional(),\n  token: z.string().optional(),\n  url: z.string().url(),\n});\n\nexport const TaskPushNotificationConfigSchema = z.object({\n  pushNotificationConfig: PushNotificationConfigSchema,\n  taskId: z.string(),\n});\n\nexport const GetTaskPushNotificationConfigParamsSchema = z\n  .object({\n    configId: z.string().optional(),\n    id: z.string().optional(),\n    taskId: z.string().optional(),\n  })\n  .refine((value) => value.taskId || value.id, {\n    message: 'taskId is required',\n  });\n\nexport const A2AMessageSchema = z.object({\n  contextId: z.string().optional(),\n  extensions: z.array(z.string()).optional(),\n  messageId: z.string(),\n  metadata: z.record(z.unknown()).optional(),\n  parts: z.array(A2APartSchema),\n  referenceTaskIds: z.array(z.string()).optional(),\n  role: A2ARoleSchema,\n  taskId: z.string().optional(),\n});\n\n/** sendMessage / sendStreamingMessage params. */\nexport const SendMessageParamsSchema = z.object({\n  message: A2AMessageSchema,\n  contextId: z.string().optional(),\n  taskId: z.string().optional(),\n  configuration: z.record(z.unknown()).optional(),\n  metadata: z.record(z.unknown()).optional(),\n  taskPushNotificationConfig: TaskPushNotificationConfigSchema.optional(),\n});\n\n/** getTask / subscribeToTask params. */\nexport const GetTaskParamsSchema = z.object({\n  id: z.string(),\n  historyLength: z.number().int().nonnegative().optional(),\n  metadata: z.record(z.unknown()).optional(),\n});\n\n/** cancelTask params \u2014 same surface as getTask in current A2A. */\nexport const CancelTaskParamsSchema = GetTaskParamsSchema;\n\n/** listTasks filters. */\nexport const ListTasksParamsSchema = z.object({\n  contextId: z.string().optional(),\n  pageSize: z.number().int().positive().optional(),\n  pageToken: z.string().optional(),\n  state: z.string().optional(),\n  metadata: z.record(z.unknown()).optional(),\n});\n\n/**\n * Schema per canonical method. The A2A server normalizes both raw\n * (`message/send`) and shortcut (`SendMessage`) method names to these keys\n * via `CANONICAL_METHODS`, so callers can look up schemas without caring\n * about transport-level aliases.\n */\nexport const INBOUND_PARAMS_SCHEMA = {\n  SendMessage: SendMessageParamsSchema,\n  SendStreamingMessage: SendMessageParamsSchema,\n  GetTask: GetTaskParamsSchema,\n  CancelTask: CancelTaskParamsSchema,\n  ListTasks: ListTasksParamsSchema,\n  SubscribeToTask: GetTaskParamsSchema,\n  SetTaskPushNotificationConfig: TaskPushNotificationConfigSchema,\n  GetTaskPushNotificationConfig: GetTaskPushNotificationConfigParamsSchema,\n  // GetExtendedAgentCard takes no params.\n} as const;\n\n/** Error class thrown on validation failure \u2014 carries the zod issues for telemetry. */\nexport class SchemaValidationError extends OctoFlowError {\n  readonly issues: z.ZodIssue[];\n  readonly boundary: string;\n  readonly schemaPath: string;\n\n  constructor(boundary: string, schemaPath: string, issues: z.ZodIssue[]) {\n    super(\n      'SCHEMA_VALIDATION',\n      `validation failed at ${boundary} (${schemaPath}): ${issues.map((i) => i.message).join('; ')}`,\n      { boundary, schemaPath, issueCount: issues.length }\n    );\n    this.name = 'SchemaValidationError';\n    this.boundary = boundary;\n    this.schemaPath = schemaPath;\n    this.issues = issues;\n  }\n}\n\n/**\n * Parse `params` against the canonical method's schema. Returns the typed\n * parsed value when a schema exists, or the raw params unchanged when the\n * method is parameterless (e.g. `GetExtendedAgentCard`).\n *\n * Throws {@link SchemaValidationError} when the body is structurally wrong \u2014\n * the A2A server converts this into a JSON-RPC `INVALID_PARAMS` response.\n */\nexport function validateA2AInbound(\n  canonicalMethod: string,\n  params: unknown\n): unknown {\n  const schema =\n    INBOUND_PARAMS_SCHEMA[\n      canonicalMethod as keyof typeof INBOUND_PARAMS_SCHEMA\n    ];\n  if (!schema) return params;\n  const result = schema.safeParse(params);\n  if (!result.success) {\n    throw new SchemaValidationError(\n      'a2a-inbound',\n      canonicalMethod,\n      result.error.issues\n    );\n  }\n  return result.data;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/adapters/transport/server-helpers.d.ts

@@ -0,0 +1,20 @@
+import type { Bridge } from '../../runtime/bridge/bridge.js';
+interface MapBridgeFailureOptions {
+    terminalStatus?: number;
+    terminalCode?: number;
+    terminalMessage?: string;
+}
+export declare function mapBridgeFailure(error: unknown, options?: MapBridgeFailureOptions): never;
+/**
+ * Emits a bridge event when the bridge exposes its event bus. Test harnesses
+ * routinely hand the A2A server a partial bridge — swallowing the
+ * missing-events case here keeps production emission typed while allowing
+ * lightweight fixtures to exercise the transport without a full bus.
+ */
+export declare function safeEmit(bridge: Bridge, event: 'validation:failed', data: {
+    boundary: string;
+    schemaPath: string;
+    errorCount: number;
+}): void;
+export {};
+//# sourceMappingURL=server-helpers.d.ts.map

package/dist/adapters/transport/server-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-helpers.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/server-helpers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAkC7D,UAAU,uBAAuB;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,uBAA4B,GACpC,KAAK,CAuBP;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACjE,IAAI,CAAC"}

package/dist/adapters/transport/server-helpers.js

@@ -0,0 +1,70 @@
+import {
+  OctoFlowError,
+  TaskNotFoundError,
+  TaskTerminalError
+} from "../../domain/errors/index.js";
+import { RpcFailure } from "./helpers.js";
+import { A2A_RPC_ERROR_CODES, rpcCodeForError } from "./rpc-errors.js";
+function httpStatusForCode(code, fallback) {
+  switch (code) {
+    case A2A_RPC_ERROR_CODES.TASK_NOT_FOUND:
+    case A2A_RPC_ERROR_CODES.SESSION_NOT_FOUND:
+    case A2A_RPC_ERROR_CODES.APPROVAL_NOT_FOUND:
+      return 404;
+    case A2A_RPC_ERROR_CODES.TASK_TERMINAL:
+    case A2A_RPC_ERROR_CODES.APPROVAL_STATE_ERROR:
+      return 409;
+    case A2A_RPC_ERROR_CODES.UNSAFE_COMMAND:
+    case A2A_RPC_ERROR_CODES.APPROVAL_REQUIRED:
+    case A2A_RPC_ERROR_CODES.AUTH_REQUIRED:
+      return 403;
+    case A2A_RPC_ERROR_CODES.QUEUE_FULL:
+    case A2A_RPC_ERROR_CODES.RATE_LIMITED:
+      return 429;
+    case A2A_RPC_ERROR_CODES.BUDGET_EXHAUSTED:
+      return 402;
+    case A2A_RPC_ERROR_CODES.BACKEND_UNAVAILABLE:
+    case A2A_RPC_ERROR_CODES.NO_BACKEND_AVAILABLE:
+    case A2A_RPC_ERROR_CODES.API_HTTP_ERROR:
+    case A2A_RPC_ERROR_CODES.API_STREAM_ERROR:
+    case A2A_RPC_ERROR_CODES.SSH_CONNECTION_ERROR:
+      return 503;
+    default:
+      return fallback;
+  }
+}
+function mapBridgeFailure(error, options = {}) {
+  if (error instanceof RpcFailure) throw error;
+  if (error instanceof TaskTerminalError) {
+    throw new RpcFailure(
+      options.terminalStatus ?? 400,
+      options.terminalCode ?? A2A_RPC_ERROR_CODES.TASK_TERMINAL,
+      options.terminalMessage ?? "Task is already terminal"
+    );
+  }
+  if (error instanceof TaskNotFoundError) {
+    throw new RpcFailure(
+      404,
+      A2A_RPC_ERROR_CODES.TASK_NOT_FOUND,
+      "Task not found"
+    );
+  }
+  if (error instanceof OctoFlowError) {
+    const code = rpcCodeForError(error);
+    if (code !== void 0) {
+      throw new RpcFailure(httpStatusForCode(code, 400), code, error.message);
+    }
+  }
+  throw error;
+}
+function safeEmit(bridge, event, data) {
+  const events = bridge.events;
+  if (events?.emit) {
+    void events.emit(event, data);
+  }
+}
+export {
+  mapBridgeFailure,
+  safeEmit
+};
+//# sourceMappingURL=server-helpers.js.map

package/dist/adapters/transport/server-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/adapters/transport/server-helpers.ts"],
+  "sourcesContent": ["import {\n  OctoFlowError,\n  TaskNotFoundError,\n  TaskTerminalError,\n} from '../../domain/errors/index.js';\nimport type { Bridge } from '../../runtime/bridge/bridge.js';\nimport { RpcFailure } from './helpers.js';\nimport { A2A_RPC_ERROR_CODES, rpcCodeForError } from './rpc-errors.js';\n\n/** HTTP status chosen per error code so clients see the right family. */\nfunction httpStatusForCode(code: number, fallback: number): number {\n  switch (code) {\n    case A2A_RPC_ERROR_CODES.TASK_NOT_FOUND:\n    case A2A_RPC_ERROR_CODES.SESSION_NOT_FOUND:\n    case A2A_RPC_ERROR_CODES.APPROVAL_NOT_FOUND:\n      return 404;\n    case A2A_RPC_ERROR_CODES.TASK_TERMINAL:\n    case A2A_RPC_ERROR_CODES.APPROVAL_STATE_ERROR:\n      return 409;\n    case A2A_RPC_ERROR_CODES.UNSAFE_COMMAND:\n    case A2A_RPC_ERROR_CODES.APPROVAL_REQUIRED:\n    case A2A_RPC_ERROR_CODES.AUTH_REQUIRED:\n      return 403;\n    case A2A_RPC_ERROR_CODES.QUEUE_FULL:\n    case A2A_RPC_ERROR_CODES.RATE_LIMITED:\n      return 429;\n    case A2A_RPC_ERROR_CODES.BUDGET_EXHAUSTED:\n      return 402;\n    case A2A_RPC_ERROR_CODES.BACKEND_UNAVAILABLE:\n    case A2A_RPC_ERROR_CODES.NO_BACKEND_AVAILABLE:\n    case A2A_RPC_ERROR_CODES.API_HTTP_ERROR:\n    case A2A_RPC_ERROR_CODES.API_STREAM_ERROR:\n    case A2A_RPC_ERROR_CODES.SSH_CONNECTION_ERROR:\n      return 503;\n    default:\n      return fallback;\n  }\n}\n\ninterface MapBridgeFailureOptions {\n  terminalStatus?: number;\n  terminalCode?: number;\n  terminalMessage?: string;\n}\n\nexport function mapBridgeFailure(\n  error: unknown,\n  options: MapBridgeFailureOptions = {}\n): never {\n  if (error instanceof RpcFailure) throw error;\n  if (error instanceof TaskTerminalError) {\n    throw new RpcFailure(\n      options.terminalStatus ?? 400,\n      options.terminalCode ?? A2A_RPC_ERROR_CODES.TASK_TERMINAL,\n      options.terminalMessage ?? 'Task is already terminal'\n    );\n  }\n  if (error instanceof TaskNotFoundError) {\n    throw new RpcFailure(\n      404,\n      A2A_RPC_ERROR_CODES.TASK_NOT_FOUND,\n      'Task not found'\n    );\n  }\n  if (error instanceof OctoFlowError) {\n    const code = rpcCodeForError(error);\n    if (code !== undefined) {\n      throw new RpcFailure(httpStatusForCode(code, 400), code, error.message);\n    }\n  }\n  throw error;\n}\n\n/**\n * Emits a bridge event when the bridge exposes its event bus. Test harnesses\n * routinely hand the A2A server a partial bridge \u2014 swallowing the\n * missing-events case here keeps production emission typed while allowing\n * lightweight fixtures to exercise the transport without a full bus.\n */\nexport function safeEmit(\n  bridge: Bridge,\n  event: 'validation:failed',\n  data: { boundary: string; schemaPath: string; errorCount: number }\n): void;\nexport function safeEmit(\n  bridge: Bridge,\n  event: string,\n  data: Record<string, unknown>\n): void {\n  const events = (\n    bridge as {\n      events?: {\n        emit?: (event: string, data: unknown) => Promise<void> | void;\n      };\n    }\n  ).events;\n  if (events?.emit) {\n    void events.emit(event, data);\n  }\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB,uBAAuB;AAGrD,SAAS,kBAAkB,MAAc,UAA0B;AACjE,UAAQ,MAAM;AAAA,IACZ,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AAAA,IACzB,KAAK,oBAAoB;AACvB,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EACX;AACF;AAQO,SAAS,iBACd,OACA,UAAmC,CAAC,GAC7B;AACP,MAAI,iBAAiB,WAAY,OAAM;AACvC,MAAI,iBAAiB,mBAAmB;AACtC,UAAM,IAAI;AAAA,MACR,QAAQ,kBAAkB;AAAA,MAC1B,QAAQ,gBAAgB,oBAAoB;AAAA,MAC5C,QAAQ,mBAAmB;AAAA,IAC7B;AAAA,EACF;AACA,MAAI,iBAAiB,mBAAmB;AACtC,UAAM,IAAI;AAAA,MACR;AAAA,MACA,oBAAoB;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AACA,MAAI,iBAAiB,eAAe;AAClC,UAAM,OAAO,gBAAgB,KAAK;AAClC,QAAI,SAAS,QAAW;AACtB,YAAM,IAAI,WAAW,kBAAkB,MAAM,GAAG,GAAG,MAAM,MAAM,OAAO;AAAA,IACxE;AAAA,EACF;AACA,QAAM;AACR;AAaO,SAAS,SACd,QACA,OACA,MACM;AACN,QAAM,SACJ,OAKA;AACF,MAAI,QAAQ,MAAM;AAChB,SAAK,OAAO,KAAK,OAAO,IAAI;AAAA,EAC9B;AACF;",
+  "names": []
+}

package/dist/adapters/transport/server-metrics.d.ts

@@ -0,0 +1,8 @@
+import type { Bridge } from '../../runtime/bridge/bridge.js';
+export interface A2AServerMetrics {
+    activeRequests: number;
+    activeSseConnections: number;
+    requestsTotal: number;
+}
+export declare function renderMetrics(bridge: Bridge, metrics: A2AServerMetrics): Promise<string>;
+//# sourceMappingURL=server-metrics.d.ts.map

package/dist/adapters/transport/server-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-metrics.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/server-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,CAuBjB"}

package/dist/adapters/transport/server-metrics.js

@@ -0,0 +1,27 @@
+async function renderMetrics(bridge, metrics) {
+  let taskQueueDepth = 0;
+  try {
+    taskQueueDepth = (await bridge.listTasks({ limit: 1 })).totalSize;
+  } catch {
+    taskQueueDepth = 0;
+  }
+  return [
+    "# HELP octoflow_a2a_requests_total Total A2A HTTP requests handled.",
+    "# TYPE octoflow_a2a_requests_total counter",
+    `octoflow_a2a_requests_total ${metrics.requestsTotal}`,
+    "# HELP octoflow_a2a_active_requests Active A2A HTTP requests.",
+    "# TYPE octoflow_a2a_active_requests gauge",
+    `octoflow_a2a_active_requests ${metrics.activeRequests}`,
+    "# HELP octoflow_a2a_active_sse_connections Active A2A SSE connections.",
+    "# TYPE octoflow_a2a_active_sse_connections gauge",
+    `octoflow_a2a_active_sse_connections ${metrics.activeSseConnections}`,
+    "# HELP octoflow_a2a_task_queue_depth Visible tasks in the bridge task store.",
+    "# TYPE octoflow_a2a_task_queue_depth gauge",
+    `octoflow_a2a_task_queue_depth ${taskQueueDepth}`,
+    ""
+  ].join("\n");
+}
+export {
+  renderMetrics
+};
+//# sourceMappingURL=server-metrics.js.map

package/dist/adapters/transport/server-metrics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/adapters/transport/server-metrics.ts"],
+  "sourcesContent": ["import type { Bridge } from '../../runtime/bridge/bridge.js';\n\nexport interface A2AServerMetrics {\n  activeRequests: number;\n  activeSseConnections: number;\n  requestsTotal: number;\n}\n\nexport async function renderMetrics(\n  bridge: Bridge,\n  metrics: A2AServerMetrics\n): Promise<string> {\n  let taskQueueDepth = 0;\n  try {\n    taskQueueDepth = (await bridge.listTasks({ limit: 1 })).totalSize;\n  } catch {\n    taskQueueDepth = 0;\n  }\n\n  return [\n    '# HELP octoflow_a2a_requests_total Total A2A HTTP requests handled.',\n    '# TYPE octoflow_a2a_requests_total counter',\n    `octoflow_a2a_requests_total ${metrics.requestsTotal}`,\n    '# HELP octoflow_a2a_active_requests Active A2A HTTP requests.',\n    '# TYPE octoflow_a2a_active_requests gauge',\n    `octoflow_a2a_active_requests ${metrics.activeRequests}`,\n    '# HELP octoflow_a2a_active_sse_connections Active A2A SSE connections.',\n    '# TYPE octoflow_a2a_active_sse_connections gauge',\n    `octoflow_a2a_active_sse_connections ${metrics.activeSseConnections}`,\n    '# HELP octoflow_a2a_task_queue_depth Visible tasks in the bridge task store.',\n    '# TYPE octoflow_a2a_task_queue_depth gauge',\n    `octoflow_a2a_task_queue_depth ${taskQueueDepth}`,\n    '',\n  ].join('\\n');\n}\n"],
+  "mappings": "AAQA,eAAsB,cACpB,QACA,SACiB;AACjB,MAAI,iBAAiB;AACrB,MAAI;AACF,sBAAkB,MAAM,OAAO,UAAU,EAAE,OAAO,EAAE,CAAC,GAAG;AAAA,EAC1D,QAAQ;AACN,qBAAiB;AAAA,EACnB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,+BAA+B,QAAQ,aAAa;AAAA,IACpD;AAAA,IACA;AAAA,IACA,gCAAgC,QAAQ,cAAc;AAAA,IACtD;AAAA,IACA;AAAA,IACA,uCAAuC,QAAQ,oBAAoB;AAAA,IACnE;AAAA,IACA;AAAA,IACA,iCAAiC,cAAc;AAAA,IAC/C;AAAA,EACF,EAAE,KAAK,IAAI;AACb;",
+  "names": []
+}

package/dist/adapters/transport/server-options.d.ts

@@ -0,0 +1,25 @@
+import type { OctoFlowConfig } from '../../config/config.js';
+import type { AgentCard } from '../../domain/core-task.js';
+import type { AgentHandle } from '../../runtime/bridge/agent-handle.js';
+import type { Bridge } from '../../runtime/bridge/bridge.js';
+export interface A2AServerOptions {
+    agentCard?: Partial<AgentCard>;
+    /**
+     * A fully-constructed `AgentHandle` (from `createAgent`).
+     * The server extracts the underlying Bridge and does not own its lifecycle.
+     */
+    agent?: AgentHandle;
+    /**
+     * A raw `Bridge` instance. Takes priority over `agent` when both are provided.
+     * The server does not own the bridge lifecycle — callers must call `bridge.close()`.
+     */
+    bridge?: Bridge;
+    config?: OctoFlowConfig;
+    host?: string;
+    port?: number;
+    pushNotifications?: {
+        /** Custom fetch for webhook delivery. Defaults to globalThis.fetch. */
+        fetch?: typeof globalThis.fetch;
+    };
+}
+//# sourceMappingURL=server-options.d.ts.map

package/dist/adapters/transport/server-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-options.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/server-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE;QAClB,uEAAuE;QACvE,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;KACjC,CAAC;CACH"}

package/dist/adapters/transport/server-options.js

@@ -0,0 +1 @@
+//# sourceMappingURL=server-options.js.map

package/dist/adapters/transport/server-options.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/adapters/transport/server-rpc-dispatch.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ResolvedOctoFlowConfig } from '../../config/config.js';
+import type { Bridge } from '../../runtime/bridge/bridge.js';
+import type { JsonRpcId, JsonRpcRequest } from './helpers.js';
+import type { CanonicalA2AMethod } from './jsonrpc-wire.js';
+import type { A2AServerOptions } from './server.js';
+import type { A2AServerMetrics } from './server-metrics.js';
+export declare function dispatchA2ARpcMethod(input: {
+    bridge: Bridge;
+    host: string;
+    method: CanonicalA2AMethod;
+    metrics: A2AServerMetrics;
+    options: A2AServerOptions;
+    payload: JsonRpcRequest;
+    port: number;
+    req: IncomingMessage;
+    res: ServerResponse;
+    resolvedConfig: ResolvedOctoFlowConfig;
+    rpcId: JsonRpcId;
+    url: string;
+}): Promise<void>;
+//# sourceMappingURL=server-rpc-dispatch.d.ts.map

package/dist/adapters/transport/server-rpc-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-rpc-dispatch.d.ts","sourceRoot":"","sources":["../../../src/adapters/transport/server-rpc-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAG7D,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgB9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAO5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAU5D,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,eAAe,CAAC;IACrB,GAAG,EAAE,cAAc,CAAC;IACpB,cAAc,EAAE,sBAAsB,CAAC;IACvC,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CA4PhB"}

package/dist/adapters/transport/server-rpc-dispatch.js

@@ -0,0 +1,282 @@
+import { TaskNotFoundError } from "../../domain/errors/index.js";
+import { assertNever } from "../../utils/assert-never.js";
+import { isTerminalTaskState } from "../data/task-store/index.js";
+import {
+  buildAgentCard,
+  buildRequestBaseUrl,
+  getContextId,
+  getStreamAfter,
+  getTaskId,
+  getTenant,
+  jsonRpcStreamEvent,
+  RpcFailure,
+  sendJson,
+  successResponse,
+  toListParams,
+  toSendParams,
+  toTaskSnapshotOptions
+} from "./helpers.js";
+import {
+  getTaskPushNotificationConfig,
+  notifyTaskPushNotifications,
+  setTaskPushNotificationConfig
+} from "./push-notifications.js";
+import { A2A_RPC_ERROR_CODES } from "./rpc-errors.js";
+import { mapBridgeFailure } from "./server-helpers.js";
+import { writeSubscriptionStream } from "./server-stream.js";
+import {
+  toA2AListTasksResponse,
+  toA2ASendMessageResponse,
+  toA2AStreamResponse,
+  toA2ATask
+} from "./wire.js";
+async function dispatchA2ARpcMethod(input) {
+  const {
+    bridge,
+    host,
+    method,
+    metrics,
+    options,
+    payload,
+    port,
+    req,
+    res,
+    resolvedConfig,
+    rpcId: id,
+    url
+  } = input;
+  const tenant = getTenant(req, payload.params);
+  switch (method) {
+    case "SendMessage": {
+      try {
+        const { pushNotificationConfig, ...sendParams } = toSendParams(
+          payload.params
+        );
+        const result = await bridge.sendMessage({
+          ...sendParams,
+          tenant
+        });
+        if (result.kind === "task") {
+          if (pushNotificationConfig) {
+            await setTaskPushNotificationConfig(bridge.taskStore, {
+              taskId: result.taskId,
+              pushNotificationConfig: pushNotificationConfig.pushNotificationConfig
+            });
+          }
+          void notifyTaskPushNotifications(bridge.taskStore, result.task, {
+            fetch: options.pushNotifications?.fetch
+          }).catch(() => void 0);
+        }
+        sendJson(
+          res,
+          200,
+          successResponse(id, toA2ASendMessageResponse(result))
+        );
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      return;
+    }
+    case "GetTask": {
+      const taskId = getTaskId(payload.params);
+      try {
+        const task = await bridge.getTask(taskId, {
+          ...toTaskSnapshotOptions(payload.params),
+          contextId: getContextId(payload.params),
+          tenant
+        });
+        sendJson(res, 200, successResponse(id, toA2ATask(task)));
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      return;
+    }
+    case "ListTasks": {
+      const tasks = await bridge.listTasks(
+        toListParams(payload.params, tenant)
+      );
+      sendJson(res, 200, successResponse(id, toA2AListTasksResponse(tasks)));
+      return;
+    }
+    case "CancelTask": {
+      const taskId = getTaskId(payload.params);
+      try {
+        const access = { contextId: getContextId(payload.params), tenant };
+        const task = await bridge.getTask(taskId, access);
+        if (isTerminalTaskState(task.status.state)) {
+          throw new RpcFailure(
+            409,
+            A2A_RPC_ERROR_CODES.TASK_TERMINAL,
+            "Task is already terminal"
+          );
+        }
+        const canceled = await bridge.cancelTask(taskId, access);
+        void notifyTaskPushNotifications(bridge.taskStore, canceled, {
+          fetch: options.pushNotifications?.fetch
+        }).catch(() => void 0);
+        sendJson(res, 200, successResponse(id, toA2ATask(canceled)));
+      } catch (error) {
+        mapBridgeFailure(error, {
+          terminalStatus: 409,
+          terminalCode: A2A_RPC_ERROR_CODES.TASK_TERMINAL
+        });
+      }
+      return;
+    }
+    case "SendStreamingMessage": {
+      const after = getStreamAfter(req, payload.params);
+      const { pushNotificationConfig, ...rawSendParams } = toSendParams(
+        payload.params
+      );
+      const sendParams = {
+        ...rawSendParams,
+        returnImmediately: true,
+        tenant
+      };
+      if (sendParams.taskId) {
+        try {
+          const subscription = await bridge.subscribeToTask(sendParams.taskId, {
+            after,
+            contextId: sendParams.contextId,
+            tenant
+          });
+          await writeSubscriptionStream(res, id, subscription, metrics);
+          return;
+        } catch (error) {
+          if (!(error instanceof TaskNotFoundError)) {
+            mapBridgeFailure(error);
+          }
+        }
+      }
+      let result;
+      try {
+        result = await bridge.sendMessage({
+          ...sendParams,
+          taskIdMode: "create-or-resume"
+        });
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      if (result.kind !== "task") {
+        metrics.activeSseConnections += 1;
+        try {
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          res.write(
+            jsonRpcStreamEvent(id, toA2AStreamResponse(result.message))
+          );
+          res.end();
+        } finally {
+          metrics.activeSseConnections -= 1;
+        }
+        return;
+      }
+      if (pushNotificationConfig) {
+        await setTaskPushNotificationConfig(bridge.taskStore, {
+          taskId: result.taskId,
+          pushNotificationConfig: pushNotificationConfig.pushNotificationConfig
+        });
+      }
+      await writeSubscriptionStream(
+        res,
+        id,
+        await bridge.subscribeToTask(result.taskId, {
+          after,
+          contextId: result.contextId ?? void 0,
+          tenant: result.task.tenant
+        }),
+        metrics
+      );
+      return;
+    }
+    case "SetTaskPushNotificationConfig": {
+      const config = payload.params;
+      try {
+        await bridge.getTask(config.taskId, {
+          contextId: getContextId(payload.params),
+          tenant
+        });
+        sendJson(
+          res,
+          200,
+          successResponse(
+            id,
+            await setTaskPushNotificationConfig(bridge.taskStore, config)
+          )
+        );
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      return;
+    }
+    case "GetTaskPushNotificationConfig": {
+      const params = payload.params ?? {};
+      try {
+        await bridge.getTask(getTaskId(params), {
+          contextId: getContextId(params),
+          tenant
+        });
+        sendJson(
+          res,
+          200,
+          successResponse(
+            id,
+            await getTaskPushNotificationConfig(bridge.taskStore, params)
+          )
+        );
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      return;
+    }
+    case "SubscribeToTask": {
+      const taskId = getTaskId(payload.params);
+      const after = getStreamAfter(req, payload.params);
+      const subscriptionAccess = {
+        after,
+        contextId: getContextId(payload.params),
+        tenant
+      };
+      try {
+        await bridge.getTask(taskId, {
+          contextId: subscriptionAccess.contextId,
+          tenant: subscriptionAccess.tenant
+        });
+      } catch (error) {
+        mapBridgeFailure(error);
+      }
+      await writeSubscriptionStream(
+        res,
+        id,
+        await bridge.subscribeToTask(taskId, subscriptionAccess),
+        metrics
+      );
+      return;
+    }
+    case "GetExtendedAgentCard": {
+      const agentCard = buildAgentCard(
+        {
+          ...options,
+          host,
+          port,
+          agentCard: {
+            ...options.agentCard,
+            url: buildRequestBaseUrl(req, url)
+          }
+        },
+        resolvedConfig
+      );
+      sendJson(res, 200, successResponse(id, agentCard));
+      return;
+    }
+    default:
+      assertNever(method, "A2A server method dispatch");
+  }
+}
+export {
+  dispatchA2ARpcMethod
+};
+//# sourceMappingURL=server-rpc-dispatch.js.map