@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-UK2SU23S.cjs

@@ -0,0 +1,93 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/llm/model-pool.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var ModelPool = (_class = class {
+  __init() {this.models = /* @__PURE__ */ new Map()}
+  
+  /**
+   * Build a pool from an array of model entries.
+   * The first entry (or the one matching `defaultKey`) becomes active.
+   */
+  constructor(entries, defaultKey) {;_class.prototype.__init.call(this);
+    if (entries) {
+      for (const e of entries) {
+        this.models.set(e.key, e);
+      }
+    }
+    if (defaultKey && this.models.has(defaultKey)) {
+      this.activeKey = defaultKey;
+    } else if (_optionalChain([entries, 'optionalAccess', _ => _.length])) {
+      this.activeKey = entries[0].key;
+    }
+  }
+  /** Register a model at runtime. */
+  register(entry) {
+    this.models.set(entry.key, entry);
+    if (!this.activeKey) {
+      this.activeKey = entry.key;
+    }
+  }
+  /** Switch the active model. Throws if key not found. */
+  switch(key) {
+    const entry = this.models.get(key);
+    if (!entry) {
+      const available = [...this.models.keys()].join(", ");
+      throw new Error(`Model "${key}" not found. Available: ${available}`);
+    }
+    this.activeKey = key;
+    return entry;
+  }
+  /** Get a model by key. No key = active model. Returns undefined if not found. */
+  get(key) {
+    if (key) return this.models.get(key);
+    if (this.activeKey) return this.models.get(this.activeKey);
+    return void 0;
+  }
+  /** Get the active model key. */
+  getActiveKey() {
+    return this.activeKey;
+  }
+  /** List all registered models. */
+  list() {
+    return [...this.models.values()];
+  }
+  /** Number of registered models. */
+  get size() {
+    return this.models.size;
+  }
+  /** Check if a key exists. */
+  has(key) {
+    return this.models.has(key);
+  }
+  /**
+   * Build an LLMConfig for a given model entry, merging with a base config
+   * (inherits apiKey, baseUrl, etc. from the base if not set on the entry).
+   */
+  toLLMConfig(entry, base) {
+    return {
+      provider: entry.provider,
+      model: entry.model,
+      apiKey: _nullishCoalesce(entry.apiKey, () => ( _optionalChain([base, 'optionalAccess', _2 => _2.apiKey]))),
+      baseUrl: _nullishCoalesce(entry.baseUrl, () => ( _optionalChain([base, 'optionalAccess', _3 => _3.baseUrl]))),
+      temperature: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _4 => _4.temperature]), () => ( 0.3)),
+      maxTokens: _nullishCoalesce(_nullishCoalesce(entry.maxOutputTokens, () => ( _optionalChain([base, 'optionalAccess', _5 => _5.maxTokens]))), () => ( 8192)),
+      enableStreaming: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _6 => _6.enableStreaming]), () => ( true))
+    };
+  }
+  /**
+   * Build an LLMConfig for the active model (or a specific key),
+   * merging with a base config.
+   */
+  resolveLLMConfig(key, base) {
+    const entry = this.get(key);
+    if (!entry) return void 0;
+    return this.toLLMConfig(entry, base);
+  }
+}, _class);
+
+
+
+exports.ModelPool = ModelPool;

package/dist/chunk-VKGNCYRL.js

@@ -0,0 +1,258 @@
+import {
+  LLMClientBase
+} from "./chunk-O6F2EF2Z.js";
+import {
+  ContextLimitError,
+  LLMError,
+  LLMRateLimitError
+} from "./chunk-FUOKLKR2.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.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;
+      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: 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);
+      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 = "";
+      const toolCallsMap = /* @__PURE__ */ new Map();
+      let streamUsage;
+      for await (const chunk of stream) {
+        if (chunk.usage) {
+          streamUsage = chunk.usage;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          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 (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);
+      return { text, toolCalls, usage, stopReason: "stop" };
+    } 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
+        });
+      }
+    }
+    return { text, toolCalls, usage, stopReason: 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(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: 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;
+  }
+};
+
+export {
+  OpenAIClient
+};

package/dist/chunk-WFQF3RT4.cjs

