@dexto/core 1.1.4 → 1.1.6

package/dist/llm/services/vercel.cjs

@@ -0,0 +1,525 @@
+"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 vercel_exports = {};
+__export(vercel_exports, {
+  VercelLLMService: () => VercelLLMService
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_ai = require("ai");
+var import_logger = require("../../logger/index.js");
+var import_ai2 = require("ai");
+var import_manager = require("../../context/manager.js");
+var import_utils = require("../../context/utils.js");
+var import_registry = require("../registry.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_error_codes = require("../error-codes.js");
+var import_types4 = require("../../errors/types.js");
+var import_error_conversion = require("../../utils/error-conversion.js");
+var import_error_codes2 = require("../../tools/error-codes.js");
+var import_vercel = require("../formatters/vercel.js");
+var import_factory = require("../tokenizer/factory.js");
+class VercelLLMService {
+  model;
+  config;
+  toolManager;
+  contextManager;
+  sessionEventBus;
+  sessionId;
+  toolSupportCache = /* @__PURE__ */ new Map();
+  // Map of toolCallId -> queue of raw results to emit with that callId
+  rawResultsByCallId = /* @__PURE__ */ new Map();
+  /**
+   * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
+   */
+  getModelId() {
+    return typeof this.model === "string" ? this.model : this.model.modelId;
+  }
+  constructor(toolManager, model, promptManager, historyProvider, sessionEventBus, config, sessionId) {
+    this.model = model;
+    this.config = config;
+    this.toolManager = toolManager;
+    this.sessionEventBus = sessionEventBus;
+    this.sessionId = sessionId;
+    const formatter = new import_vercel.VercelMessageFormatter();
+    const tokenizer = (0, import_factory.createTokenizer)(config.provider, this.getModelId());
+    const maxInputTokens = (0, import_registry.getEffectiveMaxInputTokens)(config);
+    this.contextManager = new import_manager.ContextManager(
+      config,
+      formatter,
+      promptManager,
+      maxInputTokens,
+      tokenizer,
+      historyProvider,
+      sessionId
+    );
+    import_logger.logger.debug(
+      `[VercelLLMService] Initialized for model: ${this.getModelId()}, provider: ${this.config.provider}, temperature: ${this.config.temperature}, maxOutputTokens: ${this.config.maxOutputTokens}`
+    );
+  }
+  getAllTools() {
+    return this.toolManager.getAllTools();
+  }
+  formatTools(tools) {
+    import_logger.logger.debug(`Formatting tools for vercel`);
+    return Object.keys(tools).reduce((acc, toolName) => {
+      const tool = tools[toolName];
+      if (tool) {
+        acc[toolName] = {
+          inputSchema: (0, import_ai2.jsonSchema)(tool.parameters),
+          execute: async (args, options) => {
+            try {
+              const rawResult = await this.toolManager.executeTool(
+                toolName,
+                args,
+                this.sessionId
+              );
+              const callId = options.toolCallId;
+              const queue = this.rawResultsByCallId.get(callId) ?? [];
+              queue.push(rawResult);
+              this.rawResultsByCallId.set(callId, queue);
+              const safeContent = (0, import_utils.sanitizeToolResultToContent)(rawResult);
+              const summaryText = (0, import_utils.summarizeToolContentForText)(safeContent);
+              return summaryText;
+            } catch (err) {
+              if (err instanceof import_DextoRuntimeError.DextoRuntimeError && err.code === import_error_codes2.ToolErrorCode.EXECUTION_DENIED) {
+                return { error: err.message, denied: true };
+              }
+              if (err instanceof import_DextoRuntimeError.DextoRuntimeError && err.code === import_error_codes2.ToolErrorCode.CONFIRMATION_TIMEOUT) {
+                return { error: err.message, denied: true, timeout: true };
+              }
+              const message = err instanceof Error ? err.message : String(err);
+              return { error: message };
+            }
+          },
+          ...tool.description && { description: tool.description }
+        };
+      }
+      return acc;
+    }, {});
+  }
+  async validateToolSupport() {
+    const modelKey = `${this.config.provider}:${this.getModelId()}:${this.config.baseURL ?? ""}`;
+    if (this.toolSupportCache.has(modelKey)) {
+      return this.toolSupportCache.get(modelKey);
+    }
+    if (!this.config.baseURL) {
+      import_logger.logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
+      this.toolSupportCache.set(modelKey, true);
+      return true;
+    }
+    import_logger.logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
+    const testTool = {
+      test_tool: {
+        inputSchema: (0, import_ai2.jsonSchema)({
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }),
+        execute: async () => ({ result: "test" })
+      }
+    };
+    try {
+      await (0, import_ai.generateText)({
+        model: this.model,
+        messages: [{ role: "user", content: "Hello" }],
+        tools: testTool,
+        stopWhen: (0, import_ai.stepCountIs)(1)
+      });
+      this.toolSupportCache.set(modelKey, true);
+      import_logger.logger.debug(`Model ${modelKey} supports tools`);
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("does not support tools")) {
+        this.toolSupportCache.set(modelKey, false);
+        import_logger.logger.debug(`Model ${modelKey} does not support tools`);
+        return false;
+      }
+      import_logger.logger.debug(
+        `Tool validation error for ${modelKey}, assuming supported: ${errorMessage}`
+      );
+      this.toolSupportCache.set(modelKey, true);
+      return true;
+    }
+  }
+  async completeTask(textInput, options, imageData, fileData, stream) {
+    import_logger.logger.debug(
+      `[VercelLLMService] addUserMessage(text ~${textInput.length} chars, image=${Boolean(
+        imageData
+      )}, file=${Boolean(fileData)})`
+    );
+    await this.contextManager.addUserMessage(textInput, imageData, fileData);
+    const tools = await this.toolManager.getAllTools();
+    import_logger.logger.silly(
+      `[VercelLLMService] Tools before formatting: ${JSON.stringify(tools, null, 2)}`
+    );
+    const formattedTools = this.formatTools(tools);
+    import_logger.logger.silly(
+      `[VercelLLMService] Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`
+    );
+    let fullResponse = "";
+    this.sessionEventBus.emit("llmservice:thinking");
+    const prepared = await this.contextManager.getFormattedMessagesWithCompression(
+      { mcpManager: this.toolManager.getMcpManager() },
+      { provider: this.config.provider, model: this.getModelId() }
+    );
+    const formattedMessages = prepared.formattedMessages;
+    const tokensUsed = prepared.tokensUsed;
+    import_logger.logger.silly(
+      `Messages (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
+    );
+    import_logger.logger.silly(`Tools: ${JSON.stringify(formattedTools, null, 2)}`);
+    import_logger.logger.debug(`Estimated tokens being sent to Vercel provider: ${tokensUsed}`);
+    if (stream) {
+      fullResponse = await this.streamText(
+        formattedMessages,
+        formattedTools,
+        this.config.maxIterations,
+        options?.signal
+      );
+    } else {
+      fullResponse = await this.generateText(
+        formattedMessages,
+        formattedTools,
+        this.config.maxIterations,
+        options?.signal
+      );
+    }
+    if (options?.signal?.aborted) {
+      return fullResponse;
+    }
+    return fullResponse || `Reached maximum number of steps (${this.config.maxIterations}) without a final response.`;
+  }
+  async generateText(messages, tools, maxSteps = 50, signal) {
+    let stepIteration = 0;
+    const estimatedTokens = Math.ceil(JSON.stringify(messages, null, 2).length / 4);
+    import_logger.logger.debug(
+      `vercel generateText:Generating text with messages (${estimatedTokens} estimated tokens)`
+    );
+    const temperature = this.config.temperature;
+    const maxOutputTokens = this.config.maxOutputTokens;
+    const supportsTools = await this.validateToolSupport();
+    const effectiveTools = supportsTools ? tools : {};
+    if (!supportsTools && Object.keys(tools).length > 0) {
+      import_logger.logger.debug(
+        `Model ${this.getModelId()} does not support tools, using empty tools object for generation`
+      );
+    }
+    try {
+      const includeMaxOutputTokens = typeof maxOutputTokens === "number";
+      const response = await (0, import_ai.generateText)({
+        model: this.model,
+        messages,
+        tools: effectiveTools,
+        ...signal ? { abortSignal: signal } : {},
+        onStepFinish: (step) => {
+          import_logger.logger.debug(`Step iteration: ${stepIteration}`);
+          stepIteration++;
+          import_logger.logger.debug(`Step finished, text: ${step.text}`);
+          import_logger.logger.debug(
+            `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
+          );
+          import_logger.logger.debug(
+            `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
+          );
+          if (step.toolCalls && step.toolCalls.length > 0) {
+            for (const toolCall of step.toolCalls) {
+              this.sessionEventBus.emit("llmservice:toolCall", {
+                toolName: toolCall.toolName,
+                args: toolCall.input,
+                callId: toolCall.toolCallId
+              });
+            }
+          }
+          if (step.toolResults && step.toolResults.length > 0) {
+            for (const toolResult of step.toolResults) {
+              const callId = toolResult.toolCallId;
+              const sanitized = toolResult.output;
+              let raw;
+              if (callId) {
+                const q = this.rawResultsByCallId.get(callId) ?? [];
+                raw = q.shift();
+                if (q.length > 0) this.rawResultsByCallId.set(callId, q);
+                else this.rawResultsByCallId.delete(callId);
+              }
+              this.sessionEventBus.emit("llmservice:toolResult", {
+                toolName: toolResult.toolName,
+                result: raw ?? sanitized,
+                callId,
+                success: true
+              });
+            }
+          }
+        },
+        stopWhen: (0, import_ai.stepCountIs)(maxSteps),
+        ...includeMaxOutputTokens ? { maxOutputTokens } : {},
+        ...temperature !== void 0 && { temperature }
+      });
+      this.sessionEventBus.emit("llmservice:response", {
+        content: response.text,
+        ...response.reasoningText && { reasoning: response.reasoningText },
+        provider: this.config.provider,
+        model: this.getModelId(),
+        router: "vercel",
+        tokenUsage: {
+          ...response.totalUsage.inputTokens !== void 0 && {
+            inputTokens: response.totalUsage.inputTokens
+          },
+          ...response.totalUsage.outputTokens !== void 0 && {
+            outputTokens: response.totalUsage.outputTokens
+          },
+          ...response.totalUsage.reasoningTokens !== void 0 && {
+            reasoningTokens: response.totalUsage.reasoningTokens
+          },
+          ...response.totalUsage.totalTokens !== void 0 && {
+            totalTokens: response.totalUsage.totalTokens
+          }
+        }
+      });
+      await this.contextManager.processLLMResponse(response);
+      if (typeof response.totalUsage.totalTokens === "number") {
+        this.contextManager.updateActualTokenCount(response.totalUsage.totalTokens);
+      }
+      return response.text;
+    } catch (err) {
+      this.mapProviderError(err, "generate");
+    }
+  }
+  mapProviderError(err, phase) {
+    if (import_ai.APICallError.isInstance?.(err)) {
+      const status = err.statusCode;
+      const headers = err.responseHeaders || {};
+      const retryAfter = headers["retry-after"] ? Number(headers["retry-after"]) : void 0;
+      const body = typeof err.responseBody === "string" ? err.responseBody : JSON.stringify(err.responseBody ?? "");
+      if (status === 429) {
+        throw new import_DextoRuntimeError.DextoRuntimeError(
+          import_error_codes.LLMErrorCode.RATE_LIMIT_EXCEEDED,
+          import_types4.ErrorScope.LLM,
+          import_types4.ErrorType.RATE_LIMIT,
+          `Rate limit exceeded${body ? ` - ${body}` : ""}`,
+          {
+            sessionId: this.sessionId,
+            provider: this.config.provider,
+            model: this.getModelId(),
+            status,
+            retryAfter,
+            body,
+            phase
+          }
+        );
+      }
+      if (status === 408) {
+        throw new import_DextoRuntimeError.DextoRuntimeError(
+          import_error_codes.LLMErrorCode.GENERATION_FAILED,
+          import_types4.ErrorScope.LLM,
+          import_types4.ErrorType.TIMEOUT,
+          `Provider timed out${body ? ` - ${body}` : ""}`,
+          {
+            sessionId: this.sessionId,
+            provider: this.config.provider,
+            model: this.getModelId(),
+            status,
+            body,
+            phase
+          }
+        );
+      }
+      throw new import_DextoRuntimeError.DextoRuntimeError(
+        import_error_codes.LLMErrorCode.GENERATION_FAILED,
+        import_types4.ErrorScope.LLM,
+        import_types4.ErrorType.THIRD_PARTY,
+        `Provider error ${status}${body ? ` - ${body}` : ""}`,
+        {
+          sessionId: this.sessionId,
+          provider: this.config.provider,
+          model: this.getModelId(),
+          status,
+          body,
+          phase
+        }
+      );
+    }
+    throw err;
+  }
+  // Updated streamText to behave like generateText - returns string and handles message processing internally
+  async streamText(messages, tools, maxSteps = 10, signal) {
+    let stepIteration = 0;
+    const temperature = this.config.temperature;
+    const maxOutputTokens = this.config.maxOutputTokens;
+    const supportsTools = await this.validateToolSupport();
+    const effectiveTools = supportsTools ? tools : {};
+    if (!supportsTools && Object.keys(tools).length > 0) {
+      import_logger.logger.debug(
+        `Model ${this.getModelId()} does not support tools, using empty tools object for streaming`
+      );
+    }
+    let streamErr;
+    const includeMaxOutputTokens = typeof maxOutputTokens === "number";
+    const response = (0, import_ai.streamText)({
+      model: this.model,
+      messages,
+      tools: effectiveTools,
+      ...signal ? { abortSignal: signal } : {},
+      onChunk: (chunk) => {
+        import_logger.logger.debug(`Chunk type: ${chunk.chunk.type}`);
+        if (chunk.chunk.type === "text-delta") {
+          this.sessionEventBus.emit("llmservice:chunk", {
+            type: "text",
+            content: chunk.chunk.text,
+            isComplete: false
+          });
+        } else if (chunk.chunk.type === "reasoning-delta") {
+          this.sessionEventBus.emit("llmservice:chunk", {
+            type: "reasoning",
+            content: chunk.chunk.text,
+            isComplete: false
+          });
+        }
+      },
+      // TODO: Add onAbort handler when we implement partial response handling.
+      // Vercel triggers onAbort instead of onError for cancelled streams.
+      // This is where cancellation logic should be handled properly.
+      onError: (error) => {
+        const err = (0, import_error_conversion.toError)(error);
+        import_logger.logger.error(`Error in streamText: ${err?.stack ?? err}`, null, "red");
+        this.sessionEventBus.emit("llmservice:error", {
+          error: err,
+          context: "streamText",
+          recoverable: false
+        });
+        streamErr = error;
+      },
+      onStepFinish: (step) => {
+        import_logger.logger.debug(`Step iteration: ${stepIteration}`);
+        stepIteration++;
+        import_logger.logger.debug(`Step finished, text: ${step.text}`);
+        import_logger.logger.debug(
+          `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
+        );
+        import_logger.logger.debug(
+          `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
+        );
+        if (step.toolCalls && step.toolCalls.length > 0) {
+          for (const toolCall of step.toolCalls) {
+            this.sessionEventBus.emit("llmservice:toolCall", {
+              toolName: toolCall.toolName,
+              args: toolCall.input,
+              callId: toolCall.toolCallId
+            });
+          }
+        }
+        if (step.toolResults && step.toolResults.length > 0) {
+          for (const toolResult of step.toolResults) {
+            const callId = toolResult.toolCallId;
+            const sanitized = toolResult.output;
+            let raw;
+            if (callId) {
+              const q = this.rawResultsByCallId.get(callId) ?? [];
+              raw = q.shift();
+              if (q.length > 0) this.rawResultsByCallId.set(callId, q);
+              else this.rawResultsByCallId.delete(callId);
+            }
+            this.sessionEventBus.emit("llmservice:toolResult", {
+              toolName: toolResult.toolName,
+              result: raw ?? sanitized,
+              callId,
+              success: true
+            });
+          }
+        }
+      },
+      // No onFinish: we finalize after the stream completes below.
+      stopWhen: (0, import_ai.stepCountIs)(maxSteps),
+      ...includeMaxOutputTokens ? { maxOutputTokens } : {},
+      ...temperature !== void 0 && { temperature }
+    });
+    const [finalText, usage, reasoningText] = await Promise.all([
+      response.text,
+      response.totalUsage,
+      response.reasoningText
+    ]);
+    response.totalUsage;
+    if (streamErr) {
+      return "";
+    }
+    this.sessionEventBus.emit("llmservice:response", {
+      content: finalText,
+      ...reasoningText && { reasoning: reasoningText },
+      provider: this.config.provider,
+      model: this.getModelId(),
+      router: "vercel",
+      tokenUsage: {
+        ...usage.inputTokens !== void 0 && { inputTokens: usage.inputTokens },
+        ...usage.outputTokens !== void 0 && { outputTokens: usage.outputTokens },
+        ...usage.reasoningTokens !== void 0 && {
+          reasoningTokens: usage.reasoningTokens
+        },
+        ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
+      }
+    });
+    if (typeof usage.totalTokens === "number") {
+      this.contextManager.updateActualTokenCount(usage.totalTokens);
+    }
+    await this.contextManager.processLLMStreamResponse(response);
+    import_logger.logger.silly(`streamText response object: ${JSON.stringify(response, null, 2)}`);
+    return finalText;
+  }
+  /**
+   * Get configuration information about the LLM service
+   * @returns Configuration object with provider and model information
+   */
+  getConfig() {
+    const configuredMaxTokens = this.contextManager.getMaxInputTokens();
+    let modelMaxInputTokens;
+    try {
+      modelMaxInputTokens = (0, import_registry.getMaxInputTokensForModel)(
+        this.config.provider,
+        // Use our internal provider name
+        this.getModelId()
+      );
+    } catch (error) {
+      if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
+        modelMaxInputTokens = configuredMaxTokens;
+        import_logger.logger.debug(
+          `Could not find model ${this.getModelId()} in LLM registry to get max tokens. Using configured max tokens: ${configuredMaxTokens}.`
+        );
+      } else {
+        throw error;
+      }
+    }
+    return {
+      router: "vercel",
+      provider: this.config.provider,
+      // Use our internal provider name
+      model: this.model,
+      configuredMaxInputTokens: configuredMaxTokens,
+      modelMaxInputTokens
+    };
+  }
+  /**
+   * Get the context manager for external access
+   */
+  getContextManager() {
+    return this.contextManager;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VercelLLMService
+});

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

@@ -0,0 +1,72 @@
+import { LanguageModel, ToolSet as ToolSet$1, ModelMessage } from 'ai';
+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 '../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';
+
+/**
+ * Vercel AI SDK implementation of LLMService
+ * TODO: improve token counting logic across all LLM services - approximation isn't matching vercel actual token count properly
+ */
+declare class VercelLLMService implements ILLMService {
+    private model;
+    private config;
+    private toolManager;
+    private contextManager;
+    private sessionEventBus;
+    private readonly sessionId;
+    private toolSupportCache;
+    private rawResultsByCallId;
+    /**
+     * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
+     */
+    private getModelId;
+    constructor(toolManager: ToolManager, model: LanguageModel, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, config: ValidatedLLMConfig, sessionId: string);
+    getAllTools(): Promise<ToolSet>;
+    formatTools(tools: ToolSet): ToolSet$1;
+    private validateToolSupport;
+    completeTask(textInput: string, options: {
+        signal?: AbortSignal;
+    }, imageData?: ImageData, fileData?: FileData, stream?: boolean): Promise<string>;
+    generateText(messages: ModelMessage[], tools: ToolSet$1, maxSteps?: number, signal?: AbortSignal): Promise<string>;
+    private mapProviderError;
+    streamText(messages: ModelMessage[], tools: ToolSet$1, maxSteps?: number, signal?: AbortSignal): Promise<string>;
+    /**
+     * Get configuration information about the LLM service
+     * @returns Configuration object with provider and model information
+     */
+    getConfig(): LLMServiceConfig;
+    /**
+     * Get the context manager for external access
+     */
+    getContextManager(): ContextManager<unknown>;
+}
+
+export { VercelLLMService };

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

@@ -0,0 +1,72 @@
+import { LanguageModel, ToolSet as ToolSet$1, ModelMessage } from 'ai';
+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 '../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';
+
+/**
+ * Vercel AI SDK implementation of LLMService
+ * TODO: improve token counting logic across all LLM services - approximation isn't matching vercel actual token count properly
+ */
+declare class VercelLLMService implements ILLMService {
+    private model;
+    private config;
+    private toolManager;
+    private contextManager;
+    private sessionEventBus;
+    private readonly sessionId;
+    private toolSupportCache;
+    private rawResultsByCallId;
+    /**
+     * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
+     */
+    private getModelId;
+    constructor(toolManager: ToolManager, model: LanguageModel, promptManager: PromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, config: ValidatedLLMConfig, sessionId: string);
+    getAllTools(): Promise<ToolSet>;
+    formatTools(tools: ToolSet): ToolSet$1;
+    private validateToolSupport;
+    completeTask(textInput: string, options: {
+        signal?: AbortSignal;
+    }, imageData?: ImageData, fileData?: FileData, stream?: boolean): Promise<string>;
+    generateText(messages: ModelMessage[], tools: ToolSet$1, maxSteps?: number, signal?: AbortSignal): Promise<string>;
+    private mapProviderError;
+    streamText(messages: ModelMessage[], tools: ToolSet$1, maxSteps?: number, signal?: AbortSignal): Promise<string>;
+    /**
+     * Get configuration information about the LLM service
+     * @returns Configuration object with provider and model information
+     */
+    getConfig(): LLMServiceConfig;
+    /**
+     * Get the context manager for external access
+     */
+    getContextManager(): ContextManager<unknown>;
+}
+
+export { VercelLLMService };