@axiom-lattice/gateway 3.0.9 → 4.0.0

package/dist/a2a-standard-U2XYG45L.mjs

@@ -0,0 +1,1376 @@
+import {
+  saveProjectFile
+} from "./chunk-IDOEIBCF.mjs";
+import {
+  A2AAuthError
+} from "./chunk-2HOCF46L.mjs";
+
+// src/routes/a2a-standard.ts
+import { v4 as uuidv42 } from "uuid";
+import {
+  A2AError,
+  DefaultExecutionEventBus as DefaultExecutionEventBus2,
+  DefaultRequestHandler,
+  JsonRpcTransportHandler,
+  RequestContext
+} from "@a2a-js/sdk/server";
+import { createTaskLifecycleService, getStoreLattice } from "@axiom-lattice/core";
+
+// src/services/a2a/A2AAgentCardBuilder.ts
+function buildAgentCardForAssistant(params) {
+  const { assistant, exposure, baseUrl } = params;
+  const jsonRpcUrl = `${baseUrl}/api/a2a/agents/${assistant.id}/jsonrpc`;
+  const skills = (exposure?.skills ?? []).map((s) => ({
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    tags: s.tags ?? [],
+    examples: s.examples ?? []
+  }));
+  return {
+    name: assistant.name,
+    description: assistant.description ?? "",
+    url: jsonRpcUrl,
+    protocolVersion: "0.3.0",
+    version: "1.0.0",
+    defaultInputModes: exposure?.inputModes ?? ["text"],
+    defaultOutputModes: exposure?.outputModes ?? ["text"],
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true
+    },
+    skills,
+    additionalInterfaces: [{ transport: "JSONRPC", url: jsonRpcUrl }],
+    securitySchemes: {
+      bearer: {
+        type: "http",
+        scheme: "Bearer",
+        description: "A2A API key sent as an Authorization Bearer token"
+      },
+      apiKeyHeader: {
+        type: "apiKey",
+        in: "header",
+        name: "x-api-key",
+        description: "A2A API key sent via the x-api-key header"
+      }
+    },
+    security: [{ bearer: [] }, { apiKeyHeader: [] }]
+  };
+}
+
+// src/services/a2a/A2ATaskStoreAdapter.ts
+import { createHash } from "crypto";
+import { isDeepStrictEqual } from "util";
+var TASK_STATUS_TO_A2A_STATE = {
+  pending: "submitted",
+  in_progress: "working",
+  review: "input-required",
+  interrupted: "input-required",
+  completed: "completed",
+  failed: "failed",
+  cancelled: "canceled"
+};
+var TITLE_MAX_LENGTH = 80;
+var A2ATaskScopeConflictError = class extends Error {
+  constructor(taskId) {
+    super(`A2A task ${taskId} belongs to another scope`);
+    this.code = "A2A_TASK_SCOPE_CONFLICT";
+    this.name = "A2ATaskScopeConflictError";
+    this.taskId = taskId;
+  }
+};
+function mapTaskStatusToA2AState(status) {
+  return TASK_STATUS_TO_A2A_STATE[status];
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length > 0 ? strings : void 0;
+}
+function extractText(parts) {
+  return parts.filter((part) => part.kind === "text").map((part) => part.text).join("\n");
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}\u2026`;
+}
+function extractTitleAndDescription(task) {
+  const firstUserMessage = task.history?.find((message) => message.role === "user");
+  const text = firstUserMessage ? extractText(firstUserMessage.parts) : "";
+  return {
+    title: truncate(text, TITLE_MAX_LENGTH),
+    description: text ? [
+      "## Objective",
+      "",
+      text,
+      "",
+      "## Acceptance Criteria",
+      "",
+      "Complete the requested work and return the result through A2A."
+    ].join("\n") : ""
+  };
+}
+function isFileRef(value) {
+  return typeof value === "object" && value !== null && typeof value.uri === "string";
+}
+function artifactFileRefs(artifacts) {
+  const refs = [];
+  for (const artifact of artifacts ?? []) {
+    for (const part of artifact.parts) {
+      if (part.kind !== "file") continue;
+      const file = part.file;
+      if (!("uri" in file)) continue;
+      refs.push({
+        uri: file.uri,
+        ...file.name ? { name: file.name } : {},
+        ...file.mimeType ? { mimeType: file.mimeType } : {},
+        addedBy: "agent"
+      });
+    }
+  }
+  return refs;
+}
+function extractFiles(task) {
+  const inputFiles = task.metadata?.inputFiles;
+  const inputRefs = Array.isArray(inputFiles) ? inputFiles.filter(isFileRef) : [];
+  return [...inputRefs, ...artifactFileRefs(task.artifacts)];
+}
+function extractArtifactText(artifacts) {
+  return (artifacts ?? []).map((artifact) => extractText(artifact.parts)).filter((text) => text.length > 0).join("\n");
+}
+function extractFinalTurnAgentText(history) {
+  const messages = history ?? [];
+  let lastUserIndex = -1;
+  for (let i = 0; i < messages.length; i += 1) {
+    if (messages[i].role === "user") lastUserIndex = i;
+  }
+  return messages.slice(lastUserIndex + 1).filter((message) => message.role === "agent").map((message) => extractText(message.parts)).filter((text) => text.length > 0).join("");
+}
+function isFailureState(state) {
+  return state === "failed" || state === "rejected";
+}
+function extractFailureReason(task) {
+  if (!isFailureState(task.status.state) || !task.status.message) return void 0;
+  return extractText(task.status.message.parts);
+}
+function observationEventKey(task, result, failureReason) {
+  const digest = createHash("sha256").update(JSON.stringify({
+    state: task.status.state,
+    timestamp: task.status.timestamp,
+    message: task.status.message,
+    result,
+    failureReason
+  })).digest("hex");
+  return `a2a-status-observation:${task.id}:${digest}`;
+}
+function snapshotEventKey(task) {
+  const digest = createHash("sha256").update(JSON.stringify(task)).digest("hex");
+  return `a2a-task-snapshot:${task.id}:${digest}`;
+}
+function isGovernedObservation(state) {
+  return state === "completed" || state === "failed" || state === "rejected" || state === "input-required" || state === "canceled";
+}
+function isA2ATaskSnapshot(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.status === "object" && value.status !== null;
+}
+function snapshotSequence(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+var A2ATaskStoreAdapter = class {
+  constructor(options) {
+    this.snapshotSequences = /* @__PURE__ */ new Map();
+    this.taskStore = options.taskStore;
+    this.workItemStore = options.workItemStore;
+    this.lifecycle = options.lifecycle;
+    this.scope = options.scope;
+  }
+  /**
+   * Persist an SDK task by projecting it onto a `TaskItem`, creating it when
+   * the id is unseen or updating it otherwise. A full snapshot of the SDK task
+   * is stored under `context.a2aTask` so `load` can restore it.
+   */
+  async save(task) {
+    const { tenantId } = this.scope;
+    const { title, description } = extractTitleAndDescription(task);
+    const files = extractFiles(task);
+    const result = task.status.state === "completed" ? extractArtifactText(task.artifacts) || extractFinalTurnAgentText(task.history) : void 0;
+    const failureReason = extractFailureReason(task);
+    const context = {
+      a2aContextId: task.contextId,
+      threadId: asString(task.metadata?.threadId),
+      a2aTask: task
+    };
+    let existing = await this.taskStore.getById(tenantId, task.id);
+    if (existing) {
+      this.requireScope(existing, task.id);
+      await this.recordSnapshot(task, existing);
+    } else {
+      try {
+        existing = await this.taskStore.create({
+          id: task.id,
+          tenantId,
+          ownerType: "agent",
+          ownerId: this.scope.assistantId,
+          projectId: this.scope.projectId,
+          title,
+          description,
+          sourceId: "a2a",
+          status: "pending",
+          priority: "medium",
+          dependencies: asStringArray(task.metadata?.dependencies),
+          files,
+          context
+        });
+      } catch (error) {
+        existing = await this.taskStore.getById(tenantId, task.id);
+        if (!existing) throw error;
+        this.requireScope(existing, task.id);
+      }
+      await this.recordSnapshot(task, existing);
+    }
+    const actor = `a2a:${this.scope.assistantId}`;
+    const threadId = asString(task.metadata?.threadId);
+    if (task.status.state === "working") {
+      if (existing.status === "pending") {
+        await this.requireLifecycleSuccess("start", task.id, await this.lifecycle.startTask({
+          tenantId,
+          taskId: task.id,
+          actor,
+          ...threadId ? { threadId } : {}
+        }));
+      }
+      return;
+    }
+    if (!isGovernedObservation(task.status.state)) return;
+    await this.recordObservation(task, existing, result, failureReason);
+    if (["completed", "failed", "cancelled"].includes(existing.status)) return;
+    if (task.status.state === "input-required" && this.isExactInterruptionReplay(task, existing)) return;
+    if (existing.status === "pending") {
+      const started = await this.requireLifecycleSuccess("start", task.id, await this.lifecycle.startTask({
+        tenantId,
+        taskId: task.id,
+        actor,
+        ...threadId ? { threadId } : {}
+      }));
+      existing = started.task;
+    }
+    await this.applyObservation(task, failureReason);
+  }
+  async recordSnapshot(task, item) {
+    const incomingSequence = snapshotSequence(task.metadata?.snapshotSequence) ?? 0;
+    const currentSequence = this.snapshotSequences.get(task.id) ?? 0;
+    const sequence = Math.max(incomingSequence, currentSequence) + 1;
+    this.snapshotSequences.set(task.id, sequence);
+    const sequencedTask = {
+      ...task,
+      metadata: { ...task.metadata ?? {}, snapshotSequence: sequence }
+    };
+    const eventKey = snapshotEventKey(sequencedTask);
+    await this.workItemStore.createIfAbsentByEventKey({
+      tenantId: this.scope.tenantId,
+      taskId: task.id,
+      projectId: this.scope.projectId,
+      action: "activity",
+      actor: `a2a:${this.scope.assistantId}`,
+      summary: "A2A task snapshot",
+      detail: { type: "a2a_task_snapshot", snapshotSequence: sequence, eventKey, task: sequencedTask },
+      eventKey,
+      ...asString(task.metadata?.threadId) ? { threadId: asString(task.metadata?.threadId) } : {},
+      ...item.workspaceId ? { workspaceId: item.workspaceId } : {}
+    });
+  }
+  async recordObservation(task, item, result, failureReason) {
+    await this.workItemStore.createIfAbsentByEventKey({
+      tenantId: this.scope.tenantId,
+      taskId: task.id,
+      projectId: this.scope.projectId,
+      action: "activity",
+      actor: `a2a:${this.scope.assistantId}`,
+      summary: `A2A observed ${task.status.state}`,
+      detail: {
+        type: "a2a_status_observation",
+        state: task.status.state,
+        ...result === void 0 ? {} : { result },
+        ...failureReason === void 0 ? {} : { failureReason },
+        ...task.status.message ? { message: extractText(task.status.message.parts) } : {}
+      },
+      eventKey: observationEventKey(task, result, failureReason),
+      ...asString(task.metadata?.threadId) ? { threadId: asString(task.metadata?.threadId) } : {},
+      ...item.workspaceId ? { workspaceId: item.workspaceId } : {}
+    });
+  }
+  async applyObservation(task, failureReason) {
+    const actor = `a2a:${this.scope.assistantId}`;
+    const threadId = asString(task.metadata?.threadId);
+    if (task.status.state === "canceled") {
+      await this.requireLifecycleSuccess("cancel", task.id, await this.lifecycle.cancelTask({
+        tenantId: this.scope.tenantId,
+        taskId: task.id,
+        actor,
+        summary: "A2A observed canceled",
+        ...threadId ? { threadId } : {}
+      }));
+      return;
+    }
+    if (isFailureState(task.status.state)) {
+      await this.requireLifecycleSuccess("fail", task.id, await this.lifecycle.failTask({
+        tenantId: this.scope.tenantId,
+        taskId: task.id,
+        failureReason: failureReason?.trim() || `A2A observed ${task.status.state}`,
+        actor,
+        ...threadId ? { threadId } : {}
+      }));
+      return;
+    }
+    if (task.status.state === "input-required") {
+      await this.requireLifecycleSuccess("interrupt", task.id, await this.lifecycle.interruptTask({
+        tenantId: this.scope.tenantId,
+        taskId: task.id,
+        type: "missing_input",
+        summary: task.status.message ? extractText(task.status.message.parts).trim() || "A2A requires input" : "A2A requires input",
+        actor,
+        ...threadId ? { threadId } : {}
+      }));
+      return;
+    }
+    const canonical = await this.taskStore.getById(this.scope.tenantId, task.id);
+    if (!canonical || !this.isInScope(canonical)) {
+      throw new Error(`A2A completed observation cannot reconcile missing task ${task.id}`);
+    }
+    if (canonical.status === "completed") return;
+    throw new Error(
+      `A2A completed observation conflicts with canonical ${canonical.status} task ${task.id}`
+    );
+  }
+  async requireLifecycleSuccess(operation, taskId, result) {
+    if (result.success) {
+      if (result.warnings?.length) {
+        console.warn({ event: "a2a:lifecycle:warnings", operation, taskId, warnings: result.warnings });
+      }
+      return result;
+    }
+    throw new Error(`A2A lifecycle ${operation} failed: ${result.code}: ${result.error}`);
+  }
+  isExactInterruptionReplay(task, item) {
+    const observed = task.metadata?.interruption;
+    const canonical = item.context?.interruption;
+    if (item.status !== "interrupted" || !canonical || typeof canonical !== "object") return false;
+    if (observed && typeof observed === "object") return isDeepStrictEqual(observed, canonical);
+    const observedSummary = task.status.message ? extractText(task.status.message.parts).trim() : "";
+    return observedSummary.length > 0 && canonical.summary === observedSummary;
+  }
+  /**
+   * Restore an SDK task from the stored snapshot, overlaying the current
+   * `TaskItem.status` onto `task.status.state`. Returns `undefined` when the
+   * task is unknown to the tenant or has no A2A snapshot.
+   */
+  async load(taskId) {
+    const item = await this.taskStore.getById(this.scope.tenantId, taskId);
+    if (!item || !this.isInScope(item)) return void 0;
+    const pageSize = 100;
+    let selected;
+    for (let offset = 0; ; offset += pageSize) {
+      const activities = await this.workItemStore.list({
+        tenantId: this.scope.tenantId,
+        taskId,
+        action: "activity",
+        order: "desc",
+        limit: pageSize,
+        offset
+      });
+      for (const activity of activities) {
+        if (activity.detail?.type !== "a2a_task_snapshot" || !isA2ATaskSnapshot(activity.detail.task)) continue;
+        const sequence = snapshotSequence(activity.detail.snapshotSequence) ?? snapshotSequence(activity.detail.task.metadata?.snapshotSequence);
+        const candidate = {
+          task: activity.detail.task,
+          sequence,
+          eventKey: asString(activity.detail.eventKey) ?? activity.eventKey ?? snapshotEventKey(activity.detail.task),
+          statusTimestamp: Date.parse(activity.detail.task.status.timestamp ?? ""),
+          createdAt: activity.createdAt,
+          id: activity.id
+        };
+        if (!selected || this.isLaterSnapshot(candidate, selected)) selected = candidate;
+      }
+      if (activities.length < pageSize) break;
+    }
+    const snapshot = selected?.task ?? item.context?.a2aTask;
+    if (!isA2ATaskSnapshot(snapshot)) return void 0;
+    const restoredSequence = selected?.sequence ?? snapshotSequence(snapshot.metadata?.snapshotSequence);
+    if (restoredSequence !== void 0) {
+      this.snapshotSequences.set(taskId, Math.max(this.snapshotSequences.get(taskId) ?? 0, restoredSequence));
+    }
+    const state = mapTaskStatusToA2AState(item.status);
+    const interruption = item.context?.interruption;
+    const metadata = {
+      ...snapshot.metadata ?? {},
+      ...interruption && typeof interruption === "object" ? { interruption } : {}
+    };
+    const nonResultArtifacts = (snapshot.artifacts ?? []).filter((artifact) => artifact.name !== "result");
+    const artifacts = item.status === "completed" && item.result?.trim() ? [...nonResultArtifacts, {
+      artifactId: `${item.id}:result`,
+      name: "result",
+      parts: [{ kind: "text", text: item.result }]
+    }] : nonResultArtifacts;
+    const message = state === "failed" && item.failureReason?.trim() ? {
+      kind: "message",
+      messageId: `${item.id}:failure`,
+      role: "agent",
+      parts: [{ kind: "text", text: item.failureReason }]
+    } : interruption && typeof interruption === "object" && typeof interruption.summary === "string" ? {
+      kind: "message",
+      messageId: `${item.id}:interruption`,
+      role: "agent",
+      parts: [{ kind: "text", text: interruption.summary }]
+    } : snapshot.status.message;
+    return {
+      ...snapshot,
+      metadata,
+      ...artifacts.length > 0 ? { artifacts } : { artifacts: void 0 },
+      status: {
+        ...snapshot.status,
+        state,
+        ...message ? { message } : {}
+      }
+    };
+  }
+  isInScope(item) {
+    return item.tenantId === this.scope.tenantId && item.projectId === this.scope.projectId && item.ownerType === "agent" && item.ownerId === this.scope.assistantId && item.sourceId === "a2a";
+  }
+  requireScope(item, taskId) {
+    if (!this.isInScope(item)) throw new A2ATaskScopeConflictError(taskId);
+  }
+  isLaterSnapshot(candidate, selected) {
+    if (candidate.sequence !== void 0 || selected.sequence !== void 0) {
+      if (candidate.sequence === void 0) return false;
+      if (selected.sequence === void 0) return true;
+      if (candidate.sequence !== selected.sequence) return candidate.sequence > selected.sequence;
+      const candidateTimestamp = Number.isNaN(candidate.statusTimestamp) ? Number.NEGATIVE_INFINITY : candidate.statusTimestamp;
+      const selectedTimestamp = Number.isNaN(selected.statusTimestamp) ? Number.NEGATIVE_INFINITY : selected.statusTimestamp;
+      if (candidateTimestamp !== selectedTimestamp) return candidateTimestamp > selectedTimestamp;
+      return candidate.eventKey > selected.eventKey;
+    }
+    return candidate.createdAt.getTime() > selected.createdAt.getTime() || candidate.createdAt.getTime() === selected.createdAt.getTime() && candidate.id > selected.id;
+  }
+};
+
+// src/services/a2a/AxiomAgentExecutor.ts
+import { v4 as uuidv4 } from "uuid";
+import { agentInstanceManager } from "@axiom-lattice/core";
+import { MessageChunkTypes } from "@axiom-lattice/protocols";
+
+// src/services/a2a/a2aFileRefs.ts
+function filePartsToRefs(parts, addedBy) {
+  const refs = [];
+  for (const part of parts) {
+    if (part.kind !== "file") continue;
+    const file = part.file;
+    if ("bytes" in file) {
+      throw new Error(
+        "A2A file parts with inline bytes are not supported by this pure function \u2014 bytes ingest requires filePartsToRefsWithIngest with an A2AFileIngestor; provide a file uri otherwise"
+      );
+    }
+    refs.push({
+      uri: file.uri,
+      ...file.name ? { name: file.name } : {},
+      ...file.mimeType ? { mimeType: file.mimeType } : {},
+      addedBy
+    });
+  }
+  return refs;
+}
+function formatFileRefsSection(refs) {
+  const lines = refs.map((ref) => {
+    const label = ref.name ?? ref.uri;
+    const mime = ref.mimeType ? ` (${ref.mimeType})` : "";
+    return `- ${label}${mime}: ${ref.uri}`;
+  });
+  return ["[\u9644\u4EF6]", ...lines].join("\n");
+}
+async function filePartsToRefsWithIngest(parts, addedBy, ingestor, dedupeKeyBase, projectId) {
+  if (!ingestor) {
+    return filePartsToRefs(parts, addedBy);
+  }
+  const refs = [];
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+    if (part.kind !== "file") continue;
+    const dedupeKey = `${dedupeKeyBase}:${index}`;
+    refs.push(await ingestor.ingest(part, dedupeKey, projectId, addedBy));
+  }
+  return refs;
+}
+
+// src/services/a2a/AxiomAgentExecutor.ts
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function extractText2(parts) {
+  return parts.filter((part) => part.kind === "text").map((part) => part.text).join("\n");
+}
+function agentMessage(text) {
+  return {
+    kind: "message",
+    messageId: uuidv4(),
+    role: "agent",
+    parts: [{ kind: "text", text }]
+  };
+}
+var _AxiomAgentExecutor = class _AxiomAgentExecutor {
+  constructor(options) {
+    this.scope = options.scope;
+    this.assistant = options.assistant;
+    this.taskStore = options.taskStore;
+    this.ingestor = options.ingestor;
+  }
+  /**
+   * Execute the incoming message on the bound internal agent and publish the
+   * resulting task/status/artifact events onto the bus.
+   */
+  async execute(ctx, bus) {
+    const execution = { canceled: false };
+    const taskKey = this.taskKey(ctx.taskId);
+    const active = _AxiomAgentExecutor.executions.get(taskKey) ?? /* @__PURE__ */ new Set();
+    active.add(execution);
+    _AxiomAgentExecutor.executions.set(taskKey, active);
+    const text = extractText2(ctx.userMessage.parts);
+    const existing = ctx.task;
+    const threadId = asString2(existing?.metadata?.threadId) ?? uuidv4();
+    const dependencies = ctx.referenceTasks?.map((task) => task.id) ?? [];
+    const createTask = (inputFiles) => ({
+      kind: "task",
+      id: ctx.taskId,
+      contextId: ctx.contextId,
+      ...existing?.history ? { history: existing.history } : {},
+      ...existing?.artifacts ? { artifacts: existing.artifacts } : {},
+      status: { state: "working", timestamp: isoNow() },
+      metadata: { threadId, dependencies, inputFiles }
+    });
+    const publishFailed = (err) => {
+      bus.publish({
+        kind: "status-update",
+        taskId: ctx.taskId,
+        contextId: ctx.contextId,
+        status: {
+          state: "failed",
+          message: agentMessage(err instanceof Error ? err.message : String(err)),
+          timestamp: isoNow()
+        },
+        final: true
+      });
+    };
+    try {
+      try {
+        if (!this.taskStore) {
+          throw new Error("A2A governed execution requires a canonical task store");
+        }
+        this.assertGovernedTaskCapability();
+      } catch (err) {
+        const initialTask2 = createTask([]);
+        if (this.taskStore) await this.taskStore.save(initialTask2);
+        bus.publish(initialTask2);
+        publishFailed(err);
+        return;
+      }
+      const interruption = existing?.metadata?.interruption;
+      const reviewInterruption = interruption && typeof interruption === "object" && interruption.type === "review_required";
+      const reviewCommand = reviewInterruption ? this.reviewCommand(text) : void 0;
+      if (reviewInterruption && !reviewCommand) {
+        bus.publish(agentMessage("Review response must be exactly 'approve', 'reject', or 'reject: <note>'."));
+        return;
+      }
+      let inputFiles;
+      try {
+        inputFiles = await filePartsToRefsWithIngest(
+          ctx.userMessage.parts,
+          "user",
+          this.ingestor,
+          ctx.taskId,
+          this.scope.projectId
+        );
+      } catch (err) {
+        const initialTask2 = createTask([]);
+        if (this.taskStore) await this.taskStore.save(initialTask2);
+        bus.publish(initialTask2);
+        publishFailed(err);
+        return;
+      }
+      const initialTask = createTask(inputFiles);
+      await this.taskStore.save(initialTask);
+      bus.publish(initialTask);
+      try {
+        const agent = agentInstanceManager.getAgent({
+          assistant_id: this.scope.assistantId,
+          thread_id: threadId,
+          tenant_id: this.scope.tenantId,
+          project_id: this.scope.projectId
+        });
+        const requestText = inputFiles.length > 0 ? `${text}
+
+${formatFileRefsSection(inputFiles)}` : text;
+        const messageText = [
+          `A2A governed task instruction: get and update the existing TaskItem ${ctx.taskId}; do not create a replacement task.`,
+          "Before doing the requested work, initialize its canonical description through manage_task with ## Objective, ## Acceptance Criteria, and ## Belief State sections.",
+          "Keep lifecycle status truthful. Complete only through manage_task update with a nonblank result and structured beliefImpact; use interrupted, failed, or cancelled when appropriate.",
+          "",
+          requestText
+        ].join("\n");
+        const continuationCommand = interruption && typeof interruption === "object" ? { resume: text } : void 0;
+        const { messageId } = await agent.addMessage({
+          input: { message: messageText },
+          ...reviewCommand || continuationCommand ? { command: reviewCommand ?? continuationCommand } : {},
+          custom_run_config: { taskId: ctx.taskId }
+        });
+        const stream = agent.chunkStream(messageId, [
+          MessageChunkTypes.MESSAGE_COMPLETED
+        ]);
+        for await (const chunk of stream) {
+          if (execution.canceled) return;
+          const chunkType = chunk.type;
+          const chunkText = chunk.data?.content ?? "";
+          if (chunkType === MessageChunkTypes.INTERRUPT) {
+            break;
+          }
+          if (chunkType === MessageChunkTypes.AI || chunkType === MessageChunkTypes.TOOL) {
+            if (chunkText) {
+              bus.publish({
+                kind: "status-update",
+                taskId: ctx.taskId,
+                contextId: ctx.contextId,
+                status: {
+                  state: "working",
+                  message: agentMessage(chunkText),
+                  timestamp: isoNow()
+                },
+                final: false
+              });
+            }
+          }
+        }
+        if (execution.canceled) return;
+        const canonical = await this.taskStore.load(ctx.taskId);
+        const canonicalState = canonical?.status.state;
+        if (canonicalState === "completed") {
+          const resultArtifact = canonical?.artifacts?.find((artifact) => artifact.name === "result");
+          if (!resultArtifact) {
+            throw new Error(`Canonical completed task ${ctx.taskId} has no result artifact`);
+          }
+          if (execution.canceled) return;
+          bus.publish({
+            kind: "artifact-update",
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            artifact: resultArtifact
+          });
+        }
+        if (canonicalState === "completed" || canonicalState === "failed" || canonicalState === "canceled") {
+          if (execution.canceled) return;
+          bus.publish({
+            kind: "status-update",
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: {
+              state: canonicalState,
+              ...canonical?.status.message ? { message: canonical.status.message } : {},
+              timestamp: isoNow()
+            },
+            final: true
+          });
+          return;
+        }
+        if (canonicalState === "input-required") {
+          bus.publish({
+            kind: "status-update",
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: {
+              state: "input-required",
+              ...canonical?.status.message ? { message: canonical.status.message } : {},
+              timestamp: isoNow()
+            },
+            final: true
+          });
+          return;
+        }
+        bus.publish({
+          kind: "status-update",
+          taskId: ctx.taskId,
+          contextId: ctx.contextId,
+          status: {
+            state: "failed",
+            message: agentMessage("Agent did not complete governed task lifecycle"),
+            timestamp: isoNow()
+          },
+          final: true
+        });
+      } catch (err) {
+        publishFailed(err);
+      }
+    } finally {
+      active.delete(execution);
+      if (active.size === 0) _AxiomAgentExecutor.executions.delete(taskKey);
+    }
+  }
+  reviewCommand(text) {
+    const trimmed = text.trim();
+    const normalized = trimmed.toLowerCase();
+    if (normalized === "approve") return { resume: { action: "approve" } };
+    if (normalized === "reject") {
+      return { resume: { action: "reject", data: { note: "Changes requested." } } };
+    }
+    const prefixedNote = /^reject:\s*(.+)$/is.exec(trimmed)?.[1]?.trim();
+    if (prefixedNote) {
+      return { resume: { action: "reject", data: { note: prefixedNote } } };
+    }
+    return void 0;
+  }
+  taskKey(taskId) {
+    return `${this.scope.tenantId}:${this.scope.projectId}:${this.scope.assistantId}:${taskId}`;
+  }
+  assertGovernedTaskCapability() {
+    const graph = this.assistant.graphDefinition;
+    const middleware = graph && typeof graph === "object" ? graph.middleware : void 0;
+    const taskMiddleware = Array.isArray(middleware) ? middleware.find((entry) => !!entry && typeof entry === "object" && entry.type === "task" && entry.enabled === true) : void 0;
+    const allowedTools = taskMiddleware?.allowedTools;
+    const exposesManageTask = taskMiddleware && (allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task")));
+    if (!exposesManageTask) {
+      throw new Error("A2A execution requires enabled TaskMiddleware exposing manage_task");
+    }
+  }
+  /**
+   * Cancel a running task: resolve its thread id from the task store, abort the
+   * underlying agent, and publish the terminal `canceled` event.
+   */
+  async cancelTask(taskId, bus) {
+    for (const execution of _AxiomAgentExecutor.executions.get(this.taskKey(taskId)) ?? []) {
+      execution.canceled = true;
+    }
+    const task = this.taskStore ? await this.taskStore.load(taskId) : void 0;
+    const threadId = task ? asString2(task.metadata?.threadId) : void 0;
+    if (threadId) {
+      try {
+        const agent = agentInstanceManager.getAgent({
+          assistant_id: this.scope.assistantId,
+          thread_id: threadId,
+          tenant_id: this.scope.tenantId,
+          project_id: this.scope.projectId
+        });
+        await agent.abort();
+      } catch (err) {
+        console.warn({
+          event: "a2a:cancel:no_agent",
+          taskId,
+          threadId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    bus.publish({
+      kind: "status-update",
+      taskId,
+      contextId: task?.contextId ?? "",
+      status: { state: "canceled", timestamp: isoNow() },
+      final: true
+    });
+  }
+};
+_AxiomAgentExecutor.executions = /* @__PURE__ */ new Map();
+var AxiomAgentExecutor = _AxiomAgentExecutor;
+
+// src/services/a2a/A2AFileIngestor.ts
+var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".exe",
+  ".sh",
+  ".bat",
+  ".cmd",
+  ".com",
+  ".msi",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ps1",
+  ".vbs",
+  ".dll",
+  ".so",
+  ".dylib"
+]);
+var EXECUTABLE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/x-msdownload",
+  "application/x-msdos-program",
+  "application/x-executable",
+  "application/x-sh",
+  "application/x-bat",
+  "application/x-shellscript",
+  "text/x-shellscript",
+  "application/javascript",
+  "application/x-javascript",
+  "text/javascript"
+]);
+function decodeBase64(value) {
+  return new Uint8Array(Buffer.from(value, "base64"));
+}
+function maxEncodedLengthFor(maxBytes) {
+  return Math.ceil(maxBytes * 4 / 3) + 4;
+}
+function sanitizePathSegment(segment, fallback) {
+  const cleaned = segment.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/\.{2,}/g, ".").replace(/^[.-]+|[.-]+$/g, "");
+  return cleaned.length > 0 ? cleaned : fallback;
+}
+function storageLocationFor(dedupeKey, name) {
+  const separatorIndex = dedupeKey.lastIndexOf(":");
+  const keyBase = separatorIndex >= 0 ? dedupeKey.slice(0, separatorIndex) : dedupeKey;
+  const keyIndex = separatorIndex >= 0 ? dedupeKey.slice(separatorIndex + 1) : "0";
+  return {
+    path: `a2a/${sanitizePathSegment(keyBase, "task")}`,
+    name: `${sanitizePathSegment(keyIndex, "0")}-${sanitizePathSegment(name, "file")}`
+  };
+}
+function extensionOf(name) {
+  return name.includes(".") ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
+}
+function assertAllowedFileType(name, mimeType) {
+  if (EXECUTABLE_EXTENSIONS.has(extensionOf(name))) {
+    throw new Error(`Refusing to ingest executable file "${name}"`);
+  }
+  if (mimeType && EXECUTABLE_MIME_TYPES.has(mimeType.toLowerCase())) {
+    throw new Error(`Refusing to ingest executable file "${name}"`);
+  }
+}
+var A2AFileIngestor = class {
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.saveProjectFile = options.saveProjectFile;
+    this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  }
+  /**
+   * Project a single file part onto a {@link TaskFileRef}, ingesting bytes when
+   * present. Idempotent per `dedupeKey`: a repeated key returns the cached URI
+   * without re-writing storage, and even across ingestor instances the key
+   * maps to a deterministic storage path (`a2a/<taskId>/<partIndex>-<name>`),
+   * so request retries overwrite the same object.
+   *
+   * NOTE: the key is based on `taskId` + part index rather than the internal
+   * message id because the executor must ingest files *before* `addMessage`
+   * returns a messageId. A client retrying with a different taskId for the
+   * same message writes a second copy; that is accepted and documented.
+   */
+  async ingest(part, dedupeKey, projectId, addedBy) {
+    const file = part.file;
+    if ("uri" in file) {
+      return {
+        uri: file.uri,
+        ...file.name ? { name: file.name } : {},
+        ...file.mimeType ? { mimeType: file.mimeType } : {},
+        addedBy
+      };
+    }
+    const name = file.name ?? "file";
+    assertAllowedFileType(name, file.mimeType);
+    if (file.bytes.length > maxEncodedLengthFor(this.maxBytes)) {
+      throw new Error(
+        `A2A file part exceeds the ${this.maxBytes} byte ingest limit`
+      );
+    }
+    const bytes = decodeBase64(file.bytes);
+    if (bytes.length > this.maxBytes) {
+      throw new Error(
+        `A2A file part exceeds the ${this.maxBytes} byte ingest limit`
+      );
+    }
+    const cached = this.cache.get(dedupeKey);
+    if (cached !== void 0) {
+      return {
+        uri: cached,
+        ...file.name ? { name: file.name } : {},
+        ...file.mimeType ? { mimeType: file.mimeType } : {},
+        addedBy
+      };
+    }
+    const location = storageLocationFor(dedupeKey, name);
+    const { uri } = await this.saveProjectFile({
+      projectId,
+      name: location.name,
+      path: location.path,
+      bytes,
+      ...file.mimeType ? { mimeType: file.mimeType } : {}
+    });
+    this.cache.set(dedupeKey, uri);
+    return {
+      uri,
+      ...file.name ? { name: file.name } : {},
+      ...file.mimeType ? { mimeType: file.mimeType } : {},
+      addedBy
+    };
+  }
+};
+
+// src/services/a2a/A2ARuntimeRegistry.ts
+import {
+  DefaultExecutionEventBus
+} from "@a2a-js/sdk/server";
+var DEFAULT_MAX_SCOPES = 1e3;
+var DEFAULT_IDLE_TTL_MS = 15 * 60 * 1e3;
+var A2ARuntimeCapacityError = class extends Error {
+  constructor(maxScopes) {
+    super(`A2A runtime scope capacity of ${maxScopes} is exhausted`);
+    this.name = "A2ARuntimeCapacityError";
+  }
+};
+var ScopedExecutionEventBusManager = class {
+  constructor(touch) {
+    this.buses = /* @__PURE__ */ new Map();
+    this.touch = touch;
+  }
+  createOrGetByTaskId(taskId) {
+    this.touch();
+    const existing = this.buses.get(taskId);
+    if (existing) return existing;
+    const bus = new DefaultExecutionEventBus();
+    this.buses.set(taskId, bus);
+    return bus;
+  }
+  getByTaskId(taskId) {
+    this.touch();
+    return this.buses.get(taskId);
+  }
+  cleanupByTaskId(taskId) {
+    this.touch();
+    const bus = this.buses.get(taskId);
+    bus?.removeAllListeners();
+    this.buses.delete(taskId);
+  }
+  get activeBusCount() {
+    return this.buses.size;
+  }
+  close() {
+    for (const bus of this.buses.values()) {
+      bus.removeAllListeners();
+    }
+    this.buses.clear();
+  }
+};
+var A2ARuntimeRegistry = class {
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.maxScopes = options.maxScopes ?? DEFAULT_MAX_SCOPES;
+    this.idleTtlMs = options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+    this.now = options.now ?? Date.now;
+  }
+  /**
+   * Acquire and pin the runtime manager for an authorization scope.
+   *
+   * @param scope Exact tenant, project, and assistant authorization scope.
+   * @returns A lease whose manager is shared only within that scope.
+   */
+  acquire(scope) {
+    if (this.closed) throw new Error("A2A runtime registry is closed");
+    const now = this.now();
+    this.pruneExpired(now);
+    const key = JSON.stringify([
+      scope.tenantId,
+      scope.projectId,
+      scope.assistantId
+    ]);
+    const existing = this.entries.get(key);
+    const entry = existing ?? this.createEntry(key, now);
+    entry.lastAccessedAt = now;
+    entry.leaseCount += 1;
+    let released = false;
+    return {
+      manager: entry.manager,
+      release: () => {
+        if (released) return;
+        released = true;
+        entry.leaseCount -= 1;
+        entry.lastAccessedAt = this.now();
+      }
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const entry of this.entries.values()) {
+      entry.manager.close();
+    }
+    this.entries.clear();
+  }
+  pruneExpired(now) {
+    for (const [key, entry] of this.entries) {
+      if (!this.isActive(entry) && now - entry.lastAccessedAt > this.idleTtlMs) {
+        entry.manager.close();
+        this.entries.delete(key);
+      }
+    }
+  }
+  makeCapacity() {
+    if (this.entries.size < this.maxScopes) return;
+    let oldest;
+    for (const candidate of this.entries) {
+      if (this.isActive(candidate[1])) continue;
+      if (!oldest || candidate[1].lastAccessedAt < oldest[1].lastAccessedAt) {
+        oldest = candidate;
+      }
+    }
+    if (!oldest) throw new A2ARuntimeCapacityError(this.maxScopes);
+    oldest[1].manager.close();
+    this.entries.delete(oldest[0]);
+  }
+  createEntry(key, now) {
+    this.makeCapacity();
+    const entry = {
+      lastAccessedAt: now,
+      leaseCount: 0,
+      manager: new ScopedExecutionEventBusManager(() => {
+        entry.lastAccessedAt = this.now();
+      })
+    };
+    this.entries.set(key, entry);
+    return entry;
+  }
+  isActive(entry) {
+    return entry.leaseCount > 0 || entry.manager.activeBusCount > 0;
+  }
+};
+
+// src/routes/a2a-standard.ts
+function getHeader(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function getTenantHeader(request) {
+  return getHeader(request.headers["x-tenant-id"]) ?? "default";
+}
+function getSessionUser(request) {
+  return request.user;
+}
+function getSessionTenantId(request) {
+  const userTenantId = getSessionUser(request)?.tenantId;
+  if (userTenantId) return userTenantId;
+  return getTenantHeader(request);
+}
+function buildBaseUrl(request) {
+  const protocol = getHeader(request.headers["x-forwarded-proto"]) ?? request.protocol;
+  const forwardedHost = getHeader(request.headers["x-forwarded-host"]);
+  const host = forwardedHost ? forwardedHost.split(",")[0].trim() : request.host;
+  return `${protocol}://${host}`;
+}
+function getExposure(assistant) {
+  const graphDefinition = assistant.graphDefinition;
+  return graphDefinition?.a2aExposure;
+}
+function makeFileIngestor(tenantId, maxFileBytes) {
+  return new A2AFileIngestor({
+    saveProjectFile: (params) => saveProjectFile({ tenantId, ...params }),
+    ...maxFileBytes !== void 0 ? { maxBytes: maxFileBytes } : {}
+  });
+}
+function extractRequestId(body) {
+  if (typeof body === "object" && body !== null && "id" in body) {
+    const id = body.id;
+    if (typeof id === "string" || typeof id === "number" || id === null) {
+      return id;
+    }
+  }
+  return null;
+}
+function authErrorToRpcCode(statusCode) {
+  switch (statusCode) {
+    case 401:
+      return -32001;
+    case 403:
+      return -32002;
+    case 404:
+      return -32003;
+    default:
+      return -32603;
+  }
+}
+function jsonRpcError(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+function isAsyncGenerator(value) {
+  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
+}
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "Access-Control-Allow-Origin": "*",
+  "A2A-Version": "0.3"
+};
+function registerA2AStandardRoutes(app, deps) {
+  const authService = deps.authService;
+  const getTaskStore = deps.getTaskStoreLattice ?? (() => getStoreLattice("default", "task").store);
+  const getTaskWorkItemStore = deps.getTaskWorkItemStore ?? (() => getStoreLattice("default", "taskWorkItem").store);
+  const getAssistantStore = deps.getAssistantStore ?? (() => getStoreLattice("default", "assistant").store);
+  const getProjectStore = deps.getProjectStore ?? (() => getStoreLattice("default", "project").store);
+  const getTenantStore = deps.getTenantStore ?? (() => {
+    try {
+      return getStoreLattice("default", "tenant").store;
+    } catch {
+      return void 0;
+    }
+  });
+  async function findExposedAssistant(request, assistantId) {
+    const tenantId = getSessionTenantId(request);
+    const direct = await getAssistantStore().getAssistantById(
+      tenantId,
+      assistantId
+    );
+    if (direct) return direct;
+    const tenantStore = getTenantStore();
+    if (!tenantStore) return null;
+    const tenants = await tenantStore.getAllTenants();
+    for (const tenant of tenants) {
+      if (tenant.id === tenantId) continue;
+      const found = await getAssistantStore().getAssistantById(
+        tenant.id,
+        assistantId
+      );
+      if (found) return found;
+    }
+    return null;
+  }
+  const runtimeRegistry = deps.runtimeRegistry ?? new A2ARuntimeRegistry();
+  app.addHook("onClose", async () => {
+    runtimeRegistry.close();
+  });
+  app.get(
+    "/api/a2a/agents/:assistantId/.well-known/agent-card.json",
+    async (request, reply) => {
+      const assistant = await findExposedAssistant(
+        request,
+        request.params.assistantId
+      );
+      if (!assistant || getExposure(assistant)?.enabled !== true) {
+        reply.status(404).send({ error: "Not found" });
+        return;
+      }
+      reply.header("A2A-Version", "0.3");
+      reply.status(200).send(
+        buildAgentCardForAssistant({
+          assistant,
+          exposure: getExposure(assistant),
+          baseUrl: buildBaseUrl(request)
+        })
+      );
+    }
+  );
+  app.post(
+    "/api/a2a/agents/:assistantId/jsonrpc",
+    async (request, reply) => {
+      const requestId = extractRequestId(request.body);
+      const auth = await authService.authenticate(
+        getHeader(request.headers.authorization) ?? getHeader(request.headers["x-api-key"])
+      );
+      if (!auth.authenticated) {
+        reply.status(401).send(jsonRpcError(requestId, -32001, "Unauthorized"));
+        return;
+      }
+      let assistant;
+      try {
+        assistant = await authService.assertExposedAgent(
+          auth,
+          request.params.assistantId
+        );
+      } catch (err) {
+        if (err instanceof A2AAuthError) {
+          reply.status(err.statusCode).send(
+            jsonRpcError(
+              requestId,
+              authErrorToRpcCode(err.statusCode),
+              err.message
+            )
+          );
+          return;
+        }
+        request.log.error({ err }, "a2a:jsonrpc:auth");
+        reply.status(500).send(jsonRpcError(requestId, -32603, "Internal error"));
+        return;
+      }
+      const scope = {
+        tenantId: auth.tenantId ?? "default",
+        projectId: auth.projectId ?? "",
+        assistantId: assistant.id
+      };
+      const internalTaskStore = getTaskStore();
+      const workItemStore = getTaskWorkItemStore();
+      const taskStore = new A2ATaskStoreAdapter({
+        taskStore: internalTaskStore,
+        workItemStore,
+        lifecycle: createTaskLifecycleService({
+          taskStore: internalTaskStore,
+          workItemStore
+        }),
+        scope
+      });
+      const ingestor = makeFileIngestor(scope.tenantId, deps.maxFileBytes);
+      const executor = new AxiomAgentExecutor({ scope, assistant, taskStore, ingestor });
+      const card = buildAgentCardForAssistant({
+        assistant,
+        exposure: getExposure(assistant),
+        baseUrl: buildBaseUrl(request)
+      });
+      let runtimeLease;
+      try {
+        runtimeLease = runtimeRegistry.acquire(scope);
+      } catch (err) {
+        if (err instanceof A2ARuntimeCapacityError) {
+          request.log.error({ err, scope }, "a2a:jsonrpc:runtime_capacity");
+          reply.status(503).send(jsonRpcError(requestId, -32603, "A2A runtime capacity exhausted"));
+          return;
+        }
+        throw err;
+      }
+      let result;
+      try {
+        const handler = new DefaultRequestHandler(
+          card,
+          taskStore,
+          executor,
+          runtimeLease.manager
+        );
+        const transport = new JsonRpcTransportHandler(handler);
+        reply.header("A2A-Version", "0.3");
+        result = await transport.handle(request.body);
+      } catch (err) {
+        runtimeLease.release();
+        request.log.error({ err }, "a2a:jsonrpc:handler");
+        reply.status(500).send(jsonRpcError(requestId, -32603, "Internal error"));
+        return;
+      }
+      if (isAsyncGenerator(result)) {
+        reply.hijack();
+        reply.raw.writeHead(200, SSE_HEADERS);
+        try {
+          for await (const evt of result) {
+            reply.raw.write(`data: ${JSON.stringify(evt)}
+
+`);
+          }
+        } catch (err) {
+          request.log.error({ err }, "a2a:jsonrpc:stream");
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: requestId,
+            error: A2AError.internalError(
+              err instanceof Error ? err.message : "Streaming error."
+            ).toJSONRPCError()
+          };
+          reply.raw.write(`event: error
+data: ${JSON.stringify(errorResponse)}
+
+`);
+        } finally {
+          runtimeLease.release();
+          reply.raw.end();
+        }
+        return;
+      }
+      runtimeLease.release();
+      reply.send(result);
+    }
+  );
+  app.post(
+    "/api/a2a/agents/:assistantId/test-call",
+    async (request, reply) => {
+      const user = getSessionUser(request);
+      if (!user?.tenantId) {
+        reply.status(401).send({ success: false, error: "Unauthorized" });
+        return;
+      }
+      const tenantId = user.tenantId;
+      const body = request.body ?? {};
+      const { projectId, message } = body;
+      if (!projectId) {
+        reply.status(400).send({ error: "projectId is required" });
+        return;
+      }
+      if (!message || !message.trim()) {
+        reply.status(400).send({ error: "message is required" });
+        return;
+      }
+      const assistant = await getAssistantStore().getAssistantById(
+        tenantId,
+        request.params.assistantId
+      );
+      if (!assistant) {
+        reply.status(404).send({ error: "Assistant not found" });
+        return;
+      }
+      const project = await getProjectStore().getProjectById(
+        tenantId,
+        projectId
+      );
+      if (!project || project.tenantId !== tenantId) {
+        reply.status(403).send({ error: "Project not found" });
+        return;
+      }
+      const scope = {
+        tenantId,
+        projectId,
+        assistantId: assistant.id
+      };
+      const ingestor = makeFileIngestor(scope.tenantId, deps.maxFileBytes);
+      const internalTaskStore = getTaskStore();
+      const workItemStore = getTaskWorkItemStore();
+      const taskStore = new A2ATaskStoreAdapter({
+        taskStore: internalTaskStore,
+        workItemStore,
+        lifecycle: createTaskLifecycleService({
+          taskStore: internalTaskStore,
+          workItemStore
+        }),
+        scope
+      });
+      const executor = new AxiomAgentExecutor({ scope, assistant, taskStore, ingestor });
+      const taskId = uuidv42();
+      const contextId = uuidv42();
+      const userMessage = {
+        kind: "message",
+        messageId: uuidv42(),
+        role: "user",
+        parts: [{ kind: "text", text: message }]
+      };
+      const requestContext = new RequestContext(userMessage, taskId, contextId);
+      const bus = new DefaultExecutionEventBus2();
+      reply.hijack();
+      reply.raw.writeHead(200, SSE_HEADERS);
+      const sendEvent = (event, data) => {
+        reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+      };
+      bus.on("event", (event) => {
+        sendEvent(event.kind, event);
+      });
+      try {
+        await executor.execute(requestContext, bus);
+      } catch (err) {
+        request.log.error({ err }, "a2a:test-call:execution");
+        sendEvent("status-update", {
+          kind: "status-update",
+          taskId,
+          contextId,
+          status: { state: "failed", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          final: true
+        });
+      } finally {
+        reply.raw.end();
+      }
+    }
+  );
+}
+export {
+  registerA2AStandardRoutes
+};
+//# sourceMappingURL=a2a-standard-U2XYG45L.mjs.map