@dexto/core 1.1.4 → 1.1.6

package/dist/llm/formatters/anthropic.cjs

@@ -0,0 +1,246 @@
+"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);
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicMessageFormatter: () => AnthropicMessageFormatter
+});
+module.exports = __toCommonJS(anthropic_exports);
+var import_logger = require("../../logger/index.cjs");
+var import_utils = require("../../context/utils.cjs");
+class AnthropicMessageFormatter {
+  /**
+   * Formats internal messages into Anthropic's Claude API format
+   *
+   * Handles the complex logic of:
+   * 1. Ensuring tool calls are paired with their results
+   * 2. Creating the correct nested content structure
+   * 3. Converting tool results to Anthropic's expected format
+   *
+   * @param history Array of internal messages to format
+   * @returns Array of messages formatted for Anthropic's API
+   */
+  format(history, context, _systemPrompt) {
+    const formatted = [];
+    let filteredHistory;
+    try {
+      filteredHistory = (0, import_utils.filterMessagesByLLMCapabilities)([...history], context);
+    } catch (error) {
+      import_logger.logger.warn("Failed to apply capability filtering, using original history:", error);
+      filteredHistory = [...history];
+    }
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    for (let i = 0; i < filteredHistory.length; i++) {
+      const msg = filteredHistory[i];
+      if (!msg) {
+        continue;
+      }
+      if (msg.role === "system") continue;
+      if (msg.role === "user" && !msg.toolCallId) {
+        formatted.push({
+          role: "user",
+          content: this.formatUserContent(msg.content)
+        });
+        continue;
+      }
+      if (msg.role === "tool" && msg.toolCallId) {
+        const pendingCall = pendingToolCalls.get(msg.toolCallId);
+        if (pendingCall) {
+          if (pendingCall.assistantMsg) {
+            formatted.push(pendingCall.assistantMsg);
+            pendingCall.assistantMsg = null;
+          }
+          const safeContent = (0, import_utils.toTextForToolMessage)(msg.content);
+          const toolResultMsg = {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: msg.toolCallId,
+                content: safeContent
+              }
+            ]
+          };
+          formatted.push(toolResultMsg);
+          pendingToolCalls.delete(msg.toolCallId);
+        } else {
+          import_logger.logger.warn(`Tool result found without matching tool call: ${msg.toolCallId}`);
+          const orphanSafe = (0, import_utils.toTextForToolMessage)(msg.content);
+          const orphanToolResult = {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: msg.toolCallId,
+                content: orphanSafe
+              }
+            ]
+          };
+          formatted.push(orphanToolResult);
+        }
+        continue;
+      }
+      if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const toolCall of msg.toolCalls) {
+          const contentArray = [];
+          if (msg.content) {
+            contentArray.push({
+              type: "text",
+              text: msg.content
+            });
+          }
+          contentArray.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments)
+          });
+          const assistantMsg = {
+            role: "assistant",
+            content: contentArray
+          };
+          pendingToolCalls.set(toolCall.id, {
+            assistantMsg,
+            index: i
+          });
+        }
+        continue;
+      }
+      if (msg.role === "assistant" && (!msg.toolCalls || msg.toolCalls.length === 0)) {
+        const assistantMsg = {
+          role: "assistant",
+          content: String(msg.content || "")
+        };
+        formatted.push(assistantMsg);
+        continue;
+      }
+    }
+    const remainingToolCalls = Array.from(pendingToolCalls.entries()).sort(
+      (a, b) => a[1].index - b[1].index
+    );
+    for (const [id, { assistantMsg }] of remainingToolCalls) {
+      if (assistantMsg) {
+        formatted.push(assistantMsg);
+        import_logger.logger.warn(`Tool call ${id} had no matching tool result`);
+      }
+    }
+    return formatted;
+  }
+  /**
+   * Returns the system prompt for Anthropic's API
+   *
+   * Anthropic doesn't include the system prompt in messages array
+   * but passes it as a separate parameter
+   *
+   * @param systemPrompt The system prompt to format
+   * @returns The system prompt without any modification
+   */
+  formatSystemPrompt(systemPrompt) {
+    return systemPrompt;
+  }
+  /**
+   * Parses Anthropic API response into internal message objects.
+   */
+  parseResponse(response) {
+    const internal = [];
+    const typedResponse = response;
+    if (!typedResponse || !Array.isArray(typedResponse.content)) {
+      return internal;
+    }
+    let combinedText = null;
+    const calls = [];
+    for (const block of typedResponse.content) {
+      const typedBlock = block;
+      if (typedBlock.type === "text") {
+        combinedText = (combinedText ?? "") + typedBlock.text;
+      } else if (typedBlock.type === "tool_use") {
+        calls.push({
+          id: typedBlock.id,
+          type: "function",
+          function: {
+            name: typedBlock.name,
+            arguments: JSON.stringify(typedBlock.input)
+          }
+        });
+      }
+    }
+    const assistantMessage = {
+      role: "assistant",
+      content: combinedText
+    };
+    if (calls.length > 0) {
+      assistantMessage.toolCalls = calls;
+    }
+    internal.push(assistantMessage);
+    return internal;
+  }
+  // Helper to format user message parts (text + image + file) into Anthropic multimodal API format
+  formatUserContent(content) {
+    if (!Array.isArray(content)) {
+      return String(content || "");
+    }
+    const blocks = content.map((part) => {
+      if (part.type === "text") {
+        return { type: "text", text: part.text };
+      }
+      if (part.type === "image") {
+        const raw = (0, import_utils.getImageData)(part);
+        let source;
+        if (raw.startsWith("http://") || raw.startsWith("https://")) {
+          source = { type: "url", url: raw };
+        } else if (raw.startsWith("data:")) {
+          const [meta, b64] = raw.split(",", 2);
+          const mediaTypeMatch = meta?.match(/data:(.*);base64/);
+          const media_type = mediaTypeMatch && mediaTypeMatch[1] || part.mimeType || "application/octet-stream";
+          source = { type: "base64", media_type, data: b64 };
+        } else {
+          source = { type: "base64", media_type: part.mimeType, data: raw };
+        }
+        return { type: "image", source };
+      }
+      if (part.type === "file") {
+        const raw = (0, import_utils.getFileData)(part);
+        const fileName = part.filename || "file";
+        let content2 = "";
+        try {
+          if (raw.startsWith("data:")) {
+            const [, base64Data] = raw.split(",", 2);
+            content2 = Buffer.from(base64Data || "", "base64").toString("utf-8");
+          } else if (raw.match(/^[A-Za-z0-9+/]*={0,2}$/)) {
+            content2 = Buffer.from(raw, "base64").toString("utf-8");
+          } else {
+            content2 = raw;
+          }
+        } catch {
+          content2 = `[Binary file: ${fileName}]`;
+        }
+        return {
+          type: "text",
+          text: `File "${fileName}":
+${content2}`
+        };
+      }
+      return null;
+    }).filter((block) => block !== null);
+    return blocks;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicMessageFormatter
+});

