@runtypelabs/a2a-aisdk-example 0.2.4 → 0.3.0

package/dist/{chunk-FTWT3LGM.js → chunk-EY4P4D5Y.js}

@@ -7,11 +7,20 @@ var JSON_RPC_ERRORS = {
   METHOD_NOT_FOUND: -32601,
   INVALID_PARAMS: -32602,
   INTERNAL_ERROR: -32603,
-  // Custom A2A errors
+  // A2A spec error codes
   TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  INVALID_AGENT_RESPONSE: -32006,
+  /** @deprecated Use TASK_NOT_CANCELABLE */
   SKILL_NOT_FOUND: -32002,
+  /** @deprecated */
   UNAUTHORIZED: -32003,
+  /** @deprecated */
   RATE_LIMITED: -32004,
+  /** @deprecated */
   TASK_CANCELED: -32005
 };
 
@@ -39,10 +48,10 @@ function createResponse(result, source) {
 }
 function extractInput(message) {
   for (const part of message.parts) {
-    if (part.type === "data" && part.data) {
+    if ((part.type === "data" || part.data !== void 0) && part.data) {
       return part.data;
     }
-    if (part.type === "text" && part.text) {
+    if ((part.type === "text" || part.text !== void 0) && part.text) {
       try {
         return JSON.parse(part.text);
       } catch {
@@ -262,7 +271,7 @@ var TOOL_STOP_CONDITION = stepCountIs(5);
 var TOOL_TAG = "tool";
 var LLM_TAG = "llm";
 function extractTextFromMessage(message) {
-  return message.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  return message.parts.filter((p) => (p.type === "text" || p.text !== void 0) && p.text).map((p) => p.text).join("\n");
 }
 function createLLMProvider(config) {
   const gatewayKey = process.env.AI_GATEWAY_API_KEY;
@@ -607,6 +616,56 @@ var DEFAULT_LLM_CONFIG = {
 import express from "express";
 import { v4 as uuidv4 } from "uuid";
 var A2A_PROTOCOL_VERSION = "0.3";
+function normalizePart(part) {
+  if (part.type) return part;
+  if (part.text !== void 0) return { type: "text", text: part.text, mediaType: part.mediaType };
+  if (part.data !== void 0) return { type: "data", data: part.data, mediaType: part.mediaType };
+  if (part.url !== void 0 || part.raw !== void 0) return { type: "file", uri: part.url ?? part.uri, mimeType: part.mediaType };
+  return part;
+}
+function normalizeRole(role) {
+  if (role === "ROLE_USER" || role === "user") return "user";
+  if (role === "ROLE_AGENT" || role === "agent") return "agent";
+  return "user";
+}
+function normalizeMessage(msg) {
+  const raw = msg;
+  return {
+    role: normalizeRole(raw.role || "user"),
+    messageId: raw.messageId,
+    parts: (raw.parts || []).map(normalizePart),
+    contextId: raw.contextId,
+    taskId: raw.taskId,
+    metadata: raw.metadata
+  };
+}
+function extractSendParams(params) {
+  const rawMessage = params.message || {};
+  const message = normalizeMessage(rawMessage);
+  const metadata = params.metadata;
+  const skillId = params.skill ?? metadata?.skill;
+  const contextId = params.contextId ?? message.contextId;
+  return { skillId, message, contextId, metadata };
+}
+function toSpecPart(part) {
+  const out = {};
+  if (part.type === "text" || part.text !== void 0) out.text = part.text ?? "";
+  else if (part.type === "data" || part.data !== void 0) out.data = part.data;
+  else if (part.type === "file") {
+    out.url = part.uri ?? part.url;
+    out.mediaType = part.mimeType ?? part.mediaType;
+  }
+  if (part.mediaType || part.mimeType) out.mediaType = part.mediaType ?? part.mimeType;
+  if (part.metadata) out.metadata = part.metadata;
+  return out;
+}
+function toSpecArtifact(a) {
+  return {
+    artifactId: a.artifactId ?? uuidv4(),
+    name: a.name,
+    parts: a.parts.map(toSpecPart)
+  };
+}
 var tasks = /* @__PURE__ */ new Map();
 function generateTaskId() {
   return `task_${Date.now()}_${uuidv4().substring(0, 8)}`;
@@ -634,40 +693,44 @@ function createA2AServer(options) {
   const port = config.port || 9999;
   const host = config.host || "localhost";
   const skills = config.skills || DEFAULT_SKILLS;
+  const agentUrl = `http://${host}:${port}/a2a`;
   const agentCard = {
     name: config.name,
     description: config.description || `A2A Agent: ${config.name}`,
-    url: `http://${host}:${port}/a2a`,
+    url: agentUrl,
+    supportedInterfaces: [
+      {
+        url: agentUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: A2A_PROTOCOL_VERSION
+      }
+    ],
     version: config.version || "1.0.0",
     protocolVersion: A2A_PROTOCOL_VERSION,
-    defaultInputModes: config.defaultInputModes || ["text", "data"],
-    defaultOutputModes: config.defaultOutputModes || ["text", "data"],
+    defaultInputModes: config.defaultInputModes || ["text/plain", "application/json"],
+    defaultOutputModes: config.defaultOutputModes || ["text/plain", "application/json"],
     provider: config.provider || {
       organization: "Runtype",
       url: "https://runtype.com"
     },
     capabilities: {
       streaming: true,
-      pushNotifications: false,
-      statefulness: "task"
+      pushNotifications: false
     },
     skills: skills.map((s) => ({
       id: s.id,
       name: s.name,
       description: s.description,
-      inputModes: ["text", "data"],
-      outputModes: ["text", "data"],
       tags: s.tags ?? [],
-      inputSchema: s.inputSchema
-    })),
-    authentication: {
-      type: "none"
-    }
+      examples: []
+    }))
   };
-  app.get("/.well-known/agent.json", (_req, res) => {
+  const agentCardHandler = (_req, res) => {
     res.setHeader("Cache-Control", "public, max-age=3600");
     res.json(agentCard);
-  });
+  };
+  app.get("/.well-known/agent.json", agentCardHandler);
+  app.get("/.well-known/agent-card.json", agentCardHandler);
   app.get("/health", (_req, res) => {
     res.json({ status: "healthy", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
@@ -682,17 +745,27 @@ function createA2AServer(options) {
     try {
       switch (method) {
         case "tasks/send":
+        case "message/send":
+        case "SendMessage":
           await handleTasksSend(req, res, id, params, skills, llmConfig, echoMode);
           break;
         case "tasks/sendSubscribe":
+        case "message/stream":
+        case "SendStreamingMessage":
           await handleTasksSendSubscribe(req, res, id, params, skills, llmConfig, echoMode);
           break;
         case "tasks/get":
+        case "GetTask":
           handleTasksGet(res, id, params);
           break;
         case "tasks/cancel":
+        case "CancelTask":
           handleTasksCancel(res, id, params);
           break;
+        case "tasks/resubscribe":
+        case "SubscribeToTask":
+          res.json(jsonRpcError(id, JSON_RPC_ERRORS.UNSUPPORTED_OPERATION, "SubscribeToTask is not supported"));
+          break;
         case "ping":
           res.json(jsonRpcSuccess(id, { pong: true }));
           break;
@@ -714,7 +787,7 @@ function createA2AServer(options) {
         console.log(`A2A Agent Server: ${config.name}`);
         console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
         console.log("");
-        console.log(`   Agent Card:   http://${host}:${port}/.well-known/agent.json`);
+        console.log(`   Agent Card:   http://${host}:${port}/.well-known/agent-card.json`);
         console.log(`   A2A Endpoint: http://${host}:${port}/a2a`);
         console.log(`   Health Check: http://${host}:${port}/health`);
         console.log("");
@@ -742,23 +815,24 @@ function createA2AServer(options) {
     })
   };
 }
-async function handleTasksSend(_req, res, id, params, skills, llmConfig, echoMode) {
-  const { skill: skillId, message, contextId, metadata } = params;
-  const skill = skills.find((s) => s.id === skillId);
-  if (!skill) {
-    res.json(
-      jsonRpcError(id, JSON_RPC_ERRORS.SKILL_NOT_FOUND, `Skill not found: ${skillId}`, {
-        availableSkills: skills.map((s) => s.id)
-      })
-    );
-    return;
+function resolveSkill(skillId, skills, echoMode) {
+  if (skillId) {
+    const found = skills.find((s) => s.id === skillId);
+    if (found) return found;
   }
+  if (echoMode) return skills.find((s) => s.id === "echo") || skills[0];
+  return skills.find((s) => s.id === "chat") || skills[0];
+}
+async function handleTasksSend(_req, res, id, params, skills, llmConfig, echoMode) {
+  const { skillId, message, contextId, metadata } = extractSendParams(params);
+  const skill = resolveSkill(skillId, skills, echoMode);
+  const resolvedContextId = contextId || uuidv4();
   const taskId = generateTaskId();
   const task = {
     id: taskId,
-    contextId,
+    contextId: resolvedContextId,
     status: "submitted",
-    skillId,
+    skillId: skill.id,
     requestMessage: message,
     artifacts: [],
     metadata,
@@ -770,29 +844,29 @@ async function handleTasksSend(_req, res, id, params, skills, llmConfig, echoMod
   try {
     const context = {
       taskId,
-      contextId,
+      contextId: resolvedContextId,
       skill,
       message,
       metadata
     };
     let result;
-    if (skillId.startsWith("time/")) {
+    if (skill.id.startsWith("time/")) {
       result = await executeTimeSkill(context);
-    } else if (echoMode || skillId === "echo") {
+    } else if (echoMode || skill.id === "echo") {
       result = await executeEcho(context);
     } else {
       result = await executeTask(context, llmConfig, skills);
     }
     task.status = "completed";
-    task.artifacts = result.artifacts;
+    task.artifacts = result.artifacts || [];
     task.history.push({ status: "completed", message: "Task completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
     res.json(
       jsonRpcSuccess(id, {
         task: {
           id: taskId,
-          contextId,
-          status: "completed",
-          artifacts: task.artifacts,
+          contextId: resolvedContextId,
+          status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          artifacts: task.artifacts.map(toSpecArtifact),
           metadata
         }
       })
@@ -806,22 +880,15 @@ async function handleTasksSend(_req, res, id, params, skills, llmConfig, echoMod
   }
 }
 async function handleTasksSendSubscribe(_req, res, id, params, skills, llmConfig, echoMode) {
-  const { skill: skillId, message, contextId, metadata } = params;
-  const skill = skills.find((s) => s.id === skillId);
-  if (!skill) {
-    res.json(
-      jsonRpcError(id, JSON_RPC_ERRORS.SKILL_NOT_FOUND, `Skill not found: ${skillId}`, {
-        availableSkills: skills.map((s) => s.id)
-      })
-    );
-    return;
-  }
+  const { skillId, message, contextId, metadata } = extractSendParams(params);
+  const skill = resolveSkill(skillId, skills, echoMode);
+  const resolvedContextId = contextId || uuidv4();
   const taskId = generateTaskId();
   const task = {
     id: taskId,
-    contextId,
+    contextId: resolvedContextId,
     status: "submitted",
-    skillId,
+    skillId: skill.id,
     requestMessage: message,
     artifacts: [],
     metadata,
@@ -832,72 +899,106 @@ async function handleTasksSendSubscribe(_req, res, id, params, skills, llmConfig
   res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
   res.setHeader("Connection", "keep-alive");
   res.setHeader("X-Accel-Buffering", "no");
-  const sendEvent = (event, data) => {
-    res.write(`event: ${event}
-data: ${JSON.stringify(data)}
+  const sendStreamResponse = (result) => {
+    const rpcResponse = { jsonrpc: "2.0", id, result };
+    res.write(`data: ${JSON.stringify(rpcResponse)}
 
 `);
   };
-  sendEvent("task/status", { taskId, contextId, status: "submitted" });
+  sendStreamResponse({
+    task: {
+      id: taskId,
+      contextId: resolvedContextId,
+      status: { state: "submitted", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    }
+  });
   task.status = "working";
   task.history.push({ status: "working", message: "Execution started", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  sendEvent("task/status", { taskId, contextId, status: "working" });
+  sendStreamResponse({
+    statusUpdate: {
+      taskId,
+      contextId: resolvedContextId,
+      status: { state: "working", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    }
+  });
   try {
     const context = {
       taskId,
-      contextId,
+      contextId: resolvedContextId,
       skill,
       message,
       metadata
     };
-    let artifactIndex = 0;
+    const artifactId = uuidv4();
+    let isFirstChunk = true;
     let fullText = "";
     const callbacks = {
       onChunk: async (text) => {
         fullText += text;
-        sendEvent("task/artifact", {
-          taskId,
-          artifact: {
-            name: "response",
-            parts: [{ type: "text", text }],
-            index: artifactIndex,
-            append: artifactIndex > 0,
+        sendStreamResponse({
+          artifactUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            artifact: {
+              artifactId,
+              name: "response",
+              parts: [{ text }]
+            },
+            append: !isFirstChunk,
             lastChunk: false
           }
         });
-        artifactIndex++;
+        isFirstChunk = false;
       },
       onComplete: async () => {
-        sendEvent("task/artifact", {
-          taskId,
-          artifact: {
-            name: "response",
-            parts: [{ type: "text", text: "" }],
-            index: artifactIndex,
+        sendStreamResponse({
+          artifactUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            artifact: {
+              artifactId,
+              name: "response",
+              parts: [{ text: "" }]
+            },
             append: true,
             lastChunk: true
           }
         });
         task.status = "completed";
-        task.artifacts = [{ name: "response", parts: [{ type: "text", text: fullText }] }];
+        task.artifacts = [{ artifactId, name: "response", parts: [{ type: "text", text: fullText }] }];
         task.history.push({ status: "completed", message: "Task completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-        sendEvent("task/status", { taskId, contextId, status: "completed", final: true });
+        sendStreamResponse({
+          statusUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+          }
+        });
         res.end();
       },
       onError: async (error) => {
         task.status = "failed";
         task.error = { message: error.message };
         task.history.push({ status: "failed", message: error.message, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-        sendEvent("task/error", { taskId, error: { code: -32603, message: error.message } });
-        sendEvent("task/status", { taskId, contextId, status: "failed", message: error.message, final: true });
+        sendStreamResponse({
+          statusUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            status: {
+              state: "failed",
+              message: { role: "agent", parts: [{ text: error.message }] },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        });
         res.end();
       }
     };
-    if (skillId.startsWith("time/")) {
+    if (skill.id.startsWith("time/")) {
       const timeResult = await executeTimeSkill(context);
       await callbacks.onChunk(timeResult.text);
       await callbacks.onComplete();
-    } else if (echoMode || skillId === "echo") {
+    } else if (echoMode || skill.id === "echo") {
       await executeEchoStreaming(context, callbacks);
     } else {
       await executeTaskStreaming(context, llmConfig, callbacks, skills);
@@ -907,53 +1008,70 @@ data: ${JSON.stringify(data)}
     task.status = "failed";
     task.error = { message: errorMessage };
     task.history.push({ status: "failed", message: errorMessage, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-    sendEvent("task/error", { taskId, error: { code: -32603, message: errorMessage } });
-    sendEvent("task/status", { taskId, contextId, status: "failed", message: errorMessage, final: true });
+    sendStreamResponse({
+      statusUpdate: {
+        taskId,
+        contextId: resolvedContextId,
+        status: {
+          state: "failed",
+          message: { role: "agent", parts: [{ text: errorMessage }] },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }
+    });
     res.end();
   }
 }
 function handleTasksGet(res, id, params) {
-  const { taskId, includeHistory } = params;
-  const task = tasks.get(taskId);
+  const resolvedTaskId = params.id || params.taskId;
+  if (!resolvedTaskId) {
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.INVALID_PARAMS, "Missing task id"));
+    return;
+  }
+  const task = tasks.get(resolvedTaskId);
   if (!task) {
-    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${taskId}`));
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${resolvedTaskId}`));
     return;
   }
   const result = {
     task: {
       id: task.id,
       contextId: task.contextId,
-      status: task.status,
-      artifacts: task.artifacts,
+      status: { state: task.status, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+      artifacts: task.artifacts.map(toSpecArtifact),
       metadata: task.metadata
     }
   };
-  if (task.error) {
-    result.task.error = task.error;
-  }
-  if (includeHistory) {
-    result.task.history = task.history;
-  }
   res.json(jsonRpcSuccess(id, result));
 }
 function handleTasksCancel(res, id, params) {
-  const { taskId, reason } = params;
-  const task = tasks.get(taskId);
+  const resolvedTaskId = params.id || params.taskId;
+  if (!resolvedTaskId) {
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.INVALID_PARAMS, "Missing task id"));
+    return;
+  }
+  const task = tasks.get(resolvedTaskId);
   if (!task) {
-    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${taskId}`));
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${resolvedTaskId}`));
     return;
   }
   if (["completed", "failed", "canceled"].includes(task.status)) {
-    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_CANCELED, `Task cannot be canceled: already ${task.status}`));
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_CANCELABLE, `Task cannot be canceled: already ${task.status}`));
     return;
   }
   task.status = "canceled";
   task.history.push({
     status: "canceled",
-    message: reason || "Canceled by request",
+    message: params.reason || "Canceled by request",
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
-  res.json(jsonRpcSuccess(id, { task: { id: taskId, status: "canceled" } }));
+  res.json(jsonRpcSuccess(id, {
+    task: {
+      id: resolvedTaskId,
+      contextId: task.contextId,
+      status: { state: "canceled", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    }
+  }));
 }
 
 // src/client.ts
@@ -967,13 +1085,10 @@ var A2AClient = class {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     const isA2aBase = this.baseUrl.endsWith("/a2a");
     this.rpcUrl = isA2aBase ? this.baseUrl : `${this.baseUrl}/a2a`;
-    this.agentCardUrl = `${this.baseUrl}/.well-known/agent.json`;
+    this.agentCardUrl = `${this.baseUrl}/.well-known/agent-card.json`;
     this.apiKey = options.apiKey;
     this.headers = options.headers || {};
   }
-  /**
-   * Get the agent card for discovery
-   */
   async getAgentCard() {
     const response = await fetch(this.agentCardUrl, {
       headers: this.getHeaders()
@@ -983,15 +1098,12 @@ var A2AClient = class {
     }
     return response.json();
   }
-  /**
-   * Send a task and wait for completion (synchronous)
-   */
   async sendTask(params) {
     const request = {
       jsonrpc: "2.0",
       id: `req_${Date.now()}`,
-      method: "tasks/send",
-      params
+      method: "message/send",
+      params: this.toSendMessageRequest(params)
     };
     const response = await this.sendJsonRpc(request);
     if (response.error) {
@@ -999,17 +1111,14 @@ var A2AClient = class {
     }
     return response.result.task;
   }
-  /**
-   * Send a task with streaming (SSE)
-   */
   async sendTaskStreaming(params, callbacks) {
     const request = {
       jsonrpc: "2.0",
       id: `req_${Date.now()}`,
-      method: "tasks/sendSubscribe",
-      params
+      method: "message/stream",
+      params: this.toSendMessageRequest(params)
     };
-    const response = await fetch(`${this.baseUrl}/a2a`, {
+    const response = await fetch(this.rpcUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1032,43 +1141,37 @@ var A2AClient = class {
       buffer += decoder.decode(value, { stream: true });
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
-      let currentEvent = "";
       for (const line of lines) {
-        if (line.startsWith("event: ")) {
-          currentEvent = line.substring(7);
-        } else if (line.startsWith("data: ")) {
-          const data = JSON.parse(line.substring(6));
-          switch (currentEvent) {
-            case "task/status":
-              callbacks.onStatus?.(data.status, data);
-              break;
-            case "task/artifact":
-              callbacks.onArtifact?.(data.artifact);
-              if (data.artifact?.parts) {
-                for (const part of data.artifact.parts) {
-                  if (part.type === "text" && part.text) {
-                    callbacks.onChunk?.(part.text);
-                  }
-                }
-              }
-              break;
-            case "task/error":
-              callbacks.onError?.(data.error);
-              break;
+        if (!line.startsWith("data: ")) continue;
+        const payload = JSON.parse(line.substring(6));
+        const result = payload.result || payload;
+        if (result.statusUpdate) {
+          const state = result.statusUpdate.status?.state || result.statusUpdate.status;
+          callbacks.onStatus?.(state, result.statusUpdate);
+        } else if (result.artifactUpdate) {
+          const artifact = result.artifactUpdate.artifact;
+          callbacks.onArtifact?.(artifact);
+          if (artifact?.parts) {
+            for (const part of artifact.parts) {
+              const text = part.text ?? (part.type === "text" ? part.text : void 0);
+              if (text) callbacks.onChunk?.(text);
+            }
           }
+        } else if (result.task) {
+          const state = result.task.status?.state || result.task.status;
+          if (state) callbacks.onStatus?.(state, result.task);
+        } else if (result.error || payload.error) {
+          callbacks.onError?.(result.error || payload.error);
         }
       }
     }
   }
-  /**
-   * Get task status
-   */
-  async getTask(taskId, includeHistory = false) {
+  async getTask(taskId, historyLength) {
     const request = {
       jsonrpc: "2.0",
       id: `req_${Date.now()}`,
-      method: "tasks/get",
-      params: { taskId, includeHistory }
+      method: "GetTask",
+      params: { id: taskId, historyLength }
     };
     const response = await this.sendJsonRpc(request);
     if (response.error) {
@@ -1076,15 +1179,12 @@ var A2AClient = class {
     }
     return response.result.task;
   }
-  /**
-   * Cancel a task
-   */
   async cancelTask(taskId, reason) {
     const request = {
       jsonrpc: "2.0",
       id: `req_${Date.now()}`,
-      method: "tasks/cancel",
-      params: { taskId, reason }
+      method: "CancelTask",
+      params: { id: taskId, metadata: reason ? { reason } : void 0 }
     };
     const response = await this.sendJsonRpc(request);
     if (response.error) {
@@ -1093,8 +1193,23 @@ var A2AClient = class {
     return response.result.task;
   }
   /**
-   * Send a JSON-RPC request
+   * Convert legacy TasksSendParams to spec SendMessageRequest format
    */
+  toSendMessageRequest(params) {
+    return {
+      message: {
+        messageId: `msg_${Date.now()}`,
+        role: "user",
+        parts: params.message.parts,
+        contextId: params.contextId,
+        taskId: params.message.taskId
+      },
+      metadata: {
+        ...params.metadata,
+        ...params.skill ? { skill: params.skill } : {}
+      }
+    };
+  }
   async sendJsonRpc(request) {
     const response = await fetch(this.rpcUrl, {
       method: "POST",
@@ -1109,9 +1224,6 @@ var A2AClient = class {
     }
     return response.json();
   }
-  /**
-   * Get headers for requests
-   */
   getHeaders() {
     const headers = { ...this.headers };
     if (this.apiKey) {
@@ -1151,4 +1263,4 @@ export {
   A2AClient,
   createRuntypeA2AClient
 };
-//# sourceMappingURL=chunk-FTWT3LGM.js.map
+//# sourceMappingURL=chunk-EY4P4D5Y.js.map