@runtypelabs/timely-a2a 0.3.3

package/dist/chunk-KIZQKOZR.js

@@ -0,0 +1,1261 @@
+#!/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,
+  // 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/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
+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 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/server.ts
+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)}`;
+}
+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");
+    if (req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  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: agentUrl,
+    supportedInterfaces: [
+      {
+        url: agentUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: A2A_PROTOCOL_VERSION
+      }
+    ],
+    version: config.version || "1.0.0",
+    protocolVersion: A2A_PROTOCOL_VERSION,
+    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
+    },
+    skills: skills.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+      tags: s.tags ?? [],
+      examples: []
+    }))
+  };
+  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() });
+  });
+  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":
+        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;
+        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-card.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.model.includes("/") ? llmConfig.model : `${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();
+      }
+    })
+  };
+}
+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: resolvedContextId,
+    status: "submitted",
+    skillId: skill.id,
+    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: 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);
+    }
+    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: resolvedContextId,
+          status: { state: "completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          artifacts: task.artifacts.map(toSpecArtifact),
+          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 { skillId, message, contextId, metadata } = extractSendParams(params);
+  const skill = resolveSkill(skillId, skills, echoMode);
+  const resolvedContextId = contextId || uuidv4();
+  const taskId = generateTaskId();
+  const task = {
+    id: taskId,
+    contextId: resolvedContextId,
+    status: "submitted",
+    skillId: skill.id,
+    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 sendStreamResponse = (result) => {
+    const rpcResponse = { jsonrpc: "2.0", id, result };
+    res.write(`data: ${JSON.stringify(rpcResponse)}
+
+`);
+  };
+  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() });
+  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;
+    let fullText = "";
+    const callbacks = {
+      onChunk: async (text) => {
+        fullText += 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
+          }
+        });
+        task.status = "completed";
+        task.artifacts = [{ artifactId, name: "response", parts: [{ type: "text", text: fullText }] }];
+        task.history.push({ status: "completed", message: "Task completed", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        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() });
+        sendStreamResponse({
+          statusUpdate: {
+            taskId,
+            contextId: resolvedContextId,
+            status: {
+              state: "failed",
+              message: { role: "agent", parts: [{ text: error.message }] },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        });
+        res.end();
+      }
+    };
+    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);
+    task.status = "failed";
+    task.error = { message: errorMessage };
+    task.history.push({ status: "failed", message: errorMessage, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    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 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: ${resolvedTaskId}`));
+    return;
+  }
+  const result = {
+    task: {
+      id: task.id,
+      contextId: task.contextId,
+      status: { state: task.status, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+      artifacts: task.artifacts.map(toSpecArtifact),
+      metadata: task.metadata
+    }
+  };
+  res.json(jsonRpcSuccess(id, result));
+}
+function handleTasksCancel(res, id, params) {
+  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: ${resolvedTaskId}`));
+    return;
+  }
+  if (["completed", "failed", "canceled"].includes(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: params.reason || "Canceled by request",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  res.json(jsonRpcSuccess(id, {
+    task: {
+      id: resolvedTaskId,
+      contextId: task.contextId,
+      status: { state: "canceled", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    }
+  }));
+}
+
+// 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-card.json`;
+    this.apiKey = options.apiKey;
+    this.headers = options.headers || {};
+  }
+  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();
+  }
+  async sendTask(params) {
+    const request = {
+      jsonrpc: "2.0",
+      id: `req_${Date.now()}`,
+      method: "message/send",
+      params: this.toSendMessageRequest(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;
+  }
+  async sendTaskStreaming(params, callbacks) {
+    const request = {
+      jsonrpc: "2.0",
+      id: `req_${Date.now()}`,
+      method: "message/stream",
+      params: this.toSendMessageRequest(params)
+    };
+    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}`);
+    }
+    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() || "";
+      for (const line of lines) {
+        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);
+        }
+      }
+    }
+  }
+  async getTask(taskId, historyLength) {
+    const request = {
+      jsonrpc: "2.0",
+      id: `req_${Date.now()}`,
+      method: "GetTask",
+      params: { id: taskId, historyLength }
+    };
+    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;
+  }
+  async cancelTask(taskId, reason) {
+    const request = {
+      jsonrpc: "2.0",
+      id: `req_${Date.now()}`,
+      method: "CancelTask",
+      params: { id: taskId, metadata: reason ? { reason } : void 0 }
+    };
+    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;
+  }
+  /**
+   * 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",
+      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();
+  }
+  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-KIZQKOZR.js.map