@dexto/core 1.1.4 → 1.1.6

package/dist/llm/schemas.js

@@ -0,0 +1,172 @@
+import { LLMErrorCode } from "./error-codes.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { DextoRuntimeError } from "../errors/index.js";
+import { NonEmptyTrimmed, EnvExpandedString, OptionalURL } from "../utils/result.js";
+import { getPrimaryApiKeyEnvVar } from "../utils/api-key-resolver.js";
+import { z } from "zod";
+import {
+  supportsBaseURL,
+  requiresBaseURL,
+  acceptsAnyModel,
+  getSupportedModels,
+  isValidProviderModel,
+  getMaxInputTokensForModel,
+  isRouterSupportedForModel,
+  getSupportedRoutersForModel
+} from "./registry.js";
+import { LLM_PROVIDERS, LLM_ROUTERS } from "./types.js";
+const LLMConfigFields = {
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider (e.g., 'openai', 'anthropic', 'google', 'groq')"),
+  model: NonEmptyTrimmed.describe("Specific model name for the selected provider"),
+  // Expand $ENV refs and trim; final validation happens with provider context
+  apiKey: EnvExpandedString().describe(
+    "API key for provider; can be given directly or via $ENV reference"
+  ),
+  maxIterations: z.coerce.number().int().positive().describe("Max iterations for agentic loops"),
+  router: z.enum(LLM_ROUTERS).describe("Router to use (vercel | in-built)"),
+  baseURL: OptionalURL.describe(
+    "Base URL for provider (e.g., https://api.openai.com/v1). Only certain providers support this."
+  ),
+  maxInputTokens: z.coerce.number().int().positive().optional().describe("Max input tokens for history; required for unknown models"),
+  maxOutputTokens: z.coerce.number().int().positive().optional().describe("Max tokens for model output"),
+  temperature: z.coerce.number().min(0).max(1).optional().describe("Randomness: 0 deterministic, 1 creative")
+};
+const LLMConfigSchema = z.object({
+  provider: LLMConfigFields.provider,
+  model: LLMConfigFields.model,
+  apiKey: LLMConfigFields.apiKey,
+  // Apply defaults only for complete config validation
+  maxIterations: z.coerce.number().int().positive().default(50),
+  router: z.enum(LLM_ROUTERS).default("vercel"),
+  baseURL: LLMConfigFields.baseURL,
+  maxInputTokens: LLMConfigFields.maxInputTokens,
+  maxOutputTokens: LLMConfigFields.maxOutputTokens,
+  temperature: LLMConfigFields.temperature
+}).strict().superRefine((data, ctx) => {
+  const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
+  const maxInputTokensIsSet = data.maxInputTokens != null;
+  if (!data.apiKey?.trim()) {
+    const primaryVar = getPrimaryApiKeyEnvVar(data.provider);
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["apiKey"],
+      message: `Missing API key for provider '${data.provider}' \u2013 set $${primaryVar}`,
+      params: {
+        code: LLMErrorCode.API_KEY_MISSING,
+        scope: ErrorScope.LLM,
+        type: ErrorType.USER,
+        provider: data.provider,
+        envVar: primaryVar
+      }
+    });
+  }
+  if (baseURLIsSet) {
+    if (!supportsBaseURL(data.provider)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["provider"],
+        message: `Provider '${data.provider}' does not support baseURL. Use an 'openai-compatible' provider if you need a custom base URL.`,
+        params: {
+          code: LLMErrorCode.BASE_URL_INVALID,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
+    }
+  } else if (requiresBaseURL(data.provider)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["baseURL"],
+      message: `Provider '${data.provider}' requires a 'baseURL'.`,
+      params: {
+        code: LLMErrorCode.BASE_URL_MISSING,
+        scope: ErrorScope.LLM,
+        type: ErrorType.USER
+      }
+    });
+  } else {
+    if (!acceptsAnyModel(data.provider)) {
+      const supportedModelsList = getSupportedModels(data.provider);
+      if (!isValidProviderModel(data.provider, data.model)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["model"],
+          message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
+          params: {
+            code: LLMErrorCode.MODEL_INCOMPATIBLE,
+            scope: ErrorScope.LLM,
+            type: ErrorType.USER
+          }
+        });
+      }
+    }
+    if (maxInputTokensIsSet && !acceptsAnyModel(data.provider)) {
+      try {
+        const cap = getMaxInputTokensForModel(data.provider, data.model);
+        if (data.maxInputTokens > cap) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["maxInputTokens"],
+            message: `Max input tokens for model '${data.model}' is ${cap}. You provided ${data.maxInputTokens}`,
+            params: {
+              code: LLMErrorCode.TOKENS_EXCEEDED,
+              scope: ErrorScope.LLM,
+              type: ErrorType.USER
+            }
+          });
+        }
+      } catch (error) {
+        if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["model"],
+            message: error.message,
+            params: {
+              code: error.code,
+              scope: error.scope,
+              type: error.type
+            }
+          });
+        } else {
+          const message = error instanceof Error ? error.message : "Unknown error occurred";
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["model"],
+            message,
+            params: {
+              code: LLMErrorCode.REQUEST_INVALID_SCHEMA,
+              scope: ErrorScope.LLM,
+              type: ErrorType.SYSTEM
+            }
+          });
+        }
+      }
+    }
+  }
+  if (!isRouterSupportedForModel(data.provider, data.model, data.router)) {
+    const supportedRouters = getSupportedRoutersForModel(data.provider, data.model);
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["router"],
+      message: `Model '${data.model}' (${data.provider}) does not support router '${data.router}'. Supported: ${supportedRouters.join(", ")}`,
+      params: {
+        code: LLMErrorCode.ROUTER_UNSUPPORTED,
+        scope: ErrorScope.LLM,
+        type: ErrorType.USER
+      }
+    });
+  }
+}).brand();
+const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().strict().superRefine((data, ctx) => {
+  if (!data.model && !data.provider && !data.router) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "At least model, provider, or router must be specified for LLM switch",
+      path: []
+    });
+  }
+});
+export {
+  LLMConfigSchema,
+  LLMUpdatesSchema
+};

