@axiom-lattice/gateway 7.0.0 → 8.0.1

package/dist/{a2a-standard-DP53K7RC.mjs → a2a-standard-VL5I7B4W.mjs}

@@ -1,6 +1,7 @@
 import {
-  buildAgentCardForAssistant
-} from "./chunk-J6B2VFJ7.mjs";
+  buildAgentCardForAssistant,
+  deriveAgentSkills
+} from "./chunk-W3YH4S6G.mjs";
 import {
   formatFileRefsSection,
   getRunCancelRouter,
@@ -22,6 +23,7 @@ import {
   JsonRpcTransportHandler,
   RequestContext
 } from "@a2a-js/sdk/server";
+import { AgentCard as AgentCardV1 } from "@a2a-js/sdk-v1";
 import {
   agentInstanceManager as agentInstanceManager2,
   ChunkCursorExpiredError,
@@ -32,6 +34,488 @@ import {
 } from "@axiom-lattice/core";
 import { MessageChunkTypes as MessageChunkTypes3 } from "@axiom-lattice/protocols";
 
+// src/services/a2a/A2AAgentCardBuilderV1.ts
+function buildAgentCardForAssistantV1(params) {
+  const { assistant, baseUrl } = params;
+  const v1Url = `${baseUrl}/a2a/v1/${assistant.id}`;
+  const v03Url = `${baseUrl}/a2a/${assistant.id}`;
+  const skills = deriveAgentSkills(assistant).map((skill) => ({
+    ...skill,
+    tags: skill.tags ?? [],
+    examples: skill.examples ?? [],
+    inputModes: [],
+    outputModes: [],
+    securityRequirements: []
+  }));
+  return {
+    name: assistant.name,
+    description: assistant.description ?? "",
+    supportedInterfaces: [
+      {
+        url: v1Url,
+        protocolBinding: "JSONRPC",
+        tenant: "",
+        protocolVersion: "1.0"
+      },
+      {
+        url: v03Url,
+        protocolBinding: "JSONRPC",
+        tenant: "",
+        protocolVersion: "0.3"
+      }
+    ],
+    provider: void 0,
+    version: "1.0.0",
+    capabilities: {
+      streaming: true,
+      pushNotifications: params.pushNotifications ?? true,
+      extensions: [
+        {
+          uri: "https://axiom-lattice.dev/a2a/extensions/push-notifications-experimental",
+          description: "Push notifications are experimental and best-effort. Delivery is at-most-once; clients should poll tasks/get or use SubscribeToTask for reliability.",
+          required: false,
+          params: {
+            experimental: true,
+            reliable: false,
+            delivery: "at-most-once"
+          }
+        }
+      ],
+      extendedAgentCard: true
+    },
+    securitySchemes: {
+      bearer: {
+        scheme: {
+          $case: "httpAuthSecurityScheme",
+          value: {
+            scheme: "Bearer",
+            description: "API key sent as an Authorization Bearer token",
+            bearerFormat: ""
+          }
+        }
+      },
+      apiKeyHeader: {
+        scheme: {
+          $case: "apiKeySecurityScheme",
+          value: {
+            location: "header",
+            name: "x-api-key",
+            description: "API key sent via the x-api-key header"
+          }
+        }
+      }
+    },
+    securityRequirements: [
+      { schemes: { bearer: { list: [] } } },
+      { schemes: { apiKeyHeader: { list: [] } } }
+    ],
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    skills,
+    signatures: []
+  };
+}
+
+// src/services/a2a/a2aV1Wire.ts
+var V1_TO_V03_METHOD = {
+  SendMessage: "message/send",
+  SendStreamingMessage: "message/stream",
+  GetTask: "tasks/get",
+  ListTasks: "tasks/list",
+  CancelTask: "tasks/cancel",
+  SubscribeToTask: "tasks/resubscribe",
+  CreateTaskPushNotificationConfig: "tasks/pushNotificationConfig/set",
+  GetTaskPushNotificationConfig: "tasks/pushNotificationConfig/get",
+  ListTaskPushNotificationConfigs: "tasks/pushNotificationConfig/list",
+  DeleteTaskPushNotificationConfig: "tasks/pushNotificationConfig/delete",
+  GetExtendedAgentCard: "agent/getAuthenticatedExtendedCard"
+};
+var V1_TO_V03_STATE = {
+  TASK_STATE_SUBMITTED: "submitted",
+  TASK_STATE_WORKING: "working",
+  TASK_STATE_COMPLETED: "completed",
+  TASK_STATE_FAILED: "failed",
+  TASK_STATE_CANCELED: "canceled",
+  TASK_STATE_INPUT_REQUIRED: "input-required",
+  TASK_STATE_REJECTED: "rejected",
+  TASK_STATE_AUTH_REQUIRED: "auth-required",
+  TASK_STATE_UNSPECIFIED: "unknown"
+};
+var V03_TO_V1_STATE = {
+  submitted: "TASK_STATE_SUBMITTED",
+  working: "TASK_STATE_WORKING",
+  completed: "TASK_STATE_COMPLETED",
+  failed: "TASK_STATE_FAILED",
+  canceled: "TASK_STATE_CANCELED",
+  "input-required": "TASK_STATE_INPUT_REQUIRED",
+  rejected: "TASK_STATE_REJECTED",
+  "auth-required": "TASK_STATE_AUTH_REQUIRED",
+  unknown: "TASK_STATE_UNSPECIFIED"
+};
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function withMetadata(value, metadata) {
+  return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata) ? { ...value, metadata } : value;
+}
+function v1TaskStateTo03(value) {
+  if (typeof value !== "string") return "unknown";
+  return V1_TO_V03_STATE[value] ?? value;
+}
+function v03TaskStateToV1(value) {
+  if (typeof value !== "string") return "TASK_STATE_UNSPECIFIED";
+  return V03_TO_V1_STATE[value] ?? "TASK_STATE_UNSPECIFIED";
+}
+function toV03Part(part) {
+  const record = asRecord(part);
+  if (!record) return void 0;
+  if (typeof record.text === "string") {
+    return withMetadata({ kind: "text", text: record.text }, record.metadata);
+  }
+  if (typeof record.raw === "string") {
+    return withMetadata({
+      kind: "file",
+      file: {
+        bytes: record.raw,
+        ...typeof record.mediaType === "string" ? { mimeType: record.mediaType } : {},
+        ...typeof record.filename === "string" ? { name: record.filename } : {}
+      }
+    }, record.metadata);
+  }
+  if (typeof record.url === "string") {
+    return withMetadata({
+      kind: "file",
+      file: {
+        uri: record.url,
+        ...typeof record.mediaType === "string" ? { mimeType: record.mediaType } : {},
+        ...typeof record.filename === "string" ? { name: record.filename } : {}
+      }
+    }, record.metadata);
+  }
+  if ("data" in record) {
+    return withMetadata({ kind: "data", data: record.data }, record.metadata);
+  }
+  if (record.kind === "text" && typeof record.text === "string") {
+    return withMetadata({ kind: "text", text: record.text }, record.metadata);
+  }
+  if (record.kind === "file") {
+    const file = asRecord(record.file);
+    if (!file) return void 0;
+    return withMetadata({ kind: "file", file }, record.metadata);
+  }
+  if (record.kind === "data") {
+    return withMetadata({ kind: "data", data: record.data }, record.metadata);
+  }
+  return void 0;
+}
+function toV1Part(part) {
+  if (part.kind === "text") {
+    return withMetadata({ text: part.text }, part.metadata);
+  }
+  if (part.kind === "data") {
+    return withMetadata({ data: part.data }, part.metadata);
+  }
+  const file = part.file;
+  const base = "uri" in file ? {
+    url: file.uri,
+    ...file.mimeType ? { mediaType: file.mimeType } : {},
+    ...file.name ? { filename: file.name } : {}
+  } : {
+    raw: file.bytes,
+    ...file.mimeType ? { mediaType: file.mimeType } : {},
+    ...file.name ? { filename: file.name } : {}
+  };
+  return withMetadata(base, part.metadata);
+}
+function v1RoleTo03(value) {
+  if (value === "ROLE_USER" || value === "user" || value === 1) return "user";
+  return "agent";
+}
+function v03RoleToV1(value) {
+  return value === "user" ? "ROLE_USER" : "ROLE_AGENT";
+}
+function toV03Message(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const parts = (asArray(record.parts) ?? []).map(toV03Part).filter((part) => part !== void 0);
+  return {
+    kind: "message",
+    messageId: asString(record.messageId) ?? "",
+    role: v1RoleTo03(record.role),
+    parts,
+    ...asString(record.contextId) ? { contextId: asString(record.contextId) } : {},
+    ...asString(record.taskId) ? { taskId: asString(record.taskId) } : {},
+    ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {},
+    ...asArray(record.extensions) ? { extensions: record.extensions } : {},
+    ...asArray(record.referenceTaskIds) ? { referenceTaskIds: record.referenceTaskIds } : {}
+  };
+}
+function toV1Message(message) {
+  return {
+    messageId: message.messageId,
+    ...message.contextId ? { contextId: message.contextId } : {},
+    ...message.taskId ? { taskId: message.taskId } : {},
+    role: v03RoleToV1(message.role),
+    parts: message.parts.map(toV1Part),
+    ...message.metadata ? { metadata: message.metadata } : {},
+    ...message.extensions?.length ? { extensions: message.extensions } : {},
+    ...message.referenceTaskIds?.length ? { referenceTaskIds: message.referenceTaskIds } : {}
+  };
+}
+function toV03Status(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  return {
+    state: v1TaskStateTo03(record.state),
+    ...asRecord(record.message) ? { message: toV03Message(record.message) } : {},
+    ...asString(record.timestamp) ? { timestamp: asString(record.timestamp) } : {}
+  };
+}
+function toV1Status(status) {
+  return {
+    state: v03TaskStateToV1(status.state),
+    ...status.message ? { message: toV1Message(status.message) } : {},
+    ...status.timestamp ? { timestamp: status.timestamp } : {}
+  };
+}
+function toV03Artifact(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const parts = (asArray(record.parts) ?? []).map(toV03Part).filter((part) => part !== void 0);
+  return {
+    artifactId: asString(record.artifactId) ?? "",
+    ...asString(record.name) ? { name: asString(record.name) } : {},
+    ...asString(record.description) ? { description: asString(record.description) } : {},
+    parts,
+    ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {}
+  };
+}
+function toV1Artifact(artifact) {
+  return {
+    artifactId: artifact.artifactId,
+    ...artifact.name ? { name: artifact.name } : {},
+    ...artifact.description ? { description: artifact.description } : {},
+    parts: artifact.parts.map(toV1Part),
+    ...artifact.metadata ? { metadata: artifact.metadata } : {}
+  };
+}
+function toV03Task(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const status = toV03Status(record.status);
+  if (!status) return void 0;
+  const rawArtifacts = asArray(record.artifacts);
+  const rawHistory = asArray(record.history);
+  return {
+    kind: "task",
+    id: asString(record.id) ?? "",
+    contextId: asString(record.contextId) ?? "",
+    status,
+    ...rawArtifacts ? {
+      artifacts: rawArtifacts.map(toV03Artifact).filter((artifact) => artifact !== void 0)
+    } : {},
+    ...rawHistory ? {
+      history: rawHistory.map(toV03Message).filter((message) => message !== void 0)
+    } : {},
+    ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {}
+  };
+}
+function toV1Task(task) {
+  return {
+    id: task.id,
+    contextId: task.contextId,
+    status: toV1Status(task.status),
+    ...task.artifacts?.length ? { artifacts: task.artifacts.map(toV1Artifact) } : {},
+    ...task.history?.length ? { history: task.history.map(toV1Message) } : {},
+    ...task.metadata ? { metadata: task.metadata } : {}
+  };
+}
+function toV03PushConfig(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const authentication = asRecord(record.authentication);
+  return {
+    ...asString(record.id) ? { id: asString(record.id) } : {},
+    url: asString(record.url) ?? "",
+    ...asString(record.token) ? { token: asString(record.token) } : {},
+    ...authentication ? {
+      authentication: {
+        ...asString(authentication.scheme) ? { schemes: [authentication.scheme] } : {},
+        ...asString(authentication.credentials) ? { credentials: authentication.credentials } : {}
+      }
+    } : {}
+  };
+}
+function toV1PushConfig(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const config = asRecord(record.pushNotificationConfig) ?? record;
+  const authentication = asRecord(config.authentication);
+  const schemes = asArray(authentication?.schemes);
+  return {
+    ...asString(record.taskId) ? { taskId: asString(record.taskId) } : {},
+    ...asString(config.id) ? { id: asString(config.id) } : {},
+    ...asString(config.url) ? { url: asString(config.url) } : {},
+    ...asString(config.token) ? { token: asString(config.token) } : {},
+    ...schemes?.[0] || asString(authentication?.credentials) ? {
+      authentication: {
+        ...typeof schemes?.[0] === "string" ? { scheme: schemes[0] } : {},
+        ...asString(authentication?.credentials) ? { credentials: asString(authentication?.credentials) } : {}
+      }
+    } : {}
+  };
+}
+function convertParams(method, params) {
+  const record = asRecord(params);
+  if (!record) return params;
+  if (method === "SendMessage" || method === "SendStreamingMessage") {
+    const configuration = asRecord(record.configuration);
+    const push = asRecord(configuration?.taskPushNotificationConfig);
+    return {
+      ...asRecord(record.message) ? { message: toV03Message(record.message) } : {},
+      ...configuration ? {
+        configuration: {
+          ...asArray(configuration.acceptedOutputModes) ? { acceptedOutputModes: configuration.acceptedOutputModes } : {},
+          blocking: configuration.returnImmediately !== true,
+          ...typeof configuration.historyLength === "number" ? { historyLength: configuration.historyLength } : {},
+          ...push ? { pushNotificationConfig: toV03PushConfig(push) } : {}
+        }
+      } : {},
+      ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {}
+    };
+  }
+  if (method === "ListTasks") {
+    return {
+      ...asString(record.contextId) ? { contextId: asString(record.contextId) } : {},
+      ...record.status !== void 0 ? { status: v1TaskStateTo03(record.status) } : {},
+      ...typeof record.pageSize === "number" ? { pageSize: record.pageSize } : {},
+      ...asString(record.pageToken) ? { pageToken: asString(record.pageToken) } : {},
+      ...typeof record.historyLength === "number" ? { historyLength: record.historyLength } : {},
+      ...asString(record.statusTimestampAfter) ? { statusTimestampAfter: asString(record.statusTimestampAfter) } : {},
+      ...typeof record.includeArtifacts === "boolean" ? { includeArtifacts: record.includeArtifacts } : {}
+    };
+  }
+  if (method === "CreateTaskPushNotificationConfig") {
+    const config = toV03PushConfig(record);
+    return {
+      taskId: asString(record.taskId) ?? "",
+      ...config ? { pushNotificationConfig: config } : {}
+    };
+  }
+  if (method === "GetTaskPushNotificationConfig") {
+    return {
+      id: asString(record.taskId) ?? "",
+      ...asString(record.id) ? { pushNotificationConfigId: asString(record.id) } : {}
+    };
+  }
+  if (method === "ListTaskPushNotificationConfigs" || method === "DeleteTaskPushNotificationConfig") {
+    return {
+      id: asString(record.taskId) ?? "",
+      ...asString(record.id) ? { pushNotificationConfigId: asString(record.id) } : {}
+    };
+  }
+  return record;
+}
+function toA2A03JsonRpcRequest(body) {
+  const record = asRecord(body);
+  const method = asString(record?.method);
+  if (!record || !method) return body;
+  const mapped = V1_TO_V03_METHOD[method];
+  if (!mapped) return body;
+  return {
+    ...record,
+    method: mapped,
+    params: convertParams(method, record.params)
+  };
+}
+function toA2A11Result(value, method) {
+  const record = asRecord(value);
+  if (!record) return value;
+  if (record.kind === "task") {
+    const task = toV03Task(record);
+    return task ? toV1Task(task) : value;
+  }
+  if (record.kind === "message") {
+    const message = toV03Message(record);
+    return message ? toV1Message(message) : value;
+  }
+  if (method === "CreateTaskPushNotificationConfig" || method === "GetTaskPushNotificationConfig") {
+    return toV1PushConfig(record);
+  }
+  return value;
+}
+function toA2A11StreamResult(event) {
+  const record = asRecord(event);
+  if (!record) return event;
+  if (record.kind === "task") {
+    const task = toV03Task(record);
+    return task ? { task: toV1Task(task) } : event;
+  }
+  if (record.kind === "message") {
+    const message = toV03Message(record);
+    return message ? { message: toV1Message(message) } : event;
+  }
+  if (record.kind === "status-update") {
+    const status = toV03Status(record.status);
+    return {
+      statusUpdate: {
+        taskId: asString(record.taskId) ?? "",
+        contextId: asString(record.contextId) ?? "",
+        ...status ? { status: toV1Status(status) } : {},
+        ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {}
+      }
+    };
+  }
+  if (record.kind === "artifact-update") {
+    const artifact = toV03Artifact(record.artifact);
+    return {
+      artifactUpdate: {
+        taskId: asString(record.taskId) ?? "",
+        contextId: asString(record.contextId) ?? "",
+        ...artifact ? { artifact: toV1Artifact(artifact) } : {},
+        ...record.append === true ? { append: true } : {},
+        ...record.lastChunk === true ? { lastChunk: true } : {},
+        ...typeof record.metadata === "object" && record.metadata !== null ? { metadata: record.metadata } : {}
+      }
+    };
+  }
+  return event;
+}
+function toA2A11ListResult(value, options = {}) {
+  const record = asRecord(value);
+  const tasks = asArray(record?.tasks) ?? [];
+  return {
+    tasks: tasks.map(toV03Task).filter((task) => task !== void 0).map((task) => {
+      const converted = toV1Task(task);
+      if (options.includeArtifacts !== true) delete converted.artifacts;
+      return converted;
+    }),
+    ...asString(record?.nextPageToken) ? { nextPageToken: asString(record?.nextPageToken) } : {}
+  };
+}
+function toA2A11PushListResult(value) {
+  const configs = asArray(value) ?? [];
+  return {
+    configs: configs.map(toV1PushConfig).filter((config) => config !== void 0)
+  };
+}
+function versionNotSupportedError(id, version) {
+  return {
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: {
+      code: -32009,
+      message: `The requested A2A protocol version '${version}' is not supported. Supported versions: 1.0`
+    }
+  };
+}
+
 // src/services/a2a/A2APushNotificationStore.ts
 import { decrypt, encrypt } from "@axiom-lattice/core";
 
@@ -451,10 +935,10 @@ var A2ATaskScopeConflictError = class extends Error {
 function mapTaskStatusToA2AState(status) {
   return TASK_STATUS_TO_A2A_STATE[status];
 }
-function asString(value) {
+function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asStringArray(value) {
@@ -588,11 +1072,11 @@ var A2ATaskStoreAdapter = class {
     const files = extractFiles(task);
     const result = task.status.state === "completed" ? extractArtifactText(task.artifacts) || extractFinalTurnAgentText(task.history) : void 0;
     const failureReason = extractFailureReason(task);
-    const a2aRunId = asString(task.metadata?.a2aRunId) ?? asString(task.metadata?.runId);
+    const a2aRunId = asString2(task.metadata?.a2aRunId) ?? asString2(task.metadata?.runId);
     const context = {
       a2aContextId: task.contextId,
       ...a2aRunId ? { a2aRunId } : {},
-      threadId: asString(task.metadata?.threadId),
+      threadId: asString2(task.metadata?.threadId),
       a2aTask: task
     };
     let existing = await this.taskStore.getById(tenantId, task.id);
@@ -626,7 +1110,7 @@ var A2ATaskStoreAdapter = class {
       await this.recordSnapshot(task, existing);
     }
     const actor = `a2a:${this.scope.assistantId}`;
-    const threadId = asString(task.metadata?.threadId);
+    const threadId = asString2(task.metadata?.threadId);
     if (task.status.state === "working") {
       existing = await this.refresh(existing);
       const resumesInterruption = existing.status === "interrupted" && task.metadata?.a2aResume === true;
@@ -700,7 +1184,7 @@ var A2ATaskStoreAdapter = class {
   async completeRun(task, result) {
     const { tenantId } = this.scope;
     const actor = `a2a:${this.scope.assistantId}`;
-    const threadId = asString(task.metadata?.threadId);
+    const threadId = asString2(task.metadata?.threadId);
     let item = await this.taskStore.getById(tenantId, task.id);
     if (!item) {
       throw new Error(`A2A completed run cannot reconcile missing task ${task.id}`);
@@ -781,7 +1265,7 @@ var A2ATaskStoreAdapter = class {
       summary: "A2A task snapshot",
       detail: { type: "a2a_task_snapshot", snapshotSequence: sequence, eventKey, task: sequencedTask },
       eventKey,
-      ...asString(task.metadata?.threadId) ? { threadId: asString(task.metadata?.threadId) } : {},
+      ...asString2(task.metadata?.threadId) ? { threadId: asString2(task.metadata?.threadId) } : {},
       ...workspaceId ? { workspaceId } : {}
     });
   }
@@ -802,14 +1286,14 @@ var A2ATaskStoreAdapter = class {
         ...task.status.message ? { message: extractText(task.status.message.parts) } : {}
       },
       eventKey: observationEventKey(task, result, failureReason),
-      ...asString(task.metadata?.threadId) ? { threadId: asString(task.metadata?.threadId) } : {},
+      ...asString2(task.metadata?.threadId) ? { threadId: asString2(task.metadata?.threadId) } : {},
       ...workspaceId ? { workspaceId } : {}
     });
   }
   async applyObservation(task, item, result, failureReason) {
     const actor = `a2a:${this.scope.assistantId}`;
     item = await this.refresh(item);
-    const threadId = asString(task.metadata?.threadId);
+    const threadId = asString2(task.metadata?.threadId);
     if (task.status.state === "canceled") {
       await this.requireLifecycleSuccess("cancel", task.id, await this.runBridge.settleRun({
         tenantId: this.scope.tenantId,
@@ -835,10 +1319,10 @@ var A2ATaskStoreAdapter = class {
       return;
     }
     if (task.status.state === "input-required") {
-      const observed = asRecord(task.metadata?.interruption);
-      const observedType = asString(observed?.type);
+      const observed = asRecord2(task.metadata?.interruption);
+      const observedType = asString2(observed?.type);
       const interruptionType = observedType === "review_required" || observedType === "user_decision" ? "user_decision" : "missing_input";
-      const summary = asString(observed?.summary) || (task.status.message ? extractText(task.status.message.parts).trim() : "") || "A2A requires input";
+      const summary = asString2(observed?.summary) || (task.status.message ? extractText(task.status.message.parts).trim() : "") || "A2A requires input";
       await this.requireLifecycleSuccess("interrupt", task.id, await this.lifecycle.interruptTask({
         tenantId: this.scope.tenantId,
         taskId: task.id,
@@ -869,7 +1353,7 @@ var A2ATaskStoreAdapter = class {
     const item = await this.taskStore.getById(this.scope.tenantId, taskId);
     if (!item) return;
     const context = item.context ?? {};
-    const current = asRecord(context.interruption) ?? {};
+    const current = asRecord2(context.interruption) ?? {};
     await this.taskStore.update(this.scope.tenantId, taskId, {
       context: {
         ...context,
@@ -919,7 +1403,7 @@ var A2ATaskStoreAdapter = class {
         const candidate = {
           task: activity.detail.task,
           sequence,
-          eventKey: asString(activity.detail.eventKey) ?? activity.eventKey ?? snapshotEventKey(activity.detail.task),
+          eventKey: asString2(activity.detail.eventKey) ?? activity.eventKey ?? snapshotEventKey(activity.detail.task),
           statusTimestamp: Date.parse(activity.detail.task.status.timestamp ?? ""),
           createdAt: activity.createdAt,
           id: activity.id
@@ -936,8 +1420,8 @@ var A2ATaskStoreAdapter = class {
     }
     const state = mapTaskStatusToA2AState(item.status);
     const interruption = item.context?.interruption;
-    const contextRunId = asString(item.context?.a2aRunId);
-    const contextThreadId = asString(item.context?.threadId);
+    const contextRunId = asString2(item.context?.a2aRunId);
+    const contextThreadId = asString2(item.context?.threadId);
     const metadata = {
       ...snapshot.metadata ?? {},
       ...contextRunId === void 0 ? {} : { a2aRunId: contextRunId },
@@ -1349,10 +1833,10 @@ var TERMINAL_A2A_STATES = /* @__PURE__ */ new Set([
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function asString2(value) {
+function asString3(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function extractText2(parts) {
@@ -1364,7 +1848,7 @@ function dataParts(parts) {
   );
 }
 function soleOfficialInterruptId(task) {
-  const ids = (task?.artifacts ?? []).filter((artifact) => artifact.name === "interrupt").flatMap((artifact) => artifact.parts).filter((part) => part.kind === "data").map((part) => asString2(part.data.id)).filter((id) => id !== void 0 && isOfficialInterruptId(id));
+  const ids = (task?.artifacts ?? []).filter((artifact) => artifact.name === "interrupt").flatMap((artifact) => artifact.parts).filter((part) => part.kind === "data").map((part) => asString3(part.data.id)).filter((id) => id !== void 0 && isOfficialInterruptId(id));
   return ids.length === 1 ? ids[0] : void 0;
 }
 function agentMessage(text) {
@@ -1397,7 +1881,7 @@ var AxiomAgentExecutor = class {
   /** Execute one A2A request through the durable run service. */
   async execute(ctx, bus) {
     const existing = ctx.task;
-    const threadId = asString2(existing?.metadata?.threadId) ?? ctx.contextId;
+    const threadId = asString3(existing?.metadata?.threadId) ?? ctx.contextId;
     const dependencies = ctx.referenceTasks?.map((task) => task.id) ?? [];
     const resume = this.isResume(existing);
     const text = extractText2(ctx.userMessage.parts);
@@ -1422,7 +1906,7 @@ var AxiomAgentExecutor = class {
         `Task ${existing.id} is terminal (${existing.status.state}) and cannot be modified`
       );
     }
-    const interruption = asRecord2(existing?.metadata?.interruption);
+    const interruption = asRecord3(existing?.metadata?.interruption);
     const reviewInterruption = interruption?.type === "review_required";
     const command = resume ? this.resumeCommand(
       ctx.userMessage.parts,
@@ -1589,7 +2073,7 @@ var AxiomAgentExecutor = class {
       threadId,
       this.scope.assistantId
     ).catch(() => void 0);
-    const runRecord = asRecord2(run);
+    const runRecord = asRecord3(run);
     const abortStream = runRecord?.cancelRequested === true || terminal.status === "timeout";
     if (abortStream) {
       dropChunks = true;
@@ -1610,7 +2094,7 @@ var AxiomAgentExecutor = class {
       case "error": {
         const canonical = this.taskStore ? await this.taskStore.load(ctx.taskId) : void 0;
         const canonicalMessage = canonical?.status.state === "failed" && canonical.status.message ? extractText2(canonical.status.message.parts).trim() : "";
-        const message = canonicalMessage || asString2(runRecord?.error) || (streamError instanceof Error ? streamError.message : void 0) || "A2A run failed";
+        const message = canonicalMessage || asString3(runRecord?.error) || (streamError instanceof Error ? streamError.message : void 0) || "A2A run failed";
         await this.failTask(
           ctx,
           bus,
@@ -1718,8 +2202,8 @@ var AxiomAgentExecutor = class {
       artifactId: `${ctx.taskId}:interrupt`,
       name: "interrupt",
       parts: interrupts.map((interrupt) => {
-        const payload = asRecord2(interrupt.payload);
-        const schema = asRecord2(payload?.response_schema) ?? payload?.response_schema;
+        const payload = asRecord3(interrupt.payload);
+        const schema = asRecord3(payload?.response_schema) ?? payload?.response_schema;
         return {
           kind: "data",
           data: {
@@ -1861,7 +2345,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
     const data = dataParts(parts);
     if (data.length > 0) {
       const officialIds = data.map((part) => {
-        const id = asString2(part.data.id);
+        const id = asString3(part.data.id);
         return id !== void 0 && isOfficialInterruptId(id) ? id : void 0;
       });
       if (data.length > 1 && officialIds.every((id) => id !== void 0)) {
@@ -1917,8 +2401,8 @@ ${formatFileRefsSection(inputFiles)}` : text;
    */
   async cancelTask(taskId, bus) {
     const task = this.taskStore ? await this.taskStore.load(taskId) : void 0;
-    const threadId = asString2(task?.metadata?.threadId);
-    const runId = asString2(task?.metadata?.a2aRunId) ?? asString2(task?.metadata?.runId);
+    const threadId = asString3(task?.metadata?.threadId);
+    const runId = asString3(task?.metadata?.a2aRunId) ?? asString3(task?.metadata?.runId);
     if (threadId && runId) {
       try {
         await this.runService.cancel(
@@ -2321,14 +2805,14 @@ function normalizeCheckpointMessages(messages) {
   messages.forEach((message, index) => {
     if (typeof message !== "object" || message === null) return;
     const record = message;
-    const type = typeof record.getType === "function" ? record.getType() : asString3(record.type) ?? asString3(record.role);
+    const type = typeof record.getType === "function" ? record.getType() : asString4(record.type) ?? asString4(record.role);
     const role = type === "human" || type === "user" ? "user" : type === "ai" || type === "assistant" ? "agent" : void 0;
     if (!role) return;
     const text = messageText(record.content);
     if (!text) return;
     normalized.push({
       kind: "message",
-      messageId: asString3(record.id) ?? `a2a-checkpoint:${index}`,
+      messageId: asString4(record.id) ?? `a2a-checkpoint:${index}`,
       role,
       parts: [{ kind: "text", text }]
     });
@@ -2374,11 +2858,11 @@ var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
   "timeout"
 ]);
 var RESUBSCRIBE_SETTLE_TIMEOUT_MS = 1e4;
-function asString3(value) {
+function asString4(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function requestMethod(body) {
-  return typeof body === "object" && body !== null ? asString3(body.method) : void 0;
+  return typeof body === "object" && body !== null ? asString4(body.method) : void 0;
 }
 function requestTaskId(body) {
   if (typeof body !== "object" || body === null) return void 0;
@@ -2386,11 +2870,11 @@ function requestTaskId(body) {
   const params = typeof record.params === "object" && record.params !== null ? record.params : void 0;
   if (!params) return void 0;
   if (record.method === "tasks/get" || record.method === "tasks/cancel" || record.method === "tasks/resubscribe") {
-    return asString3(params.id);
+    return asString4(params.id);
   }
   if (record.method === "message/send" || record.method === "message/stream") {
     const message = typeof params.message === "object" && params.message !== null ? params.message : void 0;
-    return asString3(message?.taskId);
+    return asString4(message?.taskId);
   }
   return void 0;
 }
@@ -2418,7 +2902,7 @@ function projectRunState(run) {
     case "timeout":
       return {
         state: "failed",
-        ...asString3(run.error) ? { message: agentMessage2(asString3(run.error)) } : {}
+        ...asString4(run.error) ? { message: agentMessage2(asString4(run.error)) } : {}
       };
     default:
       return void 0;
@@ -2497,9 +2981,9 @@ async function reconcileTaskFromRun(taskStore, runService, stateResolver, scope,
   if (isTerminalA2AState(task.status.state)) {
     if (task.status.state !== "completed") return task;
   }
-  const runId = asString3(task.metadata?.a2aRunId);
+  const runId = asString4(task.metadata?.a2aRunId);
   if (!runId) return task;
-  const threadId = asString3(task.metadata?.threadId) ?? task.contextId;
+  const threadId = asString4(task.metadata?.threadId) ?? task.contextId;
   const run = await runService.getRun(
     scope.tenantId,
     runId,
@@ -2591,9 +3075,9 @@ async function cancelTaskFromRun(taskStore, runService, scope, body) {
   if (!taskId) return void 0;
   const task = await taskStore.load(taskId);
   if (!task || isTerminalA2AState(task.status.state)) return void 0;
-  const runId = asString3(task.metadata?.a2aRunId);
+  const runId = asString4(task.metadata?.a2aRunId);
   if (!runId) return void 0;
-  const threadId = asString3(task.metadata?.threadId) ?? task.contextId;
+  const threadId = asString4(task.metadata?.threadId) ?? task.contextId;
   const before = await runService.getRun(
     scope.tenantId,
     runId,
@@ -2697,7 +3181,7 @@ var TASKS_LIST_STATUSES = {
   interrupted: ["interrupted"],
   cancelled: ["cancelled"]
 };
-function asRecord3(value) {
+function asRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function encodePageToken(offset) {
@@ -2711,12 +3195,12 @@ function decodePageToken(token) {
   return Number.isSafeInteger(offset) && offset >= 0 ? offset : void 0;
 }
 function parseTasksListQuery(body) {
-  const record = asRecord3(body);
+  const record = asRecord4(body);
   const rawParams = record?.params;
-  if (rawParams !== void 0 && rawParams !== null && asRecord3(rawParams) === void 0) {
+  if (rawParams !== void 0 && rawParams !== null && asRecord4(rawParams) === void 0) {
     return { ok: false, message: "params must be an object" };
   }
-  const params = asRecord3(rawParams) ?? {};
+  const params = asRecord4(rawParams) ?? {};
   let pageSize = DEFAULT_A2A_TASKS_PAGE_SIZE;
   if (params.pageSize !== void 0) {
     const value = params.pageSize;
@@ -2737,6 +3221,20 @@ function parseTasksListQuery(body) {
     }
     offset = decoded;
   }
+  let contextId;
+  if (params.contextId !== void 0) {
+    if (typeof params.contextId !== "string") {
+      return { ok: false, message: "contextId must be a string" };
+    }
+    contextId = params.contextId;
+  }
+  let statusTimestampAfter;
+  if (params.statusTimestampAfter !== void 0) {
+    if (typeof params.statusTimestampAfter !== "string") {
+      return { ok: false, message: "statusTimestampAfter must be a string" };
+    }
+    statusTimestampAfter = params.statusTimestampAfter;
+  }
   let statuses;
   if (params.status !== void 0) {
     const value = params.status;
@@ -2747,7 +3245,13 @@ function parseTasksListQuery(body) {
   }
   return {
     ok: true,
-    query: { pageSize, offset, ...statuses ? { statuses } : {} }
+    query: {
+      pageSize,
+      offset,
+      ...statuses ? { statuses } : {},
+      ...contextId ? { contextId } : {},
+      ...statusTimestampAfter ? { statusTimestampAfter } : {}
+    }
   };
 }
 function isA2ATaskSnapshot2(value, id) {
@@ -2782,6 +3286,8 @@ async function listCanonicalA2ATasks(internalTasks, taskStore, scope, query) {
       if (statuses && !statuses.includes(item.status)) continue;
       const restored = await taskStore.load(item.id).catch(() => void 0);
       if (!restored || !isA2ATaskSnapshot2(restored, item.id)) continue;
+      if (query.contextId && restored.contextId !== query.contextId) continue;
+      if (query.statusTimestampAfter && (!restored.status.timestamp || restored.status.timestamp <= query.statusTimestampAfter)) continue;
       if (seen.has(restored.id)) continue;
       if (tasks.length < query.pageSize) {
         seen.add(restored.id);
@@ -2880,11 +3386,12 @@ function registerA2AStandardRoutes(app, deps) {
   app.addHook("onClose", async () => {
     runtimeRegistry.close();
   });
-  const handleTaskResubscribe = async (request, reply, requestId, scope, taskStore) => {
-    reply.header("A2A-Version", "0.3");
-    const body = asRecord3(request.body);
-    const params = asRecord3(body?.params);
-    const taskId = asString3(params?.id);
+  const handleTaskResubscribe = async (request, reply, requestId, scope, taskStore, options = {}) => {
+    const version = options.version ?? "0.3";
+    reply.header("A2A-Version", version);
+    const body = asRecord4(options.body ?? request.body);
+    const params = asRecord4(body?.params);
+    const taskId = asString4(params?.id);
     if (!taskId) {
       reply.send(jsonRpcError(requestId, -32602, "Invalid params: id is required"));
       return;
@@ -2917,7 +3424,7 @@ function registerA2AStandardRoutes(app, deps) {
       throw err;
     }
     reply.hijack();
-    reply.raw.writeHead(200, SSE_HEADERS);
+    reply.raw.writeHead(200, { ...SSE_HEADERS, "A2A-Version": version });
     const writeFrame = async (frame, event) => {
       if (reply.raw.writableEnded || reply.raw.destroyed) return;
       const data = `${event ? `event: ${event}
@@ -2938,7 +3445,7 @@ function registerA2AStandardRoutes(app, deps) {
     const resultFrame = (result) => ({
       jsonrpc: "2.0",
       id: requestId,
-      result
+      result: version === "1.0" ? toA2A11StreamResult(result) : result
     });
     let disconnected = false;
     let iterator;
@@ -2959,11 +3466,11 @@ function registerA2AStandardRoutes(app, deps) {
     try {
       await writeFrame(resultFrame(task));
       if (disconnected || isTerminalA2AState(task.status.state)) return;
-      const runId = asString3(task.metadata?.a2aRunId);
+      const runId = asString4(task.metadata?.a2aRunId);
       if (!runId) return;
-      const threadId = asString3(task.metadata?.threadId) ?? task.contextId;
-      const messageId = asString3(task.metadata?.a2aMessageId);
-      const cursor = asString3(task.metadata?.a2aStreamCursor);
+      const threadId = asString4(task.metadata?.threadId) ?? task.contextId;
+      const messageId = asString4(task.metadata?.a2aMessageId);
+      const cursor = asString4(task.metadata?.a2aStreamCursor);
       const runService = runServiceFor(scope);
       const reconcileCanonicalTask = async () => {
         const reconciled = await reconcileTaskFromRun(
@@ -2971,7 +3478,7 @@ function registerA2AStandardRoutes(app, deps) {
           runService,
           stateResolver,
           scope,
-          request.body
+          options.body ?? request.body
         ).catch(() => void 0);
         return reconciled ?? taskStore.load(taskId).catch(() => void 0);
       };
@@ -3409,8 +3916,273 @@ data: ${JSON.stringify(data)}
       }
     }
   );
+  const v1CardFor = (request, assistant, pushNotifications) => buildAgentCardForAssistantV1({
+    assistant,
+    baseUrl: buildBaseUrl(request),
+    pushNotifications
+  });
+  const authenticateV1 = async (request) => {
+    const auth = await authService.authenticate(
+      getHeader(request.headers.authorization) ?? getHeader(request.headers["x-api-key"])
+    );
+    if (!auth.authenticated) {
+      return { ok: false, status: 401, message: "Unauthorized" };
+    }
+    try {
+      const assistant = await authService.assertAgentAccess(
+        auth,
+        request.params.assistantId
+      );
+      return { ok: true, assistant, auth };
+    } catch (err) {
+      if (err instanceof A2AAuthError) {
+        return { ok: false, status: err.statusCode, message: err.message };
+      }
+      throw err;
+    }
+  };
+  app.get(
+    "/a2a/v1/:assistantId/.well-known/agent-card.json",
+    async (request, reply) => {
+      const auth = await authenticateV1(request);
+      if (!auth.ok) {
+        reply.status(auth.status).send({ error: auth.message });
+        return;
+      }
+      reply.header("A2A-Version", "1.0");
+      reply.status(200).send(
+        AgentCardV1.toJSON(
+          v1CardFor(request, auth.assistant, hasPushStore())
+        )
+      );
+    }
+  );
+  app.post(
+    "/a2a/v1/:assistantId",
+    async (request, reply) => {
+      const requestBody = asRecord4(request.body) ?? {};
+      const requestId = extractRequestId(requestBody);
+      reply.header("A2A-Version", "1.0");
+      const requestedVersion = getHeader(request.headers["a2a-version"]);
+      if (requestedVersion !== void 0 && !requestedVersion.startsWith("1.0")) {
+        reply.header("A2A-Version", "1.0").send(versionNotSupportedError(requestId, requestedVersion));
+        return;
+      }
+      const auth = await authenticateV1(request);
+      if (!auth.ok) {
+        reply.status(auth.status).send(jsonRpcError(requestId, authErrorToRpcCode(auth.status), auth.message));
+        return;
+      }
+      const rawMethod = asString4(requestBody.method);
+      const tenantId = auth.auth.tenantId ?? "default";
+      const scope = {
+        tenantId,
+        projectId: auth.auth.projectId ?? "",
+        workspaceId: await resolveWorkspaceId(getProjectStore, tenantId, auth.auth.projectId),
+        assistantId: auth.assistant.id
+      };
+      const internalTasks = resolveTasks();
+      const workItems = resolveTaskWorkItems();
+      const taskStore = taskStoreFor(scope, internalTasks, workItems);
+      if (rawMethod === "ListTasks") {
+        const v03Body2 = toA2A03JsonRpcRequest(requestBody);
+        const parsed = parseTasksListQuery(v03Body2);
+        if (!parsed.ok) {
+          reply.send(jsonRpcError(requestId, -32602, parsed.message));
+          return;
+        }
+        try {
+          const result2 = await listCanonicalA2ATasks(
+            internalTasks,
+            taskStore,
+            scope,
+            parsed.query
+          );
+          const listParams = asRecord4(requestBody.params);
+          reply.send({
+            jsonrpc: "2.0",
+            id: requestId,
+            result: toA2A11ListResult(result2, {
+              includeArtifacts: listParams?.includeArtifacts === true
+            })
+          });
+        } catch (err) {
+          request.log.error({ err }, "a2a:v1:list");
+          reply.send(jsonRpcError(requestId, -32603, "Internal error"));
+        }
+        return;
+      }
+      if (rawMethod === "GetExtendedAgentCard") {
+        reply.send({
+          jsonrpc: "2.0",
+          id: requestId,
+          result: AgentCardV1.toJSON(
+            v1CardFor(request, auth.assistant, hasPushStore())
+          )
+        });
+        return;
+      }
+      const v03Body = toA2A03JsonRpcRequest(requestBody);
+      if (rawMethod === "SubscribeToTask") {
+        await handleTaskResubscribe(
+          request,
+          reply,
+          requestId,
+          scope,
+          taskStore,
+          { version: "1.0", body: v03Body }
+        );
+        return;
+      }
+      const ingestor = makeFileIngestor(scope.tenantId, deps.maxFileBytes);
+      const runService = runServiceFor(scope);
+      const executor = new AxiomAgentExecutor({
+        scope,
+        assistant: auth.assistant,
+        taskStore,
+        ingestor,
+        runService,
+        blocking: blockingFor(v03Body),
+        getInterrupts: (threadId) => stateResolver.getInterrupts(threadId, auth.assistant.id, scope)
+      });
+      try {
+        await reconcileTaskFromRun(
+          taskStore,
+          runService,
+          stateResolver,
+          scope,
+          v03Body
+        );
+        const canceled = await cancelTaskFromRun(
+          taskStore,
+          runService,
+          scope,
+          v03Body
+        );
+        if (canceled) {
+          reply.send({
+            jsonrpc: "2.0",
+            id: requestId,
+            result: toA2A11Result(canceled, rawMethod)
+          });
+          return;
+        }
+      } catch (err) {
+        if (err instanceof A2AError3) {
+          reply.send(jsonRpcError(requestId, err.code, err.message));
+          return;
+        }
+        request.log.error({ err }, "a2a:v1:reconcile");
+        reply.send(jsonRpcError(requestId, -32603, "Internal error"));
+        return;
+      }
+      const resumeError = await resumeValidationError(taskStore, v03Body).catch(() => void 0);
+      if (resumeError !== void 0) {
+        reply.send(jsonRpcError(requestId, -32602, resumeError));
+        return;
+      }
+      let pushStore;
+      try {
+        pushStore = createPushStore(scope);
+      } catch (err) {
+        request.log.warn({ err }, "a2a:v1:push-store-unavailable");
+      }
+      const card = buildAgentCardForAssistant({
+        assistant: auth.assistant,
+        baseUrl: buildBaseUrl(request),
+        pushNotifications: pushStore !== void 0,
+        jsonRpcPath: `/a2a/v1/${auth.assistant.id}`
+      });
+      let runtimeLease;
+      try {
+        runtimeLease = runtimeRegistry.acquire(scope);
+      } catch (err) {
+        if (err instanceof A2ARuntimeCapacityError) {
+          request.log.error({ err, scope }, "a2a:v1:runtime_capacity");
+          reply.status(503).send(jsonRpcError(requestId, -32603, "A2A runtime capacity exhausted"));
+          return;
+        }
+        throw err;
+      }
+      let result;
+      try {
+        const pushSender = pushStore ? deps.getPushNotificationSender?.(pushStore) ?? new A2APushNotificationSender({
+          store: pushStore,
+          ...deps.resolvePushHost ? { resolveHost: deps.resolvePushHost } : {}
+        }) : void 0;
+        const handler = new DefaultRequestHandler(
+          card,
+          taskStore,
+          executor,
+          runtimeLease.manager,
+          pushStore,
+          pushSender
+        );
+        const transport = new JsonRpcTransportHandler(handler);
+        result = await transport.handle(v03Body);
+      } catch (err) {
+        runtimeLease.release();
+        if (err instanceof A2AError3) {
+          reply.send(jsonRpcError(requestId, err.code, err.message));
+          return;
+        }
+        request.log.error({ err }, "a2a:v1:handler");
+        reply.send(jsonRpcError(requestId, -32603, "Internal error"));
+        return;
+      }
+      const convertResult = (value) => {
+        if (rawMethod === "ListTaskPushNotificationConfigs") {
+          return toA2A11PushListResult(value);
+        }
+        const converted = toA2A11Result(value, rawMethod);
+        if (rawMethod === "SendMessage") {
+          if (value && typeof value === "object" && value.kind === "task") {
+            return { task: converted };
+          }
+          if (value && typeof value === "object" && value.kind === "message") {
+            return { message: converted };
+          }
+        }
+        return converted;
+      };
+      if (isAsyncGenerator(result)) {
+        reply.hijack();
+        reply.raw.writeHead(200, SSE_HEADERS);
+        try {
+          for await (const frame of result) {
+            const converted = {
+              ...frame,
+              ..."result" in frame ? { result: toA2A11StreamResult(frame.result) } : {}
+            };
+            reply.raw.write(`data: ${JSON.stringify(converted)}
+
+`);
+          }
+        } catch (err) {
+          request.log.error({ err }, "a2a:v1:stream");
+          const errorResponse = jsonRpcError(
+            requestId,
+            -32603,
+            err instanceof Error ? err.message : "Streaming error."
+          );
+          reply.raw.write(`event: error
+data: ${JSON.stringify(errorResponse)}
+
+`);
+        } finally {
+          runtimeLease.release();
+          reply.raw.end();
+        }
+        return;
+      }
+      runtimeLease.release();
+      reply.send(
+        "result" in result ? { ...result, result: convertResult(result.result) } : result
+      );
+    }
+  );
 }
 export {
   registerA2AStandardRoutes
 };
-//# sourceMappingURL=a2a-standard-DP53K7RC.mjs.map
+//# sourceMappingURL=a2a-standard-VL5I7B4W.mjs.map