@ebowwa/coder 0.2.1 → 0.7.64

package/dist/core/api-client-impl.js

@@ -0,0 +1,479 @@
+/**
+ * API Client - SSE streaming for LLM APIs
+ */
+import { DEFAULT_CACHE_CONFIG, calculateBudgetTokens, supportsExtendedThinking as supportsThinkingType, EFFORT_TO_BUDGET, } from "../types/index.js";
+import { withRetry, parseRetryAfter } from "./retry.js";
+import { calculateCost as calculateModelCost, DEFAULT_MODEL, supportsExtendedThinking, } from "./models.js";
+/**
+ * Calculate cost for API usage including cache metrics
+ * Delegates to models.ts for centralized pricing
+ */
+export function calculateCost(model, usage) {
+    return calculateModelCost(model, usage);
+}
+/**
+ * Build system prompt with cache control
+ */
+export function buildSystemPrompt(systemPrompt, cacheConfig) {
+    if (!systemPrompt || !cacheConfig.enabled || !cacheConfig.cacheSystemPrompt) {
+        return typeof systemPrompt === "string" ? systemPrompt : undefined;
+    }
+    // If already in block format, add cache_control to the last block
+    if (Array.isArray(systemPrompt)) {
+        const blocks = [...systemPrompt];
+        if (blocks.length > 0) {
+            const lastBlock = blocks[blocks.length - 1];
+            if (lastBlock && lastBlock.type === "text") {
+                blocks[blocks.length - 1] = {
+                    type: "text",
+                    text: lastBlock.text,
+                    cache_control: { type: "ephemeral", ttl: cacheConfig.ttl },
+                };
+            }
+        }
+        return blocks;
+    }
+    // Convert string to block format with cache_control
+    return [
+        {
+            type: "text",
+            text: systemPrompt,
+            cache_control: { type: "ephemeral", ttl: cacheConfig.ttl },
+        },
+    ];
+}
+/**
+ * Build messages with cache control for long context blocks
+ */
+export function buildCachedMessages(messages, cacheConfig) {
+    if (!cacheConfig.enabled) {
+        return messages;
+    }
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        // Convert string content to content blocks array
+        const contentBlocks = typeof msg.content === "string"
+            ? [{ type: "text", text: msg.content }]
+            : msg.content;
+        const cachedContent = [];
+        for (let j = 0; j < contentBlocks.length; j++) {
+            const block = contentBlocks[j];
+            const isLastBlock = j === contentBlocks.length - 1;
+            const isLastMessage = i === messages.length - 1;
+            // Add cache_control to large text blocks (especially in user messages)
+            if (block.type === "text" &&
+                block.text.length >= cacheConfig.minTokensForCache * 4 && // Approximate chars per token
+                !block.cache_control &&
+                (isLastBlock || isLastMessage)) {
+                cachedContent.push({
+                    ...block,
+                    cache_control: { type: "ephemeral", ttl: cacheConfig.ttl },
+                });
+            }
+            else {
+                cachedContent.push(block);
+            }
+        }
+        result.push({ ...msg, content: cachedContent });
+    }
+    // Ensure the last message has cache_control on its last content block
+    if (result.length > 0 && cacheConfig.enabled) {
+        const lastMsg = result[result.length - 1];
+        const lastBlock = lastMsg.content[lastMsg.content.length - 1];
+        if (lastBlock && !("cache_control" in lastBlock)) {
+            lastMsg.content[lastMsg.content.length - 1] = {
+                ...lastBlock,
+                cache_control: { type: "ephemeral", ttl: cacheConfig.ttl },
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Calculate cache metrics from usage
+ */
+export function calculateCacheMetrics(usage) {
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+    const totalCacheTokens = cacheReadTokens + cacheWriteTokens;
+    const cacheHits = cacheReadTokens > 0 ? 1 : 0;
+    const cacheMisses = cacheWriteTokens > 0 ? 1 : 0;
+    const total = cacheHits + cacheMisses;
+    return {
+        cacheHits,
+        cacheMisses,
+        totalCacheReadTokens: cacheReadTokens,
+        totalCacheWriteTokens: cacheWriteTokens,
+        cacheHitRate: total > 0 ? cacheHits / total : 0,
+        estimatedSavingsUSD: 0, // Will be calculated after pricing lookup
+    };
+}
+/**
+ * Create a streaming message request to Anthropic API
+ */
+export async function createMessageStream(messages, options) {
+    const { apiKey, model = "claude-sonnet-4-6", maxTokens = 4096, tools, systemPrompt, cacheConfig = DEFAULT_CACHE_CONFIG, thinking, extendedThinking, onToken, onThinking, onRedactedThinking, onToolUse, signal, } = options;
+    const startTime = Date.now();
+    let ttft = 0;
+    let firstToken = true;
+    let totalThinkingTokens = 0;
+    // Build cached messages
+    const cachedMessages = buildCachedMessages(messages, cacheConfig);
+    // Build system prompt with cache control
+    const cachedSystemPrompt = buildSystemPrompt(systemPrompt, cacheConfig);
+    // Build request
+    const request = {
+        model,
+        max_tokens: maxTokens,
+        messages: cachedMessages.map((m) => ({
+            role: m.role,
+            content: m.content,
+        })),
+        stream: true,
+    };
+    // Add system prompt if provided
+    if (cachedSystemPrompt) {
+        request.system = cachedSystemPrompt;
+    }
+    // Add tools if provided (with optional caching)
+    if (tools && tools.length > 0) {
+        request.tools = tools;
+    }
+    // Determine API endpoint (support custom base URL for GLM, etc.)
+    const baseUrl = process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
+    const apiEndpoint = `${baseUrl}/v1/messages`;
+    // Build headers
+    const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+    };
+    // Determine thinking configuration
+    const shouldUseExtendedThinking = (extendedThinking?.enabled ?? false) ||
+        (thinking && thinking.type !== "disabled");
+    if (shouldUseExtendedThinking && supportsExtendedThinking(model)) {
+        // Calculate budget tokens
+        let budgetTokens;
+        if (extendedThinking?.budgetTokens) {
+            budgetTokens = extendedThinking.budgetTokens;
+        }
+        else if (thinking?.type === "enabled") {
+            budgetTokens = thinking.budget_tokens;
+        }
+        else {
+            // Use effort level to determine budget
+            const effort = extendedThinking?.effort || "medium";
+            budgetTokens = calculateBudgetTokens({
+                enabled: true,
+                effort,
+                modelMultiplier: model.includes("opus") ? 2 : 1,
+            }, model);
+        }
+        // Clamp budget to valid range
+        budgetTokens = Math.max(1024, Math.min(budgetTokens, 100000));
+        request.thinking = {
+            type: "enabled",
+            budget_tokens: budgetTokens,
+        };
+        // Add beta headers for extended thinking features
+        const betaFeatures = ["extended-thinking-2025-01-24"];
+        // Add interleaved thinking support if enabled
+        if (extendedThinking?.interleaved !== false) {
+            betaFeatures.push("interleaved-thinking-2025-01-24");
+        }
+        headers["anthropic-beta"] = betaFeatures.join(",");
+    }
+    else {
+        // Default beta header
+        headers["anthropic-beta"] = "max-tokens-3-5-sonnet-2024-07-15";
+    }
+    // Make API request with retry logic
+    const retryOptions = {
+        maxRetries: 3,
+        baseDelayMs: 1000,
+        maxDelayMs: 30000,
+        retryableStatusCodes: [429, 500, 502, 503, 504, 529],
+        onRetry: (attempt, error, delayMs) => {
+            console.log(`\x1b[33mAPI retry ${attempt}/3 after ${delayMs}ms: ${error.message}\x1b[0m`);
+        },
+    };
+    const response = await withRetry(async () => {
+        const res = await fetch(apiEndpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(request),
+            signal,
+        });
+        // Throw for retryable status codes so withRetry can handle them
+        if (!res.ok && retryOptions.retryableStatusCodes?.includes(res.status)) {
+            const errorText = await res.text();
+            throw new Error(`API error: ${res.status} - ${errorText}`);
+        }
+        return res;
+    }, retryOptions);
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error: ${response.status} - ${error}`);
+    }
+    if (!response.body) {
+        throw new Error("No response body");
+    }
+    // Parse SSE stream
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let message = null;
+    let currentContent = [];
+    let usage = { input_tokens: 0, output_tokens: 0 };
+    let currentTextBlock = null;
+    let currentThinkingBlock = null;
+    let currentRedactedThinkingBlock = null;
+    let currentToolUseBlock = null;
+    let toolUseInput = "";
+    const buffer = "";
+    try {
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                const data = line.slice(6);
+                if (!data)
+                    continue;
+                // Debug: Log all SSE data when debug enabled
+                if (process.env.DEBUG_API === '1') {
+                    console.log('\x1b[90m[DEBUG] SSE data:\x1b[0m', data.substring(0, 200));
+                }
+                try {
+                    const event = JSON.parse(data);
+                    // Debug: Log event types
+                    if (process.env.DEBUG_API === '1' && event.type) {
+                        console.log('\x1b[90m[DEBUG] SSE event type:\x1b[0m', event.type);
+                    }
+                    switch (event.type) {
+                        case "error": {
+                            // API returned an error - surface it
+                            const errorEvent = event;
+                            const errorMsg = errorEvent.error?.message || errorEvent.error?.type || "Unknown API error";
+                            console.error(`API error: ${errorMsg}`);
+                            // Include more details in debug mode
+                            if (process.env.DEBUG_API === '1') {
+                                console.log('\x1b[91m[DEBUG] API error event:', JSON.stringify(errorEvent, null, 255));
+                            }
+                            throw new Error(`API error: ${errorMsg}`);
+                        }
+                        case "message_start": {
+                            const msg = event.message;
+                            message = msg;
+                            usage = msg.usage;
+                            break;
+                        }
+                        case "content_block_start": {
+                            const block = event.content_block;
+                            if (block.type === "text") {
+                                currentTextBlock = { type: "text", text: "" };
+                            }
+                            else if (block.type === "thinking") {
+                                currentThinkingBlock = { type: "thinking", thinking: "" };
+                            }
+                            else if (block.type === "redacted_thinking") {
+                                currentRedactedThinkingBlock = { type: "redacted_thinking", data: "" };
+                            }
+                            else if (block.type === "tool_use") {
+                                currentToolUseBlock = {
+                                    type: "tool_use",
+                                    id: block.id,
+                                    name: block.name,
+                                    input: {},
+                                };
+                                toolUseInput = "";
+                            }
+                            break;
+                        }
+                        case "content_block_delta": {
+                            const delta = event.delta;
+                            if (delta.type === "text_delta" && currentTextBlock) {
+                                const text = delta.text;
+                                currentTextBlock.text += text;
+                                onToken?.(text);
+                                if (firstToken) {
+                                    ttft = Date.now() - startTime;
+                                    firstToken = false;
+                                }
+                            }
+                            else if (delta.type === "thinking_delta" && currentThinkingBlock) {
+                                const thinking = delta.thinking;
+                                currentThinkingBlock.thinking += thinking;
+                                onThinking?.(thinking);
+                                totalThinkingTokens += Math.ceil(thinking.length / 4); // Rough estimate
+                            }
+                            else if (delta.type === "redacted_thinking_delta" && currentRedactedThinkingBlock) {
+                                // Handle redacted thinking deltas
+                                const redactedData = delta.data;
+                                currentRedactedThinkingBlock.data += redactedData;
+                                onRedactedThinking?.(redactedData);
+                                totalThinkingTokens += Math.ceil(redactedData.length / 4); // Rough estimate
+                            }
+                            else if (delta.type === "input_json_delta" && currentToolUseBlock) {
+                                toolUseInput += delta.partial_json;
+                            }
+                            break;
+                        }
+                        case "content_block_stop": {
+                            // content_block_stop event has { index: number }, not the block itself
+                            // We need to check which current block is active and push it
+                            if (currentTextBlock !== null) {
+                                currentContent.push(currentTextBlock);
+                                currentTextBlock = null;
+                            }
+                            else if (currentThinkingBlock !== null) {
+                                currentContent.push(currentThinkingBlock);
+                                currentThinkingBlock = null;
+                            }
+                            else if (currentRedactedThinkingBlock !== null) {
+                                currentContent.push(currentRedactedThinkingBlock);
+                                onRedactedThinking?.(currentRedactedThinkingBlock.data);
+                                currentRedactedThinkingBlock = null;
+                            }
+                            else if (currentToolUseBlock !== null) {
+                                try {
+                                    currentToolUseBlock.input = JSON.parse(toolUseInput);
+                                }
+                                catch {
+                                    currentToolUseBlock.input = {};
+                                }
+                                currentContent.push(currentToolUseBlock);
+                                onToolUse?.({
+                                    id: currentToolUseBlock.id,
+                                    name: currentToolUseBlock.name,
+                                    input: currentToolUseBlock.input,
+                                });
+                                currentToolUseBlock = null;
+                                toolUseInput = "";
+                            }
+                            break;
+                        }
+                        case "message_delta": {
+                            const evt = event;
+                            if (evt.usage) {
+                                usage.output_tokens = evt.usage.output_tokens;
+                            }
+                            if (message && evt.delta?.stop_reason) {
+                                message.stop_reason = evt.delta.stop_reason;
+                            }
+                            break;
+                        }
+                        case "message_stop":
+                            // Message complete
+                            break;
+                        // OpenAI/Z.AI compatible format (for GLM-5, etc.)
+                        // OpenAI streaming sends chunks with choices array
+                        default: {
+                            // Check for OpenAI format: { choices: [{ delta: { content: "..." } }], usage: {...} }
+                            if (event.choices && Array.isArray(event.choices)) {
+                                const choice = event.choices[0];
+                                if (choice?.delta?.content) {
+                                    const text = choice.delta.content;
+                                    if (currentTextBlock) {
+                                        currentTextBlock.text += text;
+                                    }
+                                    else {
+                                        currentTextBlock = { type: "text", text };
+                                    }
+                                    onToken?.(text);
+                                    if (firstToken) {
+                                        ttft = Date.now() - startTime;
+                                        firstToken = false;
+                                    }
+                                }
+                                // Check for finish
+                                if (choice?.finish_reason) {
+                                    if (currentTextBlock) {
+                                        currentContent.push(currentTextBlock);
+                                        currentTextBlock = null;
+                                    }
+                                    if (!message) {
+                                        message = {
+                                            id: `msg-${Date.now()}`,
+                                            type: "message",
+                                            role: "assistant",
+                                            content: currentContent,
+                                            model: model,
+                                            stop_reason: (choice.finish_reason === "stop" ? "end_turn" : choice.finish_reason === "length" ? "max_tokens" : "end_turn"),
+                                            stop_sequence: null,
+                                            usage: { input_tokens: 0, output_tokens: 0 },
+                                        };
+                                    }
+                                    else {
+                                        message.stop_reason = (choice.finish_reason === "stop" ? "end_turn" : choice.finish_reason === "length" ? "max_tokens" : "end_turn");
+                                    }
+                                }
+                            }
+                            // OpenAI usage format (often in final chunk)
+                            if (event.usage) {
+                                const openaiUsage = event.usage;
+                                usage.input_tokens = openaiUsage.prompt_tokens || 0;
+                                usage.output_tokens = openaiUsage.completion_tokens || 0;
+                            }
+                            break;
+                        }
+                    }
+                }
+                catch (err) {
+                    // Log the parse error with more detail
+                    if (process.env.DEBUG_API === '1') {
+                        console.error('\x1b[91m[DEBUG] JSON parse error:', err);
+                        console.error('\x1b[91m[DEBUG] Error parsing SSE data:', data.substring(0, 200));
+                        console.error('\x1b[91m[DEBUG] Original buffer:', buffer.substring(0, 500));
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (!message) {
+        // If we received content via OpenAI format but no message_start, create a message
+        if (currentContent.length > 0) {
+            message = {
+                id: `msg-${Date.now()}`,
+                type: "message",
+                role: "assistant",
+                content: currentContent,
+                model: model,
+                stop_reason: "end_turn",
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 },
+            };
+        }
+        else {
+            // Debug: Log what we did receive
+            if (process.env.DEBUG_API === '1') {
+                console.log('\x1b[91m[DEBUG] No message_start event received. Buffer:\x1b[0m', buffer.substring(0, 500));
+            }
+            throw new Error("No message received from API");
+        }
+    }
+    message.content = currentContent;
+    // Calculate cost and cache metrics
+    const { costUSD, estimatedSavingsUSD } = calculateCost(model, usage);
+    const cacheMetrics = calculateCacheMetrics(usage);
+    cacheMetrics.estimatedSavingsUSD = estimatedSavingsUSD;
+    const durationMs = Date.now() - startTime;
+    return {
+        message,
+        usage,
+        cacheMetrics,
+        costUSD,
+        durationMs,
+        ttftMs: ttft || durationMs,
+        thinkingTokens: totalThinkingTokens,
+    };
+}

package/dist/core/api-client.d.ts

@@ -0,0 +1,6 @@
+/**
+ * API Client exports
+ */
+export * from "./api-client-impl.js";
+export * from "./agent-loop.js";
+//# sourceMappingURL=api-client.d.ts.map

package/dist/core/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../packages/src/core/api-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

package/dist/core/api-client.js

@@ -0,0 +1,5 @@
+/**
+ * API Client exports
+ */
+export * from "./api-client-impl.js";
+export * from "./agent-loop.js";

package/dist/core/checkpoints.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Checkpoint Manager - Save and restore conversation states
+ * Captures both chat context AND code/file changes
+ */
+import type { Message } from "../types/index.js";
+export interface FileSnapshot {
+    path: string;
+    content: string;
+    hash: string;
+}
+export interface GitState {
+    branch: string;
+    ahead: number;
+    behind: number;
+    staged: string[];
+    unstaged: string[];
+    untracked: string[];
+    stash?: string;
+}
+export interface Checkpoint {
+    id: string;
+    sessionId: string;
+    timestamp: number;
+    label: string;
+    description?: string;
+    messages: Message[];
+    files: FileSnapshot[];
+    gitState?: GitState;
+    metadata: {
+        model?: string;
+        workingDirectory?: string;
+        totalCost: number;
+        messageCount: number;
+        fileCount: number;
+    };
+}
+export interface CheckpointStore {
+    checkpoints: Map<string, Checkpoint>;
+    sessionFile: string;
+}
+/**
+ * Load checkpoints for a session
+ */
+export declare function loadCheckpoints(sessionId: string): Promise<Map<string, Checkpoint>>;
+/**
+ * Save checkpoints for a session
+ */
+export declare function saveCheckpoints(sessionId: string, checkpoints: Map<string, Checkpoint>): Promise<void>;
+/**
+ * Create a new checkpoint with file snapshots
+ */
+export declare function createCheckpoint(sessionId: string, messages: Message[], options?: {
+    label?: string;
+    description?: string;
+    model?: string;
+    workingDirectory?: string;
+    totalCost?: number;
+    trackFiles?: boolean;
+}): Promise<Checkpoint>;
+/**
+ * Restore a checkpoint (returns the checkpoint, doesn't apply it)
+ */
+export declare function restoreCheckpoint(sessionId: string, checkpointId: string): Promise<Checkpoint | null>;
+/**
+ * Apply a checkpoint - restore files and return messages
+ */
+export declare function applyCheckpoint(checkpoint: Checkpoint, options?: {
+    restoreFiles?: boolean;
+    restoreMessages?: boolean;
+    workingDirectory?: string;
+}): Promise<{
+    messages: Message[];
+    filesRestored: number;
+    filesFailed: number;
+}>;
+/**
+ * Delete a checkpoint
+ */
+export declare function deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+/**
+ * List all checkpoints for a session
+ */
+export declare function listCheckpoints(sessionId: string): Promise<Checkpoint[]>;
+/**
+ * Format checkpoint for display
+ */
+export declare function formatCheckpoint(checkpoint: Checkpoint, verbose?: boolean): string;
+/**
+ * Print checkpoints list
+ */
+export declare function printCheckpointsList(checkpoints: Checkpoint[]): void;
+/**
+ * Clear all checkpoints for a session
+ */
+export declare function clearCheckpoints(sessionId: string): Promise<number>;
+/**
+ * Get checkpoint summary for status display
+ */
+export declare function getCheckpointSummary(checkpoint: Checkpoint): string;
+/**
+ * Register a new checkpoint (called after createCheckpoint)
+ */
+export declare function registerCheckpoint(sessionId: string, checkpointId: string): Promise<void>;
+/**
+ * Undo - go back to previous checkpoint
+ */
+export declare function undoCheckpoint(sessionId: string): Promise<{
+    checkpoint: Checkpoint | null;
+    canRedo: boolean;
+}>;
+/**
+ * Redo - go forward to next checkpoint
+ */
+export declare function redoCheckpoint(sessionId: string): Promise<{
+    checkpoint: Checkpoint | null;
+    canRedo: boolean;
+}>;
+/**
+ * Get navigation status
+ */
+export declare function getNavigationStatus(sessionId: string): Promise<{
+    total: number;
+    current: number;
+    canUndo: boolean;
+    canRedo: boolean;
+    currentId?: string;
+}>;
+//# sourceMappingURL=checkpoints.d.ts.map

package/dist/core/checkpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoints.d.ts","sourceRoot":"","sources":["../../packages/src/core/checkpoints.ts"],"names":[],"mappings":"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"}