package/dist/llm/formatters/anthropic.d.cts

@@ -0,0 +1,45 @@
+import { MessageParam } from '@anthropic-ai/sdk/resources';
+import { IMessageFormatter } from './types.cjs';
+import { LLMContext } from '../types.cjs';
+import { InternalMessage } from '../../context/types.cjs';
+
+/**
+ * Message formatter for Anthropic's Claude API.
+ *
+ * Converts the internal message format to Anthropic's specific structure, which has
+ * notable differences in handling tool calls and tool results:
+ * - Anthropic uses a content array with different types (text, tool_use, tool_result)
+ * - Tool results are sent as user messages with special content structure
+ * - System prompts are not included in the messages array but sent separately
+ */
+declare class AnthropicMessageFormatter implements IMessageFormatter {
+    /**
+     * Formats internal messages into Anthropic's Claude API format
+     *
+     * Handles the complex logic of:
+     * 1. Ensuring tool calls are paired with their results
+     * 2. Creating the correct nested content structure
+     * 3. Converting tool results to Anthropic's expected format
+     *
+     * @param history Array of internal messages to format
+     * @returns Array of messages formatted for Anthropic's API
+     */
+    format(history: Readonly<InternalMessage[]>, context: LLMContext, _systemPrompt?: string | null): MessageParam[];
+    /**
+     * Returns the system prompt for Anthropic's API
+     *
+     * Anthropic doesn't include the system prompt in messages array
+     * but passes it as a separate parameter
+     *
+     * @param systemPrompt The system prompt to format
+     * @returns The system prompt without any modification
+     */
+    formatSystemPrompt(systemPrompt: string | null): string | null;
+    /**
+     * Parses Anthropic API response into internal message objects.
+     */
+    parseResponse(response: unknown): InternalMessage[];
+    private formatUserContent;
+}
+
+export { AnthropicMessageFormatter };