@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkQHDYFC5Ucjs = require('./chunk-QHDYFC5U.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/product/index.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+
+// src/product/define.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _path = require('path');
+var _os = require('os');
+function defineProduct(definition, runtime) {
+  const { preset: presetDef, adapter, contract } = definition;
+  const presetName = presetDef.name;
+  const baseTools = [
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "Bash",
+    "AskUserQuestion",
+    "Agent",
+    "ToolSearch",
+    "TaskCreate",
+    "TaskList",
+    "TaskUpdate",
+    "TaskGet"
+  ];
+  const enabledSet = /* @__PURE__ */ new Set([...baseTools, ..._nullishCoalesce(_optionalChain([adapter, 'optionalAccess', _ => _.enableTools]), () => ( []))]);
+  for (const t of _nullishCoalesce(_optionalChain([adapter, 'optionalAccess', _2 => _2.disableTools]), () => ( []))) {
+    enabledSet.delete(t);
+  }
+  const permissionRules = [
+    // Default safe rules
+    { tool: "Read", decision: "allow" },
+    { tool: "Glob", decision: "allow" },
+    { tool: "Grep", decision: "allow" },
+    { tool: "AskUserQuestion", decision: "allow" },
+    { tool: "ToolSearch", decision: "allow" },
+    { tool: "TaskCreate", decision: "allow" },
+    { tool: "TaskList", decision: "allow" },
+    { tool: "TaskUpdate", decision: "allow" },
+    { tool: "TaskGet", decision: "allow" },
+    // Product-specific rules (higher priority)
+    ..._nullishCoalesce(_optionalChain([adapter, 'optionalAccess', _3 => _3.permissionRules]), () => ( []))
+  ];
+  const agentPreset = {
+    name: presetName,
+    label: presetDef.label,
+    description: presetDef.description,
+    promptSections: _nullishCoalesce(presetDef.sections, () => ( ["base", "orchestration"])),
+    injectGitStatus: _nullishCoalesce(presetDef.injectGitStatus, () => ( false)),
+    builtinTools: [...enabledSet],
+    defaultPermissionRules: permissionRules
+  };
+  _chunkQHDYFC5Ucjs.registerPreset.call(void 0, agentPreset);
+  let evaluator;
+  if (!_optionalChain([contract, 'optionalAccess', _4 => _4.evaluator])) {
+    evaluator = new (0, _chunkQHDYFC5Ucjs.NoopEvaluator)();
+  } else if (Array.isArray(contract.evaluator)) {
+    evaluator = new (0, _chunkQHDYFC5Ucjs.CompositeEvaluator)(contract.evaluator);
+  } else {
+    evaluator = contract.evaluator;
+  }
+  const customTools = _nullishCoalesce(_optionalChain([adapter, 'optionalAccess', _5 => _5.tools]), () => ( []));
+  const customToolEntries = customTools.map((ct) => ({
+    definition: ct.definition,
+    execute: ct.execute
+  }));
+  const runsDir = _nullishCoalesce(runtime.runsDir, () => ( _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "runs")));
+  const store = new (0, _chunkQHDYFC5Ucjs.FileRunStore)(runsDir);
+  const manager = new (0, _chunkQHDYFC5Ucjs.RunManager)({
+    store,
+    executor: {
+      llm: runtime.llm,
+      maxTurns: _nullishCoalesce(_optionalChain([contract, 'optionalAccess', _6 => _6.maxTurns]), () => ( 30)),
+      maxContextTokens: _nullishCoalesce(_optionalChain([contract, 'optionalAccess', _7 => _7.maxContextTokens]), () => ( 2e5)),
+      permissionMode: _nullishCoalesce(runtime.permissionMode, () => ( "acceptEdits")),
+      sessionStorageDir: runtime.sessionStorageDir,
+      mcpServers: _optionalChain([adapter, 'optionalAccess', _8 => _8.mcpServers]),
+      enabledBuiltinTools: [...enabledSet],
+      disabledBuiltinTools: _optionalChain([adapter, 'optionalAccess', _9 => _9.disableTools]),
+      customSystemPrompt: presetDef.customPrompt,
+      appendSystemPrompt: presetDef.appendPrompt,
+      customTools: customToolEntries.length > 0 ? customToolEntries : void 0
+    },
+    concurrency: _nullishCoalesce(_optionalChain([contract, 'optionalAccess', _10 => _10.concurrency]), () => ( 1)),
+    runsDir,
+    evaluator
+  });
+  return { manager, preset: agentPreset, customTools };
+}
+
+
+
+exports.defineProduct = defineProduct;