@dexto/core 1.1.4 → 1.1.6

package/dist/llm/services/factory.js

@@ -0,0 +1,130 @@
+import { LLMError } from "../errors.js";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGroq } from "@ai-sdk/groq";
+import { createXai } from "@ai-sdk/xai";
+import { VercelLLMService } from "./vercel.js";
+import { OpenAIService } from "./openai.js";
+import { AnthropicService } from "./anthropic.js";
+import { createCohere } from "@ai-sdk/cohere";
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+function _createInBuiltLLMService(config, toolManager, promptManager, historyProvider, sessionEventBus, sessionId) {
+  const apiKey = config.apiKey;
+  switch (config.provider.toLowerCase()) {
+    case "openai": {
+      const openai = new OpenAI({ apiKey });
+      return new OpenAIService(
+        toolManager,
+        openai,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    case "openai-compatible": {
+      const baseURL = getOpenAICompatibleBaseURL(config);
+      const openai = new OpenAI({ apiKey, baseURL });
+      return new OpenAIService(
+        toolManager,
+        openai,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    case "anthropic": {
+      const anthropic = new Anthropic({ apiKey });
+      return new AnthropicService(
+        toolManager,
+        anthropic,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    default:
+      throw LLMError.unsupportedRouter("in-built", config.provider);
+  }
+}
+function _createVercelModel(llmConfig) {
+  const provider = llmConfig.provider;
+  const model = llmConfig.model;
+  const apiKey = llmConfig.apiKey;
+  switch (provider.toLowerCase()) {
+    case "openai": {
+      return createOpenAI({ apiKey })(model);
+    }
+    case "openai-compatible": {
+      const baseURL = getOpenAICompatibleBaseURL(llmConfig);
+      if (!baseURL) {
+        throw LLMError.baseUrlMissing("openai-compatible");
+      }
+      return createOpenAI({ apiKey, baseURL })(model);
+    }
+    case "anthropic":
+      return createAnthropic({ apiKey })(model);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(model);
+    case "groq":
+      return createGroq({ apiKey })(model);
+    case "xai":
+      return createXai({ apiKey })(model);
+    case "cohere":
+      return createCohere({ apiKey })(model);
+    default:
+      throw LLMError.unsupportedRouter("vercel", provider);
+  }
+}
+function getOpenAICompatibleBaseURL(llmConfig) {
+  if (llmConfig.baseURL) {
+    return llmConfig.baseURL.replace(/\/$/, "");
+  }
+  if (process.env.OPENAI_BASE_URL) {
+    return process.env.OPENAI_BASE_URL.replace(/\/$/, "");
+  }
+  return "";
+}
+function _createVercelLLMService(config, toolManager, promptManager, historyProvider, sessionEventBus, sessionId) {
+  const model = _createVercelModel(config);
+  return new VercelLLMService(
+    toolManager,
+    model,
+    promptManager,
+    historyProvider,
+    sessionEventBus,
+    config,
+    sessionId
+  );
+}
+function createLLMService(config, router, toolManager, promptManager, historyProvider, sessionEventBus, sessionId) {
+  if (router === "vercel") {
+    return _createVercelLLMService(
+      config,
+      toolManager,
+      promptManager,
+      historyProvider,
+      sessionEventBus,
+      sessionId
+    );
+  } else {
+    return _createInBuiltLLMService(
+      config,
+      toolManager,
+      promptManager,
+      historyProvider,
+      sessionEventBus,
+      sessionId
+    );
+  }
+}
+export {
+  createLLMService
+};

package/dist/llm/services/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var services_exports = {};
+module.exports = __toCommonJS(services_exports);
+__reExport(services_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types.js")
+});

package/dist/llm/services/index.d.cts

@@ -0,0 +1,21 @@
+export { ILLMService, LLMServiceConfig } from './types.cjs';
+import 'ai';
+import '../../tools/types.cjs';
+import 'json-schema';
+import 'zod';
+import '../../context/types.cjs';
+import '../types.cjs';
+import '../../context/manager.cjs';
+import '../formatters/types.cjs';
+import '../tokenizer/types.cjs';
+import '../../context/compression/types.cjs';
+import '../../systemPrompt/types.cjs';
+import '../../mcp/manager.cjs';
+import '../../mcp/schemas.cjs';
+import '../../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../../systemPrompt/manager.cjs';
+import '../../systemPrompt/schemas.cjs';
+import '../../session/history/types.cjs';
+import '../schemas.cjs';

package/dist/llm/services/index.d.ts

@@ -0,0 +1,21 @@
+export { ILLMService, LLMServiceConfig } from './types.js';
+import 'ai';
+import '../../tools/types.js';
+import 'json-schema';
+import 'zod';
+import '../../context/types.js';
+import '../types.js';
+import '../../context/manager.js';
+import '../formatters/types.js';
+import '../tokenizer/types.js';
+import '../../context/compression/types.js';
+import '../../systemPrompt/types.js';
+import '../../mcp/manager.js';
+import '../../mcp/schemas.js';
+import '../../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../../systemPrompt/manager.js';
+import '../../systemPrompt/schemas.js';
+import '../../session/history/types.js';
+import '../schemas.js';

package/dist/llm/services/index.js

@@ -0,0 +1 @@
+export * from "./types.js";

package/dist/llm/services/openai.cjs

@@ -0,0 +1,470 @@
+"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 openai_exports = {};
+__export(openai_exports, {
+  OpenAIService: () => OpenAIService
+});
+module.exports = __toCommonJS(openai_exports);
+var import_logger = require("../../logger/index.js");
+var import_manager = require("../../context/manager.js");
+var import_registry = require("../registry.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_error_codes = require("../error-codes.js");
+var import_openai2 = require("../formatters/openai.js");
+var import_factory = require("../tokenizer/factory.js");
+class OpenAIService {
+  openai;
+  config;
+  toolManager;
+  contextManager;
+  sessionEventBus;
+  sessionId;
+  constructor(toolManager, openai, promptManager, historyProvider, sessionEventBus, config, sessionId) {
+    this.config = config;
+    this.openai = openai;
+    this.toolManager = toolManager;
+    this.sessionEventBus = sessionEventBus;
+    this.sessionId = sessionId;
+    const formatter = new import_openai2.OpenAIMessageFormatter();
+    const tokenizer = (0, import_factory.createTokenizer)(config.provider, config.model);
+    const maxInputTokens = (0, import_registry.getEffectiveMaxInputTokens)(config);
+    this.contextManager = new import_manager.ContextManager(
+      config,
+      formatter,
+      promptManager,
+      maxInputTokens,
+      tokenizer,
+      historyProvider,
+      sessionId
+    );
+  }
+  getAllTools() {
+    return this.toolManager.getAllTools();
+  }
+  async completeTask(textInput, options, imageData, fileData, stream) {
+    await this.contextManager.addUserMessage(textInput, imageData, fileData);
+    const rawTools = await this.toolManager.getAllTools();
+    const formattedTools = this.formatToolsForOpenAI(rawTools);
+    import_logger.logger.silly(`Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`);
+    this.sessionEventBus.emit("llmservice:thinking");
+    let iterationCount = 0;
+    let totalTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let reasoningTokens = 0;
+    let fullResponse = "";
+    const context = stream ? "OpenAI streaming API call" : "OpenAI API call";
+    try {
+      while (iterationCount < this.config.maxIterations) {
+        if (options?.signal?.aborted) {
+          throw Object.assign(new Error("Aborted"), {
+            name: "AbortError",
+            aborted: true
+          });
+        }
+        iterationCount++;
+        const { message, usage } = stream ? await this.getAIStreamingResponseWithRetries(formattedTools, options?.signal) : await this.getAIResponseWithRetries(formattedTools, options?.signal);
+        if (usage) {
+          totalTokens += usage.total_tokens ?? 0;
+          inputTokens += usage.prompt_tokens ?? 0;
+          outputTokens += usage.completion_tokens ?? 0;
+          reasoningTokens += usage.completion_tokens_details?.reasoning_tokens ?? 0;
+        }
+        if (!message.tool_calls || message.tool_calls.length === 0) {
+          const responseText = message.content || "";
+          const finalContent = stream ? fullResponse + responseText : responseText;
+          await this.contextManager.addAssistantMessage(finalContent, void 0, {
+            tokenUsage: totalTokens > 0 ? {
+              totalTokens,
+              inputTokens,
+              outputTokens,
+              reasoningTokens
+            } : void 0
+          });
+          if (totalTokens > 0) {
+            this.contextManager.updateActualTokenCount(totalTokens);
+          }
+          this.sessionEventBus.emit("llmservice:response", {
+            content: finalContent,
+            provider: this.config.provider,
+            model: this.config.model,
+            router: "in-built",
+            tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
+          });
+          return finalContent;
+        }
+        const functionToolCalls = message.tool_calls.filter(
+          (toolCall) => {
+            import_logger.logger.debug(`Tool call type received: ${toolCall.type}`);
+            return toolCall.type === "function";
+          }
+        );
+        if (message.tool_calls.length > functionToolCalls.length) {
+          import_logger.logger.warn(
+            `Filtered out ${message.tool_calls.length - functionToolCalls.length} non-function tool calls`
+          );
+        }
+        await this.contextManager.addAssistantMessage(
+          message.content,
+          functionToolCalls.length > 0 ? functionToolCalls : void 0,
+          {}
+        );
+        if (stream && message.content) {
+          fullResponse += message.content;
+        }
+        for (const toolCall of functionToolCalls) {
+          if (options?.signal?.aborted) {
+            throw Object.assign(new Error("Aborted"), {
+              name: "AbortError",
+              aborted: true
+            });
+          }
+          import_logger.logger.debug(`Tool call initiated - Type: ${toolCall.type}`);
+          import_logger.logger.debug(`Tool call details: ${JSON.stringify(toolCall, null, 2)}`);
+          const toolName = toolCall.function.name;
+          let args = {};
+          try {
+            args = JSON.parse(toolCall.function.arguments);
+          } catch (e) {
+            import_logger.logger.error(`Error parsing arguments for ${toolName}:`, e);
+            await this.contextManager.addToolResult(toolCall.id, toolName, {
+              error: `Failed to parse arguments: ${e}`
+            });
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName,
+              result: { error: `Failed to parse arguments: ${e}` },
+              callId: toolCall.id,
+              success: false
+            });
+            continue;
+          }
+          this.sessionEventBus.emit("llmservice:toolCall", {
+            toolName,
+            args,
+            callId: toolCall.id
+          });
+          try {
+            const result = await this.toolManager.executeTool(
+              toolName,
+              args,
+              this.sessionId
+            );
+            await this.contextManager.addToolResult(toolCall.id, toolName, result);
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName,
+              result,
+              callId: toolCall.id,
+              success: true
+            });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            import_logger.logger.error(`Tool execution error for ${toolName}: ${errorMessage}`);
+            await this.contextManager.addToolResult(toolCall.id, toolName, {
+              error: errorMessage
+            });
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName,
+              result: { error: errorMessage },
+              callId: toolCall.id,
+              success: false
+            });
+          }
+        }
+      }
+      import_logger.logger.warn(`Reached maximum iterations (${this.config.maxIterations}) for task.`);
+      const finalResponse = fullResponse || "Task completed but reached maximum tool call iterations.";
+      await this.contextManager.addAssistantMessage(finalResponse, void 0, {
+        tokenUsage: totalTokens > 0 ? {
+          totalTokens,
+          inputTokens,
+          outputTokens,
+          reasoningTokens
+        } : void 0
+      });
+      if (totalTokens > 0) {
+        this.contextManager.updateActualTokenCount(totalTokens);
+      }
+      this.sessionEventBus.emit("llmservice:response", {
+        content: finalResponse,
+        provider: this.config.provider,
+        model: this.config.model,
+        router: "in-built",
+        tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
+      });
+      return finalResponse;
+    } catch (error) {
+      if (error instanceof Error && (error.name === "AbortError" || error.aborted === true)) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      import_logger.logger.error(`Error in ${context}: ${errorMessage}`, { error });
+      if (!stream) {
+        import_logger.logger.warn(
+          `If this error is due to token overflow, consider configuring 'maxInputTokens' in your LLMConfig.`
+        );
+      }
+      this.sessionEventBus.emit("llmservice:error", {
+        error: error instanceof Error ? error : new Error(errorMessage),
+        context,
+        recoverable: false
+      });
+      const errorResponse = `Error processing ${stream ? "streaming " : ""}request: ${errorMessage}`;
+      await this.contextManager.addAssistantMessage(errorResponse, void 0, {});
+      return errorResponse;
+    }
+  }
+  /**
+   * Get configuration information about the LLM service
+   * @returns Configuration object with provider and model information
+   */
+  getConfig() {
+    const configuredMaxInputTokens = this.contextManager.getMaxInputTokens();
+    let modelMaxInputTokens;
+    try {
+      modelMaxInputTokens = (0, import_registry.getMaxInputTokensForModel)(
+        this.config.provider,
+        this.config.model
+      );
+    } catch (error) {
+      if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
+        modelMaxInputTokens = configuredMaxInputTokens;
+        import_logger.logger.debug(
+          `Could not find model ${this.config.model} in LLM registry to get max tokens. Using configured max tokens: ${configuredMaxInputTokens}.`
+        );
+      } else {
+        throw error;
+      }
+    }
+    return {
+      router: "in-built",
+      provider: this.config.provider,
+      model: this.config.model,
+      configuredMaxInputTokens,
+      modelMaxInputTokens
+    };
+  }
+  // Helper methods
+  async getAIResponseWithRetries(tools, signal) {
+    let attempts = 0;
+    const MAX_ATTEMPTS = 3;
+    import_logger.logger.debug(`Tools size in getAIResponseWithRetries: ${tools.length}`);
+    while (attempts < MAX_ATTEMPTS) {
+      attempts++;
+      try {
+        const {
+          formattedMessages,
+          systemPrompt: _systemPrompt,
+          tokensUsed
+        } = await this.contextManager.getFormattedMessagesWithCompression(
+          { mcpManager: this.toolManager.getMcpManager() },
+          { provider: this.config.provider, model: this.config.model }
+        );
+        import_logger.logger.silly(
+          `Message history (potentially compressed) in getAIResponseWithRetries: ${JSON.stringify(formattedMessages, null, 2)}`
+        );
+        import_logger.logger.debug(`Estimated tokens being sent to OpenAI: ${tokensUsed}`);
+        const response = await this.openai.chat.completions.create(
+          {
+            model: this.config.model,
+            messages: formattedMessages,
+            tools: attempts === 1 ? tools : [],
+            // Only offer tools on first attempt
+            tool_choice: attempts === 1 ? "auto" : "none"
+            // Disable tool choice on retry
+          },
+          signal ? { signal } : void 0
+        );
+        import_logger.logger.silly(
+          "OPENAI CHAT COMPLETION RESPONSE: ",
+          JSON.stringify(response, null, 2)
+        );
+        const message = response.choices[0]?.message;
+        if (!message) {
+          throw new Error("Received empty message from OpenAI API");
+        }
+        const usage = response.usage;
+        return { message, ...usage && { usage } };
+      } catch (error) {
+        if (error instanceof Error && (error.name === "AbortError" || error.aborted === true)) {
+          throw error;
+        }
+        const apiError = error;
+        import_logger.logger.error(
+          `Error in OpenAI API call (Attempt ${attempts}/${MAX_ATTEMPTS}): ${apiError.message || JSON.stringify(apiError, null, 2)}`,
+          { status: apiError.status, headers: apiError.headers }
+        );
+        if (apiError.status === 400 && apiError.code === "context_length_exceeded") {
+          import_logger.logger.warn(
+            `Context length exceeded. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
+          );
+        }
+        if (attempts >= MAX_ATTEMPTS) {
+          import_logger.logger.error(
+            `Failed to get response from OpenAI after ${MAX_ATTEMPTS} attempts.`
+          );
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500 * attempts));
+      }
+    }
+    throw new Error("Failed to get response after maximum retry attempts");
+  }
+  async getAIStreamingResponseWithRetries(tools, signal) {
+    let attempts = 0;
+    const MAX_ATTEMPTS = 3;
+    while (attempts < MAX_ATTEMPTS) {
+      attempts++;
+      try {
+        const {
+          formattedMessages,
+          systemPrompt: _systemPrompt,
+          tokensUsed
+        } = await this.contextManager.getFormattedMessagesWithCompression(
+          { mcpManager: this.toolManager.getMcpManager() },
+          { provider: this.config.provider, model: this.config.model }
+        );
+        import_logger.logger.silly(
+          `Streaming message history (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
+        );
+        import_logger.logger.debug(`Estimated tokens being sent to OpenAI streaming: ${tokensUsed}`);
+        const stream = await this.openai.chat.completions.create(
+          {
+            model: this.config.model,
+            messages: formattedMessages,
+            tools: attempts === 1 ? tools : [],
+            // Only offer tools on first attempt
+            tool_choice: attempts === 1 ? "auto" : "none",
+            // Disable tool choice on retry
+            stream: true,
+            stream_options: {
+              include_usage: true
+            }
+          },
+          signal ? { signal } : void 0
+        );
+        let content = "";
+        let toolCalls = [];
+        let usage;
+        for await (const chunk of stream) {
+          if (signal?.aborted) {
+            throw Object.assign(new Error("Aborted"), {
+              name: "AbortError",
+              aborted: true
+            });
+          }
+          const delta = chunk.choices[0]?.delta;
+          if (delta?.content) {
+            content += delta.content;
+            this.sessionEventBus.emit("llmservice:chunk", {
+              type: "text",
+              content: delta.content,
+              isComplete: false
+            });
+          }
+          if (delta?.tool_calls) {
+            for (const toolCall of delta.tool_calls) {
+              const index = toolCall.index;
+              if (typeof index !== "number") {
+                continue;
+              }
+              if (!toolCalls[index]) {
+                toolCalls[index] = {
+                  id: `pending-${index}`,
+                  type: "function",
+                  function: { name: "", arguments: "" }
+                };
+              }
+              if (toolCall.id) {
+                toolCalls[index].id = toolCall.id;
+              }
+              const existingToolCall = toolCalls[index];
+              if (existingToolCall.type === "function" && toolCall.function) {
+                if (toolCall.function.name) {
+                  existingToolCall.function.name = toolCall.function.name;
+                }
+                if (toolCall.function.arguments) {
+                  existingToolCall.function.arguments += toolCall.function.arguments;
+                }
+              }
+            }
+          }
+          if (chunk.usage) {
+            usage = chunk.usage;
+          }
+        }
+        if (content) {
+          this.sessionEventBus.emit("llmservice:chunk", {
+            type: "text",
+            content: "",
+            isComplete: true
+          });
+        }
+        const message = {
+          role: "assistant",
+          content: content || null,
+          refusal: null,
+          ...toolCalls.length > 0 && { tool_calls: toolCalls }
+        };
+        import_logger.logger.debug(`OpenAI streaming completed. Usage info: ${usage}`);
+        return { message, ...usage && { usage } };
+      } catch (error) {
+        const apiError = error;
+        import_logger.logger.error(
+          `Error in OpenAI streaming API call (Attempt ${attempts}/${MAX_ATTEMPTS}): ${apiError.message || JSON.stringify(apiError, null, 2)}`,
+          { status: apiError.status, headers: apiError.headers }
+        );
+        if (apiError.status === 400 && apiError.message?.includes("maximum context length")) {
+          import_logger.logger.warn(
+            `Context length exceeded in streaming. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
+          );
+        }
+        if (attempts >= MAX_ATTEMPTS) {
+          import_logger.logger.error(
+            `Failed to get streaming response from OpenAI after ${MAX_ATTEMPTS} attempts.`
+          );
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500 * attempts));
+      }
+    }
+    throw new Error("Failed to get streaming response after maximum retry attempts");
+  }
+  formatToolsForOpenAI(tools) {
+    return Object.entries(tools).map(([name, tool]) => {
+      return {
+        type: "function",
+        function: {
+          name,
+          description: tool.description || "",
+          parameters: tool.parameters
+        }
+      };
+    });
+  }
+  /**
+   * Get the context manager for external access
+   */
+  getContextManager() {
+    return this.contextManager;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAIService
+});