package/dist/llm/formatters/anthropic.d.ts

@@ -0,0 +1,45 @@
+import { MessageParam } from '@anthropic-ai/sdk/resources';
+import { IMessageFormatter } from './types.js';
+import { LLMContext } from '../types.js';
+import { InternalMessage } from '../../context/types.js';
+
+/**
+ * Message formatter for Anthropic's Claude API.
+ *
+ * Converts the internal message format to Anthropic's specific structure, which has
+ * notable differences in handling tool calls and tool results:
+ * - Anthropic uses a content array with different types (text, tool_use, tool_result)
+ * - Tool results are sent as user messages with special content structure
+ * - System prompts are not included in the messages array but sent separately
+ */
+declare class AnthropicMessageFormatter implements IMessageFormatter {
+    /**
+     * Formats internal messages into Anthropic's Claude API format
+     *
+     * Handles the complex logic of:
+     * 1. Ensuring tool calls are paired with their results
+     * 2. Creating the correct nested content structure
+     * 3. Converting tool results to Anthropic's expected format
+     *
+     * @param history Array of internal messages to format
+     * @returns Array of messages formatted for Anthropic's API
+     */
+    format(history: Readonly<InternalMessage[]>, context: LLMContext, _systemPrompt?: string | null): MessageParam[];
+    /**
+     * Returns the system prompt for Anthropic's API
+     *
+     * Anthropic doesn't include the system prompt in messages array
+     * but passes it as a separate parameter
+     *
+     * @param systemPrompt The system prompt to format
+     * @returns The system prompt without any modification
+     */
+    formatSystemPrompt(systemPrompt: string | null): string | null;
+    /**
+     * Parses Anthropic API response into internal message objects.
+     */
+    parseResponse(response: unknown): InternalMessage[];
+    private formatUserContent;
+}
+
+export { AnthropicMessageFormatter };

package/dist/llm/formatters/anthropic.js

