@dexto/core 1.2.6 → 1.4.0

package/dist/llm/services/anthropic.js

@@ -1,447 +0,0 @@
-import {
-  __decorateElement,
-  __decoratorStart,
-  __runInitializers
-} from "../../chunk-C6A6W6XS.js";
-var _AnthropicService_decorators, _init;
-import { DextoLogComponent } from "../../logger/v2/types.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";
-import { shouldIncludeRawToolResult } from "../../utils/debug.js";
-import { InstrumentClass } from "../../telemetry/decorators.js";
-import { trace, context, propagation } from "@opentelemetry/api";
-_AnthropicService_decorators = [InstrumentClass({
-  prefix: "llm.anthropic",
-  excludeMethods: ["getAllTools", "formatToolsForClaude", "getConfig", "getContextManager"]
-})];
-class AnthropicService {
-  anthropic;
-  config;
-  toolManager;
-  contextManager;
-  sessionEventBus;
-  sessionId;
-  logger;
-  constructor(toolManager, anthropic, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager, logger) {
-    this.logger = logger.createChild(DextoLogComponent.LLM);
-    this.config = config;
-    this.anthropic = anthropic;
-    this.toolManager = toolManager;
-    this.sessionEventBus = sessionEventBus;
-    this.sessionId = sessionId;
-    const formatter = new AnthropicMessageFormatter(this.logger);
-    const tokenizer = createTokenizer(config.provider, config.model, this.logger);
-    const maxInputTokens = getEffectiveMaxInputTokens(config, this.logger);
-    this.contextManager = new ContextManager(
-      config,
-      formatter,
-      systemPromptManager,
-      maxInputTokens,
-      tokenizer,
-      historyProvider,
-      sessionId,
-      resourceManager,
-      this.logger
-      // compressionStrategies uses default
-    );
-  }
-  getAllTools() {
-    return this.toolManager.getAllTools();
-  }
-  async completeTask(textInput, options, imageData, fileData, stream) {
-    const activeSpan = trace.getActiveSpan();
-    const currentContext = context.active();
-    const provider = this.config.provider;
-    const model = this.config.model;
-    if (activeSpan) {
-      activeSpan.setAttribute("llm.provider", provider);
-      activeSpan.setAttribute("llm.model", model);
-    }
-    const existingBaggage = propagation.getBaggage(currentContext);
-    const baggageEntries = {};
-    if (existingBaggage) {
-      existingBaggage.getAllEntries().forEach(([key, entry]) => {
-        baggageEntries[key] = entry;
-      });
-    }
-    baggageEntries["llm.provider"] = { value: provider };
-    baggageEntries["llm.model"] = { value: model };
-    const updatedContext = propagation.setBaggage(
-      currentContext,
-      propagation.createBaggage(baggageEntries)
-    );
-    return await context.with(updatedContext, async () => {
-      await this.contextManager.addUserMessage(textInput, imageData, fileData);
-      const rawTools = await this.toolManager.getAllTools();
-      const formattedTools = this.formatToolsForClaude(rawTools);
-      this.logger.silly(`Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`);
-      this.sessionEventBus.emit("llm: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++;
-          this.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);
-          this.logger.debug(`Messages: ${JSON.stringify(formattedMessages, null, 2)}`);
-          this.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("llm:response", {
-              content: fullResponse,
-              provider: this.config.provider,
-              model: this.config.model,
-              router: "in-built",
-              ...totalTokens > 0 && { tokenUsage: { totalTokens } }
-            });
-            const activeSpan3 = trace.getActiveSpan();
-            if (activeSpan3 && totalTokens > 0) {
-              activeSpan3.setAttribute("gen_ai.usage.total_tokens", 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("llm:tool-call", {
-              toolName,
-              args,
-              callId: toolUseId
-            });
-            try {
-              const result = await this.toolManager.executeTool(
-                toolName,
-                args,
-                this.sessionId
-              );
-              const sanitized = await this.contextManager.addToolResult(
-                toolUseId,
-                toolName,
-                result,
-                { success: true }
-              );
-              this.sessionEventBus.emit("llm:tool-result", {
-                toolName,
-                callId: toolUseId,
-                success: true,
-                sanitized,
-                ...shouldIncludeRawToolResult() ? { rawResult: result } : {}
-              });
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              this.logger.error(
-                `Tool execution error for ${toolName}: ${errorMessage}`
-              );
-              const sanitized = await this.contextManager.addToolResult(
-                toolUseId,
-                toolName,
-                { error: errorMessage },
-                { success: false }
-              );
-              this.sessionEventBus.emit("llm:tool-result", {
-                toolName,
-                callId: toolUseId,
-                success: false,
-                sanitized,
-                ...shouldIncludeRawToolResult() ? { rawResult: { error: errorMessage } } : {}
-              });
-            }
-          }
-        }
-        this.logger.warn(
-          `Reached maximum iterations (${this.config.maxIterations}) for task.`
-        );
-        if (totalTokens > 0) {
-          this.contextManager.updateActualTokenCount(totalTokens);
-        }
-        this.sessionEventBus.emit("llm:response", {
-          content: fullResponse,
-          provider: this.config.provider,
-          model: this.config.model,
-          router: "in-built",
-          ...totalTokens > 0 && { tokenUsage: { totalTokens } }
-        });
-        const activeSpan2 = trace.getActiveSpan();
-        if (activeSpan2 && totalTokens > 0) {
-          activeSpan2.setAttribute("gen_ai.usage.total_tokens", 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);
-        this.logger.error(`Error in Anthropic service API call: ${errorMessage}`, {
-          error
-        });
-        this.sessionEventBus.emit("llm: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,
-      this.logger
-    );
-    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 {
-          this.logger.warn(
-            `Unexpected parameters format for tool ${toolName}:`,
-            jsonSchemaParams
-          );
-        }
-      } else {
-        this.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("llm:chunk", {
-            chunkType: "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 {
-              this.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("llm:chunk", {
-        chunkType: "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;
-  }
-}
-_init = __decoratorStart(null);
-AnthropicService = __decorateElement(_init, 0, "AnthropicService", _AnthropicService_decorators, AnthropicService);
-__runInitializers(_init, 1, AnthropicService);
-export {
-  AnthropicService
-};