@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-WHRTARDJ.cjs

@@ -0,0 +1,258 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkDICG4AB7cjs = require('./chunk-DICG4AB7.cjs');
+
+
+
+
+var _chunkEL2RL5DGcjs = require('./chunk-EL2RL5DG.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/llm/providers/openai.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _openai = require('openai'); var _openai2 = _interopRequireDefault(_openai);
+var OpenAIClient = (_class = class extends _chunkDICG4AB7cjs.LLMClientBase {
+  __init() {this._client = null}
+  constructor(config) {
+    super(config);_class.prototype.__init.call(this);;
+  }
+  initClient() {
+  }
+  get client() {
+    if (!this._client) {
+      this._client = new (0, _openai2.default)({
+        apiKey: _nullishCoalesce(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 = _optionalChain([options, 'access', _ => _.tools, 'optionalAccess', _2 => _2.length]) ? this.convertTools(options.tools) : void 0;
+      if (options.stream && options.onChunk) {
+        return this.streamMessage(options, messages, tools);
+      }
+      return this.nonStreamMessage(options, messages, tools);
+    });
+  }
+  async nonStreamMessage(options, messages, tools) {
+    try {
+      const response = await this.client.chat.completions.create(
+        {
+          model: this.model,
+          max_tokens: _nullishCoalesce(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 (0, _chunkEL2RL5DGcjs.LLMError)("No response from OpenAI", "openai");
+      const usage = {
+        promptTokens: _nullishCoalesce(_optionalChain([response, 'access', _3 => _3.usage, 'optionalAccess', _4 => _4.prompt_tokens]), () => ( 0)),
+        completionTokens: _nullishCoalesce(_optionalChain([response, 'access', _5 => _5.usage, 'optionalAccess', _6 => _6.completion_tokens]), () => ( 0)),
+        totalTokens: _nullishCoalesce(_optionalChain([response, 'access', _7 => _7.usage, 'optionalAccess', _8 => _8.total_tokens]), () => ( 0))
+      };
+      this.recordUsage(usage);
+      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: _nullishCoalesce(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 = "";
+      const toolCallsMap = /* @__PURE__ */ new Map();
+      let streamUsage;
+      for await (const chunk of stream) {
+        if (chunk.usage) {
+          streamUsage = chunk.usage;
+        }
+        const delta = _optionalChain([chunk, 'access', _9 => _9.choices, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.delta]);
+        if (!delta) continue;
+        if (delta.content) {
+          text += delta.content;
+          _optionalChain([options, 'access', _12 => _12.onChunk, 'optionalCall', _13 => _13({ 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: _nullishCoalesce(tc.id, () => ( "")), name: _nullishCoalesce(_optionalChain([tc, 'access', _14 => _14.function, 'optionalAccess', _15 => _15.name]), () => ( "")), args: "" });
+              _optionalChain([options, 'access', _16 => _16.onChunk, 'optionalCall', _17 => _17({
+                type: "tool_use_start",
+                toolCall: { id: tc.id, toolName: _optionalChain([tc, 'access', _18 => _18.function, 'optionalAccess', _19 => _19.name]) }
+              })]);
+            }
+            const existing = toolCallsMap.get(idx);
+            if (tc.id) existing.id = tc.id;
+            if (_optionalChain([tc, 'access', _20 => _20.function, 'optionalAccess', _21 => _21.name])) existing.name = tc.function.name;
+            if (_optionalChain([tc, 'access', _22 => _22.function, 'optionalAccess', _23 => _23.arguments])) existing.args += tc.function.arguments;
+          }
+        }
+        if (_optionalChain([chunk, 'access', _24 => _24.choices, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.finish_reason])) {
+          _optionalChain([options, 'access', _27 => _27.onChunk, 'optionalCall', _28 => _28({ type: "stop", stopReason: chunk.choices[0].finish_reason })]);
+        }
+      }
+      const toolCalls = [];
+      for (const [, tc] of toolCallsMap) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.args || "{}");
+        } catch (e) {
+        }
+        toolCalls.push({ id: tc.id, toolName: tc.name, args });
+      }
+      const usage = {
+        promptTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _29 => _29.prompt_tokens]), () => ( 0)),
+        completionTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _30 => _30.completion_tokens]), () => ( 0)),
+        totalTokens: _nullishCoalesce(_optionalChain([streamUsage, 'optionalAccess', _31 => _31.total_tokens]), () => ( 0))
+      };
+      this.recordUsage(usage);
+      return { text, toolCalls, usage, stopReason: "stop" };
+    } catch (err) {
+      this.handleApiError(err);
+      throw err;
+    }
+  }
+  processChoice(choice, usage) {
+    const text = _nullishCoalesce(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 (e2) {
+        }
+        toolCalls.push({
+          id: tc.id,
+          toolName: tc.function.name,
+          args
+        });
+      }
+    }
+    return { text, toolCalls, usage, stopReason: _nullishCoalesce(choice.finish_reason, () => ( void 0)) };
+  }
+  buildMessages(systemPrompt, messages) {
+    const result = [
+      { role: "system", content: systemPrompt }
+    ];
+    for (const msg of messages) {
+      if (msg.role === "system") continue;
+      if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          result.push({ role: "assistant", 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(_nullishCoalesce(block.input, () => ( {})))
+                }
+              });
+            }
+          }
+          const param = { role: "assistant" };
+          if (textParts.length) param.content = textParts.join("\n");
+          if (toolCalls.length) param.tool_calls = toolCalls;
+          result.push(param);
+        }
+      } else if (msg.role === "tool") {
+        result.push({
+          role: "tool",
+          tool_call_id: _nullishCoalesce(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 _openai2.default.APIError) {
+      if (err.status === 429) {
+        throw new (0, _chunkEL2RL5DGcjs.LLMRateLimitError)("openai");
+      }
+      const msg = (_nullishCoalesce(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 (0, _chunkEL2RL5DGcjs.ContextLimitError)("openai");
+      }
+      if (err.status === 401 && msg.includes("provider returned error")) {
+        throw new (0, _chunkEL2RL5DGcjs.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 (0, _chunkEL2RL5DGcjs.LLMError)(`OpenAI API error: ${err.message}`, "openai", { status: err.status });
+    }
+    throw err;
+  }
+}, _class);
+
+
+
+exports.OpenAIClient = OpenAIClient;