@runtypelabs/timely-a2a 0.3.3

package/dist/vercel/index.js

@@ -0,0 +1,1005 @@
+// src/vercel/handlers.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/types.ts
+var JSON_RPC_ERRORS = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // 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
+};
+
+// 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";
+
+// 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 !== void 0) && part.data) {
+      return part.data;
+    }
+    if ((part.type === "text" || part.text !== void 0) && 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
+var DEFAULT_SYSTEM_PROMPTS = {
+  chat: `You are Timely, a time-focused AI assistant. You help with time, date, timezone, and scheduling questions. Use the available time tools to provide accurate answers. If asked about topics unrelated to time, dates, timezones, or scheduling, politely explain that you specialize in time-related queries and suggest rephrasing the question in a time-related context.`
+};
+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 !== void 0) && 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.model.includes("/") ? config.model : `${config.provider}/${config.model}`);
+    return gateway(modelId);
+  }
+  if (config.model.includes("/")) {
+    throw new Error(
+      `Model "${config.model}" requires Vercel AI Gateway. Set AI_GATEWAY_API_KEY to use gateway models, or use a direct provider model (e.g., --model gpt-4o-mini --provider openai).`
+    );
+  }
+  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: "Time Chat",
+    description: "Conversational assistant for time, date, timezone, and scheduling questions",
+    systemPrompt: "You are Timely, a time-focused AI assistant. You help with time, date, timezone, and scheduling questions. Use the available time tools to provide accurate answers. If asked about topics unrelated to time, dates, timezones, or scheduling, politely explain that you specialize in time-related queries and suggest rephrasing the question in a time-related context.",
+    tags: ["llm"]
+  },
+  {
+    id: "echo",
+    name: "Echo",
+    description: "Echoes back the input (for testing)",
+    tags: ["testing"]
+  }
+];
+var DEFAULT_LLM_CONFIG = {
+  provider: "openai",
+  model: "alibaba/qwen3.5-flash",
+  gatewayModel: "alibaba/qwen3.5-flash",
+  temperature: 0.7,
+  maxOutputTokens: 4096
+};
+
+// src/vercel/config.ts
+function resolveConfig(config) {
+  return {
+    name: config.name,
+    description: config.description || `A2A Agent: ${config.name}`,
+    version: config.version || "1.0.0",
+    skills: config.skills || DEFAULT_SKILLS,
+    provider: config.provider || { organization: "Runtype", url: "https://runtype.com" },
+    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
+  };
+}
+function toAgentCardSkills(skills) {
+  return skills.map((s) => ({
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    tags: s.tags ?? [],
+    examples: []
+  }));
+}
+
+// src/vercel/handlers.ts
+var A2A_PROTOCOL_VERSION = "0.3";
+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 jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key"
+    }
+  });
+}
+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: agentUrl,
+    supportedInterfaces: [
+      {
+        url: agentUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: A2A_PROTOCOL_VERSION
+      }
+    ],
+    version: resolved.version,
+    protocolVersion: A2A_PROTOCOL_VERSION,
+    defaultInputModes: resolved.defaultInputModes,
+    defaultOutputModes: resolved.defaultOutputModes,
+    provider: resolved.provider,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false
+    },
+    skills: toAgentCardSkills(resolved.skills)
+  };
+  return async function handler(_request) {
+    return new Response(JSON.stringify(agentCard), {
+      headers: {
+        "Content-Type": "application/json",
+        "Cache-Control": "public, max-age=3600",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  };
+}
+function createA2AHandler(config) {
+  const resolved = resolveConfig(config);
+  const { skills, llmConfig, echoMode } = resolved;
+  return async function handler(request) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key"
+        }
+      });
+    }
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return jsonResponse(
+        jsonRpcError(void 0, JSON_RPC_ERRORS.PARSE_ERROR, "Invalid JSON"),
+        400
+      );
+    }
+    if (body.jsonrpc !== "2.0" || !body.method) {
+      return jsonResponse(
+        jsonRpcError(body?.id, JSON_RPC_ERRORS.INVALID_REQUEST, "Invalid JSON-RPC request")
+      );
+    }
+    const { id, method, params } = body;
+    console.log(`[A2A] ${method}`, params ? JSON.stringify(params).substring(0, 100) : "");
+    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,
+            skills,
+            llmConfig,
+            echoMode
+          );
+        case "tasks/get":
+        case "GetTask":
+          return jsonResponse(
+            jsonRpcError(
+              id,
+              JSON_RPC_ERRORS.TASK_NOT_FOUND,
+              "Task state not available in serverless mode. Use message/stream for streaming."
+            )
+          );
+        case "tasks/cancel":
+        case "CancelTask":
+          return jsonResponse(
+            jsonRpcError(
+              id,
+              JSON_RPC_ERRORS.TASK_NOT_FOUND,
+              "Task cancellation not available in serverless mode."
+            )
+          );
+        case "ping":
+          return jsonResponse(jsonRpcSuccess(id, { pong: true }));
+        default:
+          return jsonResponse(
+            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);
+      return jsonResponse(jsonRpcError(id, JSON_RPC_ERRORS.INTERNAL_ERROR, errorMessage));
+    }
+  };
+}
+async function handleTasksSend(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();
+  try {
+    const context = {
+      taskId,
+      contextId: resolvedContextId,
+      skill,
+      message,
+      metadata
+    };
+    let result;
+    if (skill.id.startsWith("time/")) {
+      result = await executeTimeSkill(context);
+    } else if (echoMode || skill.id === "echo") {
+      result = await executeEcho(context);
+    } else {
+      result = await executeTask(context, llmConfig, skills);
+    }
+    return jsonResponse(
+      jsonRpcSuccess(id, {
+        task: {
+          id: taskId,
+          contextId: resolvedContextId,
+          status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          artifacts: (result.artifacts || []).map(toSpecArtifact),
+          metadata
+        }
+      })
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return jsonResponse(
+      jsonRpcError(id, JSON_RPC_ERRORS.INTERNAL_ERROR, `Task execution failed: ${errorMessage}`)
+    );
+  }
+}
+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 sendStreamResponse = (result) => {
+        const rpcResponse = { jsonrpc: "2.0", id, result };
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(rpcResponse)}
+
+`));
+      };
+      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: resolvedContextId,
+          skill,
+          message,
+          metadata
+        };
+        const artifactId = uuidv4();
+        let isFirstChunk = true;
+        const callbacks = {
+          onChunk: async (text) => {
+            sendStreamResponse({
+              artifactUpdate: {
+                taskId,
+                contextId: resolvedContextId,
+                artifact: { artifactId, name: "response", parts: [{ text }] },
+                append: !isFirstChunk,
+                lastChunk: false
+              }
+            });
+            isFirstChunk = false;
+          },
+          onComplete: async () => {
+            sendStreamResponse({
+              artifactUpdate: {
+                taskId,
+                contextId: resolvedContextId,
+                artifact: { artifactId, name: "response", parts: [{ text: "" }] },
+                append: true,
+                lastChunk: true
+              }
+            });
+            sendStreamResponse({
+              statusUpdate: {
+                taskId,
+                contextId: resolvedContextId,
+                status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+              }
+            });
+            controller.close();
+          },
+          onError: async (error) => {
+            sendStreamResponse({
+              statusUpdate: {
+                taskId,
+                contextId: resolvedContextId,
+                status: {
+                  state: "failed",
+                  message: { role: "agent", parts: [{ text: error.message }] },
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              }
+            });
+            controller.close();
+          }
+        };
+        if (skill.id.startsWith("time/")) {
+          const timeResult = await executeTimeSkill(context);
+          await callbacks.onChunk(timeResult.text);
+          await callbacks.onComplete();
+        } 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);
+        sendStreamResponse({
+          statusUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            status: {
+              state: "failed",
+              message: { role: "agent", parts: [{ text: errorMessage }] },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        });
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function createHandlers(config) {
+  return {
+    agentCardHandler: createAgentCardHandler(config),
+    a2aHandler: createA2AHandler(config)
+  };
+}
+export {
+  DEFAULT_LLM_CONFIG,
+  DEFAULT_SKILLS,
+  createA2AHandler,
+  createAgentCardHandler,
+  createHandlers,
+  resolveConfig,
+  toAgentCardSkills
+};
+//# sourceMappingURL=index.js.map