package/dist/llm/services/anthropic.cjs

@@ -0,0 +1,398 @@
+"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, {
+  AnthropicService: () => AnthropicService
+});
+module.exports = __toCommonJS(anthropic_exports);
+var import_logger = require("../../logger/index.js");
+var import_manager = require("../../context/manager.js");
+var import_registry = require("../registry.js");
+var import_anthropic = require("../formatters/anthropic.js");
+var import_factory = require("../tokenizer/factory.js");
+class AnthropicService {
+  anthropic;
+  config;
+  toolManager;
+  contextManager;
+  sessionEventBus;
+  sessionId;
+  constructor(toolManager, anthropic, promptManager, historyProvider, sessionEventBus, config, sessionId) {
+    this.config = config;
+    this.anthropic = anthropic;
+    this.toolManager = toolManager;
+    this.sessionEventBus = sessionEventBus;
+    this.sessionId = sessionId;
+    const formatter = new import_anthropic.AnthropicMessageFormatter();
+    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.formatToolsForClaude(rawTools);
+    import_logger.logger.silly(`Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`);
+    this.sessionEventBus.emit("llmservice:thinking");
+    let iterationCount = 0;
+    let fullResponse = "";
+    let totalTokens = 0;
+    try {
+      while (iterationCount < this.config.maxIterations) {
+        if (options?.signal?.aborted) {
+          throw Object.assign(new Error("Aborted"), {
+            name: "AbortError",
+            aborted: true
+          });
+        }
+        iterationCount++;
+        import_logger.logger.debug(`Iteration ${iterationCount}`);
+        const contributorContext = {
+          mcpManager: this.toolManager.getMcpManager()
+        };
+        const llmContext = {
+          provider: this.config.provider,
+          model: this.config.model
+        };
+        const {
+          formattedMessages,
+          systemPrompt: _systemPrompt,
+          tokensUsed
+        } = await this.contextManager.getFormattedMessagesWithCompression(
+          contributorContext,
+          llmContext
+        );
+        const formattedSystemPrompt = await this.contextManager.getFormattedSystemPrompt(contributorContext);
+        import_logger.logger.debug(`Messages: ${JSON.stringify(formattedMessages, null, 2)}`);
+        import_logger.logger.debug(`Estimated tokens being sent to Anthropic: ${tokensUsed}`);
+        const { message, usage } = stream ? await this.getAnthropicStreamingResponse(
+          formattedMessages,
+          formattedSystemPrompt || null,
+          formattedTools,
+          options?.signal
+        ) : await this.getAnthropicResponse(
+          formattedMessages,
+          formattedSystemPrompt || null,
+          formattedTools,
+          options?.signal
+        );
+        if (usage) {
+          totalTokens += usage.input_tokens + usage.output_tokens;
+        }
+        let textContent = "";
+        const toolUses = [];
+        for (const content of message.content) {
+          if (content.type === "text") {
+            textContent += content.text;
+          } else if (content.type === "tool_use") {
+            toolUses.push(content);
+          }
+        }
+        if (toolUses.length > 0) {
+          const formattedToolCalls = toolUses.map((toolUse) => ({
+            id: toolUse.id,
+            type: "function",
+            function: {
+              name: toolUse.name,
+              arguments: JSON.stringify(toolUse.input)
+            }
+          }));
+          await this.contextManager.addAssistantMessage(textContent, formattedToolCalls, {
+            tokenUsage: totalTokens > 0 ? { totalTokens } : void 0
+          });
+        } else {
+          await this.contextManager.addAssistantMessage(textContent, void 0, {
+            tokenUsage: totalTokens > 0 ? { totalTokens } : void 0
+          });
+        }
+        if (toolUses.length === 0) {
+          fullResponse += textContent;
+          if (totalTokens > 0) {
+            this.contextManager.updateActualTokenCount(totalTokens);
+          }
+          this.sessionEventBus.emit("llmservice:response", {
+            content: fullResponse,
+            provider: this.config.provider,
+            model: this.config.model,
+            router: "in-built",
+            ...totalTokens > 0 && { tokenUsage: { totalTokens } }
+          });
+          return fullResponse;
+        }
+        if (textContent) {
+          fullResponse += textContent + "\n";
+        }
+        for (const toolUse of toolUses) {
+          if (options?.signal?.aborted) {
+            throw Object.assign(new Error("Aborted"), {
+              name: "AbortError",
+              aborted: true
+            });
+          }
+          const toolName = toolUse.name;
+          const args = toolUse.input;
+          const toolUseId = toolUse.id;
+          this.sessionEventBus.emit("llmservice:toolCall", {
+            toolName,
+            args,
+            callId: toolUseId
+          });
+          try {
+            const result = await this.toolManager.executeTool(
+              toolName,
+              args,
+              this.sessionId
+            );
+            await this.contextManager.addToolResult(toolUseId, toolName, result);
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName,
+              result,
+              callId: toolUseId,
+              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(toolUseId, toolName, {
+              error: errorMessage
+            });
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName,
+              result: { error: errorMessage },
+              callId: toolUseId,
+              success: false
+            });
+          }
+        }
+      }
+      import_logger.logger.warn(`Reached maximum iterations (${this.config.maxIterations}) for task.`);
+      if (totalTokens > 0) {
+        this.contextManager.updateActualTokenCount(totalTokens);
+      }
+      this.sessionEventBus.emit("llmservice:response", {
+        content: fullResponse,
+        provider: this.config.provider,
+        model: this.config.model,
+        router: "in-built",
+        ...totalTokens > 0 && { tokenUsage: { totalTokens } }
+      });
+      return fullResponse || "Reached maximum number of tool call iterations without a final response.";
+    } 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 Anthropic service API call: ${errorMessage}`, { error });
+      this.sessionEventBus.emit("llmservice:error", {
+        error: error instanceof Error ? error : new Error(errorMessage),
+        context: "Anthropic API call",
+        recoverable: false
+      });
+      return `Error processing request: ${errorMessage}`;
+    }
+  }
+  /**
+   * Get configuration information about the LLM service
+   * @returns Configuration object with provider and model information
+   */
+  getConfig() {
+    const configuredMaxInputTokens = this.contextManager.getMaxInputTokens();
+    const modelMaxInputTokens = (0, import_registry.getMaxInputTokensForModel)(
+      this.config.provider,
+      this.config.model
+    );
+    return {
+      router: "in-built",
+      provider: this.config.provider,
+      model: this.config.model,
+      configuredMaxInputTokens,
+      modelMaxInputTokens
+    };
+  }
+  formatToolsForClaude(tools) {
+    return Object.entries(tools).map(([toolName, tool]) => {
+      const input_schema = {
+        type: "object",
+        properties: {},
+        required: []
+      };
+      if (tool.parameters) {
+        const jsonSchemaParams = tool.parameters;
+        if (jsonSchemaParams.type === "object" && jsonSchemaParams.properties) {
+          input_schema.properties = jsonSchemaParams.properties;
+          if (Array.isArray(jsonSchemaParams.required)) {
+            input_schema.required = jsonSchemaParams.required;
+          }
+        } else {
+          import_logger.logger.warn(
+            `Unexpected parameters format for tool ${toolName}:`,
+            jsonSchemaParams
+          );
+        }
+      } else {
+        import_logger.logger.debug(`Tool ${toolName} has no defined parameters.`);
+      }
+      return {
+        name: toolName,
+        description: tool.description || "",
+        input_schema
+      };
+    });
+  }
+  async getAnthropicResponse(formattedMessages, formattedSystemPrompt, formattedTools, signal) {
+    const response = await this.anthropic.messages.create(
+      {
+        model: this.config.model,
+        messages: formattedMessages,
+        ...formattedSystemPrompt && { system: formattedSystemPrompt },
+        tools: formattedTools,
+        max_tokens: this.config.maxOutputTokens ?? 4096,
+        ...this.config.temperature !== void 0 && {
+          temperature: this.config.temperature
+        }
+      },
+      signal ? { signal } : void 0
+    );
+    return { message: response, usage: response.usage };
+  }
+  async getAnthropicStreamingResponse(formattedMessages, formattedSystemPrompt, formattedTools, signal) {
+    const stream = await this.anthropic.messages.create(
+      {
+        model: this.config.model,
+        messages: formattedMessages,
+        ...formattedSystemPrompt && { system: formattedSystemPrompt },
+        tools: formattedTools,
+        max_tokens: this.config.maxOutputTokens ?? 4096,
+        ...this.config.temperature !== void 0 && {
+          temperature: this.config.temperature
+        },
+        stream: true
+      },
+      signal ? { signal } : void 0
+    );
+    let content = [];
+    let usage;
+    let textAccumulator = "";
+    let jsonAccumulators = {};
+    for await (const chunk of stream) {
+      if (signal?.aborted) {
+        throw Object.assign(new Error("Aborted"), { name: "AbortError", aborted: true });
+      }
+      if (chunk.type === "content_block_start") {
+        content.push(chunk.content_block);
+        if (chunk.content_block.type === "text") {
+          textAccumulator = "";
+        } else if (chunk.content_block.type === "tool_use") {
+          jsonAccumulators[chunk.index] = "";
+        }
+      } else if (chunk.type === "content_block_delta") {
+        if (chunk.delta.type === "text_delta") {
+          textAccumulator += chunk.delta.text;
+          this.sessionEventBus.emit("llmservice:chunk", {
+            type: "text",
+            content: chunk.delta.text,
+            isComplete: false
+          });
+          const lastContent = content[content.length - 1];
+          if (lastContent && lastContent.type === "text") {
+            lastContent.text = textAccumulator;
+          }
+        } else if (chunk.delta.type === "input_json_delta") {
+          const blockIndex = chunk.index;
+          if (!(blockIndex in jsonAccumulators)) {
+            jsonAccumulators[blockIndex] = "";
+          }
+          jsonAccumulators[blockIndex] += chunk.delta.partial_json || "";
+          const toolContent = content[blockIndex];
+          if (toolContent && toolContent.type === "tool_use") {
+            try {
+              const jsonStr = jsonAccumulators[blockIndex];
+              if (jsonStr) {
+                toolContent.input = JSON.parse(jsonStr);
+              }
+            } catch {
+              import_logger.logger.debug(
+                `Accumulating JSON for tool ${toolContent.name}: ${jsonAccumulators[blockIndex]}`
+              );
+            }
+          }
+        }
+      } else if (chunk.type === "message_delta" && chunk.usage) {
+        usage = {
+          input_tokens: usage?.input_tokens || 0,
+          output_tokens: chunk.usage.output_tokens || 0,
+          cache_creation_input_tokens: usage?.cache_creation_input_tokens || null,
+          cache_read_input_tokens: usage?.cache_read_input_tokens || null,
+          cache_creation: usage?.cache_creation || null,
+          server_tool_use: usage?.server_tool_use || null,
+          service_tier: usage?.service_tier || null
+        };
+      } else if (chunk.type === "message_start" && chunk.message.usage) {
+        usage = chunk.message.usage;
+      }
+    }
+    if (textAccumulator) {
+      this.sessionEventBus.emit("llmservice:chunk", {
+        type: "text",
+        content: "",
+        isComplete: true
+      });
+    }
+    const message = {
+      id: "streaming_response",
+      type: "message",
+      role: "assistant",
+      content,
+      model: this.config.model,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: usage || {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: null,
+        cache_read_input_tokens: null,
+        cache_creation: null,
+        server_tool_use: null,
+        service_tier: null
+      }
+    };
+    return { message, ...usage && { usage } };
+  }
+  /**
+   * Get the context manager for external access
+   */
+  getContextManager() {
+    return this.contextManager;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicService
+});

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

@@ -0,0 +1,65 @@
+import Anthropic from '@anthropic-ai/sdk';
+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';
+
+/**
+ * Anthropic implementation of LLMService
+ * Not actively maintained, so might be buggy or outdated
+ */
+declare class AnthropicService implements ILLMService {
+    private anthropic;
+    private config;
+    private toolManager;
+    private contextManager;
+    private sessionEventBus;
+    private readonly sessionId;
+    constructor(toolManager: ToolManager, anthropic: Anthropic, 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 formatToolsForClaude;
+    private getAnthropicResponse;
+    private getAnthropicStreamingResponse;
+    /**
+     * Get the context manager for external access
+     */
+    getContextManager(): ContextManager<unknown>;
+}
+
+export { AnthropicService };