@cjhyy/code-shell 0.1.5 → 0.1.7

package/dist/chunk-7JVTYEEC.js

@@ -1,340 +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/openai.ts
-init_esm_shims();
-import OpenAI from "openai";
-var OpenAIClient = class extends LLMClientBase {
-  _client = null;
-  constructor(config) {
-    super(config);
-  }
-  initClient() {
-  }
-  get client() {
-    if (!this._client) {
-      this._client = new OpenAI({
-        apiKey: this.config.apiKey ?? process.env.OPENAI_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.systemPrompt, options.messages);
-      const tools = options.tools?.length ? 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.chat.completions.create(
-        {
-          model: this.model,
-          max_tokens: options.maxTokens ?? this.maxTokens,
-          messages,
-          ...tools ? { tools } : {},
-          ...options.temperature !== void 0 ? { temperature: options.temperature } : { temperature: this.temperature }
-        },
-        { signal: options.signal }
-      );
-      const choice = response.choices[0];
-      if (!choice) throw new LLMError("No response from OpenAI", "openai");
-      const usage = {
-        promptTokens: response.usage?.prompt_tokens ?? 0,
-        completionTokens: response.usage?.completion_tokens ?? 0,
-        totalTokens: response.usage?.total_tokens ?? 0
-      };
-      this.recordUsage(usage, options);
-      return this.processChoice(choice, usage);
-    } catch (err) {
-      this.handleApiError(err);
-      throw err;
-    }
-  }
-  async streamMessage(options, messages, tools) {
-    try {
-      const stream = await this.client.chat.completions.create(
-        {
-          model: this.model,
-          max_tokens: options.maxTokens ?? this.maxTokens,
-          messages,
-          stream: true,
-          stream_options: { include_usage: true },
-          ...tools ? { tools } : {},
-          ...options.temperature !== void 0 ? { temperature: options.temperature } : { temperature: this.temperature }
-        },
-        { signal: options.signal }
-      );
-      let text = "";
-      let reasoningContent = "";
-      const toolCallsMap = /* @__PURE__ */ new Map();
-      let streamUsage;
-      const streamStartedAt = Date.now();
-      let firstByteLogged = false;
-      for await (const chunk of stream) {
-        if (chunk.usage) {
-          streamUsage = chunk.usage;
-        }
-        const delta = chunk.choices[0]?.delta;
-        if (!delta) continue;
-        const reasoningDelta = delta.reasoning_content;
-        if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
-          reasoningContent += reasoningDelta;
-        }
-        if (delta.content) {
-          if (!firstByteLogged) {
-            firstByteLogged = true;
-            logger.debug("llm.first_byte", {
-              cat: "llm",
-              provider: this.provider,
-              model: this.model,
-              ttft_ms: Date.now() - streamStartedAt
-            });
-          }
-          text += delta.content;
-          options.onChunk?.({ type: "text", text: delta.content });
-        }
-        if (delta.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            const idx = tc.index;
-            if (!toolCallsMap.has(idx)) {
-              toolCallsMap.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", args: "" });
-              options.onChunk?.({
-                type: "tool_use_start",
-                toolCall: { id: tc.id, toolName: tc.function?.name }
-              });
-            }
-            const existing = toolCallsMap.get(idx);
-            if (tc.id) existing.id = tc.id;
-            if (tc.function?.name) existing.name = tc.function.name;
-            if (tc.function?.arguments) {
-              existing.args += tc.function.arguments;
-              if (existing.id) {
-                try {
-                  const parsed = JSON.parse(existing.args || "{}");
-                  options.onChunk?.({
-                    type: "tool_use_delta",
-                    toolCall: { id: existing.id, toolName: existing.name, args: parsed }
-                  });
-                } catch {
-                }
-              }
-            }
-          }
-        }
-        if (chunk.choices[0]?.finish_reason) {
-          options.onChunk?.({ type: "stop", stopReason: chunk.choices[0].finish_reason });
-        }
-      }
-      const toolCalls = [];
-      for (const [, tc] of toolCallsMap) {
-        let args = {};
-        try {
-          args = JSON.parse(tc.args || "{}");
-        } catch {
-        }
-        toolCalls.push({ id: tc.id, toolName: tc.name, args });
-      }
-      const usage = {
-        promptTokens: streamUsage?.prompt_tokens ?? 0,
-        completionTokens: streamUsage?.completion_tokens ?? 0,
-        totalTokens: streamUsage?.total_tokens ?? 0
-      };
-      this.recordUsage(usage, options);
-      return {
-        text,
-        toolCalls,
-        usage,
-        stopReason: "stop",
-        ...reasoningContent ? { reasoningContent } : {}
-      };
-    } catch (err) {
-      this.handleApiError(err);
-      throw err;
-    }
-  }
-  processChoice(choice, usage) {
-    const text = choice.message.content ?? "";
-    const toolCalls = [];
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        let args = {};
-        try {
-          args = JSON.parse(tc.function.arguments || "{}");
-        } catch {
-        }
-        toolCalls.push({
-          id: tc.id,
-          toolName: tc.function.name,
-          args
-        });
-      }
-    }
-    const reasoningContent = extractReasoningContent(
-      choice.message
-    );
-    return {
-      text,
-      toolCalls,
-      usage,
-      stopReason: choice.finish_reason ?? void 0,
-      ...reasoningContent ? { reasoningContent } : {}
-    };
-  }
-  buildMessages(systemPrompt, messages) {
-    const result = [{ role: "system", content: systemPrompt }];
-    const needsReasoningBackfill = isDeepSeekThinkingModel(this.model);
-    for (const msg of messages) {
-      if (msg.role === "system") continue;
-      if (msg.role === "assistant") {
-        const param = { role: "assistant" };
-        let reasoningContent;
-        if (typeof msg.content === "string") {
-          param.content = msg.content;
-        } else {
-          const textParts = [];
-          const toolCalls = [];
-          for (const block of msg.content) {
-            if (block.type === "text" && block.text) {
-              textParts.push(block.text);
-            } else if (block.type === "tool_use" && block.id && block.name) {
-              toolCalls.push({
-                id: block.id,
-                type: "function",
-                function: {
-                  name: block.name,
-                  arguments: JSON.stringify(block.input ?? {})
-                }
-              });
-            } else if (block.type === "reasoning" && block.reasoningContent) {
-              reasoningContent = block.reasoningContent;
-            }
-            if (!reasoningContent && block.reasoningContent) {
-              reasoningContent = block.reasoningContent;
-            }
-          }
-          if (textParts.length) param.content = textParts.join("\n");
-          if (toolCalls.length) param.tool_calls = toolCalls;
-        }
-        if (!reasoningContent && needsReasoningBackfill) {
-          reasoningContent = "";
-        }
-        if (reasoningContent !== void 0) {
-          param.reasoning_content = reasoningContent;
-        }
-        result.push(param);
-      } else if (msg.role === "tool") {
-        result.push({
-          role: "tool",
-          tool_call_id: msg.tool_call_id ?? "",
-          content: typeof msg.content === "string" ? msg.content : ""
-        });
-      } else {
-        if (typeof msg.content === "string") {
-          result.push({ role: "user", content: msg.content });
-        } else {
-          const textParts = [];
-          const toolResults = [];
-          for (const block of msg.content) {
-            if (block.type === "tool_result" && block.tool_use_id) {
-              toolResults.push({
-                tool_use_id: block.tool_use_id,
-                content: typeof block.content === "string" ? block.content : ""
-              });
-            } else if (block.type === "text" && block.text) {
-              textParts.push(block.text);
-            }
-          }
-          for (const tr of toolResults) {
-            result.push({
-              role: "tool",
-              tool_call_id: tr.tool_use_id,
-              content: tr.content
-            });
-          }
-          if (textParts.length > 0) {
-            result.push({ role: "user", content: textParts.join("\n") });
-          }
-        }
-      }
-    }
-    return result;
-  }
-  convertTools(tools) {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  handleApiError(err) {
-    if (err instanceof OpenAI.APIError) {
-      if (err.status === 429) {
-        throw new LLMRateLimitError("openai");
-      }
-      const msg = (err.message ?? "").toLowerCase();
-      if (msg.includes("context_length_exceeded") || msg.includes("maximum context length") || msg.includes("too many tokens") || msg.includes("prompt is too long")) {
-        throw new ContextLimitError("openai");
-      }
-      if (err.status === 401 && msg.includes("provider returned error")) {
-        throw new LLMError(
-          `OpenAI-compatible endpoint returned 401 "Provider returned error". Two likely causes: (1) the API key is invalid/revoked, or (2) the upstream provider rejects tool calls for this model (common on OpenRouter's gpt-4o-mini route). Verify the key, then try a tool-capable model such as openai/gpt-4.1-mini or anthropic/claude-3.5-haiku.`,
-          "openai",
-          { status: err.status }
-        );
-      }
-      throw new LLMError(`OpenAI API error: ${err.message}`, "openai", { status: err.status });
-    }
-    throw err;
-  }
-};
-function extractReasoningContent(msg) {
-  const candidate = msg.reasoning_content ?? msg.reasoning;
-  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
-}
-function isDeepSeekThinkingModel(model) {
-  return /^deepseek-v4(?:-|$)/i.test(model);
-}
-
-export {
-  OpenAIClient
-};