whale-code 6.4.0

package/dist/shared/sse-parser.js

@@ -0,0 +1,259 @@
+/**
+ * Unified SSE Parser — ONE implementation replacing 4 duplicates.
+ *
+ * Used by:
+ * - agent-loop.ts (processStreamWithCallbacks for real-time UI)
+ * - subagent.ts (collectStreamResult for batch collection)
+ * - teammate.ts (collectStreamResult for batch collection)
+ * - server-agent-loop.ts (processStreamWithCallbacks for SSE relay)
+ */
+// ============================================================================
+// RAW SSE PARSER — yields typed events from HTTP response body
+// ============================================================================
+/**
+ * Parse SSE stream from proxy HTTP response into typed events.
+ * Handles `data: {...}\n\n` format with [DONE] sentinel.
+ */
+export async function* parseSSEStream(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted)
+                break;
+            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) {
+                const trimmed = line.trim();
+                if (!trimmed || !trimmed.startsWith("data: "))
+                    continue;
+                const payload = trimmed.slice(6);
+                if (payload === "[DONE]")
+                    return;
+                try {
+                    yield JSON.parse(payload);
+                }
+                catch { /* skip malformed JSON */ }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+// ============================================================================
+// STREAM COLLECTOR — batch-collects all events (subagent/teammate)
+// ============================================================================
+/**
+ * Collect all events into a StreamResult. No callbacks — used by
+ * subagent and teammate where real-time text isn't needed.
+ */
+export async function collectStreamResult(events) {
+    return processStreamWithCallbacks(events, {});
+}
+// ============================================================================
+// STREAM PROCESSOR — full event processing with callbacks (agent-loop)
+// ============================================================================
+/**
+ * Process streaming events with optional real-time callbacks.
+ * Used by agent-loop (needs onText for UI) and as internal impl for collect.
+ */
+export async function processStreamWithCallbacks(events, callbacks, signal) {
+    let text = "";
+    const toolUseBlocks = [];
+    const thinkingBlocks = [];
+    const citations = [];
+    let currentToolUse = null;
+    let currentThinking = null;
+    let currentCitation = null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationTokens = 0;
+    let cacheReadTokens = 0;
+    let apiThinkingTokens = 0; // Actual count from API (Gemini/OpenAI), 0 = use char estimate
+    let compactionContent = null;
+    let isCompactionBlock = false;
+    let contextManagementApplied = false;
+    let stopReason = "end_turn";
+    for await (const event of events) {
+        if (signal?.aborted)
+            break;
+        switch (event.type) {
+            case "content_block_start": {
+                const e = event;
+                const block = e.content_block;
+                if (block.type === "tool_use") {
+                    currentToolUse = {
+                        id: block.id,
+                        name: block.name,
+                        input: "",
+                        thoughtSignature: block.thought_signature,
+                    };
+                    callbacks.onToolStart?.(block.name);
+                }
+                else if (block.type === "thinking") {
+                    currentThinking = { text: "", signature: "" };
+                }
+                else if (block.type === "compaction") {
+                    isCompactionBlock = true;
+                    compactionContent = "";
+                }
+                else if (block.type === "cite") {
+                    // Citation block — initialize from content_block_start payload
+                    currentCitation = {
+                        cited_text: block.cited_text ?? "",
+                        document_index: block.document_index ?? 0,
+                        document_title: block.document_title,
+                        start_char_index: block.start_char_index ?? 0,
+                        end_char_index: block.end_char_index ?? 0,
+                    };
+                }
+                break;
+            }
+            case "content_block_delta": {
+                const e = event;
+                const delta = e.delta;
+                if (delta.type === "text_delta") {
+                    text += delta.text;
+                    callbacks.onText?.(delta.text);
+                }
+                else if (delta.type === "input_json_delta" && currentToolUse) {
+                    currentToolUse.input += delta.partial_json;
+                }
+                else if (delta.type === "thinking_delta" && currentThinking) {
+                    currentThinking.text += delta.thinking || "";
+                    callbacks.onThinking?.(delta.thinking || "");
+                }
+                else if (delta.type === "signature_delta" && currentThinking) {
+                    currentThinking.signature += delta.signature || "";
+                }
+                else if (delta.type === "compaction_delta" && isCompactionBlock) {
+                    if (delta.content != null) {
+                        compactionContent = (compactionContent || "") + delta.content;
+                    }
+                }
+                else if (delta.type === "cite_delta" && currentCitation) {
+                    // Accumulate incremental citation data from deltas
+                    if (delta.cited_text != null)
+                        currentCitation.cited_text += delta.cited_text;
+                    if (delta.document_index != null)
+                        currentCitation.document_index = delta.document_index;
+                    if (delta.document_title != null)
+                        currentCitation.document_title = delta.document_title;
+                    if (delta.start_char_index != null)
+                        currentCitation.start_char_index = delta.start_char_index;
+                    if (delta.end_char_index != null)
+                        currentCitation.end_char_index = delta.end_char_index;
+                }
+                break;
+            }
+            case "content_block_stop": {
+                if (currentToolUse) {
+                    try {
+                        const parsed = JSON.parse(currentToolUse.input || "{}");
+                        toolUseBlocks.push({
+                            id: currentToolUse.id,
+                            name: currentToolUse.name,
+                            input: parsed,
+                            ...(currentToolUse.thoughtSignature ? { thoughtSignature: currentToolUse.thoughtSignature } : {}),
+                        });
+                        // Second callback with parsed input for UI context
+                        callbacks.onToolStart?.(currentToolUse.name, parsed);
+                    }
+                    catch { /* skip bad JSON */ }
+                    currentToolUse = null;
+                }
+                if (currentThinking) {
+                    thinkingBlocks.push({
+                        type: "thinking",
+                        thinking: currentThinking.text,
+                        signature: currentThinking.signature,
+                    });
+                    currentThinking = null;
+                }
+                if (currentCitation) {
+                    const citation = {
+                        type: "cite",
+                        cited_text: currentCitation.cited_text,
+                        document_index: currentCitation.document_index,
+                        start_char_index: currentCitation.start_char_index,
+                        end_char_index: currentCitation.end_char_index,
+                        ...(currentCitation.document_title ? { document_title: currentCitation.document_title } : {}),
+                    };
+                    citations.push(citation);
+                    callbacks.onCitation?.(citation);
+                    currentCitation = null;
+                }
+                if (isCompactionBlock) {
+                    isCompactionBlock = false;
+                    contextManagementApplied = true;
+                }
+                break;
+            }
+            case "message_start": {
+                const e = event;
+                if (e.message?.usage) {
+                    inputTokens += e.message.usage.input_tokens;
+                    cacheCreationTokens += e.message.usage.cache_creation_input_tokens || 0;
+                    cacheReadTokens += e.message.usage.cache_read_input_tokens || 0;
+                }
+                break;
+            }
+            case "message_delta": {
+                const e = event;
+                if (e.usage) {
+                    outputTokens += e.usage.output_tokens;
+                    // Non-Anthropic providers (Gemini, OpenAI) emit input_tokens and cache info in message_delta
+                    if (e.usage.input_tokens) {
+                        inputTokens += e.usage.input_tokens;
+                    }
+                    if (e.usage.cache_read_input_tokens) {
+                        cacheReadTokens += e.usage.cache_read_input_tokens;
+                    }
+                    if (e.usage.thinking_tokens) {
+                        apiThinkingTokens += e.usage.thinking_tokens;
+                    }
+                }
+                if (e.delta?.stop_reason) {
+                    stopReason = e.delta.stop_reason;
+                }
+                if (e.delta?.context_management?.applied_edits?.length) {
+                    contextManagementApplied = true;
+                }
+                break;
+            }
+            case "error": {
+                const errMsg = typeof event.error === "string"
+                    ? event.error
+                    : JSON.stringify(event.error);
+                throw new Error(errMsg);
+            }
+        }
+    }
+    // Use actual thinking token count from API when available (Gemini/OpenAI),
+    // otherwise estimate from character count (~4 chars per token)
+    const thinkingTokens = apiThinkingTokens > 0
+        ? apiThinkingTokens
+        : thinkingBlocks.reduce((sum, b) => sum + Math.ceil(b.thinking.length / 4), 0);
+    return {
+        text,
+        toolUseBlocks,
+        thinkingBlocks,
+        thinkingTokens,
+        citations,
+        usage: {
+            inputTokens,
+            outputTokens,
+            cacheCreationTokens,
+            cacheReadTokens,
+        },
+        compactionContent,
+        contextManagementApplied,
+        stopReason,
+    };
+}

package/dist/shared/tool-dispatch.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Unified Tool Dispatch — ONE implementation replacing 4 duplicates.
+ *
+ * Handles: loop detection, parallel execution, result truncation, bail-out.
+ * Used by agent-loop, subagent, teammate, and server-agent-loop.
+ */
+import { LoopDetector } from "./agent-core.js";
+import type { ToolUseBlock, ToolResultMessage } from "./types.js";
+export interface ToolDispatchOptions {
+    /** Loop detector instance (shared across turns) */
+    loopDetector: LoopDetector;
+    /** Max concurrent tool executions (7 for main, 1 for sequential) */
+    maxConcurrent?: number;
+    /** @deprecated — Anthropic context_management handles limits. Only SAFETY_MAX_CHARS applies. */
+    maxResultChars?: number;
+    /** Per-tool execution timeout in ms (default 120000 = 2 minutes) */
+    toolTimeoutMs?: number;
+    /** Called when a tool starts executing */
+    onStart?: (name: string, input: Record<string, unknown>) => void;
+    /** Called when a tool finishes */
+    onResult?: (name: string, success: boolean, result: string, durationMs: number) => void;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Transcribe audio data — called when __AUDIO__ marker detected in tool result */
+    transcribeAudio?: (base64: string, mediaType: string) => Promise<string>;
+}
+export type ToolExecutor = (name: string, input: Record<string, unknown>) => Promise<{
+    success: boolean;
+    output: string;
+}>;
+/**
+ * Execute tool calls with loop detection, parallel batching, and truncation.
+ * Returns tool result messages in original order.
+ */
+export declare function dispatchTools(toolCalls: ToolUseBlock[], executor: ToolExecutor, opts: ToolDispatchOptions): Promise<{
+    results: ToolResultMessage[];
+    bailOut: boolean;
+    bailMessage?: string;
+}>;
+/**
+ * Build assistant content array from stream result for the next conversation turn.
+ */
+export declare function buildAssistantContent(opts: {
+    text: string;
+    toolUseBlocks: ToolUseBlock[];
+    thinkingBlocks?: Array<{
+        type: "thinking";
+        thinking: string;
+        signature: string;
+    }>;
+    compactionContent?: string | null;
+}): Array<Record<string, unknown>>;

package/dist/shared/tool-dispatch.js

@@ -0,0 +1,191 @@
+/**
+ * Unified Tool Dispatch — ONE implementation replacing 4 duplicates.
+ *
+ * Handles: loop detection, parallel execution, result truncation, bail-out.
+ * Used by agent-loop, subagent, teammate, and server-agent-loop.
+ */
+// ============================================================================
+// TYPES
+// ============================================================================
+/** Hard cap on tool result size — matches Claude Code's 30K char limit.
+ *  Prevents single tool outputs from blowing up context. Anthropic's
+ *  context_management (clear_tool_uses + compact) handles multi-turn growth;
+ *  this cap prevents any ONE result from being catastrophic. */
+const SAFETY_MAX_CHARS = 30_000;
+/** Tools that spawn workers/subprocesses and need much longer than 2 min */
+const LONG_RUNNING_TOOL_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const LONG_RUNNING_TOOLS = new Set(["team_create", "task", "kali", "delegate_task"]);
+// ============================================================================
+// DISPATCH
+// ============================================================================
+/**
+ * Execute tool calls with loop detection, parallel batching, and truncation.
+ * Returns tool result messages in original order.
+ */
+export async function dispatchTools(toolCalls, executor, opts) {
+    const { loopDetector, maxConcurrent = 7, toolTimeoutMs = 120_000, onStart, onResult, signal, transcribeAudio, } = opts;
+    const resultMap = new Map();
+    async function executeSingle(tu) {
+        if (signal?.aborted) {
+            resultMap.set(tu.id, {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: JSON.stringify({ error: "Aborted" }),
+            });
+            return;
+        }
+        // Loop detection check
+        const loopCheck = loopDetector.recordCall(tu.name, tu.input);
+        if (loopCheck.blocked) {
+            onResult?.(tu.name, false, loopCheck.reason, 0);
+            resultMap.set(tu.id, {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: JSON.stringify({ error: loopCheck.reason }),
+            });
+            return;
+        }
+        onStart?.(tu.name, tu.input);
+        const toolStart = Date.now();
+        let result;
+        try {
+            const toolPromise = executor(tu.name, tu.input);
+            const effectiveTimeout = LONG_RUNNING_TOOLS.has(tu.name)
+                ? Math.max(toolTimeoutMs, LONG_RUNNING_TOOL_TIMEOUT_MS)
+                : toolTimeoutMs;
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool "${tu.name}" timed out after ${effectiveTimeout}ms`)), effectiveTimeout));
+            result = await Promise.race([toolPromise, timeoutPromise]);
+        }
+        catch (err) {
+            result = {
+                success: false,
+                output: `Tool execution error: ${err.message || String(err)}`,
+            };
+        }
+        const durationMs = Date.now() - toolStart;
+        loopDetector.recordResult(tu.name, result.success, tu.input);
+        onResult?.(tu.name, result.success, result.output, durationMs);
+        // Check for media markers — convert to appropriate content blocks
+        const mediaMatch = result.success && typeof result.output === "string"
+            ? result.output.match(/^__(IMAGE|AUDIO)__(.+?)__(.+)$/)
+            : null;
+        let resultBlock;
+        if (mediaMatch && mediaMatch[1] === "IMAGE") {
+            // Image → multimodal image content block
+            resultBlock = {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: [
+                    {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: mediaMatch[2],
+                            data: mediaMatch[3],
+                        },
+                    },
+                ],
+            };
+        }
+        else if (mediaMatch && mediaMatch[1] === "AUDIO") {
+            // Audio → transcribe via Whisper, return transcript as text
+            let transcript;
+            if (transcribeAudio) {
+                try {
+                    transcript = await transcribeAudio(mediaMatch[3], mediaMatch[2]);
+                }
+                catch (err) {
+                    transcript = `Audio transcription failed: ${err.message}. The audio file was read successfully but could not be transcribed.`;
+                }
+            }
+            else {
+                transcript = "Audio file detected but transcription is not available. Configure an OpenAI API key for audio transcription via Whisper.";
+            }
+            resultBlock = {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: transcript,
+            };
+        }
+        else {
+            const rawContent = result.success
+                ? result.output
+                : JSON.stringify({ error: result.output });
+            let contentStr = typeof rawContent === "string"
+                ? rawContent
+                : JSON.stringify(rawContent);
+            // Safety-only cap — prevents OOM from pathological tool outputs.
+            // Normal results flow through unmodified; Anthropic's context_management
+            // API clears old tool uses when context grows (clear_tool_uses_20250919).
+            if (contentStr.length > SAFETY_MAX_CHARS) {
+                contentStr =
+                    contentStr.slice(0, SAFETY_MAX_CHARS) +
+                        `\n\n... (safety truncated — ${contentStr.length.toLocaleString()} chars total)`;
+            }
+            resultBlock = {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: contentStr,
+            };
+        }
+        resultMap.set(tu.id, resultBlock);
+    }
+    // Execute in parallel batches
+    for (let i = 0; i < toolCalls.length; i += maxConcurrent) {
+        if (signal?.aborted)
+            break;
+        const batch = toolCalls.slice(i, i + maxConcurrent);
+        await Promise.all(batch.map((tu) => executeSingle(tu)));
+    }
+    // Collect results in original order
+    const results = [];
+    for (const tu of toolCalls) {
+        const r = resultMap.get(tu.id);
+        if (r)
+            results.push(r);
+    }
+    // Bail-out detection
+    const bailCheck = loopDetector.endTurn();
+    if (bailCheck.shouldBail && results.length > 0) {
+        const lastResult = results[results.length - 1];
+        if (typeof lastResult.content === "string") {
+            lastResult.content = `[SYSTEM WARNING] ${bailCheck.message}\n\n${lastResult.content}`;
+        }
+    }
+    return {
+        results,
+        bailOut: bailCheck.shouldBail,
+        bailMessage: bailCheck.message,
+    };
+}
+// ============================================================================
+// ASSISTANT CONTENT BUILDER — builds message content for next turn
+// ============================================================================
+/**
+ * Build assistant content array from stream result for the next conversation turn.
+ */
+export function buildAssistantContent(opts) {
+    const content = [];
+    // Compaction block must come first
+    if (opts.compactionContent !== null && opts.compactionContent !== undefined) {
+        content.push({ type: "compaction", content: opts.compactionContent });
+    }
+    // Thinking blocks before text/tool_use
+    if (opts.thinkingBlocks) {
+        for (const tb of opts.thinkingBlocks) {
+            content.push(tb);
+        }
+    }
+    if (opts.text) {
+        content.push({ type: "text", text: opts.text });
+    }
+    content.push(...opts.toolUseBlocks.map((t) => ({
+        type: "tool_use",
+        id: t.id,
+        name: t.name,
+        input: t.input,
+        // Preserve Gemini thought signatures through function call round-trips
+        ...(t.thoughtSignature ? { thought_signature: t.thoughtSignature } : {}),
+    })));
+    return content;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Shared Types — unified interfaces used by both CLI and server.
+ *
+ * Replaces 3 separate ToolResult definitions and provides typed SSE events.
+ * Pure TypeScript, no runtime dependencies.
+ */
+/** Canonical tool result format — CLI tools return { success, output } */
+export interface ToolResult {
+    success: boolean;
+    output: string;
+}
+export interface ToolUseBlock {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    /** Gemini thought signature — must be preserved through function call round-trips */
+    thoughtSignature?: string;
+}
+export interface ThinkingBlock {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+}
+export interface CitationBlock {
+    type: "cite";
+    cited_text: string;
+    document_index: number;
+    document_title?: string;
+    start_char_index: number;
+    end_char_index: number;
+}
+/** Result of processing a complete SSE stream */
+export interface StreamResult {
+    text: string;
+    toolUseBlocks: ToolUseBlock[];
+    thinkingBlocks: ThinkingBlock[];
+    thinkingTokens: number;
+    citations: CitationBlock[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+    };
+    compactionContent: string | null;
+    contextManagementApplied: boolean;
+    stopReason: string;
+}
+/** Callbacks for real-time stream processing (used by agent-loop for UI) */
+export interface StreamCallbacks {
+    onText?: (text: string) => void;
+    onToolStart?: (name: string, input?: Record<string, unknown>) => void;
+    onThinking?: (text: string) => void;
+    onCitation?: (citation: CitationBlock) => void;
+}
+export type ContextProfile = "main" | "subagent" | "teammate";
+export interface APIRequestConfig {
+    betas: string[];
+    contextManagement: {
+        edits: Array<Record<string, unknown>>;
+    };
+    thinking?: {
+        type: string;
+        budget_tokens?: number;
+    };
+    maxTokens: number;
+}
+export interface ToolResultMessage {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | Array<Record<string, unknown>>;
+}

package/dist/shared/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared Types — unified interfaces used by both CLI and server.
+ *
+ * Replaces 3 separate ToolResult definitions and provides typed SSE events.
+ * Pure TypeScript, no runtime dependencies.
+ */
+export {};

package/dist/updater.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OTA Auto-Updater for SwagManager MCP Server
+ *
+ * Checks the npm registry for newer versions and self-updates.
+ * - Runs on server startup (non-blocking)
+ * - Runs periodically (default: every 4 hours)
+ * - Updates in-place via `npm install -g` or local install
+ * - Signals the process to restart after update
+ */
+export interface UpdateCheckResult {
+    currentVersion: string;
+    latestVersion: string | null;
+    updateAvailable: boolean;
+    updated: boolean;
+}
+/**
+ * Check for updates and install if available.
+ * Returns the result without restarting — caller decides restart behavior.
+ */
+export declare function checkForUpdates(autoInstall?: boolean): Promise<UpdateCheckResult>;
+/**
+ * Start periodic update checks in the background.
+ * First check runs immediately (non-blocking), then every CHECK_INTERVAL_MS.
+ */
+export declare function startUpdateLoop(autoInstall?: boolean): NodeJS.Timeout;