@cjhyy/code-shell 0.1.6 → 0.2.0

package/dist/chunk-ZBPSQCPU.js

@@ -1,264 +0,0 @@
-import {
-  LLMClientBase
-} from "./chunk-6S4BJ65N.js";
-import {
-  ContextLimitError,
-  LLMError,
-  LLMRateLimitError
-} from "./chunk-SFXHZSRF.js";
-import {
-  logger
-} from "./chunk-BXCY2FSE.js";
-import {
-  init_esm_shims
-} from "./chunk-MD32R22I.js";
-
-// src/llm/providers/anthropic.ts
-init_esm_shims();
-import Anthropic from "@anthropic-ai/sdk";
-var AnthropicClient = class extends LLMClientBase {
-  _client = null;
-  constructor(config) {
-    super(config);
-  }
-  initClient() {
-  }
-  get client() {
-    if (!this._client) {
-      this._client = new Anthropic({
-        apiKey: this.config.apiKey ?? process.env.ANTHROPIC_API_KEY,
-        ...this.config.baseUrl ? { baseURL: this.config.baseUrl } : {},
-        timeout: this.timeout
-      });
-    }
-    return this._client;
-  }
-  async createMessage(options) {
-    return this.withRetry(async () => {
-      const messages = this.buildMessages(options.messages);
-      const tools = options.tools ? this.convertTools(options.tools) : void 0;
-      const span = logger.span("llm.request", {
-        cat: "llm",
-        provider: this.provider,
-        model: this.model,
-        stream: !!(options.stream && options.onChunk),
-        messageCount: messages.length,
-        toolCount: tools?.length ?? 0
-      });
-      try {
-        const response = options.stream && options.onChunk ? await this.streamMessage(options, messages, tools) : await this.nonStreamMessage(options, messages, tools);
-        span.end({
-          stopReason: response.stopReason,
-          promptTokens: response.usage?.promptTokens,
-          completionTokens: response.usage?.completionTokens,
-          cacheReadTokens: response.usage?.cacheReadTokens,
-          cacheCreationTokens: response.usage?.cacheCreationTokens
-        });
-        return response;
-      } catch (err) {
-        span.fail(err);
-        throw err;
-      }
-    });
-  }
-  async nonStreamMessage(options, messages, tools) {
-    try {
-      const response = await this.client.messages.create(
-        {
-          model: this.model,
-          max_tokens: options.maxTokens ?? this.maxTokens,
-          system: [
-            {
-              type: "text",
-              text: options.systemPrompt,
-              cache_control: { type: "ephemeral" }
-            }
-          ],
-          messages,
-          ...tools?.length ? { tools } : {},
-          ...options.temperature !== void 0 ? { temperature: options.temperature } : { temperature: this.temperature }
-        },
-        { signal: options.signal }
-      );
-      const usage = {
-        promptTokens: response.usage.input_tokens,
-        completionTokens: response.usage.output_tokens,
-        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
-        cacheReadTokens: response.usage.cache_read_input_tokens,
-        cacheCreationTokens: response.usage.cache_creation_input_tokens
-      };
-      this.recordUsage(usage, options);
-      return this.processResponse(response, usage);
-    } catch (err) {
-      this.handleApiError(err);
-      throw err;
-    }
-  }
-  async streamMessage(options, messages, tools) {
-    try {
-      const stream = this.client.messages.stream(
-        {
-          model: this.model,
-          max_tokens: options.maxTokens ?? this.maxTokens,
-          system: [
-            {
-              type: "text",
-              text: options.systemPrompt,
-              cache_control: { type: "ephemeral" }
-            }
-          ],
-          messages,
-          ...tools?.length ? { tools } : {},
-          ...options.temperature !== void 0 ? { temperature: options.temperature } : { temperature: this.temperature }
-        },
-        { signal: options.signal }
-      );
-      let currentText = "";
-      let currentToolName = "";
-      let currentToolId = "";
-      let currentToolInput = "";
-      const streamStartedAt = Date.now();
-      let firstByteLogged = false;
-      stream.on("text", (text) => {
-        if (!firstByteLogged) {
-          firstByteLogged = true;
-          logger.debug("llm.first_byte", {
-            cat: "llm",
-            provider: this.provider,
-            model: this.model,
-            ttft_ms: Date.now() - streamStartedAt
-          });
-        }
-        currentText += text;
-        options.onChunk?.({ type: "text", text });
-      });
-      stream.on("contentBlock", (block) => {
-        if (block.type === "tool_use") {
-          currentToolName = block.name;
-          currentToolId = block.id;
-          currentToolInput = "";
-          options.onChunk?.({
-            type: "tool_use_start",
-            toolCall: { id: block.id, toolName: block.name, args: {} }
-          });
-        }
-      });
-      stream.on("inputJson", (_delta, snapshot) => {
-        currentToolInput = JSON.stringify(snapshot);
-        if (currentToolId) {
-          options.onChunk?.({
-            type: "tool_use_delta",
-            toolCall: {
-              id: currentToolId,
-              toolName: currentToolName,
-              args: snapshot ?? {}
-            }
-          });
-        }
-      });
-      const finalMessage = await stream.finalMessage();
-      const usage = {
-        promptTokens: finalMessage.usage.input_tokens,
-        completionTokens: finalMessage.usage.output_tokens,
-        totalTokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
-        cacheReadTokens: finalMessage.usage.cache_read_input_tokens,
-        cacheCreationTokens: finalMessage.usage.cache_creation_input_tokens
-      };
-      this.recordUsage(usage, options);
-      options.onChunk?.({ type: "stop", stopReason: finalMessage.stop_reason ?? void 0 });
-      return this.processResponse(finalMessage, usage);
-    } catch (err) {
-      this.handleApiError(err);
-      throw err;
-    }
-  }
-  processResponse(response, usage) {
-    let text = "";
-    const toolCalls = [];
-    for (const block of response.content) {
-      if (block.type === "text") {
-        text += block.text;
-      } else if (block.type === "tool_use") {
-        toolCalls.push({
-          id: block.id,
-          toolName: block.name,
-          args: block.input ?? {}
-        });
-      }
-    }
-    return {
-      text,
-      toolCalls,
-      usage,
-      stopReason: response.stop_reason ?? void 0
-    };
-  }
-  buildMessages(messages) {
-    const result = [];
-    for (const msg of messages) {
-      if (msg.role === "system") continue;
-      const role = msg.role === "tool" ? "user" : msg.role;
-      if (typeof msg.content === "string") {
-        result.push({ role, content: msg.content });
-      } else {
-        const blocks = [];
-        for (const block of msg.content) {
-          if (block.type === "text" && block.text) {
-            blocks.push({ type: "text", text: block.text });
-          } else if (block.type === "tool_use" && block.id && block.name && block.input) {
-            blocks.push({
-              type: "tool_use",
-              id: block.id,
-              name: block.name,
-              input: block.input
-            });
-          } else if (block.type === "tool_result" && block.tool_use_id) {
-            blocks.push({
-              type: "tool_result",
-              tool_use_id: block.tool_use_id,
-              content: typeof block.content === "string" ? block.content : ""
-            });
-          } else if (block.type === "image" && block.source) {
-            blocks.push({
-              type: "image",
-              source: {
-                type: "base64",
-                media_type: block.source.media_type,
-                data: block.source.data
-              }
-            });
-          }
-        }
-        if (blocks.length > 0) {
-          result.push({ role, content: blocks });
-        }
-      }
-    }
-    return result;
-  }
-  convertTools(tools) {
-    return tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
-  }
-  handleApiError(err) {
-    if (err instanceof Anthropic.APIError) {
-      if (err.status === 429) {
-        throw new LLMRateLimitError("anthropic");
-      }
-      if (err.message?.includes("prompt is too long") || err.message?.includes("context_length_exceeded")) {
-        throw new ContextLimitError("anthropic");
-      }
-      throw new LLMError(`Anthropic API error: ${err.message}`, "anthropic", {
-        status: err.status
-      });
-    }
-    throw err;
-  }
-};
-
-export {
-  AnthropicClient
-};