@band-ai/sdk 0.1.2

package/dist/converters.cjs

@@ -0,0 +1,1086 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/converters/index.ts
+var converters_exports = {};
+__export(converters_exports, {
+  A2AHistoryConverter: () => A2AHistoryConverter,
+  ACPClientHistoryConverter: () => ACPClientHistoryConverter,
+  ACPServerHistoryConverter: () => ACPServerHistoryConverter,
+  AnthropicHistoryConverter: () => AnthropicHistoryConverter,
+  ClaudeSDKHistoryConverter: () => ClaudeSDKHistoryConverter,
+  CodexHistoryConverter: () => CodexHistoryConverter,
+  GatewayHistoryConverter: () => GatewayHistoryConverter,
+  GeminiHistoryConverter: () => GeminiHistoryConverter,
+  GoogleADKHistoryConverter: () => GoogleADKHistoryConverter,
+  LangChainHistoryConverter: () => LangChainHistoryConverter,
+  OpencodeHistoryConverter: () => OpencodeHistoryConverter,
+  ParlantHistoryConverter: () => ParlantHistoryConverter,
+  VercelAISDKHistoryConverter: () => VercelAISDKHistoryConverter,
+  buildA2AAuthHeaders: () => buildA2AAuthHeaders,
+  extractClaudeSessionId: () => extractClaudeSessionId,
+  extractCodexSessionId: () => extractCodexSessionId,
+  extractGoogleAdkSessionId: () => extractGoogleAdkSessionId,
+  extractOpencodeSessionId: () => extractOpencodeSessionId
+});
+module.exports = __toCommonJS(converters_exports);
+
+// src/converters/acp-client.ts
+var ACPClientHistoryConverter = class {
+  convert(raw) {
+    const roomToSession = {};
+    for (const entry of raw) {
+      const metadataRaw = entry.metadata;
+      if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+        continue;
+      }
+      const metadata = metadataRaw;
+      const sessionId = metadata.acp_client_session_id;
+      const roomId = metadata.acp_client_room_id;
+      if (typeof sessionId === "string" && typeof roomId === "string" && sessionId && roomId) {
+        roomToSession[roomId] = sessionId;
+      }
+    }
+    return { roomToSession };
+  }
+};
+
+// src/converters/acp-server.ts
+var ACPServerHistoryConverter = class {
+  convert(raw) {
+    const sessionToRoom = {};
+    const sessionCwd = {};
+    const sessionMcpServers = {};
+    for (const entry of raw) {
+      const metadataRaw = entry.metadata;
+      if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+        continue;
+      }
+      const metadata = metadataRaw;
+      const sessionId = metadata.acp_session_id;
+      if (typeof sessionId !== "string" || sessionId.length === 0) {
+        continue;
+      }
+      const roomId = typeof metadata.acp_room_id === "string" ? metadata.acp_room_id : typeof entry.room_id === "string" ? entry.room_id : null;
+      if (roomId) {
+        sessionToRoom[sessionId] = roomId;
+      }
+      if (typeof metadata.acp_cwd === "string" && metadata.acp_cwd.length > 0) {
+        sessionCwd[sessionId] = metadata.acp_cwd;
+      }
+      if (Array.isArray(metadata.acp_mcp_servers)) {
+        sessionMcpServers[sessionId] = metadata.acp_mcp_servers.filter((server) => !!server && typeof server === "object" && !Array.isArray(server));
+      }
+    }
+    return {
+      sessionToRoom,
+      sessionCwd,
+      sessionMcpServers
+    };
+  }
+};
+
+// src/converters/shared.ts
+function asOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function parseDate(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseToolPayload(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseToolCall(value) {
+  const parsed = parseToolPayload(value);
+  const name = asOptionalString(parsed?.name);
+  const toolCallId = asOptionalString(parsed?.tool_call_id);
+  if (!name || !toolCallId) {
+    return null;
+  }
+  const args = parsed?.args;
+  return {
+    name,
+    toolCallId,
+    args: args && typeof args === "object" && !Array.isArray(args) ? args : {}
+  };
+}
+function parseToolResult(value) {
+  const parsed = parseToolPayload(value);
+  const name = asOptionalString(parsed?.name);
+  const toolCallId = asOptionalString(parsed?.tool_call_id);
+  if (!name || !toolCallId) {
+    return null;
+  }
+  return {
+    name,
+    toolCallId,
+    output: parsed?.output === void 0 ? "" : String(parsed.output),
+    isError: parsed?.is_error === true
+  };
+}
+
+// src/converters/vercel-ai-sdk.ts
+function flushPendingToolCalls(messages, pendingToolCalls) {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "assistant",
+    content: [...pendingToolCalls]
+  });
+  pendingToolCalls.length = 0;
+}
+function flushPendingToolResults(messages, pendingToolResults) {
+  if (pendingToolResults.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "tool",
+    content: [...pendingToolResults]
+  });
+  pendingToolResults.length = 0;
+}
+var VercelAISDKHistoryConverter = class {
+  agentName;
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    const pendingToolResults = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      if (messageType === "tool_call") {
+        flushPendingToolResults(messages, pendingToolResults);
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push({
+            type: "tool-call",
+            toolCallId: parsed.toolCallId,
+            toolName: parsed.name,
+            input: parsed.args
+          });
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        flushPendingToolCalls(messages, pendingToolCalls);
+        const parsed = parseToolResult(content);
+        if (parsed) {
+          pendingToolResults.push({
+            type: "tool-result",
+            toolCallId: parsed.toolCallId,
+            toolName: parsed.name,
+            output: parsed.isError ? { error: parsed.output } : parsed.output
+          });
+        }
+        continue;
+      }
+      if (messageType !== "text") {
+        continue;
+      }
+      flushPendingToolCalls(messages, pendingToolCalls);
+      flushPendingToolResults(messages, pendingToolResults);
+      const role = String(entry.role ?? "user");
+      const senderName = String(entry.sender_name ?? "");
+      if (role === "assistant" && senderName === this.agentName) {
+        continue;
+      }
+      messages.push({
+        role: "user",
+        content: senderName ? `[${senderName}]: ${content}` : content
+      });
+    }
+    flushPendingToolCalls(messages, pendingToolCalls);
+    flushPendingToolResults(messages, pendingToolResults);
+    return messages;
+  }
+};
+
+// src/adapters/a2a/A2AAdapter.ts
+var import_node_crypto = require("crypto");
+
+// src/adapters/shared/coercion.ts
+function asOptionalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+// src/adapters/shared/history.ts
+function findLatestTaskMetadata(raw, predicate) {
+  for (let index = raw.length - 1; index >= 0; index -= 1) {
+    const message = raw[index] ?? {};
+    const messageType = String(message.message_type ?? message.messageType ?? "");
+    if (messageType !== "task") {
+      continue;
+    }
+    const metadata = asOptionalRecord(message.metadata) ?? {};
+    if (predicate(metadata)) {
+      return metadata;
+    }
+  }
+  return null;
+}
+
+// src/adapters/a2a/types.ts
+function buildA2AAuthHeaders(auth) {
+  const headers = {};
+  for (const [key, value] of Object.entries(auth?.headers ?? {})) {
+    headers[key] = sanitizeHeaderValue(value, key);
+  }
+  if (auth?.apiKey) {
+    headers["X-API-Key"] = sanitizeHeaderValue(auth.apiKey, "X-API-Key");
+  }
+  if (auth?.bearerToken) {
+    headers.Authorization = `Bearer ${sanitizeHeaderValue(auth.bearerToken, "Authorization")}`;
+  }
+  return headers;
+}
+function sanitizeHeaderValue(value, headerName) {
+  if (/[\r\n]/u.test(value)) {
+    throw new Error(`${headerName} header value must not contain CR or LF characters.`);
+  }
+  return value;
+}
+var A2AHistoryConverter = class {
+  convert(raw) {
+    const metadata = findLatestTaskMetadata(
+      raw,
+      (entry) => Object.prototype.hasOwnProperty.call(entry, "a2a_context_id")
+    );
+    if (metadata) {
+      return {
+        contextId: asNonEmptyString(metadata.a2a_context_id),
+        taskId: asNonEmptyString(metadata.a2a_task_id),
+        taskState: asNonEmptyString(metadata.a2a_task_state)
+      };
+    }
+    return {
+      contextId: null,
+      taskId: null,
+      taskState: null
+    };
+  }
+};
+
+// src/converters/anthropic.ts
+function flushPendingToolCalls2(messages, pendingToolCalls) {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "assistant",
+    content: [...pendingToolCalls]
+  });
+  pendingToolCalls.length = 0;
+}
+function flushPendingToolResults2(messages, pendingToolResults) {
+  if (pendingToolResults.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "user",
+    content: [...pendingToolResults]
+  });
+  pendingToolResults.length = 0;
+}
+function patchOrphanedToolUses(messages) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+      continue;
+    }
+    const toolUseIds = /* @__PURE__ */ new Map();
+    for (const block of message.content) {
+      if (block.type === "tool_use") {
+        toolUseIds.set(block.id, block.name);
+      }
+    }
+    if (toolUseIds.size === 0) {
+      continue;
+    }
+    const nextMessage = messages[index + 1];
+    const matchedIds = /* @__PURE__ */ new Set();
+    if (nextMessage?.role === "user" && Array.isArray(nextMessage.content)) {
+      for (const block of nextMessage.content) {
+        if (block.type === "tool_result" && toolUseIds.has(block.tool_use_id)) {
+          matchedIds.add(block.tool_use_id);
+        }
+      }
+    }
+    const syntheticResults = [...toolUseIds.entries()].filter(([toolUseId]) => !matchedIds.has(toolUseId)).map(([toolUseId]) => ({
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      content: "Error: tool execution was interrupted",
+      is_error: true
+    }));
+    if (syntheticResults.length === 0) {
+      continue;
+    }
+    if (nextMessage?.role === "user") {
+      if (typeof nextMessage.content === "string") {
+        nextMessage.content = [
+          ...syntheticResults,
+          { type: "text", text: nextMessage.content }
+        ];
+      } else {
+        nextMessage.content = [...syntheticResults, ...nextMessage.content];
+      }
+      continue;
+    }
+    messages.splice(index + 1, 0, {
+      role: "user",
+      content: syntheticResults
+    });
+    index += 1;
+  }
+}
+var AnthropicHistoryConverter = class {
+  agentName;
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    const pendingToolResults = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      if (messageType === "tool_call") {
+        flushPendingToolResults2(messages, pendingToolResults);
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push({
+            type: "tool_use",
+            id: parsed.toolCallId,
+            name: parsed.name,
+            input: parsed.args
+          });
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        flushPendingToolCalls2(messages, pendingToolCalls);
+        const parsed = parseToolResult(content);
+        if (parsed) {
+          pendingToolResults.push({
+            type: "tool_result",
+            tool_use_id: parsed.toolCallId,
+            content: parsed.output,
+            ...parsed.isError ? { is_error: true } : {}
+          });
+        }
+        continue;
+      }
+      if (messageType !== "text") {
+        continue;
+      }
+      flushPendingToolCalls2(messages, pendingToolCalls);
+      flushPendingToolResults2(messages, pendingToolResults);
+      const role = String(entry.role ?? "user");
+      const senderName = String(entry.sender_name ?? "");
+      if (role === "assistant" && senderName === this.agentName) {
+        continue;
+      }
+      messages.push({
+        role: "user",
+        content: senderName ? `[${senderName}]: ${content}` : content
+      });
+    }
+    flushPendingToolCalls2(messages, pendingToolCalls);
+    flushPendingToolResults2(messages, pendingToolResults);
+    patchOrphanedToolUses(messages);
+    return messages;
+  }
+};
+
+// src/adapters/a2a-gateway/A2AGatewayAdapter.ts
+var import_node_crypto4 = require("crypto");
+
+// src/adapters/a2a-gateway/history.ts
+var GatewayHistoryConverter = class {
+  convert(raw) {
+    const contextToRoom = {};
+    const roomParticipants = /* @__PURE__ */ new Map();
+    for (const entry of raw) {
+      const metadata = asOptionalRecord(entry.metadata) ?? {};
+      const contextId = asNonEmptyString(metadata.gateway_context_id);
+      if (contextId) {
+        const roomId2 = asNonEmptyString(metadata.gateway_room_id) ?? asNonEmptyString(entry.room_id) ?? asNonEmptyString(entry.roomId);
+        if (roomId2) {
+          contextToRoom[contextId] = roomId2;
+        }
+      }
+      const senderType = (asNonEmptyString(entry.sender_type) ?? asNonEmptyString(entry.senderType) ?? "").trim().toLowerCase();
+      const roomId = asNonEmptyString(entry.room_id) ?? asNonEmptyString(entry.roomId);
+      const senderId = asNonEmptyString(entry.sender_id) ?? asNonEmptyString(entry.senderId);
+      if (senderType !== "agent" || !roomId || !senderId) {
+        continue;
+      }
+      const participants = roomParticipants.get(roomId) ?? /* @__PURE__ */ new Set();
+      participants.add(senderId);
+      roomParticipants.set(roomId, participants);
+    }
+    const serializedParticipants = {};
+    for (const [roomId, participants] of roomParticipants) {
+      serializedParticipants[roomId] = [...participants];
+    }
+    return {
+      contextToRoom,
+      roomParticipants: serializedParticipants
+    };
+  }
+};
+
+// src/adapters/a2a-gateway/server.ts
+var import_node_crypto3 = require("crypto");
+
+// src/adapters/a2a-gateway/statusEvent.ts
+var import_node_crypto2 = require("crypto");
+
+// src/adapters/a2a-gateway/A2AGatewayAdapter.ts
+var DEFAULT_PORT = 1e4;
+var DEFAULT_GATEWAY_URL = `http://localhost:${DEFAULT_PORT}`;
+
+// src/runtime/prompts.ts
+var BASE_INSTRUCTIONS = `
+## Environment
+
+Multi-participant chat. Messages show sender: [Name]: content.
+Messages prefixed with [System]: are platform updates (participant changes, contact updates, etc.) \u2014 not messages from users.
+Use \`thenvoi_send_message(content, mentions)\` to respond. Plain text output is not delivered.
+Mentions use handles: @<username> for users, @<username>/<agent-name> for agents.
+
+## CRITICAL: Delegate When You Cannot Help Directly
+
+You have NO internet access and NO real-time data. When asked about weather, news, stock prices,
+or any current information you cannot answer directly:
+
+1. Call \`thenvoi_lookup_peers()\` to find available specialized agents
+2. If a relevant agent exists, call \`thenvoi_add_participant(name)\` to add them
+3. Ask that agent using \`thenvoi_send_message(question, mentions=[agent_handle])\`
+4. Wait for their response and relay it back to the user
+
+NEVER say "I can't do that" without first checking if another agent can help via \`thenvoi_lookup_peers()\`.
+
+## CRITICAL: Do NOT Remove Agents Automatically
+
+After adding an agent to help with a task:
+1. Ask your question and wait for their response
+2. Relay their response back to the original requester
+3. **Do NOT remove the agent** - they stay silent unless mentioned and may be useful for follow-ups
+
+Only remove agents if the user explicitly requests it.
+
+## CRITICAL: Always Relay Information Back to the Requester
+
+When someone asks you to get information from another agent:
+1. Ask the other agent for the information
+2. When you receive the response, IMMEDIATELY relay it back to the ORIGINAL REQUESTER
+3. Do NOT just thank the helper agent - the requester is waiting for their answer!
+
+## IMPORTANT: Always Share Your Thinking
+
+You MUST call \`thenvoi_send_event(content, message_type="thought")\` BEFORE every action.
+This is required so users can see your reasoning process.
+
+## Examples
+
+### Simple question - answer directly
+[John Doe]: What's 2+2?
+-> thenvoi_send_event("Simple arithmetic, answering directly.", message_type="thought")
+-> thenvoi_send_message("4", mentions=["@john"])
+
+### User asks about weather (you cannot answer directly)
+[John Doe]: What's the weather in Tokyo?
+-> thenvoi_send_event("I can't check weather directly. Looking for a Weather Agent.", message_type="thought")
+-> thenvoi_lookup_peers()
+-> thenvoi_send_event("Found Weather Agent. Adding to room.", message_type="thought")
+-> thenvoi_add_participant("Weather Agent")
+-> thenvoi_send_message("What's the weather in Tokyo?", mentions=["@john/weather-agent"])
+
+[Weather Agent]: Tokyo is 15\xB0C and cloudy.
+-> thenvoi_send_event("Got weather response. Relaying back to John Doe.", message_type="thought")
+-> thenvoi_send_message("The weather in Tokyo is 15\xB0C and cloudy.", mentions=["@john"])
+
+### No suitable agent available
+[John Doe]: What's the stock price of AAPL?
+-> thenvoi_send_event("I can't check stock prices. Looking for a Stock Agent.", message_type="thought")
+-> thenvoi_lookup_peers()
+-> thenvoi_send_event("No stock agent available. Must inform user.", message_type="thought")
+-> thenvoi_send_message("I don't have access to stock prices, and there's no specialized agent available to help with that.", mentions=["@john"])
+
+### Follow-up question in same conversation
+[John Doe]: What about London?
+-> thenvoi_send_event("Follow-up weather question. Asking Weather Agent.", message_type="thought")
+-> thenvoi_send_message("What's the weather in London?", mentions=["@john/weather-agent"])
+
+[Weather Agent]: London is 8\xB0C and rainy.
+-> thenvoi_send_event("Got London weather. Relaying to John Doe.", message_type="thought")
+-> thenvoi_send_message("London is 8\xB0C and rainy.", mentions=["@john"])
+`;
+var TEMPLATES = {
+  default: `You are {agent_name}, {agent_description}.
+
+{custom_section}
+` + BASE_INSTRUCTIONS
+};
+
+// src/adapters/parlant/types.ts
+var ParlantHistoryConverter = class {
+  convert(raw) {
+    const messages = [];
+    for (const entry of raw) {
+      const messageType = asNonEmptyString(entry.message_type) ?? "text";
+      if (messageType !== "text") {
+        continue;
+      }
+      const content = asNonEmptyString(entry.content);
+      if (!content) {
+        continue;
+      }
+      const sender = asNonEmptyString(entry.sender_name) ?? asNonEmptyString(entry.senderName) ?? "";
+      const senderType = asNonEmptyString(entry.sender_type) ?? asNonEmptyString(entry.senderType) ?? "User";
+      const role = (asNonEmptyString(entry.role) ?? "user").toLowerCase() === "assistant" ? "assistant" : "user";
+      if (role === "assistant") {
+        messages.push({
+          role,
+          content,
+          sender,
+          senderType
+        });
+        continue;
+      }
+      messages.push({
+        role,
+        content: sender ? `[${sender}]: ${content}` : content,
+        sender,
+        senderType
+      });
+    }
+    return messages;
+  }
+};
+
+// src/converters/claude-sdk.ts
+var ClaudeSDKHistoryConverter = class {
+  agentName = "";
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    return {
+      text: buildClaudeSdkText(raw, this.agentName),
+      sessionId: extractClaudeSessionId(raw)
+    };
+  }
+};
+function extractClaudeSessionId(raw) {
+  const metadata = findLatestTaskMetadata(
+    raw,
+    (entry) => typeof entry.claude_sdk_session_id === "string" && entry.claude_sdk_session_id.length > 0 || typeof entry.claude_session_id === "string" && entry.claude_session_id.length > 0
+  );
+  const sessionId = metadata?.claude_sdk_session_id ?? metadata?.claude_session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+function buildClaudeSdkText(raw, agentName) {
+  const lines = [];
+  for (const entry of raw) {
+    const messageType = String(entry.message_type ?? "text");
+    if (messageType === "task") {
+      continue;
+    }
+    const content = asOptionalString(entry.content);
+    if (!content) {
+      continue;
+    }
+    const role = String(entry.role ?? "user");
+    const senderName = asOptionalString(entry.sender_name) ?? "Unknown";
+    if (messageType === "text") {
+      if (role === "assistant" && senderName === agentName) {
+        continue;
+      }
+      lines.push(`[${senderName}]: ${content}`);
+      continue;
+    }
+    if (messageType === "tool_call" || messageType === "tool_result") {
+      lines.push(content);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/converters/codex.ts
+var CodexHistoryConverter = class {
+  setAgentName(_name) {
+  }
+  convert(raw) {
+    const metadata = findLatestTaskMetadata(
+      raw,
+      (entry) => typeof entry.codex_thread_id === "string" && entry.codex_thread_id.length > 0
+    );
+    if (!metadata) {
+      return {
+        threadId: null,
+        roomId: null,
+        createdAt: null
+      };
+    }
+    return {
+      threadId: asOptionalString(metadata.codex_thread_id),
+      roomId: asOptionalString(metadata.codex_room_id),
+      createdAt: parseDate(metadata.codex_created_at)
+    };
+  }
+};
+function extractCodexSessionId(raw) {
+  const metadata = findLatestTaskMetadata(
+    raw,
+    (entry) => typeof entry.codex_thread_id === "string" && entry.codex_thread_id.length > 0
+  );
+  const sessionId = metadata?.codex_thread_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+
+// src/converters/google-adk.ts
+function appendToolCalls(messages, pendingToolCalls) {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "model",
+    content: [...pendingToolCalls]
+  });
+  pendingToolCalls.length = 0;
+}
+function appendToolResults(messages, pendingToolResults) {
+  if (pendingToolResults.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "user",
+    content: [...pendingToolResults]
+  });
+  pendingToolResults.length = 0;
+}
+function patchOrphanedToolCalls(messages) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message.role !== "model" || !Array.isArray(message.content)) {
+      continue;
+    }
+    const callNames = /* @__PURE__ */ new Map();
+    for (const block of message.content) {
+      if (block.type === "function_call" && typeof block.id === "string" && block.id.length > 0) {
+        callNames.set(block.id, typeof block.name === "string" ? block.name : "");
+      }
+    }
+    if (callNames.size === 0) {
+      continue;
+    }
+    const nextMessage = messages[index + 1];
+    const matchedIds = /* @__PURE__ */ new Set();
+    if (nextMessage?.role === "user" && Array.isArray(nextMessage.content)) {
+      for (const block of nextMessage.content) {
+        if (block.type === "function_response" && typeof block.tool_call_id === "string" && callNames.has(block.tool_call_id)) {
+          matchedIds.add(block.tool_call_id);
+        }
+      }
+    }
+    const orphanedIds = [...callNames.keys()].filter((toolCallId) => !matchedIds.has(toolCallId));
+    if (orphanedIds.length === 0) {
+      continue;
+    }
+    const syntheticResponses = orphanedIds.map((toolCallId) => ({
+      type: "function_response",
+      tool_call_id: toolCallId,
+      name: callNames.get(toolCallId) ?? "",
+      output: "Error: tool execution was interrupted",
+      is_error: true
+    }));
+    if (nextMessage?.role === "user") {
+      if (typeof nextMessage.content === "string") {
+        nextMessage.content = [
+          ...syntheticResponses,
+          { type: "text", text: nextMessage.content }
+        ];
+      } else if (Array.isArray(nextMessage.content)) {
+        nextMessage.content = [...syntheticResponses, ...nextMessage.content];
+      }
+      continue;
+    }
+    messages.splice(index + 1, 0, {
+      role: "user",
+      content: syntheticResponses
+    });
+    index += 1;
+  }
+}
+var GoogleADKHistoryConverter = class {
+  agentName = "";
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    const pendingToolResults = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      if (messageType === "tool_call") {
+        appendToolResults(messages, pendingToolResults);
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push({
+            type: "function_call",
+            id: parsed.toolCallId,
+            name: parsed.name,
+            args: parsed.args
+          });
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        appendToolCalls(messages, pendingToolCalls);
+        const parsed = parseToolResult(content);
+        if (parsed) {
+          pendingToolResults.push({
+            type: "function_response",
+            tool_call_id: parsed.toolCallId,
+            name: parsed.name,
+            output: parsed.output,
+            ...parsed.isError ? { is_error: true } : {}
+          });
+        }
+        continue;
+      }
+      if (messageType === "thought" || messageType === "error") {
+        continue;
+      }
+      appendToolCalls(messages, pendingToolCalls);
+      appendToolResults(messages, pendingToolResults);
+      const senderName = String(entry.sender_name ?? "");
+      const role = String(entry.role ?? "user");
+      if (role === "assistant" && senderName === this.agentName) {
+        continue;
+      }
+      messages.push({
+        role: "user",
+        content: senderName ? `[${senderName}]: ${content}` : content
+      });
+    }
+    appendToolCalls(messages, pendingToolCalls);
+    appendToolResults(messages, pendingToolResults);
+    patchOrphanedToolCalls(messages);
+    return messages;
+  }
+};
+function extractGoogleAdkSessionId(raw) {
+  const metadata = findLatestTaskMetadata(
+    raw,
+    (entry) => typeof entry.google_adk_session_id === "string" && entry.google_adk_session_id.length > 0
+  );
+  const sessionId = metadata?.google_adk_session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+
+// src/converters/gemini.ts
+function flushPendingToolCalls3(messages, pendingToolCalls) {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "model",
+    parts: [...pendingToolCalls]
+  });
+  pendingToolCalls.length = 0;
+}
+function flushPendingToolResults3(messages, pendingToolResults) {
+  if (pendingToolResults.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "user",
+    parts: [...pendingToolResults]
+  });
+  pendingToolResults.length = 0;
+}
+function mergeConsecutiveRoles(messages) {
+  if (messages.length <= 1) {
+    return messages;
+  }
+  const merged = [messages[0]];
+  for (const message of messages.slice(1)) {
+    const previous = merged[merged.length - 1];
+    if (previous && previous.role === message.role) {
+      previous.parts = [...previous.parts, ...message.parts];
+      continue;
+    }
+    merged.push(message);
+  }
+  return merged;
+}
+var GeminiHistoryConverter = class {
+  agentName;
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    const pendingToolResults = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      if (messageType === "tool_call") {
+        flushPendingToolResults3(messages, pendingToolResults);
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push({
+            type: "function_call",
+            id: parsed.toolCallId,
+            name: parsed.name,
+            args: parsed.args
+          });
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        flushPendingToolCalls3(messages, pendingToolCalls);
+        const parsed = parseToolResult(content);
+        if (parsed) {
+          pendingToolResults.push({
+            type: "function_response",
+            tool_call_id: parsed.toolCallId,
+            name: parsed.name,
+            response: parsed.isError ? { error: parsed.output } : { output: parsed.output }
+          });
+        }
+        continue;
+      }
+      if (messageType !== "text") {
+        continue;
+      }
+      const role = String(entry.role ?? "user");
+      const senderName = String(entry.sender_name ?? "");
+      if (role === "assistant" && senderName === this.agentName) {
+        if (pendingToolCalls.length > 0 || pendingToolResults.length > 0) {
+          continue;
+        }
+        flushPendingToolCalls3(messages, pendingToolCalls);
+        flushPendingToolResults3(messages, pendingToolResults);
+        messages.push({
+          role: "model",
+          parts: [{ type: "text", text: content }]
+        });
+        continue;
+      }
+      flushPendingToolCalls3(messages, pendingToolCalls);
+      flushPendingToolResults3(messages, pendingToolResults);
+      messages.push({
+        role: "user",
+        parts: [{ type: "text", text: senderName ? `[${senderName}]: ${content}` : content }]
+      });
+    }
+    flushPendingToolCalls3(messages, pendingToolCalls);
+    flushPendingToolResults3(messages, pendingToolResults);
+    return mergeConsecutiveRoles(messages);
+  }
+};
+
+// src/converters/langchain.ts
+var LangChainHistoryConverter = class {
+  agentName;
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      const role = String(entry.role ?? "user");
+      const senderName = String(entry.sender_name ?? "");
+      if (messageType === "tool_call") {
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push(parsed);
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        const parsed = parseToolResult(content);
+        if (!parsed) {
+          continue;
+        }
+        const matchingCallIndex = pendingToolCalls.findIndex(
+          (toolCall) => toolCall.toolCallId === parsed.toolCallId || toolCall.name === parsed.name
+        );
+        if (matchingCallIndex >= 0) {
+          const matchingCall = pendingToolCalls.splice(matchingCallIndex, 1)[0];
+          messages.push({
+            type: "ai",
+            content: "",
+            tool_calls: [{
+              id: matchingCall.toolCallId,
+              name: matchingCall.name,
+              args: matchingCall.args
+            }]
+          });
+        }
+        messages.push({
+          type: "tool",
+          content: parsed.output,
+          tool_call_id: parsed.toolCallId
+        });
+        continue;
+      }
+      if (messageType !== "text") {
+        continue;
+      }
+      if (role === "assistant" && senderName === this.agentName) {
+        continue;
+      }
+      messages.push({
+        type: "human",
+        content: senderName ? `[${senderName}]: ${content}` : content
+      });
+    }
+    return messages;
+  }
+};
+
+// src/converters/opencode.ts
+var OpencodeHistoryConverter = class {
+  setAgentName(_name) {
+  }
+  convert(raw) {
+    const replayMessages = buildReplayMessages(raw);
+    const metadata = findLatestTaskMetadata(
+      raw,
+      (entry) => typeof entry.opencode_session_id === "string" && entry.opencode_session_id.length > 0
+    );
+    if (!metadata) {
+      return {
+        sessionId: null,
+        roomId: null,
+        createdAt: null,
+        replayMessages
+      };
+    }
+    return {
+      sessionId: asOptionalString(metadata.opencode_session_id),
+      roomId: asOptionalString(metadata.opencode_room_id),
+      createdAt: parseDate(metadata.opencode_created_at),
+      replayMessages
+    };
+  }
+};
+function extractOpencodeSessionId(raw) {
+  return asOptionalString(
+    findLatestTaskMetadata(
+      raw,
+      (entry) => typeof entry.opencode_session_id === "string" && entry.opencode_session_id.length > 0
+    )?.opencode_session_id
+  );
+}
+function buildReplayMessages(raw) {
+  const replayMessages = [];
+  for (const entry of raw) {
+    if (String(entry.message_type ?? "text") !== "text") {
+      continue;
+    }
+    const content = asOptionalString(entry.content);
+    if (!content) {
+      continue;
+    }
+    const senderName = asOptionalString(entry.sender_name) ?? asOptionalString(entry.sender_type) ?? "Unknown";
+    replayMessages.push(`[${senderName}]: ${content}`);
+  }
+  return replayMessages;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AHistoryConverter,
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter,
+  AnthropicHistoryConverter,
+  ClaudeSDKHistoryConverter,
+  CodexHistoryConverter,
+  GatewayHistoryConverter,
+  GeminiHistoryConverter,
+  GoogleADKHistoryConverter,
+  LangChainHistoryConverter,
+  OpencodeHistoryConverter,
+  ParlantHistoryConverter,
+  VercelAISDKHistoryConverter,
+  buildA2AAuthHeaders,
+  extractClaudeSessionId,
+  extractCodexSessionId,
+  extractGoogleAdkSessionId,
+  extractOpencodeSessionId
+});