@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,267 @@
+/**
+ * Anthropic Claude provider using @anthropic-ai/sdk.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { LLMClientBase } from "../client-base.js";
+import { ContextLimitError, LLMError, LLMRateLimitError } from "../../exceptions.js";
+import { logger } from "../../logging/logger.js";
+import { countTokens } from "../token-counter.js";
+export class AnthropicClient extends LLMClientBase {
+    _client = null;
+    constructor(config) {
+        super(config);
+    }
+    initClient() {
+        // Lazy init
+    }
+    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) : undefined;
+            // One span per outbound LLM request. Begin emits debug-level so the
+            // info log isn't spammed during normal operation; end emits info with
+            // duration_ms + usage so `--debug=llm` already gives a quick latency
+            // histogram even at info level.
+            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 !== undefined
+                    ? { 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 !== undefined
+                    ? { temperature: options.temperature }
+                    : { temperature: this.temperature }),
+            }, { signal: options.signal });
+            let currentText = "";
+            let currentToolName = "";
+            let currentToolId = "";
+            let currentToolInput = "";
+            // Time-to-first-byte: log exactly once per stream so streaming-latency
+            // questions ("model felt slow tonight") get a clean number per request.
+            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, tokens: countTokens(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 ?? undefined });
+            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 ?? undefined,
+        };
+    }
+    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: 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: 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;
+    }
+}

package/dist/llm/providers/openai.d.ts

@@ -0,0 +1,64 @@
+/**
+ * OpenAI GPT provider using openai SDK.
+ *
+ * Serves every OpenAI-compatible endpoint we support (OpenAI, DeepSeek,
+ * OpenRouter, Z.AI, xAI, Mistral, Groq, Gemini-OpenAI-compat, Ollama,
+ * custom). Per-(provider, model) request-shape divergence — token-limit
+ * field name, rejected sampling params, thinking knob, reasoning echo —
+ * is resolved through `capabilitiesFor()`, not hardcoded.
+ */
+import type { LLMConfig, LLMResponse } from "../../types.js";
+import type { CreateMessageOptions } from "../types.js";
+import { LLMClientBase } from "../client-base.js";
+interface RunStreamOpts {
+    idleTimeoutMs?: number;
+    requestId?: string;
+    /**
+     * Per-chunk handler — invoked synchronously with the raw chunk for the
+     * provider to do its own parsing. Returns the text delta (or "") for
+     * the watchdog-side text accumulator used in tests.
+     */
+    onChunk?: (chunk: any) => string;
+}
+/**
+ * Consume an async iterable of stream chunks with an idle watchdog.
+ * Returns the accumulated text — either from onChunk return values, or
+ * by extracting choices[0].delta.content from raw chunks (useful in tests
+ * that call runStreamWithWatchdog directly without an onChunk handler).
+ *
+ * The watchdog is active whenever opts.idleTimeoutMs is explicitly provided,
+ * or when STREAM_WATCHDOG_CONFIG.enabled is true. When active, each call to
+ * iterator.next() races against an idle deadline; if the deadline fires first
+ * the function rejects with StreamIdleTimeoutError.
+ */
+export declare function runStreamWithWatchdog<T = any>(stream: AsyncIterable<T>, opts?: RunStreamOpts): Promise<string>;
+export declare class OpenAIClient extends LLMClientBase {
+    private _client;
+    private _forceMaxCompletionTokens;
+    constructor(config: LLMConfig);
+    protected initClient(): void;
+    private get client();
+    /**
+     * Resolve the capability descriptor for the current (provider kind, model)
+     * pair. Cached for the lifetime of the client — model never changes
+     * mid-client. `providerKind` defaults to "openai" because legacy LLMConfig
+     * paths (arena, env-derived) don't always populate it; for those, the
+     * built-in rules table treats them as plain OpenAI.
+     */
+    private _capability;
+    private get capability();
+    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    /**
+     * Build the request body honoring the model's capability descriptor.
+     * Centralized so both streaming and non-streaming paths agree on the
+     * exact shape.
+     */
+    private buildRequestBody;
+    private nonStreamMessage;
+    private streamMessage;
+    private processChoice;
+    private buildMessages;
+    private convertTools;
+    private handleApiError;
+}
+export {};