@runtypelabs/a2a-aisdk-example 0.2.3 → 0.3.0

package/dist/vercel/index.js

@@ -8,11 +8,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
 };
 
@@ -46,10 +55,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 {
@@ -265,7 +274,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;
@@ -614,8 +623,8 @@ function resolveConfig(config) {
     version: config.version || "1.0.0",
     skills: config.skills || DEFAULT_SKILLS,
     provider: config.provider || { organization: "Runtype", url: "https://runtype.com" },
-    defaultInputModes: config.defaultInputModes || ["text", "data"],
-    defaultOutputModes: config.defaultOutputModes || ["text", "data"],
+    defaultInputModes: config.defaultInputModes || ["text/plain", "application/json"],
+    defaultOutputModes: config.defaultOutputModes || ["text/plain", "application/json"],
     echoMode: config.echoMode ?? false,
     llmConfig: config.llmConfig || DEFAULT_LLM_CONFIG,
     agentUrl: config.agentUrl
@@ -626,10 +635,8 @@ function toAgentCardSkills(skills) {
     id: s.id,
     name: s.name,
     description: s.description,
-    inputModes: ["text", "data"],
-    outputModes: ["text", "data"],
     tags: s.tags ?? [],
-    inputSchema: s.inputSchema
+    examples: []
   }));
 }
 
@@ -655,12 +662,77 @@ function jsonResponse(data, status = 200) {
     }
   });
 }
+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 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];
+}
+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;
+  return out;
+}
+function toSpecArtifact(a) {
+  return {
+    artifactId: a.artifactId ?? uuidv4(),
+    name: a.name,
+    parts: a.parts.map(toSpecPart)
+  };
+}
 function createAgentCardHandler(config) {
   const resolved = resolveConfig(config);
+  const agentUrl = resolved.agentUrl || "/api/a2a";
   const agentCard = {
     name: resolved.name,
     description: resolved.description,
-    url: resolved.agentUrl || "/api/a2a",
+    url: agentUrl,
+    supportedInterfaces: [
+      {
+        url: agentUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: A2A_PROTOCOL_VERSION
+      }
+    ],
     version: resolved.version,
     protocolVersion: A2A_PROTOCOL_VERSION,
     defaultInputModes: resolved.defaultInputModes,
@@ -668,14 +740,9 @@ function createAgentCardHandler(config) {
     provider: resolved.provider,
     capabilities: {
       streaming: true,
-      pushNotifications: false,
-      statefulness: "none"
-      // Serverless is stateless
+      pushNotifications: false
     },
-    skills: toAgentCardSkills(resolved.skills),
-    authentication: {
-      type: "none"
-    }
+    skills: toAgentCardSkills(resolved.skills)
   };
   return async function handler(_request) {
     return new Response(JSON.stringify(agentCard), {
@@ -720,8 +787,12 @@ function createA2AHandler(config) {
     try {
       switch (method) {
         case "tasks/send":
+        case "message/send":
+        case "SendMessage":
           return await handleTasksSend(id, params, skills, llmConfig, echoMode);
         case "tasks/sendSubscribe":
+        case "message/stream":
+        case "SendStreamingMessage":
           return await handleTasksSendSubscribe(
             id,
             params,
@@ -730,14 +801,16 @@ function createA2AHandler(config) {
             echoMode
           );
         case "tasks/get":
+        case "GetTask":
           return jsonResponse(
             jsonRpcError(
               id,
               JSON_RPC_ERRORS.TASK_NOT_FOUND,
-              "Task state not available in serverless mode. Use tasks/sendSubscribe for streaming."
+              "Task state not available in serverless mode. Use message/stream for streaming."
             )
           );
         case "tasks/cancel":
+        case "CancelTask":
           return jsonResponse(
             jsonRpcError(
               id,
@@ -760,28 +833,22 @@ function createA2AHandler(config) {
   };
 }
 async function handleTasksSend(id, params, skills, llmConfig, echoMode) {
-  const { skill: skillId, message, contextId, metadata } = params;
-  const skill = skills.find((s) => s.id === skillId);
-  if (!skill) {
-    return jsonResponse(
-      jsonRpcError(id, JSON_RPC_ERRORS.SKILL_NOT_FOUND, `Skill not found: ${skillId}`, {
-        availableSkills: skills.map((s) => s.id)
-      })
-    );
-  }
+  const { skillId, message, contextId, metadata } = extractSendParams(params);
+  const skill = resolveSkill(skillId, skills, echoMode);
+  const resolvedContextId = contextId || uuidv4();
   const taskId = generateTaskId();
   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);
@@ -790,9 +857,9 @@ async function handleTasksSend(id, params, skills, llmConfig, echoMode) {
       jsonRpcSuccess(id, {
         task: {
           id: taskId,
-          contextId,
-          status: "completed",
-          artifacts: result.artifacts,
+          contextId: resolvedContextId,
+          status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          artifacts: (result.artifacts || []).map(toSpecArtifact),
           metadata
         }
       })
@@ -804,95 +871,112 @@ async function handleTasksSend(id, params, skills, llmConfig, echoMode) {
     );
   }
 }
-async function handleTasksSendSubscribe(_id, params, skills, llmConfig, echoMode) {
-  const { skill: skillId, message, contextId, metadata } = params;
-  const skill = skills.find((s) => s.id === skillId);
-  if (!skill) {
-    return jsonResponse(
-      jsonRpcError(void 0, JSON_RPC_ERRORS.SKILL_NOT_FOUND, `Skill not found: ${skillId}`, {
-        availableSkills: skills.map((s) => s.id)
-      })
-    );
-  }
+async function handleTasksSendSubscribe(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 stream = new ReadableStream({
     async start(controller) {
       const encoder = new TextEncoder();
-      const sendEvent = (event, data) => {
-        controller.enqueue(encoder.encode(`event: ${event}
-data: ${JSON.stringify(data)}
+      const sendStreamResponse = (result) => {
+        const rpcResponse = { jsonrpc: "2.0", id, result };
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(rpcResponse)}
 
 `));
       };
-      sendEvent("task/status", { taskId, contextId, status: "submitted" });
-      sendEvent("task/status", { taskId, contextId, status: "working" });
+      sendStreamResponse({
+        task: {
+          id: taskId,
+          contextId: resolvedContextId,
+          status: { state: "submitted", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        }
+      });
+      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;
         const callbacks = {
           onChunk: async (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
               }
             });
-            sendEvent("task/status", { taskId, contextId, status: "completed", final: true });
+            sendStreamResponse({
+              statusUpdate: {
+                taskId,
+                contextId: resolvedContextId,
+                status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+              }
+            });
             controller.close();
           },
           onError: async (error) => {
-            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()
+                }
+              }
             });
             controller.close();
           }
         };
-        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);
         }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        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()
+            }
+          }
         });
         controller.close();
       }