@band-ai/sdk 0.1.2

package/dist/converters.js

@@ -0,0 +1,468 @@
+import {
+  A2AHistoryConverter,
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter,
+  ClaudeSDKHistoryConverter,
+  GatewayHistoryConverter,
+  GoogleADKHistoryConverter,
+  OpencodeHistoryConverter,
+  ParlantHistoryConverter,
+  asOptionalString,
+  buildA2AAuthHeaders,
+  extractClaudeSessionId,
+  extractGoogleAdkSessionId,
+  extractOpencodeSessionId,
+  findLatestTaskMetadata,
+  parseDate,
+  parseToolCall,
+  parseToolResult
+} from "./chunk-FUODYQRE.js";
+import "./chunk-AVVDPXP4.js";
+import "./chunk-SFVKOEQH.js";
+import "./chunk-ZZJRRBPQ.js";
+import "./chunk-3BKAC4OZ.js";
+import "./chunk-OD2G5LFQ.js";
+import "./chunk-YR3BOQNW.js";
+
+// 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/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/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/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;
+  }
+};
+export {
+  A2AHistoryConverter,
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter,
+  AnthropicHistoryConverter,
+  ClaudeSDKHistoryConverter,
+  CodexHistoryConverter,
+  GatewayHistoryConverter,
+  GeminiHistoryConverter,
+  GoogleADKHistoryConverter,
+  LangChainHistoryConverter,
+  OpencodeHistoryConverter,
+  ParlantHistoryConverter,
+  VercelAISDKHistoryConverter,
+  buildA2AAuthHeaders,
+  extractClaudeSessionId,
+  extractCodexSessionId,
+  extractGoogleAdkSessionId,
+  extractOpencodeSessionId
+};

package/dist/core.cjs

@@ -0,0 +1,185 @@
+"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/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  ConsoleLogger: () => ConsoleLogger,
+  NoopLogger: () => NoopLogger,
+  RuntimeStateError: () => RuntimeStateError,
+  SimpleAdapter: () => SimpleAdapter,
+  ThenvoiSdkError: () => ThenvoiSdkError,
+  TransportError: () => TransportError,
+  UnsupportedFeatureError: () => UnsupportedFeatureError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/simpleAdapter.ts
+var SimpleAdapter = class {
+  historyConverter;
+  agentName = "";
+  agentDescription = "";
+  constructor(options) {
+    this.historyConverter = options?.historyConverter;
+  }
+  async onCleanup(_roomId) {
+  }
+  async onStarted(agentName, agentDescription) {
+    this.agentName = agentName;
+    this.agentDescription = agentDescription;
+  }
+  async onEvent(input) {
+    const history = this.convertHistory(input.history);
+    await this.onMessage(
+      input.message,
+      input.tools,
+      history,
+      input.participantsMessage,
+      input.contactsMessage,
+      {
+        isSessionBootstrap: input.isSessionBootstrap,
+        roomId: input.roomId
+      }
+    );
+  }
+  convertHistory(provider) {
+    if (!this.historyConverter) {
+      return provider;
+    }
+    return provider.convert(this.historyConverter);
+  }
+};
+
+// src/core/errors.ts
+var ThenvoiSdkError = class extends Error {
+  constructor(message, cause) {
+    super(message, cause !== void 0 ? { cause } : void 0);
+    this.name = "ThenvoiSdkError";
+  }
+};
+var UnsupportedFeatureError = class extends ThenvoiSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedFeatureError";
+  }
+};
+var ValidationError = class extends ThenvoiSdkError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ValidationError";
+  }
+};
+var TransportError = class extends ThenvoiSdkError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TransportError";
+  }
+};
+var RuntimeStateError = class extends ThenvoiSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeStateError";
+  }
+};
+
+// src/core/logger.ts
+var noop = () => void 0;
+var REDACTED_VALUE = "[REDACTED]";
+var CIRCULAR_VALUE = "[Circular]";
+var SENSITIVE_KEY_PATTERN = /(authorization|api[-_]?key|token|secret|password|cookie)/i;
+var NoopLogger = class {
+  debug = noop;
+  info = noop;
+  warn = noop;
+  error = noop;
+};
+var ConsoleLogger = class {
+  debug(message, context) {
+    this.emit("debug", message, context);
+  }
+  info(message, context) {
+    this.emit("info", message, context);
+  }
+  warn(message, context) {
+    this.emit("warn", message, context);
+  }
+  error(message, context) {
+    const payload = context ? ` ${safeSerializeContext(context)}` : "";
+    process.stderr.write(`${message}${payload}
+`);
+  }
+  emit(level, message, context) {
+    const fn = console[level];
+    if (context === void 0) {
+      fn(message);
+      return;
+    }
+    fn(message, sanitizeValue(context));
+  }
+};
+function safeSerializeContext(context) {
+  try {
+    return JSON.stringify(sanitizeValue(context));
+  } catch {
+    return JSON.stringify({ context: "[Unserializable]" });
+  }
+}
+function sanitizeValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return sanitizeValue(
+      {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        ...value.cause !== void 0 ? { cause: value.cause } : {}
+      },
+      seen
+    );
+  }
+  if (seen.has(value)) {
+    return CIRCULAR_VALUE;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeValue(entry, seen));
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    sanitized[key] = SENSITIVE_KEY_PATTERN.test(key) ? REDACTED_VALUE : sanitizeValue(entry, seen);
+  }
+  return sanitized;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleLogger,
+  NoopLogger,
+  RuntimeStateError,
+  SimpleAdapter,
+  ThenvoiSdkError,
+  TransportError,
+  UnsupportedFeatureError,
+  ValidationError
+});