@@ -0,0 +1,227 @@
+import { logger } from "../../logger/index.js";
+import {
+  getImageData,
+  getFileData,
+  filterMessagesByLLMCapabilities,
+  toTextForToolMessage
+} from "../../context/utils.js";
+class AnthropicMessageFormatter {
+  /**
+   * Formats internal messages into Anthropic's Claude API format
+   *
+   * Handles the complex logic of:
+   * 1. Ensuring tool calls are paired with their results
+   * 2. Creating the correct nested content structure
+   * 3. Converting tool results to Anthropic's expected format
+   *
+   * @param history Array of internal messages to format
+   * @returns Array of messages formatted for Anthropic's API
+   */
+  format(history, context, _systemPrompt) {
+    const formatted = [];
+    let filteredHistory;
+    try {
+      filteredHistory = filterMessagesByLLMCapabilities([...history], context);
+    } catch (error) {
+      logger.warn("Failed to apply capability filtering, using original history:", error);
+      filteredHistory = [...history];
+    }
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    for (let i = 0; i < filteredHistory.length; i++) {
+      const msg = filteredHistory[i];
+      if (!msg) {
+        continue;
+      }
+      if (msg.role === "system") continue;
+      if (msg.role === "user" && !msg.toolCallId) {
+        formatted.push({
+          role: "user",
+          content: this.formatUserContent(msg.content)
+        });
+        continue;
+      }
+      if (msg.role === "tool" && msg.toolCallId) {
+        const pendingCall = pendingToolCalls.get(msg.toolCallId);
+        if (pendingCall) {
+          if (pendingCall.assistantMsg) {
+            formatted.push(pendingCall.assistantMsg);
+            pendingCall.assistantMsg = null;
+          }
+          const safeContent = toTextForToolMessage(msg.content);
+          const toolResultMsg = {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: msg.toolCallId,
+                content: safeContent
+              }
+            ]
+          };
+          formatted.push(toolResultMsg);
+          pendingToolCalls.delete(msg.toolCallId);
+        } else {
+          logger.warn(`Tool result found without matching tool call: ${msg.toolCallId}`);
+          const orphanSafe = toTextForToolMessage(msg.content);
+          const orphanToolResult = {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: msg.toolCallId,
+                content: orphanSafe
+              }
+            ]
+          };
+          formatted.push(orphanToolResult);
+        }
+        continue;
+      }
+      if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const toolCall of msg.toolCalls) {
+          const contentArray = [];
+          if (msg.content) {
+            contentArray.push({
+              type: "text",
+              text: msg.content
+            });
+          }
+          contentArray.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments)
+          });
+          const assistantMsg = {
+            role: "assistant",
+            content: contentArray
+          };
+          pendingToolCalls.set(toolCall.id, {
+            assistantMsg,
+            index: i
+          });
+        }
+        continue;
+      }
+      if (msg.role === "assistant" && (!msg.toolCalls || msg.toolCalls.length === 0)) {
+        const assistantMsg = {
+          role: "assistant",
+          content: String(msg.content || "")
+        };
+        formatted.push(assistantMsg);
+        continue;
+      }
+    }
+    const remainingToolCalls = Array.from(pendingToolCalls.entries()).sort(
+      (a, b) => a[1].index - b[1].index
+    );
+    for (const [id, { assistantMsg }] of remainingToolCalls) {
+      if (assistantMsg) {
+        formatted.push(assistantMsg);
+        logger.warn(`Tool call ${id} had no matching tool result`);
+      }
+    }
+    return formatted;
+  }
+  /**
+   * Returns the system prompt for Anthropic's API
+   *
+   * Anthropic doesn't include the system prompt in messages array
+   * but passes it as a separate parameter
+   *
+   * @param systemPrompt The system prompt to format
+   * @returns The system prompt without any modification
+   */
+  formatSystemPrompt(systemPrompt) {
+    return systemPrompt;
+  }
+  /**
+   * Parses Anthropic API response into internal message objects.
+   */
+  parseResponse(response) {
+    const internal = [];
+    const typedResponse = response;
+    if (!typedResponse || !Array.isArray(typedResponse.content)) {
+      return internal;
+    }
+    let combinedText = null;
+    const calls = [];
+    for (const block of typedResponse.content) {
+      const typedBlock = block;
+      if (typedBlock.type === "text") {
+        combinedText = (combinedText ?? "") + typedBlock.text;
+      } else if (typedBlock.type === "tool_use") {
+        calls.push({
+          id: typedBlock.id,
+          type: "function",
+          function: {
+            name: typedBlock.name,
+            arguments: JSON.stringify(typedBlock.input)
+          }
+        });
+      }
+    }
+    const assistantMessage = {
+      role: "assistant",
+      content: combinedText
+    };
+    if (calls.length > 0) {
+      assistantMessage.toolCalls = calls;
+    }
+    internal.push(assistantMessage);
+    return internal;
+  }
+  // Helper to format user message parts (text + image + file) into Anthropic multimodal API format
+  formatUserContent(content) {
+    if (!Array.isArray(content)) {
+      return String(content || "");
+    }
+    const blocks = content.map((part) => {
+      if (part.type === "text") {
+        return { type: "text", text: part.text };
+      }
+      if (part.type === "image") {
+        const raw = getImageData(part);
+        let source;
+        if (raw.startsWith("http://") || raw.startsWith("https://")) {
+          source = { type: "url", url: raw };
+        } else if (raw.startsWith("data:")) {
+          const [meta, b64] = raw.split(",", 2);
+          const mediaTypeMatch = meta?.match(/data:(.*);base64/);
+          const media_type = mediaTypeMatch && mediaTypeMatch[1] || part.mimeType || "application/octet-stream";
+          source = { type: "base64", media_type, data: b64 };
+        } else {
+          source = { type: "base64", media_type: part.mimeType, data: raw };
+        }
+        return { type: "image", source };
+      }
+      if (part.type === "file") {
+        const raw = getFileData(part);
+        const fileName = part.filename || "file";
+        let content2 = "";
+        try {
+          if (raw.startsWith("data:")) {
+            const [, base64Data] = raw.split(",", 2);
+            content2 = Buffer.from(base64Data || "", "base64").toString("utf-8");
+          } else if (raw.match(/^[A-Za-z0-9+/]*={0,2}$/)) {
+            content2 = Buffer.from(raw, "base64").toString("utf-8");
+          } else {
+            content2 = raw;
+          }
+        } catch {
+          content2 = `[Binary file: ${fileName}]`;
+        }
+        return {
+          type: "text",
+          text: `File "${fileName}":
+${content2}`
+        };
+      }
+      return null;
+    }).filter((block) => block !== null);
+    return blocks;
+  }
+}
+export {
+  AnthropicMessageFormatter
+};

