@dexto/core 1.1.4 → 1.1.6

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

@@ -0,0 +1,65 @@
+import Anthropic from '@anthropic-ai/sdk';
+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';
+
+/**
+ * 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 };

package/dist/llm/services/anthropic.js

@@ -0,0 +1,374 @@
+import { logger } from "../../logger/index.js";
+import { ContextManager } from "../../context/manager.js";
+import { getMaxInputTokensForModel, getEffectiveMaxInputTokens } from "../registry.js";
+import { AnthropicMessageFormatter } from "../formatters/anthropic.js";
+import { createTokenizer } from "../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 AnthropicMessageFormatter();
+    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.formatToolsForClaude(rawTools);
+    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++;
+        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);
+        logger.debug(`Messages: ${JSON.stringify(formattedMessages, null, 2)}`);
+        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);
+            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
+            });
+          }
+        }
+      }
+      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);
+      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 = 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 {
+          logger.warn(
+            `Unexpected parameters format for tool ${toolName}:`,
+            jsonSchemaParams
+          );
+        }
+      } else {
+        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 {
+              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;
+  }
+}
+export {
+  AnthropicService
+};

package/dist/llm/services/factory.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  createLLMService: () => createLLMService
+});
+module.exports = __toCommonJS(factory_exports);
+var import_errors = require("../errors.js");
+var import_openai = require("@ai-sdk/openai");
+var import_google = require("@ai-sdk/google");
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_groq = require("@ai-sdk/groq");
+var import_xai = require("@ai-sdk/xai");
+var import_vercel = require("./vercel.js");
+var import_openai2 = require("./openai.js");
+var import_anthropic2 = require("./anthropic.js");
+var import_cohere = require("@ai-sdk/cohere");
+var import_openai3 = __toESM(require("openai"), 1);
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+function _createInBuiltLLMService(config, toolManager, promptManager, historyProvider, sessionEventBus, sessionId) {
+  const apiKey = config.apiKey;
+  switch (config.provider.toLowerCase()) {
+    case "openai": {
+      const openai = new import_openai3.default({ apiKey });
+      return new import_openai2.OpenAIService(
+        toolManager,
+        openai,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    case "openai-compatible": {
+      const baseURL = getOpenAICompatibleBaseURL(config);
+      const openai = new import_openai3.default({ apiKey, baseURL });
+      return new import_openai2.OpenAIService(
+        toolManager,
+        openai,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    case "anthropic": {
+      const anthropic = new import_sdk.default({ apiKey });
+      return new import_anthropic2.AnthropicService(
+        toolManager,
+        anthropic,
+        promptManager,
+        historyProvider,
+        sessionEventBus,
+        config,
+        sessionId
+      );
+    }
+    default:
+      throw import_errors.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 (0, import_openai.createOpenAI)({ apiKey })(model);
+    }
+    case "openai-compatible": {
+      const baseURL = getOpenAICompatibleBaseURL(llmConfig);
+      if (!baseURL) {
+        throw import_errors.LLMError.baseUrlMissing("openai-compatible");
+      }
+      return (0, import_openai.createOpenAI)({ apiKey, baseURL })(model);
+    }
+    case "anthropic":
+      return (0, import_anthropic.createAnthropic)({ apiKey })(model);
+    case "google":
+      return (0, import_google.createGoogleGenerativeAI)({ apiKey })(model);
+    case "groq":
+      return (0, import_groq.createGroq)({ apiKey })(model);
+    case "xai":
+      return (0, import_xai.createXai)({ apiKey })(model);
+    case "cohere":
+      return (0, import_cohere.createCohere)({ apiKey })(model);
+    default:
+      throw import_errors.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 import_vercel.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
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLLMService
+});

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

@@ -0,0 +1,39 @@
+import { ToolManager } from '../../tools/tool-manager.cjs';
+import { ILLMService } from './types.cjs';
+import { ValidatedLLMConfig } from '../schemas.cjs';
+import { SessionEventBus } from '../../events/index.cjs';
+import { LLMRouter } from '../types.cjs';
+import { IConversationHistoryProvider } from '../../session/history/types.cjs';
+import { PromptManager } from '../../systemPrompt/manager.cjs';
+import '../../mcp/manager.cjs';
+import '../../mcp/schemas.cjs';
+import 'zod';
+import '../../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '../../tools/types.cjs';
+import 'json-schema';
+import '@modelcontextprotocol/sdk/types.js';
+import '../../tools/internal-tools/registry.cjs';
+import '../../search/search-service.cjs';
+import '../../storage/backend/database-backend.cjs';
+import '../../search/types.cjs';
+import '../../context/types.cjs';
+import '../../tools/schemas.cjs';
+import '../../tools/confirmation/types.cjs';
+import '../../tools/confirmation/allowed-tools-provider/types.cjs';
+import 'ai';
+import '../../context/manager.cjs';
+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';
+
+/**
+ * Enum/type for LLM routing backend selection.
+ */
+declare function createLLMService(config: ValidatedLLMConfig, router: LLMRouter, toolManager: ToolManager, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, sessionId: string): ILLMService;
+
+export { createLLMService };

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

@@ -0,0 +1,39 @@
+import { ToolManager } from '../../tools/tool-manager.js';
+import { ILLMService } from './types.js';
+import { ValidatedLLMConfig } from '../schemas.js';
+import { SessionEventBus } from '../../events/index.js';
+import { LLMRouter } from '../types.js';
+import { IConversationHistoryProvider } from '../../session/history/types.js';
+import { PromptManager } from '../../systemPrompt/manager.js';
+import '../../mcp/manager.js';
+import '../../mcp/schemas.js';
+import 'zod';
+import '../../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '../../tools/types.js';
+import 'json-schema';
+import '@modelcontextprotocol/sdk/types.js';
+import '../../tools/internal-tools/registry.js';
+import '../../search/search-service.js';
+import '../../storage/backend/database-backend.js';
+import '../../search/types.js';
+import '../../context/types.js';
+import '../../tools/schemas.js';
+import '../../tools/confirmation/types.js';
+import '../../tools/confirmation/allowed-tools-provider/types.js';
+import 'ai';
+import '../../context/manager.js';
+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';
+
+/**
+ * Enum/type for LLM routing backend selection.
+ */
+declare function createLLMService(config: ValidatedLLMConfig, router: LLMRouter, toolManager: ToolManager, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, sessionId: string): ILLMService;
+
+export { createLLMService };