package/dist/core.d.cts

@@ -0,0 +1,22 @@
+export { S as SimpleAdapter } from './simpleAdapter-DqhvjsGr.cjs';
+export { A as AdapterToolsProtocol, a as AgentToolsProtocol, C as ContactTools, F as FrameworkAdapter, b as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, c as MessagingTools, P as ParticipantTools, d as PeerLookupTools, e as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, f as ToolSchemaProvider } from './protocols-CInhtFpA.cjs';
+export { C as ConsoleLogger, L as Logger, N as NoopLogger } from './logger-CABQOnlR.cjs';
+import './dtos-DUpbIu8k.cjs';
+
+declare class ThenvoiSdkError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+declare class UnsupportedFeatureError extends ThenvoiSdkError {
+    constructor(message: string);
+}
+declare class ValidationError extends ThenvoiSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class TransportError extends ThenvoiSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class RuntimeStateError extends ThenvoiSdkError {
+    constructor(message: string);
+}
+
+export { RuntimeStateError, ThenvoiSdkError, TransportError, UnsupportedFeatureError, ValidationError };

package/dist/core.d.ts

@@ -0,0 +1,22 @@
+export { S as SimpleAdapter } from './simpleAdapter-9OE_p6QW.js';
+export { A as AdapterToolsProtocol, a as AgentToolsProtocol, C as ContactTools, F as FrameworkAdapter, b as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, c as MessagingTools, P as ParticipantTools, d as PeerLookupTools, e as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, f as ToolSchemaProvider } from './protocols-DrhzOH6K.js';
+export { C as ConsoleLogger, L as Logger, N as NoopLogger } from './logger-CABQOnlR.js';
+import './dtos-DUpbIu8k.js';
+
+declare class ThenvoiSdkError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+declare class UnsupportedFeatureError extends ThenvoiSdkError {
+    constructor(message: string);
+}
+declare class ValidationError extends ThenvoiSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class TransportError extends ThenvoiSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class RuntimeStateError extends ThenvoiSdkError {
+    constructor(message: string);
+}
+
+export { RuntimeStateError, ThenvoiSdkError, TransportError, UnsupportedFeatureError, ValidationError };