package/dist/llm/formatters/factory.cjs

@@ -0,0 +1,51 @@
+"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);
+var factory_exports = {};
+__export(factory_exports, {
+  createMessageFormatter: () => createMessageFormatter
+});
+module.exports = __toCommonJS(factory_exports);
+var import_vercel = require("./vercel.js");
+var import_openai = require("./openai.js");
+var import_anthropic = require("./anthropic.js");
+var import_logger = require("../../logger/index.cjs");
+var import_errors = require("../errors.js");
+function createMessageFormatter(provider, router) {
+  if (router === "vercel") {
+    return new import_vercel.VercelMessageFormatter();
+  } else if (router === "in-built") {
+    if (provider === "openai" || provider === "openai-compatible") {
+      return new import_openai.OpenAIMessageFormatter();
+    } else if (provider === "anthropic") {
+      return new import_anthropic.AnthropicMessageFormatter();
+    } else {
+      import_logger.logger.error(
+        `Provider '${provider}' supported by registry but not configured for 'default' router message formatting.`
+      );
+      throw import_errors.LLMError.unsupportedRouter(router, provider);
+    }
+  } else {
+    import_logger.logger.error(`Unsupported LLM router specified: ${router}`);
+    throw import_errors.LLMError.unsupportedRouter(router, provider);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMessageFormatter
+});

package/dist/llm/formatters/factory.d.cts

@@ -0,0 +1,12 @@
+import { IMessageFormatter } from './types.cjs';
+import { LLMProvider, LLMRouter } from '../types.cjs';
+import '../../context/types.cjs';
+
+/**
+ * Creates a message formatter for the specified provider and router combination.
+ * Each formatter handles the conversion between internal message format and
+ * provider-specific message structures.
+ */
+declare function createMessageFormatter(provider: LLMProvider, router: LLMRouter): IMessageFormatter;
+
+export { createMessageFormatter };

package/dist/llm/formatters/factory.d.ts

@@ -0,0 +1,12 @@
+import { IMessageFormatter } from './types.js';
+import { LLMProvider, LLMRouter } from '../types.js';
+import '../../context/types.js';
+
+/**
+ * Creates a message formatter for the specified provider and router combination.
+ * Each formatter handles the conversion between internal message format and
+ * provider-specific message structures.
+ */
+declare function createMessageFormatter(provider: LLMProvider, router: LLMRouter): IMessageFormatter;
+
+export { createMessageFormatter };

package/dist/llm/formatters/factory.js

@@ -0,0 +1,27 @@
+import { VercelMessageFormatter } from "./vercel.js";
+import { OpenAIMessageFormatter } from "./openai.js";
+import { AnthropicMessageFormatter } from "./anthropic.js";
+import { logger } from "../../logger/index.js";
+import { LLMError } from "../errors.js";
+function createMessageFormatter(provider, router) {
+  if (router === "vercel") {
+    return new VercelMessageFormatter();
+  } else if (router === "in-built") {
+    if (provider === "openai" || provider === "openai-compatible") {
+      return new OpenAIMessageFormatter();
+    } else if (provider === "anthropic") {
+      return new AnthropicMessageFormatter();
+    } else {
+      logger.error(
+        `Provider '${provider}' supported by registry but not configured for 'default' router message formatting.`
+      );
+      throw LLMError.unsupportedRouter(router, provider);
+    }
+  } else {
+    logger.error(`Unsupported LLM router specified: ${router}`);
+    throw LLMError.unsupportedRouter(router, provider);
+  }
+}
+export {
+  createMessageFormatter
+};