@runtypelabs/a2a-aisdk-example 0.0.1 → 0.2.3

package/dist/chunk-OLB7ZZNY.js

@@ -0,0 +1,1153 @@
+#!/usr/bin/env node
+
+// src/types.ts
+var JSON_RPC_ERRORS = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // Custom A2A errors
+  TASK_NOT_FOUND: -32001,
+  SKILL_NOT_FOUND: -32002,
+  UNAUTHORIZED: -32003,
+  RATE_LIMITED: -32004,
+  TASK_CANCELED: -32005
+};
+
+// src/time-executor.ts
+import {
+  format,
+  addDays,
+  addWeeks,
+  addMonths,
+  addBusinessDays,
+  differenceInDays,
+  differenceInHours,
+  differenceInMinutes,
+  isWeekend,
+  isBefore,
+  parseISO
+} from "date-fns";
+import { formatInTimeZone } from "date-fns-tz";
+function createResponse(result, source) {
+  return {
+    result,
+    computed: { method: "deterministic", source },
+    usage: "Use this value directly. Do not recalculate."
+  };
+}
+function extractInput(message) {
+  for (const part of message.parts) {
+    if (part.type === "data" && part.data) {
+      return part.data;
+    }
+    if (part.type === "text" && part.text) {
+      try {
+        return JSON.parse(part.text);
+      } catch {
+        return { expression: part.text };
+      }
+    }
+  }
+  return {};
+}
+async function executeTimeSkill(context) {
+  const input = extractInput(context.message);
+  let response;
+  switch (context.skill.id) {
+    case "time/now": {
+      const tz = input.timezone || "UTC";
+      const now = /* @__PURE__ */ new Date();
+      response = createResponse(
+        {
+          timestamp: now.toISOString(),
+          timezone: tz,
+          formatted: formatInTimeZone(now, tz, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+          human: formatInTimeZone(now, tz, "EEEE, MMMM d, yyyy h:mm a zzz"),
+          day: formatInTimeZone(now, tz, "EEEE"),
+          offset: formatInTimeZone(now, tz, "xxx")
+        },
+        "system_clock"
+      );
+      break;
+    }
+    case "time/day_of_week": {
+      const dateStr = input.date;
+      if (!dateStr) throw new Error("Missing required field: date");
+      const date = parseISO(dateStr);
+      if (isNaN(date.getTime())) throw new Error(`Invalid date: ${dateStr}`);
+      response = createResponse(
+        {
+          date: dateStr,
+          day: format(date, "EEEE"),
+          // @snake-case-ok: A2A protocol response field
+          day_index: date.getDay(),
+          // @snake-case-ok: A2A protocol response field
+          is_weekend: isWeekend(date)
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    case "time/add": {
+      const baseStr = input.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const base = parseISO(baseStr);
+      if (isNaN(base.getTime())) throw new Error(`Invalid date: ${baseStr}`);
+      let result = base;
+      if (input.days) result = addDays(result, input.days);
+      if (input.weeks) result = addWeeks(result, input.weeks);
+      if (input.months) result = addMonths(result, input.months);
+      response = createResponse(
+        {
+          original: baseStr,
+          computed: format(result, "yyyy-MM-dd"),
+          day: format(result, "EEEE"),
+          operation: { days: input.days, weeks: input.weeks, months: input.months }
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    case "time/business_days": {
+      const baseStr = input.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const days = input.days;
+      if (typeof days !== "number") throw new Error("Missing required field: days");
+      const base = parseISO(baseStr);
+      if (isNaN(base.getTime())) throw new Error(`Invalid date: ${baseStr}`);
+      const result = addBusinessDays(base, days);
+      response = createResponse(
+        {
+          original: baseStr,
+          computed: format(result, "yyyy-MM-dd"),
+          day: format(result, "EEEE"),
+          // @snake-case-ok: A2A protocol response field
+          business_days_added: days
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    case "time/diff": {
+      const from = parseISO(input.from);
+      const to = parseISO(input.to);
+      if (isNaN(from.getTime())) throw new Error(`Invalid from date: ${input.from}`);
+      if (isNaN(to.getTime())) throw new Error(`Invalid to date: ${input.to}`);
+      const days = differenceInDays(to, from);
+      const hours = differenceInHours(to, from);
+      const minutes = differenceInMinutes(to, from);
+      response = createResponse(
+        {
+          from: input.from,
+          to: input.to,
+          difference: { days, hours, minutes },
+          human: `${Math.abs(days)} days`
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    case "time/is_past": {
+      const ts = input.timestamp;
+      if (!ts) throw new Error("Missing required field: timestamp");
+      const check = parseISO(ts);
+      if (isNaN(check.getTime())) throw new Error(`Invalid timestamp: ${ts}`);
+      const now = /* @__PURE__ */ new Date();
+      response = createResponse(
+        {
+          timestamp: ts,
+          // @snake-case-ok: A2A protocol response field
+          is_past: isBefore(check, now),
+          // @snake-case-ok: A2A protocol response field
+          is_future: isBefore(now, check),
+          // @snake-case-ok: A2A protocol response field
+          checked_at: now.toISOString()
+        },
+        "system_clock"
+      );
+      break;
+    }
+    case "time/convert": {
+      const ts = input.timestamp;
+      const toTz = input.to;
+      if (!ts) throw new Error("Missing required field: timestamp");
+      if (!toTz) throw new Error("Missing required field: to (timezone)");
+      const date = parseISO(ts);
+      if (isNaN(date.getTime())) throw new Error(`Invalid timestamp: ${ts}`);
+      response = createResponse(
+        {
+          original: ts,
+          converted: formatInTimeZone(date, toTz, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+          timezone: toTz,
+          human: formatInTimeZone(date, toTz, "EEEE, MMMM d, yyyy h:mm a zzz")
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    case "time/parse": {
+      const expr = input.expression?.toLowerCase();
+      const tz = input.timezone || "UTC";
+      const ref = input.reference ? parseISO(input.reference) : /* @__PURE__ */ new Date();
+      if (!expr) throw new Error("Missing required field: expression");
+      let result = null;
+      if (expr === "today") {
+        result = ref;
+      } else if (expr === "tomorrow") {
+        result = addDays(ref, 1);
+      } else if (expr === "yesterday") {
+        result = addDays(ref, -1);
+      } else if (expr.startsWith("next ")) {
+        const dayName = expr.replace("next ", "").split(" ")[0];
+        const days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+        const targetDay = days.indexOf(dayName);
+        if (targetDay >= 0) {
+          let daysToAdd = targetDay - ref.getDay();
+          if (daysToAdd <= 0) daysToAdd += 7;
+          result = addDays(ref, daysToAdd);
+        }
+      } else if (expr.includes("in ") && expr.includes(" day")) {
+        const match = expr.match(/in (\d+) days?/);
+        if (match) result = addDays(ref, parseInt(match[1]));
+      } else if (expr.includes("in ") && expr.includes(" week")) {
+        const match = expr.match(/in (\d+) weeks?/);
+        if (match) result = addWeeks(ref, parseInt(match[1]));
+      }
+      if (!result) {
+        throw new Error(
+          `Could not parse expression: "${expr}". Supported: today, tomorrow, yesterday, next [day], in N days/weeks`
+        );
+      }
+      response = createResponse(
+        {
+          expression: input.expression,
+          resolved: format(result, "yyyy-MM-dd"),
+          day: format(result, "EEEE"),
+          timezone: tz,
+          // @snake-case-ok: A2A protocol response field
+          reference_used: ref.toISOString()
+        },
+        "date_arithmetic"
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown time skill: ${context.skill.id}`);
+  }
+  const text = JSON.stringify(response, null, 2);
+  return {
+    text,
+    artifacts: [
+      {
+        name: "response",
+        parts: [{ type: "text", text }]
+      }
+    ]
+  };
+}
+
+// src/executor.ts
+import { streamText, generateText, tool, jsonSchema, stepCountIs } from "ai";
+import { createGateway } from "@ai-sdk/gateway";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+var DEFAULT_SYSTEM_PROMPTS = {
+  chat: `You are a helpful AI assistant. Respond concisely and accurately to the user's questions.`,
+  analyze: `You are an analytical AI assistant. Analyze the provided input and give detailed insights.`,
+  summarize: `You are a summarization assistant. Provide clear, concise summaries of the provided content.`,
+  code: `You are a coding assistant. Help with code-related questions, provide examples, and explain concepts clearly.`
+};
+var CHAT_SKILL_ID = "chat";
+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");
+}
+function createLLMProvider(config) {
+  const gatewayKey = process.env.AI_GATEWAY_API_KEY;
+  if (gatewayKey) {
+    const gateway = createGateway({ apiKey: gatewayKey });
+    const modelId = config.gatewayModel || `${config.provider}/${config.model}`;
+    return gateway(modelId);
+  }
+  const apiKey = config.apiKey || process.env[`${config.provider.toUpperCase()}_API_KEY`];
+  if (!apiKey) {
+    throw new Error(
+      `API key not provided. Set AI_GATEWAY_API_KEY for Vercel AI Gateway, or ${config.provider.toUpperCase()}_API_KEY for direct provider access.`
+    );
+  }
+  switch (config.provider) {
+    case "openai":
+      return createOpenAI({ apiKey })(config.model);
+    case "anthropic":
+      return createAnthropic({ apiKey })(config.model);
+    default:
+      throw new Error(`Unsupported LLM provider: ${config.provider}`);
+  }
+}
+function getSystemPrompt(skill) {
+  if (skill.systemPrompt) {
+    return skill.systemPrompt;
+  }
+  return DEFAULT_SYSTEM_PROMPTS[skill.id] || DEFAULT_SYSTEM_PROMPTS.chat;
+}
+function sanitizeToolName(skillId) {
+  let name = skillId.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  if (!name) {
+    name = "tool";
+  }
+  if (/^[0-9]/.test(name)) {
+    name = `tool_${name}`;
+  }
+  return name;
+}
+function makeUniqueToolName(skillId, usedNames) {
+  const baseName = sanitizeToolName(skillId);
+  if (!usedNames.has(baseName)) {
+    usedNames.add(baseName);
+    return baseName;
+  }
+  let counter = 1;
+  let candidate = `${baseName}_${counter}`;
+  while (usedNames.has(candidate)) {
+    counter += 1;
+    candidate = `${baseName}_${counter}`;
+  }
+  usedNames.add(candidate);
+  return candidate;
+}
+function toToolInput(params) {
+  if (params && typeof params === "object" && !Array.isArray(params)) {
+    return params;
+  }
+  return { input: params };
+}
+function parseToolResult(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { text };
+  }
+}
+async function executeCatalogToolSkill(parentContext, skill, params) {
+  if (skill.id.startsWith("time/")) {
+    const toolContext = {
+      taskId: `${parentContext.taskId}_tool_${skill.id}`,
+      contextId: parentContext.contextId,
+      skill,
+      message: {
+        role: "user",
+        parts: [{ type: "data", data: toToolInput(params) }]
+      },
+      metadata: parentContext.metadata
+    };
+    const result = await executeTimeSkill(toolContext);
+    return parseToolResult(result.text);
+  }
+  throw new Error(`Unsupported tool skill: ${skill.id}`);
+}
+function buildChatTools(context, skillsCatalog) {
+  if (context.skill.id !== CHAT_SKILL_ID || !skillsCatalog || skillsCatalog.length === 0) {
+    return {};
+  }
+  const tools = {};
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const skill of skillsCatalog) {
+    if (skill.id === context.skill.id) {
+      continue;
+    }
+    const tags = skill.tags ?? [];
+    if (!tags.includes(TOOL_TAG) || tags.includes(LLM_TAG)) {
+      continue;
+    }
+    if (!skill.id.startsWith("time/")) {
+      continue;
+    }
+    const toolName = makeUniqueToolName(skill.id, usedNames);
+    const schema = skill.inputSchema ?? {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+    tools[toolName] = tool({
+      description: skill.description || `Execute ${skill.name}`,
+      inputSchema: jsonSchema(schema),
+      execute: async (params) => executeCatalogToolSkill(context, skill, params)
+    });
+  }
+  return tools;
+}
+async function executeTask(context, llmConfig, skillsCatalog) {
+  const model = createLLMProvider(llmConfig);
+  const userMessage = extractTextFromMessage(context.message);
+  const systemPrompt = getSystemPrompt(context.skill);
+  const chatTools = buildChatTools(context, skillsCatalog);
+  const hasChatTools = Object.keys(chatTools).length > 0;
+  const result = await generateText({
+    model,
+    system: systemPrompt,
+    prompt: userMessage,
+    temperature: llmConfig.temperature ?? 0.7,
+    maxOutputTokens: llmConfig.maxOutputTokens ?? 4096,
+    ...hasChatTools ? { tools: chatTools, stopWhen: TOOL_STOP_CONDITION } : {}
+  });
+  return {
+    text: result.text,
+    artifacts: [
+      {
+        name: "response",
+        parts: [{ type: "text", text: result.text }]
+      }
+    ]
+  };
+}
+async function executeTaskStreaming(context, llmConfig, callbacks, skillsCatalog) {
+  const model = createLLMProvider(llmConfig);
+  const userMessage = extractTextFromMessage(context.message);
+  const systemPrompt = getSystemPrompt(context.skill);
+  const chatTools = buildChatTools(context, skillsCatalog);
+  const hasChatTools = Object.keys(chatTools).length > 0;
+  const result = streamText({
+    model,
+    system: systemPrompt,
+    prompt: userMessage,
+    temperature: llmConfig.temperature ?? 0.7,
+    maxOutputTokens: llmConfig.maxOutputTokens ?? 4096,
+    ...hasChatTools ? { tools: chatTools, stopWhen: TOOL_STOP_CONDITION } : {},
+    onError: async ({ error }) => {
+      await callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+  for await (const chunk of result.textStream) {
+    await callbacks.onChunk(chunk);
+  }
+  await callbacks.onComplete();
+}
+async function executeEcho(context) {
+  const userMessage = extractTextFromMessage(context.message);
+  return {
+    text: `Echo from ${context.skill.name}: ${userMessage}`,
+    artifacts: [
+      {
+        name: "response",
+        parts: [{ type: "text", text: `Echo from ${context.skill.name}: ${userMessage}` }]
+      }
+    ]
+  };
+}
+async function executeEchoStreaming(context, callbacks) {
+  const userMessage = extractTextFromMessage(context.message);
+  const response = `Echo from ${context.skill.name}: ${userMessage}`;
+  try {
+    const words = response.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      const chunk = (i === 0 ? "" : " ") + words[i];
+      await callbacks.onChunk(chunk);
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    await callbacks.onComplete();
+  } catch (error) {
+    await callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+// src/default-skills.ts
+var DEFAULT_SKILLS = [
+  // Time tools (deterministic — no LLM)
+  {
+    id: "time/now",
+    name: "Current Time",
+    description: "Returns current UTC time with optional timezone conversion",
+    inputSchema: {
+      type: "object",
+      properties: {
+        timezone: { type: "string", description: "IANA timezone name (e.g. America/New_York)" }
+      },
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/parse",
+    name: "Parse Date Expression",
+    description: 'Converts "next Tuesday at 3pm" to ISO timestamp',
+    inputSchema: {
+      type: "object",
+      properties: {
+        expression: { type: "string", description: "Natural language date expression" },
+        timezone: { type: "string", description: "IANA timezone name (default: UTC)" },
+        reference: { type: "string", description: "Reference ISO timestamp", format: "date-time" }
+      },
+      required: ["expression"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/convert",
+    name: "Convert Timezone",
+    description: "Converts a timestamp between timezones",
+    inputSchema: {
+      type: "object",
+      properties: {
+        timestamp: { type: "string", description: "ISO timestamp to convert", format: "date-time" },
+        to: { type: "string", description: "Target IANA timezone name" }
+      },
+      required: ["timestamp", "to"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/add",
+    name: "Date Arithmetic",
+    description: "Add days, weeks, or months to a date",
+    inputSchema: {
+      type: "object",
+      properties: {
+        date: { type: "string", description: "Base ISO date (defaults to today)" },
+        days: { type: "number", description: "Days to add (can be negative)" },
+        weeks: { type: "number", description: "Weeks to add (can be negative)" },
+        months: { type: "number", description: "Months to add (can be negative)" }
+      },
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/diff",
+    name: "Date Difference",
+    description: "Calculate duration between two dates",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Start ISO timestamp", format: "date-time" },
+        to: { type: "string", description: "End ISO timestamp", format: "date-time" }
+      },
+      required: ["from", "to"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/day_of_week",
+    name: "Day of Week",
+    description: "Returns the day of the week for a given date",
+    inputSchema: {
+      type: "object",
+      properties: {
+        date: { type: "string", description: "ISO date string" }
+      },
+      required: ["date"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/is_past",
+    name: "Is Past",
+    description: "Checks whether a timestamp is in the past",
+    inputSchema: {
+      type: "object",
+      properties: {
+        timestamp: { type: "string", description: "ISO timestamp to check", format: "date-time" }
+      },
+      required: ["timestamp"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  {
+    id: "time/business_days",
+    name: "Business Days",
+    description: "Add or subtract business days from a date",
+    inputSchema: {
+      type: "object",
+      properties: {
+        date: { type: "string", description: "Base ISO date (defaults to today)" },
+        days: { type: "number", description: "Business days to add/subtract" }
+      },
+      required: ["days"],
+      additionalProperties: false
+    },
+    tags: ["deterministic", "time", "tool"]
+  },
+  // LLM-powered skills
+  {
+    id: "chat",
+    name: "Chat",
+    description: "General conversational AI assistant",
+    systemPrompt: "You are a helpful AI assistant. Respond concisely and accurately.",
+    tags: ["llm"]
+  },
+  {
+    id: "echo",
+    name: "Echo",
+    description: "Echoes back the input (for testing)",
+    tags: ["testing"]
+  },
+  {
+    id: "analyze",
+    name: "Analyze",
+    description: "Analyzes provided content and gives insights",
+    systemPrompt: "You are an analytical AI. Analyze the input and provide detailed insights.",
+    tags: ["llm"]
+  }
+];
+var DEFAULT_LLM_CONFIG = {
+  provider: "openai",
+  model: "gpt-5-nano",
+  gatewayModel: "openai/gpt-5-nano",
+  temperature: 0.7,
+  maxOutputTokens: 4096
+};
+
+// src/server.ts
+import express from "express";
+import { v4 as uuidv4 } from "uuid";
+var A2A_PROTOCOL_VERSION = "0.3";
+var tasks = /* @__PURE__ */ new Map();
+function generateTaskId() {
+  return `task_${Date.now()}_${uuidv4().substring(0, 8)}`;
+}
+function jsonRpcSuccess(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function jsonRpcError(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+function createA2AServer(options) {
+  const { config, llmConfig = DEFAULT_LLM_CONFIG, echoMode = false } = options;
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type, Authorization, X-API-Key");
+    next();
+  });
+  app.options("*", (_req, res) => {
+    res.sendStatus(204);
+  });
+  const port = config.port || 9999;
+  const host = config.host || "localhost";
+  const skills = config.skills || DEFAULT_SKILLS;
+  const agentCard = {
+    name: config.name,
+    description: config.description || `A2A Agent: ${config.name}`,
+    url: `http://${host}:${port}/a2a`,
+    version: config.version || "1.0.0",
+    protocolVersion: A2A_PROTOCOL_VERSION,
+    defaultInputModes: config.defaultInputModes || ["text", "data"],
+    defaultOutputModes: config.defaultOutputModes || ["text", "data"],
+    provider: config.provider || {
+      organization: "Runtype",
+      url: "https://runtype.com"
+    },
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      statefulness: "task"
+    },
+    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"
+    }
+  };
+  app.get("/.well-known/agent.json", (_req, res) => {
+    res.setHeader("Cache-Control", "public, max-age=3600");
+    res.json(agentCard);
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "healthy", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  app.post("/a2a", async (req, res) => {
+    const body = req.body;
+    if (body.jsonrpc !== "2.0" || !body.method) {
+      res.json(jsonRpcError(body?.id, JSON_RPC_ERRORS.INVALID_REQUEST, "Invalid JSON-RPC request"));
+      return;
+    }
+    const { id, method, params } = body;
+    console.log(`[A2A] ${method}`, params ? JSON.stringify(params).substring(0, 100) : "");
+    try {
+      switch (method) {
+        case "tasks/send":
+          await handleTasksSend(req, res, id, params, skills, llmConfig, echoMode);
+          break;
+        case "tasks/sendSubscribe":
+          await handleTasksSendSubscribe(req, res, id, params, skills, llmConfig, echoMode);
+          break;
+        case "tasks/get":
+          handleTasksGet(res, id, params);
+          break;
+        case "tasks/cancel":
+          handleTasksCancel(res, id, params);
+          break;
+        case "ping":
+          res.json(jsonRpcSuccess(id, { pong: true }));
+          break;
+        default:
+          res.json(jsonRpcError(id, JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Method not found: ${method}`));
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[A2A] Error in ${method}:`, errorMessage);
+      res.json(jsonRpcError(id, JSON_RPC_ERRORS.INTERNAL_ERROR, errorMessage));
+    }
+  });
+  let server = null;
+  return {
+    app,
+    start: () => new Promise((resolve) => {
+      server = app.listen(port, () => {
+        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(`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(`   A2A Endpoint: http://${host}:${port}/a2a`);
+        console.log(`   Health Check: http://${host}:${port}/health`);
+        console.log("");
+        console.log("   Skills:");
+        for (const skill of skills) {
+          console.log(`   - ${skill.id}: ${skill.description}`);
+        }
+        console.log("");
+        console.log(`   Mode: ${echoMode ? "Echo (testing)" : `LLM (${llmConfig.provider}/${llmConfig.model})`}`);
+        console.log("");
+        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("");
+        resolve();
+      });
+    }),
+    stop: () => new Promise((resolve, reject) => {
+      if (server) {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      } else {
+        resolve();
+      }
+    })
+  };
+}
+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;
+  }
+  const taskId = generateTaskId();
+  const task = {
+    id: taskId,
+    contextId,
+    status: "submitted",
+    skillId,
+    requestMessage: message,
+    artifacts: [],
+    metadata,
+    history: [{ status: "submitted", message: "Task created", timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
+  };
+  tasks.set(taskId, task);
+  task.status = "working";
+  task.history.push({ status: "working", message: "Execution started", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  try {
+    const context = {
+      taskId,
+      contextId,
+      skill,
+      message,
+      metadata
+    };
+    let result;
+    if (skillId.startsWith("time/")) {
+      result = await executeTimeSkill(context);
+    } else if (echoMode || skillId === "echo") {
+      result = await executeEcho(context);
+    } else {
+      result = await executeTask(context, llmConfig, skills);
+    }
+    task.status = "completed";
+    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,
+          metadata
+        }
+      })
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    task.status = "failed";
+    task.error = { message: errorMessage };
+    task.history.push({ status: "failed", message: errorMessage, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.INTERNAL_ERROR, `Task execution failed: ${errorMessage}`));
+  }
+}
+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 taskId = generateTaskId();
+  const task = {
+    id: taskId,
+    contextId,
+    status: "submitted",
+    skillId,
+    requestMessage: message,
+    artifacts: [],
+    metadata,
+    history: [{ status: "submitted", message: "Task created", timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
+  };
+  tasks.set(taskId, task);
+  res.setHeader("Content-Type", "text/event-stream");
+  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)}
+
+`);
+  };
+  sendEvent("task/status", { taskId, contextId, status: "submitted" });
+  task.status = "working";
+  task.history.push({ status: "working", message: "Execution started", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  sendEvent("task/status", { taskId, contextId, status: "working" });
+  try {
+    const context = {
+      taskId,
+      contextId,
+      skill,
+      message,
+      metadata
+    };
+    let artifactIndex = 0;
+    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,
+            lastChunk: false
+          }
+        });
+        artifactIndex++;
+      },
+      onComplete: async () => {
+        sendEvent("task/artifact", {
+          taskId,
+          artifact: {
+            name: "response",
+            parts: [{ type: "text", text: "" }],
+            index: artifactIndex,
+            append: true,
+            lastChunk: true
+          }
+        });
+        task.status = "completed";
+        task.artifacts = [{ 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 });
+        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 });
+        res.end();
+      }
+    };
+    if (skillId.startsWith("time/")) {
+      const timeResult = await executeTimeSkill(context);
+      await callbacks.onChunk(timeResult.text);
+      await callbacks.onComplete();
+    } else if (echoMode || skillId === "echo") {
+      await executeEchoStreaming(context, callbacks);
+    } else {
+      await executeTaskStreaming(context, llmConfig, callbacks, skills);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    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 });
+    res.end();
+  }
+}
+function handleTasksGet(res, id, params) {
+  const { taskId, includeHistory } = params;
+  const task = tasks.get(taskId);
+  if (!task) {
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${taskId}`));
+    return;
+  }
+  const result = {
+    task: {
+      id: task.id,
+      contextId: task.contextId,
+      status: task.status,
+      artifacts: task.artifacts,
+      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);
+  if (!task) {
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_NOT_FOUND, `Task not found: ${taskId}`));
+    return;
+  }
+  if (["completed", "failed", "canceled"].includes(task.status)) {
+    res.json(jsonRpcError(id, JSON_RPC_ERRORS.TASK_CANCELED, `Task cannot be canceled: already ${task.status}`));
+    return;
+  }
+  task.status = "canceled";
+  task.history.push({
+    status: "canceled",
+    message: reason || "Canceled by request",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  res.json(jsonRpcSuccess(id, { task: { id: taskId, status: "canceled" } }));
+}
+
+// src/client.ts
+var A2AClient = class {
+  baseUrl;
+  rpcUrl;
+  agentCardUrl;
+  apiKey;
+  headers;
+  constructor(options) {
+    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.apiKey = options.apiKey;
+    this.headers = options.headers || {};
+  }
+  /**
+   * Get the agent card for discovery
+   */
+  async getAgentCard() {
+    const response = await fetch(this.agentCardUrl, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch agent card: ${response.status} ${response.statusText}`);
+    }
+    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
+    };
+    const response = await this.sendJsonRpc(request);
+    if (response.error) {
+      throw new Error(`A2A error: ${response.error.message} (code: ${response.error.code})`);
+    }
+    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
+    };
+    const response = await fetch(`${this.baseUrl}/a2a`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.getHeaders()
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      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;
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get task status
+   */
+  async getTask(taskId, includeHistory = false) {
+    const request = {
+      jsonrpc: "2.0",
+      id: `req_${Date.now()}`,
+      method: "tasks/get",
+      params: { taskId, includeHistory }
+    };
+    const response = await this.sendJsonRpc(request);
+    if (response.error) {
+      throw new Error(`A2A error: ${response.error.message} (code: ${response.error.code})`);
+    }
+    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 }
+    };
+    const response = await this.sendJsonRpc(request);
+    if (response.error) {
+      throw new Error(`A2A error: ${response.error.message} (code: ${response.error.code})`);
+    }
+    return response.result.task;
+  }
+  /**
+   * Send a JSON-RPC request
+   */
+  async sendJsonRpc(request) {
+    const response = await fetch(this.rpcUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.getHeaders()
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get headers for requests
+   */
+  getHeaders() {
+    const headers = { ...this.headers };
+    if (this.apiKey) {
+      if (this.apiKey.startsWith("a2a_")) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      } else {
+        headers["X-API-Key"] = this.apiKey;
+      }
+    }
+    return headers;
+  }
+};
+function createRuntypeA2AClient(options) {
+  const { productId, surfaceId, apiKey, environment = "production" } = options;
+  const baseUrls = {
+    production: "https://api.runtype.com",
+    staging: "https://api.runtype-staging.com",
+    local: "http://localhost:8787"
+  };
+  const baseUrl = `${baseUrls[environment]}/v1/products/${productId}/surfaces/${surfaceId}/a2a`;
+  return new A2AClient({
+    baseUrl,
+    apiKey
+  });
+}
+
+export {
+  JSON_RPC_ERRORS,
+  executeTimeSkill,
+  executeTask,
+  executeTaskStreaming,
+  executeEcho,
+  executeEchoStreaming,
+  DEFAULT_SKILLS,
+  DEFAULT_LLM_CONFIG,
+  createA2AServer,
+  A2AClient,
+  createRuntypeA2AClient
+};
+//# sourceMappingURL=chunk-OLB7ZZNY.js.map