a2a-mesh 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1392 @@
+import { J as JsonRpcError, E as ErrorCodes, c as createRateLimiter } from './shared/a2a-mesh.CpP0sKxA.mjs';
+export { I as InMemoryRateLimitStore, R as RedisRateLimitStore } from './shared/a2a-mesh.CpP0sKxA.mjs';
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import express from 'express';
+import { EventEmitter } from 'node:events';
+import { a2aMeshTracer } from './telemetry/index.mjs';
+export { withA2ABaggage } from './telemetry/index.mjs';
+import { SpanStatusCode } from '@opentelemetry/api';
+export { SpanStatusCode } from '@opentelemetry/api';
+import { J as JwtAuthMiddleware } from './shared/a2a-mesh.DOHcVRN8.mjs';
+import { createRequire } from 'node:module';
+import EventSource from 'eventsource';
+import 'jose';
+
+function normalizeAgentCard(card) {
+  if (card.protocolVersion === "1.0") {
+    return card;
+  }
+  const capabilities = card.capabilities || card.supportsAuthenticatedExtendedCard ? {
+    ...card.capabilities ?? {},
+    ...card.supportsAuthenticatedExtendedCard || card.capabilities?.extendedAgentCard ? { extendedAgentCard: true } : {}
+  } : void 0;
+  return {
+    protocolVersion: "1.0",
+    name: card.name,
+    description: card.description,
+    url: card.url,
+    version: card.version,
+    ...card.iconUrl ? { iconUrl: card.iconUrl } : {},
+    ...card.provider ? { provider: card.provider } : {},
+    ...capabilities ? { capabilities } : {},
+    ...card.defaultInputMode ? { defaultInputModes: [card.defaultInputMode] } : {},
+    ...card.defaultOutputMode ? { defaultOutputModes: [card.defaultOutputMode] } : {},
+    ...card.skills ? { skills: card.skills } : {},
+    ...card.authentication ? { securitySchemes: card.authentication } : {}
+  };
+}
+
+const LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function resolveLogLevel() {
+  const level = process.env.LOG_LEVEL?.toLowerCase();
+  if (level === "debug" || level === "info" || level === "warn" || level === "error") {
+    return level;
+  }
+  return "info";
+}
+function isProductionMode() {
+  return process.env.NODE_ENV === "production";
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return { error: String(error) };
+}
+function formatPretty(level, message, context) {
+  const contextEntries = Object.entries(context).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(" ");
+  return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()} ${message}${contextEntries ? ` ${contextEntries}` : ""}`;
+}
+function writeLog(level, message, context) {
+  if (LOG_LEVELS[level] < LOG_LEVELS[resolveLogLevel()]) {
+    return;
+  }
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message,
+    ...context
+  };
+  const output = isProductionMode() ? JSON.stringify(payload) : formatPretty(level, message, context);
+  if (level === "error") {
+    process.stderr.write(`${output}
+`);
+    return;
+  }
+  process.stdout.write(`${output}
+`);
+}
+const logger = {
+  debug(message, context = {}) {
+    writeLog("debug", message, context);
+  },
+  info(message, context = {}) {
+    writeLog("info", message, context);
+  },
+  warn(message, context = {}) {
+    writeLog("warn", message, context);
+  },
+  error(message, context = {}) {
+    const normalizedContext = { ...context };
+    if ("error" in normalizedContext) {
+      normalizedContext.error = serializeError(normalizedContext.error);
+    }
+    writeLog("error", message, normalizedContext);
+  }
+};
+
+const AuthSchemeSchema = z.union([
+  z.object({
+    type: z.literal("apiKey"),
+    id: z.string(),
+    in: z.enum(["header", "query"]),
+    name: z.string(),
+    description: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("http"),
+    id: z.string(),
+    scheme: z.literal("bearer"),
+    bearerFormat: z.string().optional(),
+    description: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("openIdConnect"),
+    id: z.string(),
+    openIdConnectUrl: z.string().url(),
+    audience: z.union([z.string(), z.array(z.string())]).optional(),
+    issuer: z.string().optional(),
+    jwksUri: z.string().url().optional(),
+    algorithms: z.array(z.string()).optional(),
+    description: z.string().optional()
+  })
+]);
+const A2AExtensionSchema = z.object({
+  uri: z.string().url(),
+  version: z.string().optional(),
+  required: z.boolean().optional()
+});
+const JsonRpcRequestSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  method: z.string(),
+  params: z.union([z.record(z.unknown()), z.array(z.unknown())]).optional(),
+  id: z.union([z.string(), z.number(), z.null()]).optional()
+});
+const PartSchema = z.union([
+  z.object({ type: z.literal("text"), text: z.string() }),
+  z.object({
+    type: z.literal("file"),
+    file: z.object({
+      name: z.string().optional(),
+      mimeType: z.string(),
+      bytes: z.string().optional(),
+      uri: z.string().optional()
+    })
+  }),
+  z.object({ type: z.literal("data"), data: z.record(z.unknown()) })
+]);
+const MessageSchema = z.object({
+  kind: z.literal("message").optional(),
+  role: z.enum(["user", "agent"]),
+  parts: z.array(PartSchema),
+  messageId: z.string(),
+  timestamp: z.string(),
+  // ISO8601
+  contextId: z.string().optional()
+});
+const PushNotificationConfigSchema = z.object({
+  id: z.string().optional(),
+  url: z.string().url(),
+  token: z.string().optional(),
+  authentication: AuthSchemeSchema.optional()
+});
+const MessageRequestConfigurationSchema = z.object({
+  blocking: z.boolean().optional(),
+  acceptedOutputModes: z.array(z.string()).optional(),
+  pushNotificationConfig: PushNotificationConfigSchema.optional(),
+  extensions: z.array(A2AExtensionSchema).optional()
+});
+const MessageSendParamsSchema = z.object({
+  message: MessageSchema,
+  taskId: z.string().optional(),
+  sessionId: z.string().optional(),
+  contextId: z.string().optional(),
+  configuration: MessageRequestConfigurationSchema.optional()
+});
+const TaskListParamsSchema = z.object({
+  contextId: z.string().optional(),
+  limit: z.number().int().positive().max(500).optional(),
+  offset: z.number().int().min(0).optional()
+});
+function validateRequest(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new JsonRpcError(ErrorCodes.InvalidParams, "Invalid parameters", result.error.errors);
+  }
+  return result.data;
+}
+function validateMessageSendParams(data) {
+  return validateRequest(MessageSendParamsSchema, data);
+}
+function validateTaskListParams(data) {
+  return validateRequest(TaskListParamsSchema, data);
+}
+
+class InMemoryTaskStorage {
+  tasks = /* @__PURE__ */ new Map();
+  contextIndex = /* @__PURE__ */ new Map();
+  pushNotifications = /* @__PURE__ */ new Map();
+  insertTask(task) {
+    const storedTask = structuredClone(task);
+    this.tasks.set(storedTask.id, storedTask);
+    this.syncContextIndex(void 0, storedTask.contextId, storedTask.id);
+    return structuredClone(storedTask);
+  }
+  getTask(taskId) {
+    const task = this.tasks.get(taskId);
+    return task ? structuredClone(task) : void 0;
+  }
+  saveTask(task) {
+    const previousTask = this.tasks.get(task.id);
+    const storedTask = structuredClone(task);
+    this.tasks.set(task.id, storedTask);
+    this.syncContextIndex(previousTask?.contextId, storedTask.contextId, storedTask.id);
+  }
+  getAllTasks() {
+    return Array.from(this.tasks.values(), (task) => structuredClone(task));
+  }
+  getTasksByContextId(contextId) {
+    const ids = this.contextIndex.get(contextId);
+    if (!ids) {
+      return [];
+    }
+    return Array.from(ids).map((taskId) => this.tasks.get(taskId)).filter((task) => task !== void 0).map((task) => structuredClone(task));
+  }
+  setPushNotification(taskId, config) {
+    if (!this.tasks.has(taskId)) {
+      return void 0;
+    }
+    const storedConfig = structuredClone(config);
+    this.pushNotifications.set(taskId, storedConfig);
+    return structuredClone(storedConfig);
+  }
+  getPushNotification(taskId) {
+    const config = this.pushNotifications.get(taskId);
+    return config ? structuredClone(config) : void 0;
+  }
+  syncContextIndex(previousContextId, nextContextId, taskId) {
+    if (previousContextId && previousContextId !== nextContextId) {
+      const previousIds = this.contextIndex.get(previousContextId);
+      previousIds?.delete(taskId);
+      if (previousIds?.size === 0) {
+        this.contextIndex.delete(previousContextId);
+      }
+    }
+    if (!nextContextId) {
+      return;
+    }
+    const nextIds = this.contextIndex.get(nextContextId) ?? /* @__PURE__ */ new Set();
+    nextIds.add(taskId);
+    this.contextIndex.set(nextContextId, nextIds);
+  }
+}
+
+class TaskManager extends EventEmitter {
+  constructor(storage = new InMemoryTaskStorage()) {
+    super();
+    this.storage = storage;
+  }
+  /**
+   * Creates a new task and stores it in memory.
+   *
+   * @param sessionId Optional session identifier.
+   * @param contextId Optional conversation context identifier.
+   * @returns Newly created task.
+   */
+  createTask(sessionId, contextId) {
+    const task = {
+      kind: "task",
+      id: randomUUID(),
+      status: {
+        state: "submitted",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      history: [],
+      artifacts: [],
+      extensions: [],
+      metadata: {},
+      ...sessionId ? { sessionId } : {},
+      ...contextId ? { contextId } : {}
+    };
+    const storedTask = this.storage.insertTask(task);
+    this.emitTaskUpdated(storedTask, "created");
+    return storedTask;
+  }
+  getTask(taskId) {
+    return this.storage.getTask(taskId);
+  }
+  getAllTasks() {
+    return this.storage.getAllTasks();
+  }
+  getTasksByContext(contextId) {
+    return this.storage.getTasksByContextId(contextId);
+  }
+  getTasksByContextId(contextId) {
+    return this.getTasksByContext(contextId);
+  }
+  addHistoryMessage(taskId, message) {
+    const task = this.storage.getTask(taskId);
+    if (!task) {
+      return void 0;
+    }
+    task.history.push({
+      ...message,
+      ...message.contextId ?? task.contextId ? { contextId: message.contextId ?? task.contextId } : {}
+    });
+    this.storage.saveTask(task);
+    this.emitTaskUpdated(task, "message");
+    return task;
+  }
+  addArtifact(taskId, artifact) {
+    const task = this.storage.getTask(taskId);
+    if (!task) {
+      return void 0;
+    }
+    const nextArtifact = {
+      ...artifact,
+      ...artifact.extensions ?? task.extensions ? { extensions: artifact.extensions ?? task.extensions } : {},
+      metadata: {
+        ...artifact.metadata ?? {},
+        ...task.contextId ? { contextId: task.contextId } : {}
+      }
+    };
+    task.artifacts = [...task.artifacts ?? [], nextArtifact];
+    this.storage.saveTask(task);
+    this.emitTaskUpdated(task, "artifact");
+    return task;
+  }
+  updateTaskState(taskId, state, historyMessage, metadata) {
+    const task = this.storage.getTask(taskId);
+    if (!task) {
+      return void 0;
+    }
+    task.status = {
+      state,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...typeof metadata?.message === "string" ? { message: metadata.message } : {}
+    };
+    if (historyMessage) {
+      task.history.push({
+        ...historyMessage,
+        ...historyMessage.contextId ?? task.contextId ? { contextId: historyMessage.contextId ?? task.contextId } : {}
+      });
+    }
+    if (metadata) {
+      task.metadata = { ...task.metadata ?? {}, ...metadata };
+    }
+    this.storage.saveTask(task);
+    this.emitTaskUpdated(task, "state");
+    return task;
+  }
+  cancelTask(taskId) {
+    return this.updateTaskState(taskId, "canceled");
+  }
+  setPushNotification(taskId, config) {
+    const task = this.storage.getTask(taskId);
+    if (!task) {
+      return void 0;
+    }
+    const storedConfig = this.storage.setPushNotification(taskId, config);
+    this.emitTaskUpdated(task, "push-config");
+    return storedConfig;
+  }
+  getPushNotification(taskId) {
+    return this.storage.getPushNotification(taskId);
+  }
+  setTaskExtensions(taskId, extensions) {
+    const task = this.storage.getTask(taskId);
+    if (!task) {
+      return void 0;
+    }
+    task.extensions = extensions;
+    this.storage.saveTask(task);
+    return task;
+  }
+  getTaskCounts() {
+    return this.storage.getAllTasks().reduce(
+      (counts, task) => {
+        counts.total += 1;
+        switch (task.status.state) {
+          case "submitted":
+            counts.submitted += 1;
+            counts.active += 1;
+            break;
+          case "working":
+            counts.working += 1;
+            counts.active += 1;
+            break;
+          case "input-required":
+            counts.inputRequired += 1;
+            counts.active += 1;
+            break;
+          case "completed":
+            counts.completed += 1;
+            break;
+          case "failed":
+            counts.failed += 1;
+            break;
+          case "canceled":
+            counts.canceled += 1;
+            break;
+        }
+        return counts;
+      },
+      {
+        total: 0,
+        active: 0,
+        completed: 0,
+        failed: 0,
+        canceled: 0,
+        submitted: 0,
+        inputRequired: 0,
+        working: 0
+      }
+    );
+  }
+  emitTaskUpdated(task, reason) {
+    this.emit("taskUpdated", { task: structuredClone(task), reason });
+  }
+}
+
+class SSEStreamer {
+  clients = /* @__PURE__ */ new Map();
+  /**
+   * Add a client to the stream map (allows multiple subscribers per task).
+   * @param taskId The task ID associated with the stream.
+   * @param res The Express Response object.
+   */
+  addClient(taskId, res) {
+    if (!this.clients.has(taskId)) {
+      this.clients.set(taskId, /* @__PURE__ */ new Set());
+    }
+    const taskClients = this.clients.get(taskId);
+    if (!taskClients) {
+      return;
+    }
+    taskClients.add(res);
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.on("close", () => {
+      this.removeClient(taskId, res);
+    });
+  }
+  /**
+   * Broadcast an event to all subscribers of a specific task.
+   * @param taskId The task ID.
+   * @param event The SSE event type (e.g. 'task_updated').
+   * @param data The JSON data payload.
+   */
+  sendEvent(taskId, event, data) {
+    const taskClients = this.clients.get(taskId);
+    if (taskClients) {
+      const span = a2aMeshTracer.startSpan("sse.sendEvent", {
+        attributes: {
+          "a2a.task_id": taskId,
+          "a2a.event": event,
+          "a2a.client_count": taskClients.size
+        }
+      });
+      try {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        taskClients.forEach((res) => {
+          try {
+            res.write(payload);
+          } catch {
+            this.removeClient(taskId, res);
+          }
+        });
+      } finally {
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+      }
+    }
+  }
+  /**
+   * Send a task update and complete the streams if terminal state reached.
+   * @param taskId The task ID.
+   * @param task The updated task object.
+   */
+  sendTaskUpdate(taskId, task) {
+    this.sendEvent(taskId, "task_updated", task);
+    if (["completed", "failed", "canceled"].includes(task.status.state)) {
+      this.closeStream(taskId);
+    }
+  }
+  /**
+   * Close all streams for a specific task.
+   * @param taskId The task ID.
+   */
+  closeStream(taskId) {
+    const taskClients = this.clients.get(taskId);
+    if (taskClients) {
+      taskClients.forEach((res) => {
+        try {
+          res.end();
+        } catch {
+        }
+      });
+      this.clients.delete(taskId);
+    }
+  }
+  /**
+   * Remove a specific client from the map.
+   * @param taskId The task ID.
+   * @param res The specific Response object.
+   */
+  removeClient(taskId, res) {
+    const taskClients = this.clients.get(taskId);
+    if (taskClients) {
+      taskClients.delete(res);
+      if (taskClients.size === 0) {
+        this.clients.delete(taskId);
+      }
+    }
+  }
+}
+
+class CircuitOpenError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CircuitOpenError";
+  }
+}
+class CircuitBreaker {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.failureThreshold = options.failureThreshold ?? 5;
+    this.recoveryTimeoutMs = options.recoveryTimeoutMs ?? 6e4;
+    this.successThreshold = options.successThreshold ?? 2;
+  }
+  state = "CLOSED";
+  failureCount = 0;
+  successCount = 0;
+  nextAttemptAt = 0;
+  failureThreshold;
+  recoveryTimeoutMs;
+  successThreshold;
+  getState() {
+    return this.state;
+  }
+  async execute(fn) {
+    if (this.state === "OPEN") {
+      if (Date.now() < this.nextAttemptAt) {
+        throw new CircuitOpenError(
+          `Circuit breaker [${this.name}] is OPEN. Next attempt at ${new Date(this.nextAttemptAt).toISOString()}`
+        );
+      }
+      this.state = "HALF_OPEN";
+      this.successCount = 0;
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    if (this.state === "HALF_OPEN") {
+      this.successCount += 1;
+      if (this.successCount >= this.successThreshold) {
+        this.state = "CLOSED";
+        this.successCount = 0;
+      }
+    }
+  }
+  onFailure() {
+    this.failureCount += 1;
+    if (this.state === "HALF_OPEN" || this.failureCount >= this.failureThreshold) {
+      this.state = "OPEN";
+      this.nextAttemptAt = Date.now() + this.recoveryTimeoutMs;
+      this.failureCount = 0;
+      this.successCount = 0;
+    }
+  }
+}
+
+class PushNotificationService {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  breakers = /* @__PURE__ */ new Map();
+  getBreakerFor(url) {
+    const existing = this.breakers.get(url);
+    if (existing) {
+      return existing;
+    }
+    const breaker = new CircuitBreaker(`push:${url}`, this.options.circuitBreaker);
+    this.breakers.set(url, breaker);
+    return breaker;
+  }
+  /**
+   * Sends a task snapshot to the configured webhook endpoint.
+   *
+   * @param config Webhook delivery configuration.
+   * @param task Current task snapshot to deliver.
+   * @returns Resolves when delivery succeeds.
+   * @throws When the endpoint responds with a non-2xx status.
+   */
+  async sendNotification(config, task) {
+    const breaker = this.getBreakerFor(config.url);
+    try {
+      await breaker.execute(async () => {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        let url = config.url;
+        if (config.token) {
+          headers["X-A2A-Notification-Token"] = config.token;
+        }
+        if (config.authentication && config.token) {
+          if (config.authentication.type === "apiKey") {
+            if (config.authentication.in === "header") {
+              headers[config.authentication.name] = config.token;
+            } else {
+              const nextUrl = new URL(url);
+              nextUrl.searchParams.set(config.authentication.name, config.token);
+              url = nextUrl.toString();
+            }
+          }
+          if (config.authentication.type === "http") {
+            headers.Authorization = `Bearer ${config.token}`;
+          }
+          if (config.authentication.type === "openIdConnect") {
+            headers.Authorization = `Bearer ${config.token}`;
+          }
+        }
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(task)
+        });
+        if (!response.ok) {
+          throw new Error(`Push notification failed: HTTP ${response.status}`);
+        }
+      });
+    } catch (error) {
+      if (error instanceof CircuitOpenError) {
+        logger.warn("Push notification skipped - circuit open", {
+          taskId: task.id,
+          url: config.url
+        });
+        return;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Executes an async action with exponential backoff.
+   *
+   * @param fn Async operation to retry.
+   * @param maxRetries Maximum number of retry attempts.
+   * @returns Resolves when the operation succeeds.
+   * @throws Re-throws the last failure when retries are exhausted.
+   */
+  async retryWithBackoff(fn, maxRetries = 3) {
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        await fn();
+        return;
+      } catch (error) {
+        if (error instanceof CircuitOpenError) {
+          return;
+        }
+        lastError = error;
+        attempt += 1;
+        if (attempt >= maxRetries) {
+          break;
+        }
+        const delayMs = 250 * 2 ** (attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+}
+
+class A2AServer {
+  constructor(agentCard, options = {}) {
+    this.options = options;
+    this.app = express();
+    this.app.use(express.json());
+    this.agentCard = agentCard;
+    this.taskManager = new TaskManager(options.taskStorage ?? new InMemoryTaskStorage());
+    this.streamer = new SSEStreamer();
+    this.pushNotificationService = new PushNotificationService();
+    this.authMiddleware = options.auth ? new JwtAuthMiddleware(options.auth) : void 0;
+    this.setupMiddleware();
+    this.setupRoutes();
+    this.bindTaskObservers();
+  }
+  app;
+  agentCard;
+  taskManager;
+  streamer;
+  pushNotificationService;
+  authMiddleware;
+  startedAt = Date.now();
+  setupMiddleware() {
+    this.app.use((req, _res, next) => {
+      req.requestId = req.header("x-request-id") ?? randomUUID();
+      next();
+    });
+    if (this.options.rateLimit) {
+      this.app.use(createRateLimiter(this.options.rateLimit, this.options.rateLimitStore));
+    }
+  }
+  setupRoutes() {
+    const serveCard = (_req, res) => {
+      res.json(this.agentCard);
+    };
+    this.app.get("/.well-known/agent-card.json", serveCard);
+    this.app.get("/.well-known/agent.json", serveCard);
+    this.app.get("/health", (_req, res) => {
+      const taskCounts = this.taskManager.getTaskCounts();
+      const memoryUsage = process.memoryUsage();
+      const payload = {
+        status: "healthy",
+        version: this.agentCard.version,
+        protocol: "A2A/1.0",
+        uptime: Math.floor((Date.now() - this.startedAt) / 1e3),
+        tasks: {
+          active: taskCounts.active,
+          completed: taskCounts.completed,
+          failed: taskCounts.failed,
+          total: taskCounts.total
+        },
+        memory: {
+          heapUsedMb: Number((memoryUsage.heapUsed / 1024 / 1024).toFixed(1)),
+          heapTotalMb: Number((memoryUsage.heapTotal / 1024 / 1024).toFixed(1))
+        }
+      };
+      res.json(payload);
+    });
+    const handleJsonRpc = async (req, res) => {
+      try {
+        const rpcReq = validateRequest(JsonRpcRequestSchema, req.body);
+        const result = await this.handleRpc(rpcReq, { req });
+        const response = {
+          jsonrpc: "2.0",
+          result,
+          id: rpcReq.id || null
+        };
+        res.json(response);
+      } catch (err) {
+        if (err instanceof JsonRpcError) {
+          res.json({
+            jsonrpc: "2.0",
+            error: { code: err.code, message: err.message, data: err.data },
+            id: req.body.id || null
+          });
+        } else {
+          logger.error("Unhandled internal error", { error: String(err) });
+          res.json({
+            jsonrpc: "2.0",
+            error: { code: ErrorCodes.InternalError, message: "Internal Error" },
+            id: req.body.id || null
+          });
+        }
+      }
+    };
+    this.app.post("/", handleJsonRpc);
+    this.app.post("/a2a/jsonrpc", handleJsonRpc);
+    const handleStreamRequest = (req, res) => {
+      const taskId = req.query.taskId;
+      if (!taskId) {
+        res.status(400).send("Missing taskId query parameter");
+        return;
+      }
+      this.streamer.addClient(taskId, res);
+      const task = this.taskManager.getTask(taskId);
+      if (task) {
+        this.streamer.sendTaskUpdate(taskId, task);
+      }
+    };
+    this.app.get("/stream", handleStreamRequest);
+    this.app.get("/a2a/stream", handleStreamRequest);
+  }
+  bindTaskObservers() {
+    this.taskManager.on("taskUpdated", async ({ task, reason }) => {
+      if (reason !== "push-config") {
+        this.streamer.sendTaskUpdate(task.id, task);
+      }
+      if (reason === "state") {
+        const pushConfig = this.taskManager.getPushNotification(task.id);
+        if (pushConfig) {
+          try {
+            await this.pushNotificationService.retryWithBackoff(
+              () => this.pushNotificationService.sendNotification(pushConfig, task)
+            );
+          } catch (error) {
+            logger.error("Push notification delivery failed", {
+              taskId: task.id,
+              contextId: task.contextId,
+              error
+            });
+          }
+        }
+      }
+    });
+  }
+  async handleRpc(req, context) {
+    const span = a2aMeshTracer.startSpan("a2a.handleRpc", {
+      attributes: {
+        "rpc.method": req.method,
+        "a2a.agent_name": this.agentCard.name
+      }
+    });
+    const requestId = context.req.requestId;
+    const startedAt = Date.now();
+    let failed = false;
+    try {
+      const params = req.params ?? {};
+      switch (req.method) {
+        case "message/send":
+        case "message/stream":
+          return await this.handleMessageRequest(validateMessageSendParams(params), req.method);
+        case "tasks/get": {
+          if (typeof params.taskId !== "string") {
+            throw new JsonRpcError(ErrorCodes.InvalidParams, "Missing taskId");
+          }
+          const task = this.taskManager.getTask(params.taskId);
+          if (!task) {
+            throw new JsonRpcError(ErrorCodes.TaskNotFound, "Task not found");
+          }
+          return task;
+        }
+        case "tasks/cancel": {
+          if (typeof params.taskId !== "string") {
+            throw new JsonRpcError(ErrorCodes.InvalidParams, "Missing taskId");
+          }
+          const task = this.taskManager.cancelTask(params.taskId);
+          if (!task) {
+            throw new JsonRpcError(ErrorCodes.TaskNotFound, "Task not found");
+          }
+          return task;
+        }
+        case "tasks/pushNotification/set": {
+          if (typeof params.taskId !== "string" || typeof params.pushNotificationConfig !== "object") {
+            throw new JsonRpcError(
+              ErrorCodes.InvalidParams,
+              "Missing taskId or pushNotificationConfig"
+            );
+          }
+          const config = this.taskManager.setPushNotification(
+            params.taskId,
+            params.pushNotificationConfig
+          );
+          if (!config) {
+            throw new JsonRpcError(ErrorCodes.TaskNotFound, "Task not found");
+          }
+          return config;
+        }
+        case "tasks/pushNotification/get": {
+          if (typeof params.taskId !== "string") {
+            throw new JsonRpcError(ErrorCodes.InvalidParams, "Missing taskId");
+          }
+          return this.taskManager.getPushNotification(params.taskId) ?? null;
+        }
+        case "tasks/list": {
+          const { contextId, limit = 50, offset = 0 } = validateTaskListParams(params);
+          const tasks = contextId ? this.taskManager.getTasksByContext(contextId) : this.taskManager.getAllTasks();
+          return {
+            tasks: tasks.slice(offset, offset + limit),
+            total: tasks.length
+          };
+        }
+        case "agent/authenticatedExtendedCard": {
+          if (!this.agentCard.capabilities?.extendedAgentCard) {
+            throw new JsonRpcError(ErrorCodes.UnsupportedOperation, "Extended card not supported");
+          }
+          if (this.authMiddleware) {
+            try {
+              await this.authMiddleware.authenticateRequest(context.req);
+            } catch (error) {
+              throw new JsonRpcError(ErrorCodes.Unauthorized, "Unauthorized", {
+                reason: String(error)
+              });
+            }
+          }
+          return this.agentCard;
+        }
+        default:
+          throw new JsonRpcError(ErrorCodes.MethodNotFound, `Method ${req.method} not found`);
+      }
+    } catch (error) {
+      failed = true;
+      span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+      throw error;
+    } finally {
+      if (!failed) {
+        span.setStatus({ code: SpanStatusCode.OK });
+      }
+      span.end();
+      logger.info("Handled RPC request", {
+        ...requestId ? { requestId } : {},
+        method: req.method,
+        agentName: this.agentCard.name,
+        durationMs: Date.now() - startedAt
+      });
+    }
+  }
+  async handleMessageRequest(params, method) {
+    const task = params.taskId ? this.taskManager.getTask(params.taskId) : this.taskManager.createTask(params.sessionId, params.contextId ?? params.message.contextId);
+    if (!task) {
+      throw new JsonRpcError(ErrorCodes.TaskNotFound, "Task not found");
+    }
+    const appliedExtensions = this.negotiateExtensions(params.configuration?.extensions ?? []);
+    this.taskManager.setTaskExtensions(task.id, appliedExtensions);
+    if (params.configuration?.pushNotificationConfig) {
+      this.taskManager.setPushNotification(task.id, params.configuration.pushNotificationConfig);
+    }
+    const message = {
+      ...params.message,
+      kind: params.message.kind ?? "message",
+      ...params.message.contextId ?? task.contextId ? { contextId: params.message.contextId ?? task.contextId } : {}
+    };
+    this.taskManager.addHistoryMessage(task.id, message);
+    this.taskManager.updateTaskState(task.id, "working");
+    this.processTaskInternal(task, message).catch((error) => {
+      logger.error("Task processing failed", {
+        taskId: task.id,
+        ...task.contextId ? { contextId: task.contextId } : {},
+        error
+      });
+    });
+    if (method === "message/stream") {
+      return this.taskManager.getTask(task.id) ?? task;
+    }
+    return this.taskManager.getTask(task.id) ?? task;
+  }
+  negotiateExtensions(requestedExtensions) {
+    if (requestedExtensions.length === 0) {
+      return [];
+    }
+    const supported = new Set((this.agentCard.extensions ?? []).map((extension) => extension.uri));
+    const applied = [];
+    for (const extension of requestedExtensions) {
+      if (supported.has(extension.uri)) {
+        applied.push(extension.uri);
+        continue;
+      }
+      if (extension.required) {
+        throw new JsonRpcError(
+          ErrorCodes.ExtensionRequired,
+          `Required extension not supported: ${extension.uri}. See: https://oaslananka.github.io/a2a-mesh/protocol/extensions`
+        );
+      }
+    }
+    return applied;
+  }
+  normalizeArtifacts(task, artifacts) {
+    return artifacts.map((artifact) => ({
+      ...artifact,
+      ...artifact.extensions ?? task.extensions ? { extensions: artifact.extensions ?? task.extensions } : {},
+      metadata: {
+        ...artifact.metadata ?? {},
+        taskId: task.id,
+        ...task.contextId ? { contextId: task.contextId } : {},
+        appliedExtensions: task.extensions ?? []
+      }
+    }));
+  }
+  getExpressApp() {
+    return this.app;
+  }
+  getAgentCard() {
+    return this.agentCard;
+  }
+  getTaskManager() {
+    return this.taskManager;
+  }
+  static fromCard(card) {
+    return card.protocolVersion === "1.0" ? card : { ...card, protocolVersion: "1.0" };
+  }
+  async processTaskInternal(task, message) {
+    const span = a2aMeshTracer.startSpan("a2a.processTask", {
+      attributes: {
+        "a2a.task_id": task.id,
+        "a2a.context_id": task.contextId ?? ""
+      }
+    });
+    try {
+      const artifacts = await this.handleTask(task, message);
+      this.normalizeArtifacts(task, artifacts).forEach((artifact) => {
+        this.taskManager.addArtifact(task.id, artifact);
+      });
+      this.taskManager.updateTaskState(task.id, "completed");
+      span.setStatus({ code: SpanStatusCode.OK });
+    } catch (error) {
+      this.taskManager.updateTaskState(task.id, "failed");
+      span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  start(port) {
+    return this.app.listen(port, () => {
+      logger.info(`A2A Server listening on port ${port}`);
+    });
+  }
+}
+
+function parseTask(row) {
+  return row ? JSON.parse(row.task_json) : void 0;
+}
+function parsePushNotification(row) {
+  return row ? JSON.parse(row.config_json) : void 0;
+}
+class SqliteTaskStorage {
+  db;
+  constructor(path) {
+    const require = createRequire(import.meta.url);
+    const imported = require("better-sqlite3");
+    const Database = "default" in imported ? imported.default : imported;
+    this.db = new Database(path);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        context_id TEXT,
+        task_json TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS push_notifications (
+        task_id TEXT PRIMARY KEY,
+        config_json TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_tasks_context_id ON tasks(context_id);
+    `);
+  }
+  insertTask(task) {
+    this.db.prepare("INSERT INTO tasks (id, context_id, task_json) VALUES (?, ?, ?)").run(task.id, task.contextId ?? null, JSON.stringify(task));
+    return structuredClone(task);
+  }
+  getTask(taskId) {
+    return parseTask(
+      this.db.prepare("SELECT task_json FROM tasks WHERE id = ?").get(taskId)
+    );
+  }
+  saveTask(task) {
+    this.db.prepare("UPDATE tasks SET context_id = ?, task_json = ? WHERE id = ?").run(task.contextId ?? null, JSON.stringify(task), task.id);
+  }
+  getAllTasks() {
+    return this.db.prepare("SELECT task_json FROM tasks ORDER BY id").all().map((row) => JSON.parse(row.task_json));
+  }
+  getTasksByContextId(contextId) {
+    return this.db.prepare("SELECT task_json FROM tasks WHERE context_id = ? ORDER BY id").all(contextId).map((row) => JSON.parse(row.task_json));
+  }
+  setPushNotification(taskId, config) {
+    if (!this.getTask(taskId)) {
+      return void 0;
+    }
+    this.db.prepare(
+      "INSERT INTO push_notifications (task_id, config_json) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET config_json = excluded.config_json"
+    ).run(taskId, JSON.stringify(config));
+    return structuredClone(config);
+  }
+  getPushNotification(taskId) {
+    return parsePushNotification(
+      this.db.prepare(
+        "SELECT config_json FROM push_notifications WHERE task_id = ?"
+      ).get(taskId)
+    );
+  }
+}
+
+class A2AClient {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl;
+    this.fetchImplementation = options.fetchImplementation ?? fetch;
+    this.cardPath = options.cardPath ?? "/.well-known/agent-card.json";
+    this.rpcPath = options.rpcPath ?? "/a2a/jsonrpc";
+    this.streamPath = options.streamPath ?? "/a2a/stream";
+    this.eventSourceImplementation = options.eventSourceImplementation ?? EventSource;
+    this.interceptors = options.interceptors ?? [];
+    this.headers = options.headers ?? {};
+    this.retry = {
+      maxAttempts: options.retry?.maxAttempts ?? 3,
+      backoffMs: options.retry?.backoffMs ?? 1e3,
+      retryOn: options.retry?.retryOn ?? [502, 503, 504]
+    };
+  }
+  fetchImplementation;
+  cardPath;
+  rpcPath;
+  streamPath;
+  eventSourceImplementation;
+  interceptors;
+  headers;
+  retry;
+  async resolveCard() {
+    const canonicalUrl = new URL(this.cardPath, this.baseUrl).toString();
+    const legacyUrl = new URL("/.well-known/agent.json", this.baseUrl).toString();
+    const response = await this.fetchWithRetry(canonicalUrl);
+    if (response.ok) {
+      return await response.json();
+    }
+    const legacyResponse = await this.fetchWithRetry(legacyUrl);
+    if (!legacyResponse.ok) {
+      throw new Error(`Failed to resolve agent card from ${canonicalUrl}`);
+    }
+    return await legacyResponse.json();
+  }
+  async sendMessage(params) {
+    return this.rpc("message/send", this.normalizeParams(params));
+  }
+  async sendMessageStream(params) {
+    const task = await this.rpc(
+      "message/stream",
+      this.normalizeParams(params)
+    );
+    return this.subscribeToTask(task.id);
+  }
+  async getTask(taskId) {
+    return this.rpc("tasks/get", { taskId });
+  }
+  async listTasks(params = {}) {
+    return this.rpc("tasks/list", params);
+  }
+  async cancelTask(taskId) {
+    return this.rpc("tasks/cancel", { taskId });
+  }
+  async setPushNotification(taskId, pushNotificationConfig) {
+    return this.rpc("tasks/pushNotification/set", {
+      taskId,
+      pushNotificationConfig
+    });
+  }
+  async getPushNotification(taskId) {
+    return this.rpc(
+      "tasks/pushNotification/get",
+      {
+        taskId
+      }
+    );
+  }
+  async health() {
+    const response = await this.fetchWithRetry(new URL("/health", this.baseUrl), {
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Health check failed with status ${response.status}`);
+    }
+    return await response.json();
+  }
+  async rpc(method, params) {
+    const options = { headers: { ...this.headers } };
+    const payload = {
+      jsonrpc: "2.0",
+      id: `${Date.now()}`,
+      method,
+      params
+    };
+    for (const interceptor of this.interceptors) {
+      await interceptor.before({ method, body: payload, options });
+    }
+    const response = await this.fetchWithRetry(new URL(this.rpcPath, this.baseUrl), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers ?? {},
+        ...options.serviceParameters ?? {}
+      },
+      ...options.signal ? { signal: options.signal } : {},
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`RPC request failed with status ${response.status}`);
+    }
+    const json = await response.json();
+    if ("error" in json) {
+      const failure = json;
+      throw new Error(`${failure.error.message} (${failure.error.code})`);
+    }
+    const success = json;
+    for (const interceptor of this.interceptors) {
+      await interceptor.after?.({ method, response: success.result });
+    }
+    return success.result;
+  }
+  normalizeParams(params) {
+    if ("message" in params) {
+      return params;
+    }
+    return { message: params };
+  }
+  async *subscribeToTask(taskId) {
+    const streamUrl = new URL(this.streamPath, this.baseUrl);
+    streamUrl.searchParams.set("taskId", taskId);
+    const queue = [];
+    let resolveNext;
+    let closed = false;
+    const source = new this.eventSourceImplementation(streamUrl.toString(), {
+      headers: this.headers
+    });
+    const push = (data) => {
+      queue.push(data);
+      resolveNext?.();
+    };
+    source.addEventListener("task_updated", (event) => {
+      const data = "data" in event ? JSON.parse(String(event.data)) : null;
+      push(data);
+      if (data && typeof data === "object" && "status" in data && typeof data.status === "object" && data.status !== null && "state" in data.status && ["completed", "failed", "canceled"].includes(String(data.status.state))) {
+        closed = true;
+        source.close();
+        resolveNext?.();
+      }
+    });
+    source.onerror = () => {
+      closed = true;
+      source.close();
+      resolveNext?.();
+    };
+    try {
+      while (!closed || queue.length > 0) {
+        if (queue.length === 0) {
+          await new Promise((resolve) => {
+            resolveNext = resolve;
+          });
+          resolveNext = void 0;
+        }
+        const next = queue.shift();
+        if (next !== void 0) {
+          yield next;
+        }
+      }
+    } finally {
+      source.close();
+    }
+  }
+  async fetchWithRetry(input, init) {
+    let lastError;
+    for (let attempt = 1; attempt <= this.retry.maxAttempts; attempt += 1) {
+      try {
+        const response = await this.fetchImplementation(input, init);
+        if (response.ok || attempt === this.retry.maxAttempts || !this.retry.retryOn.includes(response.status)) {
+          return response;
+        }
+      } catch (error) {
+        lastError = error;
+        if (attempt === this.retry.maxAttempts) {
+          throw error;
+        }
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, this.retry.backoffMs * attempt);
+      });
+    }
+    throw new Error(
+      `Request failed after ${this.retry.maxAttempts} attempts: ${String(lastError)}`
+    );
+  }
+}
+
+class AgentRegistryClient {
+  constructor(baseUrl, fetchImplementation = fetch) {
+    this.baseUrl = baseUrl;
+    this.fetchImplementation = fetchImplementation;
+  }
+  async register(agentUrl, agentCard) {
+    const response = await this.fetchImplementation(new URL("/agents/register", this.baseUrl), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agentUrl, agentCard })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to register agent (${response.status})`);
+    }
+    return await response.json();
+  }
+  async listAgents() {
+    const response = await this.fetchImplementation(new URL("/agents", this.baseUrl));
+    if (!response.ok) {
+      throw new Error(`Failed to list agents (${response.status})`);
+    }
+    return await response.json();
+  }
+  async getAgent(id) {
+    const response = await this.fetchImplementation(new URL(`/agents/${id}`, this.baseUrl));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch agent (${response.status})`);
+    }
+    return await response.json();
+  }
+  async searchAgents(query, filters = {}) {
+    const url = new URL("/agents/search", this.baseUrl);
+    url.searchParams.set("skill", query);
+    for (const [key, value] of Object.entries(filters)) {
+      url.searchParams.set(key, value);
+    }
+    const response = await this.fetchImplementation(url);
+    if (!response.ok) {
+      throw new Error(`Failed to search agents (${response.status})`);
+    }
+    return await response.json();
+  }
+  async sendHeartbeat(id) {
+    const response = await this.fetchImplementation(new URL(`/agents/${id}/heartbeat`, this.baseUrl), {
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to send heartbeat (${response.status})`);
+    }
+    return await response.json();
+  }
+  async health() {
+    const response = await this.fetchImplementation(new URL("/health", this.baseUrl));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch registry health (${response.status})`);
+    }
+    return await response.json();
+  }
+  async *events() {
+    const source = new EventSource(new URL("/events", this.baseUrl).toString());
+    const queue = [];
+    let resolveNext;
+    let closed = false;
+    source.addEventListener("registry_update", (event) => {
+      const data = "data" in event ? JSON.parse(String(event.data)) : null;
+      queue.push(data);
+      resolveNext?.();
+    });
+    source.onerror = () => {
+      closed = true;
+      source.close();
+      resolveNext?.();
+    };
+    try {
+      while (!closed || queue.length > 0) {
+        if (queue.length === 0) {
+          await new Promise((resolve) => {
+            resolveNext = resolve;
+          });
+          resolveNext = void 0;
+        }
+        const next = queue.shift();
+        if (next !== void 0) {
+          yield next;
+        }
+      }
+    } finally {
+      source.close();
+    }
+  }
+}
+
+function createAuthenticatingFetchWithRetry(baseFetch, handler) {
+  return async (input, init) => {
+    const nextInit = {
+      ...init ?? {},
+      headers: {
+        ...init?.headers ?? {},
+        ...await handler.headers()
+      }
+    };
+    const firstResponse = await baseFetch(input, nextInit);
+    const retryHeaders = handler.shouldRetryWithHeaders ? await handler.shouldRetryWithHeaders(nextInit, firstResponse) : void 0;
+    if (!retryHeaders) {
+      return firstResponse;
+    }
+    return baseFetch(input, {
+      ...nextInit,
+      headers: {
+        ...nextInit.headers ?? {},
+        ...retryHeaders
+      }
+    });
+  };
+}
+
+export { A2AClient, A2AServer, AgentRegistryClient, CircuitBreaker, CircuitOpenError, ErrorCodes, InMemoryTaskStorage, JsonRpcError, JsonRpcRequestSchema, JwtAuthMiddleware, MessageRequestConfigurationSchema, MessageSchema, MessageSendParamsSchema, PartSchema, PushNotificationConfigSchema, PushNotificationService, SSEStreamer, SqliteTaskStorage, TaskListParamsSchema, TaskManager, a2aMeshTracer, createAuthenticatingFetchWithRetry, createRateLimiter, logger, normalizeAgentCard, validateMessageSendParams, validateRequest, validateTaskListParams };