@ap3x/a2a 1.0.0 → 2.1.0

package/dist/chunk-PYM7LV6R.js

@@ -0,0 +1,1590 @@
+// src/model.ts
+import { Type } from "@sinclair/typebox";
+var A2A_PROTOCOL_VERSION = "1.0.0";
+var A2A_CARD_PROTOCOL_VERSION = "0.3.0";
+var TASK_STATES = [
+  "submitted",
+  "working",
+  "input_required",
+  "auth_required",
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+];
+var TERMINAL_TASK_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+]);
+function isTerminal(state) {
+  return TERMINAL_TASK_STATES.has(state);
+}
+var TaskStateSchema = Type.Union(TASK_STATES.map((state) => Type.Literal(state)));
+var WIRE_TASK_STATE_ALIASES = {
+  "input-required": "input_required",
+  "auth-required": "auth_required",
+  unknown: "submitted"
+};
+function normalizeTaskState(state) {
+  return typeof state === "string" ? WIRE_TASK_STATE_ALIASES[state] ?? state : state;
+}
+var OPAQUE_WIRE_KEYS = /* @__PURE__ */ new Set(["metadata", "data"]);
+function normalizeWireTaskStates(value) {
+  if (Array.isArray(value)) return value.map((item) => normalizeWireTaskStates(item));
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (OPAQUE_WIRE_KEYS.has(key)) out[key] = entry;
+    else if (key === "state") out[key] = normalizeTaskState(entry);
+    else out[key] = normalizeWireTaskStates(entry);
+  }
+  return out;
+}
+var Metadata = Type.Record(Type.String(), Type.Unknown());
+var partExtras = {
+  mediaType: Type.Optional(Type.String()),
+  metadata: Type.Optional(Metadata)
+};
+var TextPartSchema = Type.Object({
+  kind: Type.Literal("text"),
+  text: Type.String(),
+  ...partExtras
+});
+var DataPartSchema = Type.Object({
+  kind: Type.Literal("data"),
+  data: Type.Record(Type.String(), Type.Unknown()),
+  ...partExtras
+});
+var UrlPartSchema = Type.Object({
+  kind: Type.Literal("url"),
+  url: Type.String(),
+  ...partExtras
+});
+var RawPartSchema = Type.Object({
+  kind: Type.Literal("raw"),
+  data: Type.String(),
+  ...partExtras
+});
+var PartSchema = Type.Union([
+  TextPartSchema,
+  DataPartSchema,
+  UrlPartSchema,
+  RawPartSchema
+]);
+var MessageSchema = Type.Object({
+  messageId: Type.String(),
+  contextId: Type.Optional(Type.String()),
+  taskId: Type.Optional(Type.String()),
+  role: Type.Union([Type.Literal("user"), Type.Literal("agent")]),
+  parts: Type.Array(PartSchema),
+  metadata: Type.Optional(Metadata)
+});
+var TaskStatusSchema = Type.Object({
+  state: TaskStateSchema,
+  /** Agent message accompanying the state (final text, error, or a streamed chunk). */
+  message: Type.Optional(MessageSchema),
+  /** ISO-8601 timestamp of when the state was entered. */
+  timestamp: Type.Optional(Type.String())
+});
+var ArtifactSchema = Type.Object({
+  artifactId: Type.String(),
+  name: Type.Optional(Type.String()),
+  description: Type.Optional(Type.String()),
+  parts: Type.Array(PartSchema),
+  metadata: Type.Optional(Metadata)
+});
+var TaskSchema = Type.Object({
+  id: Type.String(),
+  contextId: Type.String(),
+  status: TaskStatusSchema,
+  artifacts: Type.Optional(Type.Array(ArtifactSchema)),
+  history: Type.Optional(Type.Array(MessageSchema))
+});
+var TaskStatusUpdateEventSchema = Type.Object({
+  kind: Type.Literal("status-update"),
+  taskId: Type.String(),
+  contextId: Type.String(),
+  status: TaskStatusSchema,
+  /** True exactly when `status.state` is terminal — the stream ends here. */
+  final: Type.Boolean(),
+  metadata: Type.Optional(Metadata)
+});
+var TaskArtifactUpdateEventSchema = Type.Object({
+  kind: Type.Literal("artifact-update"),
+  taskId: Type.String(),
+  contextId: Type.String(),
+  artifact: ArtifactSchema,
+  append: Type.Optional(Type.Boolean()),
+  lastChunk: Type.Optional(Type.Boolean()),
+  metadata: Type.Optional(Metadata)
+});
+var AgentSkillSchema = Type.Object({
+  name: Type.String(),
+  description: Type.String(),
+  tags: Type.Optional(Type.Array(Type.String())),
+  examples: Type.Optional(Type.Array(Type.String()))
+});
+var AgentInterfaceSchema = Type.Object({
+  transport: Type.Union([Type.Literal("JSONRPC"), Type.Literal("HTTP+JSON"), Type.Literal("GRPC")]),
+  url: Type.String()
+});
+var BearerSecuritySchemeSchema = Type.Object({
+  type: Type.Literal("http"),
+  scheme: Type.Literal("bearer"),
+  description: Type.Optional(Type.String())
+});
+var AgentCapabilitiesSchema = Type.Object({
+  streaming: Type.Boolean(),
+  // Schema-only in v1: declared on the card, but webhook plumbing is deferred.
+  pushNotifications: Type.Boolean({ default: false })
+});
+var AgentProviderSchema = Type.Object({
+  name: Type.String(),
+  url: Type.Optional(Type.String())
+});
+var AgentCardSchema = Type.Object({
+  /** AP3X-assigned card id. Optional: reference-SDK cards carry no id. */
+  id: Type.Optional(Type.String()),
+  name: Type.String(),
+  description: Type.String(),
+  capabilities: AgentCapabilitiesSchema,
+  skills: Type.Array(AgentSkillSchema),
+  interfaces: Type.Array(AgentInterfaceSchema),
+  securitySchemes: Type.Optional(Type.Record(Type.String(), BearerSecuritySchemeSchema)),
+  provider: Type.Optional(AgentProviderSchema),
+  // Reference-SDK (0.3.x) card surface: the preferred endpoint lives at the
+  // TOP LEVEL (`url` + `preferredTransport`); `interfaces` above is kept as
+  // the richer AP3X view of the same endpoints.
+  /** The preferred endpoint URL (mirrors the first/preferred interface). */
+  url: Type.Optional(Type.String()),
+  /** Transport served at `url` (e.g. "JSONRPC"). */
+  preferredTransport: Type.Optional(Type.String()),
+  /** A2A protocol version, e.g. {@link A2A_CARD_PROTOCOL_VERSION}. */
+  protocolVersion: Type.Optional(Type.String()),
+  /** The agent's own version string. */
+  version: Type.Optional(Type.String()),
+  defaultInputModes: Type.Optional(Type.Array(Type.String())),
+  defaultOutputModes: Type.Optional(Type.Array(Type.String()))
+});
+var RemoteAgentInterfaceSchema = Type.Object({
+  transport: Type.String(),
+  url: Type.String()
+});
+var RemoteAgentCardSchema = Type.Object({
+  name: Type.String(),
+  description: Type.Optional(Type.String()),
+  id: Type.Optional(Type.String()),
+  capabilities: Type.Optional(
+    Type.Object({
+      streaming: Type.Optional(Type.Boolean()),
+      pushNotifications: Type.Optional(Type.Boolean())
+    })
+  ),
+  skills: Type.Optional(Type.Array(Type.Unknown())),
+  interfaces: Type.Optional(Type.Array(RemoteAgentInterfaceSchema)),
+  /** Reference-SDK name for extra transport/URL combinations. */
+  additionalInterfaces: Type.Optional(Type.Array(RemoteAgentInterfaceSchema)),
+  url: Type.Optional(Type.String()),
+  preferredTransport: Type.Optional(Type.String()),
+  securitySchemes: Type.Optional(Type.Unknown()),
+  provider: Type.Optional(Type.Unknown())
+});
+var A2A_ERROR_CODES = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603,
+  taskNotFound: -32001,
+  taskNotCancelable: -32002,
+  pushNotificationNotSupported: -32003,
+  unsupportedOperation: -32004,
+  contentTypeNotSupported: -32005,
+  invalidAgentResponse: -32006
+};
+
+// src/task-store.ts
+import { uuidv7 } from "@ap3x/agent-core";
+var TaskNotFoundError = class extends Error {
+  taskId;
+  constructor(taskId) {
+    super(`A2A task not found: ${taskId}`);
+    this.name = "TaskNotFoundError";
+    this.taskId = taskId;
+  }
+};
+var IllegalTaskTransitionError = class extends Error {
+  taskId;
+  from;
+  to;
+  constructor(taskId, from, to) {
+    super(`illegal A2A task transition on ${taskId}: ${from} -> ${to} (terminal states are final)`);
+    this.name = "IllegalTaskTransitionError";
+    this.taskId = taskId;
+    this.from = from;
+    this.to = to;
+  }
+};
+var TaskStore = class {
+  now;
+  maxRetainedTasks;
+  tasks = /* @__PURE__ */ new Map();
+  subscribers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.now = options.now;
+    if (options.maxRetainedTasks !== void 0) {
+      this.maxRetainedTasks = Math.max(0, Math.floor(options.maxRetainedTasks));
+    }
+  }
+  /** Create a task in the `submitted` state. */
+  create(options = {}) {
+    const task = {
+      id: uuidv7(),
+      contextId: options.contextId ?? uuidv7(),
+      status: { state: "submitted", timestamp: this.timestamp() },
+      ...options.history ? { history: [...options.history] } : {}
+    };
+    this.tasks.set(task.id, task);
+    return task;
+  }
+  get(id) {
+    return this.tasks.get(id);
+  }
+  list(filter = {}) {
+    const out = [];
+    for (const task of this.tasks.values()) {
+      if (filter.contextId !== void 0 && task.contextId !== filter.contextId) continue;
+      if (filter.state !== void 0 && task.status.state !== filter.state) continue;
+      out.push(task);
+    }
+    return out;
+  }
+  /**
+   * Transition a task to `state`, notify its subscribers, and — when the new
+   * state is terminal — clear those subscribers. Leaving a terminal state
+   * throws {@link IllegalTaskTransitionError}.
+   */
+  updateState(id, state, message) {
+    const task = this.tasks.get(id);
+    if (!task) throw new TaskNotFoundError(id);
+    if (isTerminal(task.status.state)) {
+      throw new IllegalTaskTransitionError(id, task.status.state, state);
+    }
+    task.status = { state, ...message ? { message } : {}, timestamp: this.timestamp() };
+    const final = isTerminal(state);
+    const event = {
+      kind: "status-update",
+      taskId: id,
+      contextId: task.contextId,
+      status: task.status,
+      final
+    };
+    const subs = this.subscribers.get(id);
+    if (subs) {
+      for (const fn of [...subs]) fn(event);
+      if (final) this.subscribers.delete(id);
+    }
+    if (final) this.evictBeyondRetention();
+    return task;
+  }
+  /** Drop the oldest TERMINAL tasks beyond `maxRetainedTasks` (no-op when unset). */
+  evictBeyondRetention() {
+    const cap = this.maxRetainedTasks;
+    if (cap === void 0) return;
+    const terminal = [];
+    for (const task of this.tasks.values()) {
+      if (isTerminal(task.status.state)) terminal.push(task.id);
+    }
+    for (let i = 0; i < terminal.length - cap; i++) {
+      const id = terminal[i];
+      this.tasks.delete(id);
+      this.subscribers.delete(id);
+    }
+  }
+  /** Cancel a task (illegal from a terminal state, like any other exit). */
+  cancel(id) {
+    return this.updateState(id, "canceled");
+  }
+  /** Subscribe to a task's status updates; returns an unsubscribe function. */
+  subscribe(taskId, fn) {
+    if (!this.tasks.has(taskId)) throw new TaskNotFoundError(taskId);
+    let subs = this.subscribers.get(taskId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscribers.set(taskId, subs);
+    }
+    subs.add(fn);
+    return () => {
+      subs.delete(fn);
+      if (subs.size === 0) this.subscribers.delete(taskId);
+    };
+  }
+  /** Live subscriber count for a task (0 after a terminal transition). */
+  subscriberCount(taskId) {
+    return this.subscribers.get(taskId)?.size ?? 0;
+  }
+  timestamp() {
+    return new Date(this.now()).toISOString();
+  }
+};
+
+// src/executor.ts
+import {
+  availableParallelism,
+  createLimiter,
+  finalTextOf,
+  lastAssistant,
+  uuidv7 as uuidv72
+} from "@ap3x/agent-core";
+function messageText(message) {
+  const chunks = [];
+  for (const part of message.parts) {
+    if (part.kind === "text") chunks.push(part.text);
+    else if (part.kind === "data") chunks.push(JSON.stringify(part.data));
+    else if (part.kind === "url") chunks.push(part.url);
+  }
+  return chunks.join("\n");
+}
+function agentMessageText(message) {
+  if (message.role === "user") {
+    if (typeof message.content === "string") return message.content;
+    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  if (message.role === "assistant" || message.role === "toolResult") {
+    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  return "";
+}
+var A2aExecutor = class {
+  backend;
+  store;
+  now;
+  limit;
+  /**
+   * contextId -> transcript so a follow-up message keeps its conversational
+   * thread. Access-ordered (delete + re-set on touch) so Map insertion order
+   * doubles as LRU order for {@link maxRetainedContexts} eviction.
+   */
+  transcripts = /* @__PURE__ */ new Map();
+  maxRetainedContexts;
+  aborts = /* @__PURE__ */ new Map();
+  constructor(backend, options) {
+    this.backend = backend;
+    this.now = options.now;
+    if (options.maxRetainedContexts !== void 0) {
+      this.maxRetainedContexts = Math.max(0, Math.floor(options.maxRetainedContexts));
+    }
+    this.store = new TaskStore({
+      now: options.now,
+      ...options.maxRetainedTasks !== void 0 ? { maxRetainedTasks: options.maxRetainedTasks } : {}
+    });
+    this.limit = createLimiter(options.maxConcurrentTasks ?? Math.max(4, availableParallelism()));
+  }
+  /** Whether the wrapped backend supports incremental streaming. */
+  get streaming() {
+    return typeof this.backend.runStream === "function";
+  }
+  /** Accept an inbound message: create a task and run the backend against it. */
+  async sendMessage(message, options = {}) {
+    const contextId = message.contextId ?? uuidv72();
+    const task = this.store.create({ contextId });
+    task.history = [{ ...message, taskId: task.id, contextId }];
+    if (options.onEvent) this.store.subscribe(task.id, options.onEvent);
+    options.onTask?.(structuredClone(task));
+    const controller = new AbortController();
+    this.aborts.set(task.id, controller);
+    const running = this.limit(
+      () => this.execute(task.id, contextId, message, controller.signal)
+    ).finally(() => this.aborts.delete(task.id));
+    if (options.blocking) await running;
+    return this.snapshot(task.id);
+  }
+  /** Deep-copied task lookup (undefined when unknown). */
+  getTask(id) {
+    return this.snapshot(id);
+  }
+  /** Deep-copied task listing. */
+  listTasks(filter = {}) {
+    return this.store.list(filter).map((task) => structuredClone(task));
+  }
+  /**
+   * Cancel a task: best-effort abort of the underlying run + store cancel.
+   * A backend without `abort` still cancels — the guarded terminal write in
+   * {@link execute} discards the late result. Throws TaskNotFoundError /
+   * IllegalTaskTransitionError for unknown / already-terminal tasks.
+   */
+  cancel(taskId) {
+    this.store.cancel(taskId);
+    this.aborts.get(taskId)?.abort();
+    this.backend.abort?.();
+    return this.snapshot(taskId);
+  }
+  /** Subscribe to a task's status updates; returns an unsubscribe function. */
+  subscribe(taskId, fn) {
+    return this.store.subscribe(taskId, fn);
+  }
+  /** LRU read: touching a context moves it to the back of the eviction order. */
+  recallTranscript(contextId) {
+    const transcript = this.transcripts.get(contextId);
+    if (transcript !== void 0) {
+      this.transcripts.delete(contextId);
+      this.transcripts.set(contextId, transcript);
+    }
+    return transcript;
+  }
+  /** LRU write: (re-)insert at the back, then evict the oldest beyond the cap. */
+  retainTranscript(contextId, transcript) {
+    this.transcripts.delete(contextId);
+    this.transcripts.set(contextId, transcript);
+    const cap = this.maxRetainedContexts;
+    if (cap === void 0) return;
+    while (this.transcripts.size > cap) {
+      const oldest = this.transcripts.keys().next().value;
+      if (oldest === void 0) break;
+      this.transcripts.delete(oldest);
+    }
+  }
+  snapshot(id) {
+    const task = this.store.get(id);
+    return task ? structuredClone(task) : void 0;
+  }
+  agentMessage(taskId, contextId, text) {
+    const parts = [{ kind: "text", text }];
+    return { messageId: uuidv72(), taskId, contextId, role: "agent", parts };
+  }
+  /**
+   * Terminal write, guarded: a task canceled mid-run stays canceled — the
+   * store's terminal-state rejection is caught and the late result discarded.
+   */
+  finish(taskId, contextId, state, text) {
+    try {
+      this.store.updateState(
+        taskId,
+        state,
+        text === void 0 ? void 0 : this.agentMessage(taskId, contextId, text)
+      );
+    } catch (error) {
+      if (!(error instanceof IllegalTaskTransitionError)) throw error;
+    }
+  }
+  async execute(taskId, contextId, message, signal) {
+    const current = this.store.get(taskId);
+    if (!current || isTerminal(current.status.state)) return;
+    try {
+      this.store.updateState(taskId, "working");
+    } catch (error) {
+      if (error instanceof IllegalTaskTransitionError) return;
+      throw error;
+    }
+    const prior = this.recallTranscript(contextId) ?? [];
+    const userMessage = {
+      role: "user",
+      content: messageText(message),
+      timestamp: this.now()
+    };
+    const input = [...prior, userMessage];
+    let messages;
+    let finalText;
+    let stopReason;
+    let errorMessage;
+    try {
+      if (this.backend.runStream) {
+        const stream = this.backend.runStream(input, { signal });
+        for await (const event of stream) {
+          if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+            try {
+              this.store.updateState(
+                taskId,
+                "working",
+                this.agentMessage(taskId, contextId, event.assistantMessageEvent.delta)
+              );
+            } catch (error) {
+              if (!(error instanceof IllegalTaskTransitionError)) throw error;
+            }
+          }
+        }
+        messages = await stream.result();
+        const assistant = lastAssistant(messages);
+        finalText = finalTextOf(assistant);
+        stopReason = assistant?.stopReason ?? "error";
+        errorMessage = assistant?.errorMessage;
+      } else {
+        const result = await this.backend.run(input, { signal });
+        ({ messages, finalText, stopReason, errorMessage } = result);
+      }
+    } catch (error) {
+      this.finish(
+        taskId,
+        contextId,
+        "failed",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+    if (stopReason === "aborted") {
+      this.finish(taskId, contextId, "canceled");
+      return;
+    }
+    if (stopReason === "error") {
+      this.finish(taskId, contextId, "failed", errorMessage ?? "agent run failed");
+      return;
+    }
+    this.retainTranscript(contextId, [...input, ...messages]);
+    const task = this.store.get(taskId);
+    if (task && !isTerminal(task.status.state)) {
+      const mapped = messages.map((m) => ({
+        messageId: uuidv72(),
+        taskId,
+        contextId,
+        role: m.role === "user" ? "user" : "agent",
+        parts: [{ kind: "text", text: agentMessageText(m) }]
+      }));
+      task.history = [...task.history ?? [], ...mapped];
+    }
+    this.finish(taskId, contextId, "completed", finalText);
+  }
+};
+
+// src/bindings/jsonrpc.ts
+import { Type as Type2 } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+var A2A_RPC_METHODS = {
+  sendMessage: "message/send",
+  sendStreamingMessage: "message/stream",
+  getTask: "tasks/get",
+  listTasks: "tasks/list",
+  cancelTask: "tasks/cancel",
+  subscribeToTask: "tasks/resubscribe"
+};
+var A2A_RPC_METHOD_ALIASES = {
+  ...Object.fromEntries(
+    Object.entries(A2A_RPC_METHODS).map(([operation, method]) => [method, operation])
+  ),
+  SendMessage: "sendMessage",
+  SendStreamingMessage: "sendStreamingMessage",
+  GetTask: "getTask",
+  ListTasks: "listTasks",
+  CancelTask: "cancelTask",
+  SubscribeToTask: "subscribeToTask"
+};
+var JsonRpcRequestSchema = Type2.Object({
+  jsonrpc: Type2.Literal("2.0"),
+  id: Type2.Union([Type2.String(), Type2.Number(), Type2.Null()]),
+  method: Type2.String(),
+  params: Type2.Optional(Type2.Unknown())
+});
+var MessageSendParamsSchema = Type2.Object({
+  message: MessageSchema,
+  configuration: Type2.Optional(
+    Type2.Object({
+      /**
+       * When true, `SendMessage` returns the Task snapshot immediately instead
+       * of waiting for the terminal state. Default false — blocking is the
+       * spec default.
+       */
+      returnImmediately: Type2.Optional(Type2.Boolean()),
+      /**
+       * The reference SDK's (0.3.x) knob for the same choice, inverted:
+       * `blocking: true` waits for the terminal state. Accepted for interop;
+       * AP3X clients emit `returnImmediately`.
+       */
+      blocking: Type2.Optional(Type2.Boolean())
+    })
+  )
+});
+function resolveBlocking(configuration) {
+  if (configuration?.returnImmediately !== void 0) return !configuration.returnImmediately;
+  return configuration?.blocking ?? true;
+}
+var TaskIdParamsSchema = Type2.Object({ id: Type2.String() });
+var TaskListParamsSchema = Type2.Object({
+  contextId: Type2.Optional(Type2.String()),
+  state: Type2.Optional(TaskStateSchema)
+});
+function respond(res, id, body) {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify({ jsonrpc: "2.0", id, ...body }));
+}
+function rpcError(code, message) {
+  return { error: { code, message } };
+}
+function mapThrown(error) {
+  if (error instanceof TaskNotFoundError) {
+    return rpcError(A2A_ERROR_CODES.taskNotFound, error.message);
+  }
+  if (error instanceof IllegalTaskTransitionError) {
+    return rpcError(A2A_ERROR_CODES.taskNotCancelable, error.message);
+  }
+  return rpcError(
+    A2A_ERROR_CODES.internalError,
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function startSse(res, sseStreams) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache",
+    connection: "keep-alive"
+  });
+  sseStreams.add(res);
+  res.on("close", () => sseStreams.delete(res));
+}
+function sseWrite(res, id, result) {
+  res.write(`data: ${JSON.stringify({ jsonrpc: "2.0", id, result })}
+
+`);
+}
+async function handleJsonRpc(executor, rawBody, res, sseStreams) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    respond(res, null, rpcError(A2A_ERROR_CODES.parseError, "malformed JSON"));
+    return;
+  }
+  if (!Value.Check(JsonRpcRequestSchema, parsed)) {
+    respond(res, null, rpcError(A2A_ERROR_CODES.invalidRequest, "not a JSON-RPC 2.0 request"));
+    return;
+  }
+  const { id, method, params } = parsed;
+  try {
+    switch (A2A_RPC_METHOD_ALIASES[method]) {
+      case "sendMessage": {
+        if (!Value.Check(MessageSendParamsSchema, params)) {
+          respond(res, id, rpcError(A2A_ERROR_CODES.invalidParams, "invalid SendMessage params"));
+          return;
+        }
+        const task = await executor.sendMessage(params.message, {
+          blocking: resolveBlocking(params.configuration)
+        });
+        respond(res, id, { result: task });
+        return;
+      }
+      case "sendStreamingMessage": {
+        if (!Value.Check(MessageSendParamsSchema, params)) {
+          respond(
+            res,
+            id,
+            rpcError(A2A_ERROR_CODES.invalidParams, "invalid SendStreamingMessage params")
+          );
+          return;
+        }
+        startSse(res, sseStreams);
+        await executor.sendMessage(params.message, {
+          blocking: false,
+          // Spec: the stream MUST begin with the full Task object.
+          onTask: (task) => sseWrite(res, id, task),
+          onEvent: (event) => {
+            sseWrite(res, id, event);
+            if (event.final) res.end();
+          }
+        });
+        return;
+      }
+      case "getTask": {
+        if (!Value.Check(TaskIdParamsSchema, params)) {
+          respond(res, id, rpcError(A2A_ERROR_CODES.invalidParams, "invalid GetTask params"));
+          return;
+        }
+        const task = executor.getTask(params.id);
+        if (!task) {
+          respond(
+            res,
+            id,
+            rpcError(A2A_ERROR_CODES.taskNotFound, `A2A task not found: ${params.id}`)
+          );
+          return;
+        }
+        respond(res, id, { result: task });
+        return;
+      }
+      case "listTasks": {
+        const filter = normalizeWireTaskStates(params ?? {});
+        if (!Value.Check(TaskListParamsSchema, filter)) {
+          respond(res, id, rpcError(A2A_ERROR_CODES.invalidParams, "invalid ListTasks params"));
+          return;
+        }
+        respond(res, id, { result: { tasks: executor.listTasks(filter) } });
+        return;
+      }
+      case "cancelTask": {
+        if (!Value.Check(TaskIdParamsSchema, params)) {
+          respond(res, id, rpcError(A2A_ERROR_CODES.invalidParams, "invalid CancelTask params"));
+          return;
+        }
+        respond(res, id, { result: executor.cancel(params.id) });
+        return;
+      }
+      case "subscribeToTask": {
+        if (!Value.Check(TaskIdParamsSchema, params)) {
+          respond(
+            res,
+            id,
+            rpcError(A2A_ERROR_CODES.invalidParams, "invalid SubscribeToTask params")
+          );
+          return;
+        }
+        const task = executor.getTask(params.id);
+        if (!task) {
+          respond(
+            res,
+            id,
+            rpcError(A2A_ERROR_CODES.taskNotFound, `A2A task not found: ${params.id}`)
+          );
+          return;
+        }
+        startSse(res, sseStreams);
+        sseWrite(res, id, task);
+        if (isTerminal(task.status.state)) {
+          const event = {
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: task.status,
+            final: true
+          };
+          sseWrite(res, id, event);
+          res.end();
+          return;
+        }
+        const unsubscribe = executor.subscribe(task.id, (event) => {
+          sseWrite(res, id, event);
+          if (event.final) res.end();
+        });
+        res.on("close", unsubscribe);
+        return;
+      }
+      default:
+        respond(res, id, rpcError(A2A_ERROR_CODES.methodNotFound, `unknown method: ${method}`));
+        return;
+    }
+  } catch (error) {
+    if (res.headersSent) {
+      res.end();
+      return;
+    }
+    respond(res, id, mapThrown(error));
+  }
+}
+
+// src/bindings/rest.ts
+import { Type as Type3 } from "@sinclair/typebox";
+import { Value as Value2 } from "@sinclair/typebox/value";
+var A2A_REST_ROUTES = {
+  sendMessage: { httpMethod: "POST", path: "/v1/message:send" },
+  sendStreamingMessage: { httpMethod: "POST", path: "/v1/message:stream" },
+  getTask: { httpMethod: "GET", path: "/v1/tasks/{id}" },
+  listTasks: { httpMethod: "GET", path: "/v1/tasks" },
+  cancelTask: { httpMethod: "POST", path: "/v1/tasks/{id}:cancel" },
+  subscribeToTask: { httpMethod: "POST", path: "/v1/tasks/{id}:subscribe" }
+};
+var RestErrorBodySchema = Type3.Object({
+  error: Type3.Object({ code: Type3.Number(), message: Type3.String() })
+});
+function restStatusFor(code) {
+  switch (code) {
+    case A2A_ERROR_CODES.taskNotFound:
+    case A2A_ERROR_CODES.methodNotFound:
+      return 404;
+    case A2A_ERROR_CODES.parseError:
+    case A2A_ERROR_CODES.invalidRequest:
+    case A2A_ERROR_CODES.invalidParams:
+      return 400;
+    case A2A_ERROR_CODES.taskNotCancelable:
+      return 409;
+    default:
+      return 500;
+  }
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function restError(res, code, message) {
+  sendJson(res, restStatusFor(code), { error: { code, message } });
+}
+function mapThrown2(res, error) {
+  if (error instanceof TaskNotFoundError) {
+    restError(res, A2A_ERROR_CODES.taskNotFound, error.message);
+    return;
+  }
+  if (error instanceof IllegalTaskTransitionError) {
+    restError(res, A2A_ERROR_CODES.taskNotCancelable, error.message);
+    return;
+  }
+  restError(
+    res,
+    A2A_ERROR_CODES.internalError,
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function sseWrite2(res, frame) {
+  res.write(`data: ${JSON.stringify(frame)}
+
+`);
+}
+function matchRoute(httpMethod, path) {
+  for (const op of Object.keys(A2A_REST_ROUTES)) {
+    const route = A2A_REST_ROUTES[op];
+    if (route.httpMethod !== httpMethod) continue;
+    const idAt = route.path.indexOf("{id}");
+    if (idAt === -1) {
+      if (path === route.path) return { op };
+      continue;
+    }
+    const prefix = route.path.slice(0, idAt);
+    const suffix = route.path.slice(idAt + "{id}".length);
+    if (!path.startsWith(prefix) || !path.endsWith(suffix)) continue;
+    const raw = path.slice(prefix.length, path.length - suffix.length);
+    if (raw.length === 0 || raw.includes("/") || raw.includes(":")) continue;
+    return { op, id: decodeURIComponent(raw) };
+  }
+  return void 0;
+}
+async function handleRest(executor, httpMethod, path, query, rawBody, res, sseStreams) {
+  const match = matchRoute(httpMethod, path);
+  if (!match) {
+    restError(res, A2A_ERROR_CODES.methodNotFound, `no A2A route: ${httpMethod} ${path}`);
+    return;
+  }
+  try {
+    switch (match.op) {
+      case "sendMessage":
+      case "sendStreamingMessage": {
+        let parsed;
+        try {
+          parsed = JSON.parse(rawBody);
+        } catch {
+          restError(res, A2A_ERROR_CODES.parseError, "malformed JSON");
+          return;
+        }
+        if (!Value2.Check(MessageSendParamsSchema, parsed)) {
+          restError(res, A2A_ERROR_CODES.invalidParams, `invalid ${match.op} body`);
+          return;
+        }
+        if (match.op === "sendMessage") {
+          const task = await executor.sendMessage(parsed.message, {
+            blocking: resolveBlocking(parsed.configuration)
+          });
+          sendJson(res, 200, task);
+          return;
+        }
+        startSse(res, sseStreams);
+        await executor.sendMessage(parsed.message, {
+          blocking: false,
+          // Spec: the stream MUST begin with the full Task object.
+          onTask: (task) => sseWrite2(res, task),
+          onEvent: (event) => {
+            sseWrite2(res, event);
+            if (event.final) res.end();
+          }
+        });
+        return;
+      }
+      case "getTask": {
+        const task = executor.getTask(match.id);
+        if (!task) {
+          restError(res, A2A_ERROR_CODES.taskNotFound, `A2A task not found: ${match.id}`);
+          return;
+        }
+        sendJson(res, 200, task);
+        return;
+      }
+      case "listTasks": {
+        const filter = {};
+        const contextId = query.get("contextId");
+        if (contextId !== null) filter.contextId = contextId;
+        const state = query.get("state");
+        if (state !== null) filter.state = normalizeTaskState(state);
+        if (!Value2.Check(TaskListParamsSchema, filter)) {
+          restError(res, A2A_ERROR_CODES.invalidParams, "invalid ListTasks query");
+          return;
+        }
+        sendJson(res, 200, { tasks: executor.listTasks(filter) });
+        return;
+      }
+      case "cancelTask": {
+        sendJson(res, 200, executor.cancel(match.id));
+        return;
+      }
+      case "subscribeToTask": {
+        const task = executor.getTask(match.id);
+        if (!task) {
+          restError(res, A2A_ERROR_CODES.taskNotFound, `A2A task not found: ${match.id}`);
+          return;
+        }
+        startSse(res, sseStreams);
+        sseWrite2(res, task);
+        if (isTerminal(task.status.state)) {
+          const event = {
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: task.status,
+            final: true
+          };
+          sseWrite2(res, event);
+          res.end();
+          return;
+        }
+        const unsubscribe = executor.subscribe(task.id, (event) => {
+          sseWrite2(res, event);
+          if (event.final) res.end();
+        });
+        res.on("close", unsubscribe);
+        return;
+      }
+    }
+  } catch (error) {
+    if (res.headersSent) {
+      res.end();
+      return;
+    }
+    mapThrown2(res, error);
+  }
+}
+
+// src/client.ts
+import { Type as Type4 } from "@sinclair/typebox";
+import { Value as Value3 } from "@sinclair/typebox/value";
+var AGENT_CARD_PATH = "/.well-known/agent-card.json";
+var A2A_VERSION_HEADER = "A2A-Version";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var A2aClientError = class extends Error {
+  /** JSON-RPC error code when the server answered with an error object. */
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "A2aClientError";
+    if (code !== void 0) this.code = code;
+  }
+};
+var JsonRpcResponseSchema = Type4.Object({
+  jsonrpc: Type4.Literal("2.0"),
+  id: Type4.Union([Type4.String(), Type4.Number(), Type4.Null()]),
+  result: Type4.Optional(Type4.Unknown()),
+  error: Type4.Optional(Type4.Object({ code: Type4.Number(), message: Type4.String() }))
+});
+var TaskListResultSchema = Type4.Object({ tasks: Type4.Array(TaskSchema) });
+var SendMessageResultSchema = Type4.Union([TaskSchema, MessageSchema]);
+var StreamFrameSchema = Type4.Union([
+  TaskStatusUpdateEventSchema,
+  TaskArtifactUpdateEventSchema,
+  TaskSchema,
+  MessageSchema
+]);
+function isTaskFrame(frame) {
+  if (!("kind" in frame)) return !("messageId" in frame);
+  return frame.kind === "task";
+}
+function isMessageFrame(frame) {
+  return "messageId" in frame;
+}
+function isStatusUpdateFrame(frame) {
+  return "kind" in frame && frame.kind === "status-update";
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var KNOWN_TRANSPORTS = /* @__PURE__ */ new Set(["JSONRPC", "HTTP+JSON", "GRPC"]);
+var SecuritySchemesSchema = Type4.Record(Type4.String(), BearerSecuritySchemeSchema);
+function normalizeRemoteCard(card) {
+  const declared = [
+    ...card.url !== void 0 ? [{ transport: card.preferredTransport ?? "JSONRPC", url: card.url }] : [],
+    ...card.interfaces ?? [],
+    ...card.additionalInterfaces ?? []
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const interfaces = [];
+  for (const iface of declared) {
+    const key = `${iface.transport} ${iface.url}`;
+    if (!KNOWN_TRANSPORTS.has(iface.transport) || seen.has(key)) continue;
+    seen.add(key);
+    interfaces.push(iface);
+  }
+  return {
+    ...card.id !== void 0 ? { id: card.id } : {},
+    name: card.name,
+    description: card.description ?? "",
+    capabilities: {
+      streaming: card.capabilities?.streaming ?? false,
+      pushNotifications: card.capabilities?.pushNotifications ?? false
+    },
+    skills: (card.skills ?? []).filter(
+      (skill) => Value3.Check(AgentSkillSchema, skill)
+    ),
+    interfaces,
+    ...Value3.Check(SecuritySchemesSchema, card.securitySchemes) ? { securitySchemes: card.securitySchemes } : {},
+    ...Value3.Check(AgentProviderSchema, card.provider) ? { provider: card.provider } : {},
+    ...card.url !== void 0 ? { url: card.url } : {},
+    ...card.preferredTransport !== void 0 ? { preferredTransport: card.preferredTransport } : {}
+  };
+}
+var A2aClient = class _A2aClient {
+  /** The Agent Card fetched (once) at connect time. */
+  card;
+  /** The transport negotiated from the card (JSONRPC preferred). */
+  transport;
+  endpoint;
+  fetchImpl;
+  timeoutMs;
+  bearerToken;
+  nextId = 1;
+  /** Present exactly when `transport` is GRPC (lazy-loaded at connect time). */
+  grpcTransport;
+  constructor(card, endpoint, transport, options) {
+    this.card = card;
+    this.endpoint = endpoint;
+    this.transport = transport;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (options.bearerToken !== void 0) this.bearerToken = options.bearerToken;
+  }
+  /**
+   * Fetch + validate the Agent Card from the well-known path, negotiate the
+   * transport (JSONRPC preferred, then HTTP+JSON, then GRPC as a last resort),
+   * and return a connected client.
+   */
+  static async connect(baseUrl, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const url = new URL(AGENT_CARD_PATH, baseUrl).toString();
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        headers: { [A2A_VERSION_HEADER]: A2A_PROTOCOL_VERSION },
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      throw new A2aClientError(`A2A agent card fetch failed: ${describe(error)}`);
+    }
+    if (!res.ok) throw new A2aClientError(`A2A agent card fetch failed: HTTP ${res.status}`);
+    let raw;
+    try {
+      raw = await res.json();
+    } catch {
+      throw new A2aClientError("A2A agent card is not valid JSON");
+    }
+    if (!Value3.Check(RemoteAgentCardSchema, raw)) {
+      throw new A2aClientError("A2A agent card failed validation");
+    }
+    const card = normalizeRemoteCard(raw);
+    const iface = card.interfaces.find((candidate) => candidate.transport === "JSONRPC") ?? card.interfaces.find((candidate) => candidate.transport === "HTTP+JSON") ?? card.interfaces.find((candidate) => candidate.transport === "GRPC");
+    if (!iface) {
+      throw new A2aClientError(
+        "A2A agent card advertises no JSONRPC, HTTP+JSON, or GRPC interface (this client speaks all three)"
+      );
+    }
+    const client = new _A2aClient(card, iface.url, iface.transport, options);
+    if (iface.transport === "GRPC") {
+      const { GrpcClientTransport } = await import("./grpc-5DAU6EYQ.js");
+      client.grpcTransport = new GrpcClientTransport(iface.url, {
+        timeoutMs,
+        ...options.bearerToken !== void 0 ? { bearerToken: options.bearerToken } : {}
+      });
+    }
+    return client;
+  }
+  /** Release transport resources (the gRPC channel; HTTP needs nothing). */
+  close() {
+    this.grpcTransport?.close();
+  }
+  /**
+   * `SendMessage` — blocking by default; returns the (validated) Task
+   * snapshot, or a bare Message when the peer's executor answered directly
+   * without creating a task (a Task has `status`, a Message does not).
+   *
+   * `signal` cancels the in-flight HTTP request (combined with the per-request
+   * timeout). The gRPC transport relies on its own deadline — best-effort.
+   */
+  async sendMessage(message, config, signal) {
+    if (this.grpcTransport) {
+      return this.expect(
+        SendMessageResultSchema,
+        await this.grpcTransport.sendMessage(message, config),
+        "SendMessage"
+      );
+    }
+    const params = { message, ...config !== void 0 ? { configuration: config } : {} };
+    if (this.transport === "JSONRPC") {
+      const method = A2A_RPC_METHODS.sendMessage;
+      return this.expect(SendMessageResultSchema, await this.rpc(method, params, signal), method);
+    }
+    const op = "sendMessage";
+    return this.expect(
+      SendMessageResultSchema,
+      await this.restJson(op, { body: params, ...signal ? { signal } : {} }),
+      op
+    );
+  }
+  /** `SendStreamingMessage` — SSE: the Task object first, then update events. */
+  sendStreamingMessage(message, signal) {
+    if (this.grpcTransport) return this.grpcTransport.sendStreamingMessage(message);
+    if (this.transport === "JSONRPC") {
+      return this.rpcSse(A2A_RPC_METHODS.sendStreamingMessage, { message }, signal);
+    }
+    return this.restSse("sendStreamingMessage", {
+      body: { message },
+      ...signal ? { signal } : {}
+    });
+  }
+  /** `GetTask`. */
+  async getTask(id, signal) {
+    if (this.grpcTransport) {
+      return this.expect(TaskSchema, await this.grpcTransport.getTask(id), "GetTask");
+    }
+    if (this.transport === "JSONRPC") {
+      const method = A2A_RPC_METHODS.getTask;
+      return this.expect(TaskSchema, await this.rpc(method, { id }, signal), method);
+    }
+    const op = "getTask";
+    return this.expect(
+      TaskSchema,
+      await this.restJson(op, { id, ...signal ? { signal } : {} }),
+      op
+    );
+  }
+  /** `ListTasks`. */
+  async listTasks(filter = {}) {
+    if (this.grpcTransport) {
+      const tasks = await this.grpcTransport.listTasks(filter);
+      return this.expect(TaskListResultSchema, { tasks }, "ListTasks").tasks;
+    }
+    if (this.transport === "JSONRPC") {
+      const method = A2A_RPC_METHODS.listTasks;
+      return this.expect(TaskListResultSchema, await this.rpc(method, filter), method).tasks;
+    }
+    const query = {
+      ...filter.contextId !== void 0 ? { contextId: filter.contextId } : {},
+      ...filter.state !== void 0 ? { state: filter.state } : {}
+    };
+    const op = "listTasks";
+    return this.expect(TaskListResultSchema, await this.restJson(op, { query }), op).tasks;
+  }
+  /** `CancelTask`. */
+  async cancelTask(id) {
+    if (this.grpcTransport) {
+      return this.expect(TaskSchema, await this.grpcTransport.cancelTask(id), "CancelTask");
+    }
+    if (this.transport === "JSONRPC") {
+      const method = A2A_RPC_METHODS.cancelTask;
+      return this.expect(TaskSchema, await this.rpc(method, { id }), method);
+    }
+    const op = "cancelTask";
+    return this.expect(TaskSchema, await this.restJson(op, { id }), op);
+  }
+  /** `SubscribeToTask` — SSE: the Task snapshot first, then update events. */
+  subscribeToTask(id) {
+    if (this.grpcTransport) return this.grpcTransport.subscribeToTask(id);
+    if (this.transport === "JSONRPC") {
+      return this.rpcSse(A2A_RPC_METHODS.subscribeToTask, { id });
+    }
+    return this.restSse("subscribeToTask", { id });
+  }
+  headers() {
+    return {
+      "content-type": "application/json",
+      [A2A_VERSION_HEADER]: A2A_PROTOCOL_VERSION,
+      ...this.bearerToken !== void 0 ? { authorization: `Bearer ${this.bearerToken}` } : {}
+    };
+  }
+  /** Per-request timeout signal, optionally combined with a caller's signal. */
+  requestSignal(signal) {
+    const timeout = AbortSignal.timeout(this.timeoutMs);
+    return signal ? AbortSignal.any([timeout, signal]) : timeout;
+  }
+  async post(method, params, signal) {
+    try {
+      return await this.fetchImpl(this.endpoint, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, params }),
+        signal: this.requestSignal(signal)
+      });
+    } catch (error) {
+      throw new A2aClientError(`A2A ${method} request failed: ${describe(error)}`);
+    }
+  }
+  async rpc(method, params, signal) {
+    const res = await this.post(method, params, signal);
+    if (!res.ok) throw new A2aClientError(`A2A ${method} failed: HTTP ${res.status}`);
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      throw new A2aClientError(`A2A ${method} response is not valid JSON`);
+    }
+    return this.unwrap(body, method);
+  }
+  /** Validate a JSON-RPC response envelope; throw the server's error typed. */
+  unwrap(body, method) {
+    if (!Value3.Check(JsonRpcResponseSchema, body)) {
+      throw new A2aClientError(`A2A ${method} returned an invalid JSON-RPC envelope`);
+    }
+    if (body.error !== void 0) {
+      throw new A2aClientError(`A2A ${method} error: ${body.error.message}`, body.error.code);
+    }
+    return body.result;
+  }
+  expect(schema, value, method) {
+    const normalized = normalizeWireTaskStates(value);
+    if (!Value3.Check(schema, normalized)) {
+      throw new A2aClientError(`A2A ${method} returned a malformed result`);
+    }
+    return normalized;
+  }
+  async *rpcSse(method, params, signal) {
+    const res = await this.post(method, params, signal);
+    if (!res.ok) throw new A2aClientError(`A2A ${method} failed: HTTP ${res.status}`);
+    const contentType = res.headers.get("content-type") ?? "";
+    if (!contentType.includes("text/event-stream")) {
+      let body;
+      try {
+        body = await res.json();
+      } catch {
+        throw new A2aClientError(`A2A ${method} answered neither SSE nor valid JSON`);
+      }
+      this.unwrap(body, method);
+      throw new A2aClientError(`A2A ${method} answered JSON instead of an SSE stream`);
+    }
+    for await (const data of this.sseData(res, method)) {
+      yield this.parseSseFrame(data, method);
+    }
+  }
+  parseSseFrame(data, method) {
+    let body;
+    try {
+      body = JSON.parse(data);
+    } catch {
+      throw new A2aClientError(`A2A ${method} SSE frame is not valid JSON`);
+    }
+    const result = this.unwrap(body, method);
+    return this.expect(StreamFrameSchema, result, method);
+  }
+  /** The raw `data:` payloads of an SSE response — shared by both transports. */
+  async *sseData(res, label) {
+    if (!res.body) throw new A2aClientError(`A2A ${label} SSE response has no body`);
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of res.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let frameEnd = buffer.indexOf("\n\n");
+      while (frameEnd !== -1) {
+        const frame = buffer.slice(0, frameEnd);
+        buffer = buffer.slice(frameEnd + 2);
+        const data = frame.split("\n").filter((line) => line.startsWith("data: ")).map((line) => line.slice("data: ".length)).join("\n");
+        if (data.length > 0) yield data;
+        frameEnd = buffer.indexOf("\n\n");
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // HTTP+JSON (REST) transport — the same six operations over A2A_REST_ROUTES
+  // -------------------------------------------------------------------------
+  async restRequest(op, args) {
+    const route = A2A_REST_ROUTES[op];
+    const path = args.id !== void 0 ? route.path.replace("{id}", encodeURIComponent(args.id)) : route.path;
+    const target = new URL(path, this.endpoint);
+    if (args.query !== void 0) {
+      for (const [key, value] of Object.entries(args.query)) {
+        target.searchParams.set(key, value);
+      }
+    }
+    try {
+      return await this.fetchImpl(target.toString(), {
+        method: route.httpMethod,
+        headers: this.headers(),
+        ...args.body !== void 0 ? { body: JSON.stringify(args.body) } : {},
+        signal: this.requestSignal(args.signal)
+      });
+    } catch (error) {
+      throw new A2aClientError(`A2A ${op} request failed: ${describe(error)}`);
+    }
+  }
+  /** Map a non-2xx REST answer to a typed error carrying the A2A code. */
+  async restErrorFrom(res, op) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      return new A2aClientError(`A2A ${op} failed: HTTP ${res.status}`);
+    }
+    if (Value3.Check(RestErrorBodySchema, body)) {
+      return new A2aClientError(`A2A ${op} error: ${body.error.message}`, body.error.code);
+    }
+    return new A2aClientError(`A2A ${op} failed: HTTP ${res.status}`);
+  }
+  async restJson(op, args) {
+    const res = await this.restRequest(op, args);
+    if (!res.ok) throw await this.restErrorFrom(res, op);
+    try {
+      return await res.json();
+    } catch {
+      throw new A2aClientError(`A2A ${op} response is not valid JSON`);
+    }
+  }
+  async *restSse(op, args) {
+    const res = await this.restRequest(op, args);
+    if (!res.ok) throw await this.restErrorFrom(res, op);
+    const contentType = res.headers.get("content-type") ?? "";
+    if (!contentType.includes("text/event-stream")) {
+      throw new A2aClientError(`A2A ${op} answered JSON instead of an SSE stream`);
+    }
+    for await (const data of this.sseData(res, op)) {
+      let frame;
+      try {
+        frame = JSON.parse(data);
+      } catch {
+        throw new A2aClientError(`A2A ${op} SSE frame is not valid JSON`);
+      }
+      yield this.expect(StreamFrameSchema, frame, op);
+    }
+  }
+};
+
+// src/server.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { createServer } from "http";
+import { logger, uuidv7 as uuidv73 } from "@ap3x/agent-core";
+var AGENT_CARD_PATH2 = "/.well-known/agent-card.json";
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+var BODY_DRAIN_TIMEOUT_MS = 3e3;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
+function constantTimeEqual(a, b) {
+  const ha = createHash("sha256").update(a).digest();
+  const hb = createHash("sha256").update(b).digest();
+  return timingSafeEqual(ha, hb);
+}
+function sendJson2(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+var A2aServer = class {
+  card;
+  /** Base URL of the bound server (ephemeral port resolved). */
+  url;
+  executor;
+  httpServer;
+  sseStreams;
+  closeGrpc;
+  constructor(card, url, executor, httpServer, sseStreams, closeGrpc) {
+    this.card = card;
+    this.url = url;
+    this.executor = executor;
+    this.httpServer = httpServer;
+    this.sseStreams = sseStreams;
+    if (closeGrpc !== void 0) this.closeGrpc = closeGrpc;
+  }
+  /** Stop listening and tear down any open SSE streams (+ the gRPC listener). */
+  async close() {
+    for (const res of this.sseStreams) res.end();
+    this.sseStreams.clear();
+    await this.closeGrpc?.();
+    await new Promise((resolve, reject) => {
+      this.httpServer.close((error) => error ? reject(error) : resolve());
+      this.httpServer.closeAllConnections();
+    });
+  }
+};
+async function serveA2a(backend, options) {
+  if (options.bindings !== void 0 && options.bindings.length === 0) {
+    throw new Error("A2A server requires at least one binding (omit `bindings` for the default)");
+  }
+  const host = options.host ?? "127.0.0.1";
+  const bearerToken = options.auth?.bearerToken;
+  if (!LOOPBACK_HOSTS.has(host) && bearerToken === void 0) {
+    logger.warn(`A2A server binding non-loopback host ${host} WITHOUT auth \u2014 set auth.bearerToken`);
+  }
+  const executor = new A2aExecutor(backend, {
+    now: options.now ?? (() => Date.now()),
+    ...options.maxConcurrentTasks !== void 0 ? { maxConcurrentTasks: options.maxConcurrentTasks } : {},
+    ...options.maxRetainedTasks !== void 0 ? { maxRetainedTasks: options.maxRetainedTasks } : {},
+    ...options.maxRetainedContexts !== void 0 ? { maxRetainedContexts: options.maxRetainedContexts } : {}
+  });
+  const sseStreams = /* @__PURE__ */ new Set();
+  const authorized = (req) => {
+    if (bearerToken === void 0) return true;
+    const header = req.headers.authorization;
+    if (typeof header !== "string" || !header.startsWith("Bearer ")) return false;
+    return constantTimeEqual(header.slice("Bearer ".length), bearerToken);
+  };
+  const httpServer = createServer();
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(options.port ?? 0, host, () => resolve());
+  });
+  const address = httpServer.address();
+  const port = typeof address === "object" && address !== null ? address.port : options.port;
+  const url = `http://${host.includes(":") ? `[${host}]` : host}:${port}/`;
+  const bindings = options.bindings ?? ["jsonrpc"];
+  const interfaces = [];
+  if (bindings.includes("jsonrpc")) interfaces.push({ transport: "JSONRPC", url });
+  if (bindings.includes("rest")) interfaces.push({ transport: "HTTP+JSON", url });
+  let grpcServer;
+  if (bindings.includes("grpc")) {
+    try {
+      const { startGrpcServer } = await import("./grpc-5DAU6EYQ.js");
+      grpcServer = await startGrpcServer(executor, {
+        host,
+        port: options.grpcPort ?? 0,
+        ...bearerToken !== void 0 ? { bearerToken } : {}
+      });
+    } catch (error) {
+      httpServer.close();
+      httpServer.closeAllConnections();
+      throw error;
+    }
+    interfaces.push({ transport: "GRPC", url: grpcServer.url });
+  }
+  const preferred = interfaces[0] ?? { transport: "JSONRPC", url };
+  const card = {
+    id: uuidv73(),
+    name: options.card.name,
+    description: options.card.description,
+    url: preferred.url,
+    preferredTransport: preferred.transport,
+    protocolVersion: A2A_CARD_PROTOCOL_VERSION,
+    version: "1.0.0",
+    capabilities: {
+      streaming: typeof backend.runStream === "function",
+      pushNotifications: false
+      // webhooks deferred in v1
+    },
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    skills: options.card.skills ?? [],
+    interfaces,
+    ...bearerToken !== void 0 ? { securitySchemes: { bearer: { type: "http", scheme: "bearer" } } } : {},
+    ...options.card.provider ? { provider: options.card.provider } : {}
+  };
+  const collectBody = (req, res, onBody) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        req.removeAllListeners("data");
+        req.removeAllListeners("end");
+        const drainTimer = setTimeout(() => req.destroy(), BODY_DRAIN_TIMEOUT_MS);
+        drainTimer.unref();
+        req.on("end", () => {
+          clearTimeout(drainTimer);
+          sendJson2(res, 413, { error: "payload too large" });
+        });
+        req.resume();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      onBody(Buffer.concat(chunks).toString("utf8"));
+    });
+  };
+  httpServer.on("request", (req, res) => {
+    let requestUrl;
+    try {
+      requestUrl = new URL(req.url ?? "/", "http://a2a.internal");
+    } catch {
+      sendJson2(res, 400, { error: "malformed request path" });
+      return;
+    }
+    const path = requestUrl.pathname;
+    if (req.method === "GET" && path === AGENT_CARD_PATH2) {
+      sendJson2(res, 200, card);
+      return;
+    }
+    if (!authorized(req)) {
+      sendJson2(res, 401, { error: "unauthorized" });
+      return;
+    }
+    if (bindings.includes("jsonrpc") && req.method === "POST" && path === "/") {
+      collectBody(req, res, (rawBody) => {
+        void handleJsonRpc(executor, rawBody, res, sseStreams);
+      });
+      return;
+    }
+    if (bindings.includes("rest") && path.startsWith("/v1/")) {
+      const httpMethod = req.method ?? "GET";
+      const dispatch = (rawBody) => {
+        void handleRest(
+          executor,
+          httpMethod,
+          path,
+          requestUrl.searchParams,
+          rawBody,
+          res,
+          sseStreams
+        );
+      };
+      if (httpMethod === "POST") collectBody(req, res, dispatch);
+      else dispatch("");
+      return;
+    }
+    sendJson2(res, 404, { error: "not found" });
+  });
+  return new A2aServer(card, url, executor, httpServer, sseStreams, grpcServer?.close);
+}
+
+export {
+  A2A_PROTOCOL_VERSION,
+  A2A_CARD_PROTOCOL_VERSION,
+  TASK_STATES,
+  TERMINAL_TASK_STATES,
+  isTerminal,
+  TaskStateSchema,
+  normalizeTaskState,
+  normalizeWireTaskStates,
+  TextPartSchema,
+  DataPartSchema,
+  UrlPartSchema,
+  RawPartSchema,
+  PartSchema,
+  MessageSchema,
+  TaskStatusSchema,
+  ArtifactSchema,
+  TaskSchema,
+  TaskStatusUpdateEventSchema,
+  TaskArtifactUpdateEventSchema,
+  AgentSkillSchema,
+  AgentInterfaceSchema,
+  BearerSecuritySchemeSchema,
+  AgentCapabilitiesSchema,
+  AgentProviderSchema,
+  AgentCardSchema,
+  RemoteAgentInterfaceSchema,
+  RemoteAgentCardSchema,
+  A2A_ERROR_CODES,
+  TaskNotFoundError,
+  IllegalTaskTransitionError,
+  TaskStore,
+  messageText,
+  agentMessageText,
+  A2aExecutor,
+  A2A_RPC_METHODS,
+  A2A_RPC_METHOD_ALIASES,
+  JsonRpcRequestSchema,
+  MessageSendParamsSchema,
+  resolveBlocking,
+  TaskIdParamsSchema,
+  TaskListParamsSchema,
+  startSse,
+  handleJsonRpc,
+  A2A_REST_ROUTES,
+  RestErrorBodySchema,
+  restStatusFor,
+  handleRest,
+  A2A_VERSION_HEADER,
+  DEFAULT_TIMEOUT_MS,
+  A2aClientError,
+  isTaskFrame,
+  isMessageFrame,
+  isStatusUpdateFrame,
+  normalizeRemoteCard,
+  A2aClient,
+  AGENT_CARD_PATH2 as AGENT_CARD_PATH,
+  constantTimeEqual,
+  A2aServer,
+  serveA2a
+};