@dexto/core 1.1.4 → 1.1.6

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

@@ -0,0 +1,65 @@
+import OpenAI from 'openai';
+import { ToolManager } from '../../tools/tool-manager.cjs';
+import { ILLMService, LLMServiceConfig } from './types.cjs';
+import { ToolSet } from '../../tools/types.cjs';
+import { ContextManager } from '../../context/manager.cjs';
+import { ImageData, FileData } from '../../context/types.cjs';
+import { SessionEventBus } from '../../events/index.cjs';
+import { IConversationHistoryProvider } from '../../session/history/types.cjs';
+import { PromptManager } from '../../systemPrompt/manager.cjs';
+import { ValidatedLLMConfig } from '../schemas.cjs';
+import '../../mcp/manager.cjs';
+import '../../mcp/schemas.cjs';
+import 'zod';
+import '../../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'json-schema';
+import '../../tools/internal-tools/registry.cjs';
+import '../../search/search-service.cjs';
+import '../../storage/backend/database-backend.cjs';
+import '../../search/types.cjs';
+import '../types.cjs';
+import '../../tools/schemas.cjs';
+import '../../tools/confirmation/types.cjs';
+import '../../tools/confirmation/allowed-tools-provider/types.cjs';
+import 'ai';
+import '../formatters/types.cjs';
+import '../tokenizer/types.cjs';
+import '../../context/compression/types.cjs';
+import '../../systemPrompt/types.cjs';
+import 'events';
+import '../../agent/schemas.cjs';
+import '../../systemPrompt/schemas.cjs';
+
+/**
+ * OpenAI implementation of LLMService
+ * Not actively maintained, so might be buggy or outdated
+ */
+declare class OpenAIService implements ILLMService {
+    private openai;
+    private config;
+    private toolManager;
+    private contextManager;
+    private sessionEventBus;
+    private readonly sessionId;
+    constructor(toolManager: ToolManager, openai: OpenAI, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, config: ValidatedLLMConfig, sessionId: string);
+    getAllTools(): Promise<ToolSet>;
+    completeTask(textInput: string, options: {
+        signal?: AbortSignal;
+    }, imageData?: ImageData, fileData?: FileData, stream?: boolean): Promise<string>;
+    /**
+     * Get configuration information about the LLM service
+     * @returns Configuration object with provider and model information
+     */
+    getConfig(): LLMServiceConfig;
+    private getAIResponseWithRetries;
+    private getAIStreamingResponseWithRetries;
+    private formatToolsForOpenAI;
+    /**
+     * Get the context manager for external access
+     */
+    getContextManager(): ContextManager<unknown>;
+}
+
+export { OpenAIService };

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

@@ -0,0 +1,65 @@
+import OpenAI from 'openai';
+import { ToolManager } from '../../tools/tool-manager.js';
+import { ILLMService, LLMServiceConfig } from './types.js';
+import { ToolSet } from '../../tools/types.js';
+import { ContextManager } from '../../context/manager.js';
+import { ImageData, FileData } from '../../context/types.js';
+import { SessionEventBus } from '../../events/index.js';
+import { IConversationHistoryProvider } from '../../session/history/types.js';
+import { PromptManager } from '../../systemPrompt/manager.js';
+import { ValidatedLLMConfig } from '../schemas.js';
+import '../../mcp/manager.js';
+import '../../mcp/schemas.js';
+import 'zod';
+import '../../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'json-schema';
+import '../../tools/internal-tools/registry.js';
+import '../../search/search-service.js';
+import '../../storage/backend/database-backend.js';
+import '../../search/types.js';
+import '../types.js';
+import '../../tools/schemas.js';
+import '../../tools/confirmation/types.js';
+import '../../tools/confirmation/allowed-tools-provider/types.js';
+import 'ai';
+import '../formatters/types.js';
+import '../tokenizer/types.js';
+import '../../context/compression/types.js';
+import '../../systemPrompt/types.js';
+import 'events';
+import '../../agent/schemas.js';
+import '../../systemPrompt/schemas.js';
+
+/**
+ * OpenAI implementation of LLMService
+ * Not actively maintained, so might be buggy or outdated
+ */
+declare class OpenAIService implements ILLMService {
+    private openai;
+    private config;
+    private toolManager;
+    private contextManager;
+    private sessionEventBus;
+    private readonly sessionId;
+    constructor(toolManager: ToolManager, openai: OpenAI, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, config: ValidatedLLMConfig, sessionId: string);
+    getAllTools(): Promise<ToolSet>;
+    completeTask(textInput: string, options: {
+        signal?: AbortSignal;
+    }, imageData?: ImageData, fileData?: FileData, stream?: boolean): Promise<string>;
+    /**
+     * Get configuration information about the LLM service
+     * @returns Configuration object with provider and model information
+     */
+    getConfig(): LLMServiceConfig;
+    private getAIResponseWithRetries;
+    private getAIStreamingResponseWithRetries;
+    private formatToolsForOpenAI;
+    /**
+     * Get the context manager for external access
+     */
+    getContextManager(): ContextManager<unknown>;
+}
+
+export { OpenAIService };

package/dist/llm/services/openai.js

@@ -0,0 +1,446 @@
+import { logger } from "../../logger/index.js";
+import { ContextManager } from "../../context/manager.js";
+import { getMaxInputTokensForModel, getEffectiveMaxInputTokens } from "../registry.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { LLMErrorCode } from "../error-codes.js";
+import { OpenAIMessageFormatter } from "../formatters/openai.js";
+import { createTokenizer } from "../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 OpenAIMessageFormatter();
+    const tokenizer = createTokenizer(config.provider, config.model);
+    const maxInputTokens = getEffectiveMaxInputTokens(config);
+    this.contextManager = new 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);
+    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) => {
+            logger.debug(`Tool call type received: ${toolCall.type}`);
+            return toolCall.type === "function";
+          }
+        );
+        if (message.tool_calls.length > functionToolCalls.length) {
+          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
+            });
+          }
+          logger.debug(`Tool call initiated - Type: ${toolCall.type}`);
+          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) {
+            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);
+            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
+            });
+          }
+        }
+      }
+      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);
+      logger.error(`Error in ${context}: ${errorMessage}`, { error });
+      if (!stream) {
+        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 = getMaxInputTokensForModel(
+        this.config.provider,
+        this.config.model
+      );
+    } catch (error) {
+      if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
+        modelMaxInputTokens = configuredMaxInputTokens;
+        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;
+    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 }
+        );
+        logger.silly(
+          `Message history (potentially compressed) in getAIResponseWithRetries: ${JSON.stringify(formattedMessages, null, 2)}`
+        );
+        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
+        );
+        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;
+        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") {
+          logger.warn(
+            `Context length exceeded. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
+          );
+        }
+        if (attempts >= MAX_ATTEMPTS) {
+          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 }
+        );
+        logger.silly(
+          `Streaming message history (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
+        );
+        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 }
+        };
+        logger.debug(`OpenAI streaming completed. Usage info: ${usage}`);
+        return { message, ...usage && { usage } };
+      } catch (error) {
+        const apiError = error;
+        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")) {
+          logger.warn(
+            `Context length exceeded in streaming. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
+          );
+        }
+        if (attempts >= MAX_ATTEMPTS) {
+          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;
+  }
+}
+export {
+  OpenAIService
+};