@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

package/dist/src/openai-compat/non-streaming-handler.d.ts

@@ -1,29 +0,0 @@
-/**
- * Cluster B Phase 2 — Non-streaming HTTP handler.
- *
- * Extracted verbatim from `openai-compat.ts:508-615` (Module G).
- * Handles the response path when the caller did NOT request `stream:true` —
- * a single buffered Claude CLI session call, then one JSON object back to
- * the client.
- *
- * Lifecycle:
- *   1. reportStatus('thinking') → SessionManager.sendMessage(...)
- *   2. On each tool_use event → push a status update + emit trajectory
- *   3. On each tool_result event → emit trajectory only (no status)
- *   4. v0.7.1: accumulate thinking-block content when surfaceThinking is on
- *   5. On completion → read token stats, format response, write back
- *   6. On error → reportStatus('idle','Request failed') + 500 with
- *      structured `formatError` telemetry
- *
- * Parameterized fully — no closure capture from openai-compat.ts. All
- * dependencies are imported from their dedicated Cluster B modules
- * (response-formatter, tool-calls-parser, status-reporter,
- * message-extractor for types) or from lib/.
- */
-import type * as http from 'node:http';
-import type { SessionManagerLike } from './openai-compat.js';
-import type { UserMessageBlock } from './message-extractor.js';
-export declare function handleNonStreaming(manager: SessionManagerLike, sessionName: string, model: string, userMessage: string | UserMessageBlock[], completionId: string, res: http.ServerResponse, hasTools: boolean, slashCommand?: {
-    cmd: string;
-    mode?: string;
-}): Promise<void>;

package/dist/src/openai-compat/openai-chunk-types.d.ts

@@ -1,35 +0,0 @@
-/**
- * OpenAI streaming chunk types.
- *
- * Extracted from `openai-compat.ts` 2026-05-13 to push that file under the
- * 500-LOC ceiling. Single source of truth for the SSE chunk shape; also
- * imported by `response-formatter.ts`, `types/route.ts`, `types/sse.ts`.
- */
-export interface OpenAIChatCompletionChunk {
-    id: string;
-    object: 'chat.completion.chunk';
-    created: number;
-    model: string;
-    choices: Array<{
-        index: number;
-        delta: {
-            role?: string;
-            content?: string | null;
-            tool_calls?: Array<{
-                index: number;
-                id?: string;
-                type?: 'function';
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }>;
-        };
-        finish_reason: string | null;
-    }>;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}

package/dist/src/openai-compat/openai-compat.d.ts

@@ -1,49 +0,0 @@
-/**
- * OpenAI-compatible /v1/chat/completions endpoint.
- *
- * Bridges OpenAI API format to persistent Claude Code sessions, enabling
- * webchat frontends (ChatGPT-Next-Web, Open WebUI, etc.) to use the plugin
- * as a drop-in backend. Stateful sessions maximize Anthropic prompt caching.
- */
-import * as http from 'node:http';
-import { type UserMessageBlock } from './message-extractor.js';
-export { isToolsPerMessageModeEnabled, isToolStreamMode } from './mode-flags.js';
-export { resolveSessionKey, sessionNameFromKey } from './session-key-resolver.js';
-export { noToolsSystemPrompt, buildSessionSystemPrompt, buildToolPromptBlock } from './prompts.js';
-export { parseToolCallsFromText, type ParsedToolCalls } from './tool-calls-parser.js';
-export { serializeToolResults, serializeToolResultsAsBlocks, type AnthropicToolResultBlock, } from './tool-results-serializer.js';
-export { extractUserMessage, type UserMessageBlock, type ExtractedMessage, } from './message-extractor.js';
-export { formatCompletionResponse, formatCompletionChunk } from './response-formatter.js';
-export { reportStatus, getToolDescription } from './status-reporter.js';
-export { handleNonStreaming } from './non-streaming-handler.js';
-export { handleStreaming } from './streaming-handler.js';
-import type { OpenAIChatCompletionRequest as OpenAIChatCompletionRequestType } from './openai-types.js';
-export type { OpenAIChatMessage, OpenAIChatCompletionRequest, OpenAIToolCall, OpenAIChatCompletionResponse, } from './openai-types.js';
-export type { OpenAIChatCompletionChunk } from './openai-chunk-types.js';
-/** SessionManager-like interface to avoid circular imports. Exported so
- * the extracted handlers (non-streaming-handler.ts, streaming-handler.ts)
- * can type their `manager` parameter from a single canonical definition. */
-export interface SessionManagerLike {
-    startSession(config: Record<string, unknown>): Promise<{
-        name: string;
-    }>;
-    sendMessage(name: string, message: string | UserMessageBlock[], options?: Record<string, unknown>): Promise<{
-        output: string;
-        sessionId?: string;
-        events: unknown[];
-    }>;
-    stopSession(name: string): Promise<void>;
-    listSessions(): Array<{
-        name: string;
-    }>;
-    getStatus(name: string): {
-        stats: {
-            tokensIn: number;
-            tokensOut: number;
-            contextPercent: number;
-        };
-    };
-    compactSession(name: string): Promise<unknown>;
-}
-export declare function applyDefaultPathPerfHooks(request: OpenAIChatCompletionRequestType): void;
-export declare function handleChatCompletion(manager: SessionManagerLike, body: Record<string, unknown>, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;

package/dist/src/openai-compat/openai-types.d.ts

@@ -1,71 +0,0 @@
-/**
- * Canonical OpenAI request/response type definitions.
- *
- * Extracted from `openai-compat.ts` 2026-05-13 to push that file under the
- * 500-LOC ceiling and to give 4 downstream importers
- * (`tool-results-serializer`, `session-key-resolver`, `message-extractor`,
- * `tool-calls-parser`) a single canonical source instead of importing back
- * through the godmodule.
- */
-export interface OpenAIChatMessage {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string | Array<{
-        type?: string;
-        text?: string;
-    }> | null;
-    tool_calls?: Array<{
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    tool_call_id?: string;
-}
-export interface OpenAIChatCompletionRequest {
-    model?: string;
-    messages: OpenAIChatMessage[];
-    stream?: boolean;
-    temperature?: number;
-    max_tokens?: number;
-    max_completion_tokens?: number;
-    user?: string;
-    tools?: Array<{
-        type: 'function';
-        function: {
-            name: string;
-            description: string;
-            parameters: unknown;
-        };
-    }>;
-}
-export interface OpenAIToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface OpenAIChatCompletionResponse {
-    id: string;
-    object: 'chat.completion';
-    created: number;
-    model: string;
-    choices: Array<{
-        index: number;
-        message: {
-            role: 'assistant';
-            content: string | null;
-            tool_calls?: OpenAIToolCall[];
-            reasoning?: string;
-        };
-        finish_reason: 'stop' | 'length' | 'tool_calls';
-    }>;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}

package/dist/src/openai-compat/parse-route-body.d.ts

@@ -1,24 +0,0 @@
-/**
- * `parseRouteBody` — typed boundary parser for openai-compat HTTP route.
- *
- * Replaces inline `as OpenAIChatMessage[]` casts with a discriminated-union
- * returning either a fully-typed `OpenAIChatCompletionRequest` or an
- * error-coded response. The type system enforces "validate before use."
- *
- * Extracted from `openai-compat.ts` 2026-05-13. Pure validation function —
- * no I/O, no module state. Behavior preserved bit-for-bit per the existing
- * `tests/openai-compat.test.ts` round-trip cases.
- *
- * Type imports cross-reference back to openai-compat.ts; TypeScript handles
- * type-only circular imports cleanly without runtime cycle.
- */
-import type { OpenAIChatCompletionRequest } from './openai-compat.js';
-export type ParseRequestResult = {
-    readonly ok: true;
-    readonly request: OpenAIChatCompletionRequest;
-} | {
-    readonly ok: false;
-    readonly status: number;
-    readonly error: string;
-};
-export declare function parseRouteBody(body: Record<string, unknown>): ParseRequestResult;

package/dist/src/openai-compat/prompts.d.ts

@@ -1,47 +0,0 @@
-/**
- * Cluster B — Session system-prompt builders.
- *
- * Extracted verbatim from `openai-compat.ts:143-250` (Phase 4 Cluster B).
- * Three tightly-coupled pure functions that compose the session-level
- * system prompt sent to Claude CLI on session create:
- *
- *   - `noToolsSystemPrompt(toolLocation)` — anti-hallucination preamble
- *     (varies by CC_OPENCLAW_ALLOW_BUILTINS env flag)
- *   - `buildToolPromptBlock(tools)`       — `<available_tools>` XML block
- *   - `buildSessionSystemPrompt(...)`     — orchestrator that combines
- *     the above with the caller-supplied prompt, honoring tool-stream
- *     and tools-per-message mode flags
- *
- * Behavior is preserved bit-for-bit. The orchestrator (`handleChatCompletion`
- * in openai-compat.ts) calls `buildSessionSystemPrompt` exactly once per
- * fresh session create; `buildToolPromptBlock` is also called directly when
- * tools must be injected per-turn into the user message (legacy path).
- *
- * Type-only import of `OpenAIChatCompletionRequest` keeps the file in a
- * one-way relationship with openai-compat.ts at runtime (ESM erases type
- * imports), so this module can be loaded standalone.
- */
-import type { OpenAIChatCompletionRequest } from './openai-compat.js';
-/**
- * Generate the "no built-in tools" system prompt preamble.
- * The `toolLocation` parameter controls how the model is told where to find
- * tool definitions — 'system' means "in the <available_tools> block below"
- * (tools baked into system prompt), 'user' means "in <available_tools> tags
- * in the user message" (legacy per-turn injection).
- */
-export declare function noToolsSystemPrompt(toolLocation: 'system' | 'user'): string;
-/**
- * Convert OpenAI tool definitions into a structured prompt block.
- * Injected into the user message so the CLI model sees tool definitions
- * and responds with <tool_calls> tags when it wants to invoke a function.
- */
-export declare function buildToolPromptBlock(tools: OpenAIChatCompletionRequest['tools']): string;
-/**
- * Build the full session system prompt for a Claude Code session with tools.
- * Exported for testability — called from `handleChatCompletion`.
- *
- * - Default mode: tools are embedded in the system prompt (cacheable by Anthropic).
- * - Legacy mode (OPENAI_COMPAT_TOOLS_PER_MESSAGE=1): tools are NOT embedded;
- *   they'll be injected per-turn in the user message instead.
- */
-export declare function buildSessionSystemPrompt(tools: OpenAIChatCompletionRequest['tools'], callerSystemPrompt: string | undefined): string;

package/dist/src/openai-compat/request-coalescer.d.ts

@@ -1,77 +0,0 @@
-/**
- * Single-flight request coalescer for the openai-compat streaming path (v0.27.5).
- *
- * THE PROBLEM (2026-05-22 incident)
- * ─────────────────────────────────
- * When a turn is OOM-killed mid-stream (exit 137) — or simply runs long enough
- * that OpenClaw's HTTP client perceives the SSE stream as dead — OpenClaw fires
- * a RETRY with a byte-identical request body. session-manager.sendMessage()
- * *serializes* concurrent same-session sends via a per-session promise chain
- * (session-manager.ts:437-453) rather than coalescing them, so the retry runs
- * the FULL turn a second time and delivers a second, identical Telegram message
- * (the "two identical messages" the user reported).
- *
- * THE FIX
- * ───────
- * Classic single-flight (a.k.a. request coalescing): the FIRST request for a
- * given signature becomes the "leader" and runs the model once; any duplicate
- * arriving within DEDUP_WINDOW_MS becomes a "follower" that AWAITS the leader's
- * result and replays it — no second subprocess, no divergent second generation.
- * In the common retry-after-perceived-death case, OpenClaw has already abandoned
- * the leader's connection, so only the follower delivers → exactly one message.
- *
- * SAFETY: FAIL-OPEN BY CONSTRUCTION
- * ─────────────────────────────────
- * The caller wraps every coalescer interaction in try/catch and, on ANY error
- * (or a leader that produced empty text, or a leader that exceeds the turn
- * timeout), falls THROUGH to a normal dispatch. The worst case this can produce
- * is the prior behavior (a possible duplicate) — it can NEVER drop a real reply.
- * That property is the whole point: the user's deepest pain is missing messages,
- * so the duplicate defense must not be able to cause a miss.
- */
-import type * as http from 'node:http';
-/** The leader's captured turn output, replayed verbatim to followers. */
-export interface CoalescedResult {
-    text: string;
-    finishReason: 'stop' | 'tool_calls';
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-interface InFlightEntry {
-    startedAt: number;
-    /** Resolves when the leader's turn completes. `null` ⇒ leader failed or
-     *  produced no replayable text; followers must fail-open to a fresh run. */
-    resultPromise: Promise<CoalescedResult | null>;
-}
-/** Resolve the dedup window. CC_OPENCLAW_DEDUP_WINDOW_MS=0 disables coalescing
- *  entirely (the caller then never enters the leader/follower branches). */
-export declare function getDedupWindowMs(): number;
-/** Stable signature for "the same turn". Session-scoped so two chats sending
- *  identical text never collide. SHA-256 of sessionName + NUL + serialized
- *  input keeps the key bounded regardless of prompt size. */
-export declare function computeSignature(sessionName: string, input: unknown): string;
-/** Return a live (within-window) in-flight entry for `sig`, or undefined.
- *  Prunes a stale entry as a side effect so the map self-heals. */
-export declare function findInFlight(sig: string, windowMs: number): InFlightEntry | undefined;
-/** Register the current request as the leader for `sig`. Returns a `resolve`
- *  the caller MUST invoke in a finally block with the captured result (or
- *  `null` on failure) so followers never hang. The entry is retained for the
- *  window after resolution, then evicted. */
-export declare function registerLeader(sig: string): {
-    resolve: (r: CoalescedResult | null) => void;
-};
-/** Await a leader's result with a hard cap so a wedged leader can't hang the
- *  follower forever. On timeout returns `null` ⇒ caller fails open. */
-export declare function awaitLeader(entry: InFlightEntry, timeoutMs: number): Promise<CoalescedResult | null>;
-/** Replay a leader's captured result to a follower's response as a complete,
- *  well-formed SSE stream (role chunk → content chunk → final chunk → [DONE]).
- *  Mirrors the shape handleStreaming emits so OpenClaw sees an ordinary, valid
- *  completion. Best-effort writes: a disconnected follower socket is harmless. */
-export declare function replayCoalesced(res: http.ServerResponse, completionId: string, model: string, result: CoalescedResult): void;
-/** Test-only helpers. */
-export declare function _resetForTest(): void;
-export declare function _size(): number;
-export {};

package/dist/src/openai-compat/response-formatter.d.ts

@@ -1,33 +0,0 @@
-/**
- * Cluster B — Response formatters.
- *
- * Extracted verbatim from `openai-compat.ts:178-241` (Phase 4 Cluster B
- * Module E — the final Cluster B extraction). Two pure formatters that
- * wrap the model's output in the OpenAI Chat-Completions envelope:
- *
- *   - `formatCompletionResponse(...)` — non-streaming (single object).
- *     Carries `usage`, optional `tool_calls`, optional `reasoning` field,
- *     and a v0.7.2 "Done." text backstop when the model produced no
- *     visible text (the openclaw upstream classifier rejects payloads=0
- *     turns and burns a retry attempt; the directive in the system
- *     prompt is the primary fix, this is belt-and-suspenders).
- *
- *   - `formatCompletionChunk(...)` — streaming SSE chunk. Called once
- *     per delta (start, content, tool_calls, finish_reason).
- *
- * Twelve+ call sites in the orchestrator (handleChatCompletion) — every
- * place that writes back to the OpenAI-shaped HTTP response. Pulling
- * these out keeps the orchestrator focused on session lifecycle and CLI
- * IO; the OpenAI envelope details live alongside the types they shape.
- */
-import type { OpenAIToolCall, OpenAIChatCompletionResponse, OpenAIChatCompletionChunk } from './openai-compat.js';
-export declare function formatCompletionResponse(id: string, model: string, text: string, tokensIn: number, tokensOut: number, toolCalls?: OpenAIToolCall[], 
-/** v0.7.0: when present + non-empty, attached as `choices[0].message.reasoning`
- *  (mirrors OpenAI o1/o3 schema). Caller must already be gated on
- *  `getSurfaceThinkingEnabled()` from `lib/config.ts` — this function does
- *  not re-check the flag. Pass empty string or undefined to omit. */
-reasoning?: string): OpenAIChatCompletionResponse;
-export declare function formatCompletionChunk(id: string, model: string, delta: {
-    role?: string;
-    content?: string;
-}, finishReason: string | null): OpenAIChatCompletionChunk;

package/dist/src/openai-compat/session-key-resolver.d.ts

@@ -1,41 +0,0 @@
-/**
- * Cluster B beachhead — session key resolution.
- *
- * Extracted from `openai-compat.ts:224-270`. Pure functions, no side
- * effects, no external state. The session key is the single most
- * load-bearing concept in the cc-openclaw bridge: it determines whether
- * two requests share a persistent Claude CLI session (and thus benefit
- * from prompt caching) or land in separate sessions.
- *
- * Resolution priority chain (highest → lowest):
- *   1. `X-Session-Id` header                   → caller-explicit override
- *   2. `body.user` field                        → OpenAI standard convention
- *   3. sha1(model + system messages + tools)    → content-derived fingerprint
- *   4. literal `'default'`                      → fallback when nothing distinguishes
- *
- * Tool fingerprint inclusion (point 3) is the v0.4.x fix for the
- * "session reuse with stale tool list" bug — see openai-compat.ts:233-243
- * comments for the original rationale.
- */
-import * as http from 'node:http';
-import type { OpenAIChatCompletionRequest } from './openai-compat.js';
-/**
- * Resolve a stable session key from a request. Behavior preserved
- * verbatim from the original at openai-compat.ts:224.
- *
- * The `tools-per-message` mode opt-out (line 244) restores pre-fix
- * behavior of keying sessions only by system prompt + model — needed
- * for callers that mutate their tool list within one conversation
- * and rely on continuing history across tool changes.
- */
-export declare function resolveSessionKey(body: OpenAIChatCompletionRequest, headers: http.IncomingHttpHeaders): string;
-/**
- * Build the full session name from a key. Adds the `'openai-'` prefix
- * that gates downstream behavior (CWD redirect, tools restoration,
- * CLAUDE.md injection — all in cwd-patch.ts:489). The prefix is
- * load-bearing; do not remove or modify without checking those gates.
- *
- * Cluster D `SessionRegistry` will introduce a branded `SessionName`
- * type so this function returns a typed value rather than a raw string.
- */
-export declare function sessionNameFromKey(key: string): string;

package/dist/src/openai-compat/skill-resolver.d.ts

@@ -1,59 +0,0 @@
-/**
- * Workspace skill resolver — finds and reads
- * ~/.openclaw/workspace/skills/*\/SKILL.md by slash command name (taken
- * from each SKILL.md's frontmatter `name:` field).
- *
- * Used by openai-compat.ts to inline the SKILL.md body into the user
- * prompt when the user invokes /<skillname>. This makes workspace
- * skills work through the cc-openclaw bridge without requiring the
- * model to use the Read tool (which the legacy code path intentionally
- * disables — see the gated `sessionConfig.tools = ''` in openai-compat.ts,
- * Phase 2 R5).
- *
- * Phase 2 R6 (2026-05-02): the resolver operates purely on user-message
- * text — it never reads `request.tools` and never rejects requests that
- * carry tool definitions. Tool-stream mode (CC_OPENCLAW_TOOL_STREAM=1)
- * therefore coexists with skill auto-inline by construction: the user
- * message text gets the SKILL.md body inlined, AND the tools[] allowlist
- * gets forwarded to Claude CLI via sessionConfig.tools (R3). Both fire,
- * neither blocks the other.
- *
- * v0.9.2 (2026-05-11): SKILL.md **bodies** are re-read from disk on
- * every slash invocation; only the directory listing (filename →
- * frontmatter `name:` mapping) is cached, keyed by directory mtime.
- * Pre-v0.9.2 the body was also cached, which surfaced stale content
- * when a user edited a SKILL.md file in place (the dir mtime stayed
- * unchanged, so the cache wasn't refreshed). Analogous in spirit to
- * the upstream OpenClaw 2026.5.7 "clear cached skills snapshots on
- * /new" fix, but narrower. SKILL.md files are small (~few KB); a
- * per-invocation read is ~1ms, well-bounded against rare slash usage.
- *
- * Override path with OPENCLAW_WORKSPACE_SKILLS_DIR env var.
- */
-/**
- * Public shape returned by `resolveSkillForSlash`. Caller (`maybeInlineSkill`)
- * consumes `fullText` and `body`. Both are re-read fresh on every invocation
- * from v0.9.2 onward — previously cached, now fresh-from-disk so in-place
- * SKILL.md edits surface immediately.
- */
-interface SkillEntry {
-    skillDir: string;
-    skillMd: string;
-    body: string;
-    fullText: string;
-}
-export declare function resolveSkillForSlash(name: string): SkillEntry | null;
-/**
- * v0.19.1 M3 — detect leading `/<slash>` (with optional `<system>` wrap)
- * in raw user text, returning `{cmd, mode}` for the live-card pill.
- *
- * Decoupled from `maybeInlineSkill` because the pill should surface even
- * when the slash has no matching SKILL.md (e.g. `/cc /custom-thing`).
- * `mode` is the first whitespace-separated arg token if present.
- */
-export declare function detectSlashCommand(userText: string): {
-    cmd: string;
-    mode?: string;
-} | null;
-export declare function maybeInlineSkill(userText: string): string | null;
-export {};

package/dist/src/openai-compat/sse-translator.d.ts

@@ -1,51 +0,0 @@
-/**
- * Translates parsed Anthropic Messages stream events (from cli-stream-parser)
- * into OpenAI-shaped Server-Sent Events for `/v1/chat/completions` streaming.
- *
- * Output format: each entry is a complete SSE wire chunk including the `data: `
- * prefix and trailing `\n\n`. Caller writes them directly to the response
- * stream.
- *
- * Anthropic content blocks (text vs tool_use vs thinking) become OpenAI
- * `delta.content` (text) or `delta.tool_calls[N]` (tool_use). Thinking
- * blocks are dropped by default; v0.7.0 added an opt-in `surfaceThinking`
- * flag that accumulates thinking_delta text and exposes it as a `reasoning`
- * field (mirroring OpenAI o1/o3 schema). Default OFF for privacy: thinking
- * content can contain raw chain-of-thought, considered-but-rejected
- * candidates, and PII. `signature_delta` is NEVER forwarded — it carries
- * Anthropic's cryptographic block-integrity signature, internal-only.
- *
- * State: each translator instance tracks a per-content-block-index map of
- * `tool_use` blocks to their assigned OpenAI tool_calls index, so
- * `input_json_delta` events emit deltas at the correct tool_calls[N] slot.
- * When `surfaceThinking` is on, additionally tracks `thinkingBuffer` and
- * `thinkingIndex` to assemble the reasoning text across deltas.
- */
-import type { ParsedEvent } from './cli-stream-parser.js';
-export interface SseTranslator {
-    /** Translate a single ParsedEvent into zero or more SSE chunks. */
-    translate(event: ParsedEvent): string[];
-    /** Emit final `data: [DONE]\n\n` sentinel. Call once at end of stream. */
-    done(): string[];
-    /**
-     * v0.7.0: read accumulated thinking text after stream ends. Empty string
-     * when `surfaceThinking` was off or no thinking blocks fired. Used by
-     * non-streaming response builder to attach `choices[0].message.reasoning`.
-     */
-    getReasoning(): string;
-}
-export interface CreateSseTranslatorParams {
-    completionId: string;
-    model: string;
-    /** When true, emits an OpenAI usage chunk on message_delta (default false). */
-    emitUsage?: boolean;
-    /**
-     * v0.7.0: when true, accumulates `thinking_delta` text and emits synthetic
-     * SSE chunks with `delta.reasoning = <text>` (mirroring OpenAI o1/o3 streaming
-     * shape). Default false. Privacy-sensitive — opt-in only via env-flag-driven
-     * caller, typically `getSurfaceThinkingEnabled()` from `lib/config.ts`.
-     * `signature_delta` is NEVER forwarded regardless of this flag.
-     */
-    surfaceThinking?: boolean;
-}
-export declare function createSseTranslator(params: CreateSseTranslatorParams): SseTranslator;

package/dist/src/openai-compat/status-reporter.d.ts

@@ -1,30 +0,0 @@
-/**
- * Cluster B Phase 2 — Status reporting + tool-description helpers.
- *
- * Extracted verbatim from `openai-compat.ts:516-569` (Module F).
- *
- *   - `reportStatus(state, activity, tool?)` — best-effort fire-and-forget
- *     HTTP POST to the OPENAI_COMPAT_STATUS_URL webhook. The receiving
- *     dashboard (e.g. a webchat status bar) gets real-time progress while
- *     the CLI agent runs tools. No-op when the env var is unset.
- *
- *   - `getToolDescription(toolName, toolInput?)` — human-readable one-liner
- *     for a tool call. Used by handleNonStreaming + handleStreaming to
- *     populate the `tool` field of the status payload. Switch on tool name
- *     with sensible fallback ("Using tool: <name>") for unknown tools.
- *
- * Both functions are pure-ish: no shared mutable state, no closure
- * capture from the orchestrator. `reportStatus` reads the URL env
- * variable on every call so ops can flip it via launchctl/PM2 env
- * without restarting the gateway.
- */
-/**
- * Optional status webhook — set `OPENAI_COMPAT_STATUS_URL` to an HTTP endpoint
- * that accepts `POST { state, activity, tool }`. The bridge will fire-and-forget
- * status updates when the CLI agent uses tools, so an external dashboard (e.g.
- * a webchat status bar) can show real-time progress.
- *
- * Example: `OPENAI_COMPAT_STATUS_URL=http://127.0.0.1:18795/my-app/agent-status`
- */
-export declare function reportStatus(state: string, activity: string, tool?: string): void;
-export declare function getToolDescription(toolName: string, toolInput?: Record<string, unknown>): string;

package/dist/src/openai-compat/streaming-handler.d.ts

@@ -1,52 +0,0 @@
-/**
- * Cluster B Phase 2 — Streaming SSE HTTP handler.
- *
- * Extracted verbatim from `openai-compat.ts:514-775` (Module H).
- * Handles the response path when the caller requested `stream:true`.
- * Emits Server-Sent Events with intermediate `delta` chunks and a final
- * chunk carrying `finish_reason` + token usage.
- *
- * Three dispatch paths (decided at runtime by `useToolStream + hasTools`):
- *
- *   1. **Tool-stream mode** (`isToolStreamMode() && hasTools`)
- *      Session-manager's pre-parsed `tool_use` events are bridged
- *      directly to OpenAI `tool_calls` SSE deltas — two chunks per
- *      tool use (start + arguments). Text deltas stream inline.
- *
- *   2. **Legacy tools mode** (`hasTools && !useToolStream`)
- *      Buffer the full response text, post-stream-parse `<tool_calls>`
- *      XML via `parseToolCallsFromText`, emit text + tool_call chunks
- *      with `finish_reason='tool_calls'`.
- *
- *   3. **No-tools** (`!hasTools`)
- *      Stream text deltas inline, emit final chunk with
- *      `finish_reason='stop'`.
- *
- * v0.7.2 backstop: if no visible payload was streamed (no text, no
- * tool_calls), emit a minimal "Done." text chunk before finalizing so
- * the upstream "incomplete terminal response" classifier sees content.
- *
- * Heartbeat: 30s SSE keepalive comment (`: keepalive`) prevents proxies
- * from closing the connection during long Claude CLI thinking phases.
- * Cleaned up in the `finally` block.
- *
- * Client disconnect: `res.on('close')` flips `clientDisconnected` so
- * writes after disconnect short-circuit instead of throwing.
- *
- * Parameterized fully — no closure capture from openai-compat.ts.
- */
-import type * as http from 'node:http';
-import type { SessionManagerLike } from './openai-compat.js';
-import type { UserMessageBlock } from './message-extractor.js';
-export declare function handleStreaming(manager: SessionManagerLike, sessionName: string, model: string, userMessage: string | UserMessageBlock[], completionId: string, res: http.ServerResponse, hasTools: boolean, slashCommand?: {
-    cmd: string;
-    mode?: string;
-}, onFinalText?: (result: {
-    text: string;
-    finishReason: 'stop' | 'tool_calls';
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}) => void): Promise<void>;

package/dist/src/openai-compat/tool-calls-parser.d.ts

@@ -1,34 +0,0 @@
-/**
- * Cluster B — Tool-calls parser.
- *
- * Extracted verbatim from `openai-compat.ts:147-221` (Phase 4 Cluster B
- * Module B). Reads model output text and pulls out any `<tool_calls>`
- * XML blocks, converting them to OpenAI-compatible `OpenAIToolCall[]`.
- *
- * This is the response-side counterpart to `prompts.ts:buildToolPromptBlock`
- * — the prompt tells the model "wrap your tool calls in `<tool_calls>`",
- * and this parser is what reads those tool calls back out of the model's
- * text response on the legacy (non-stream) tool path.
- *
- * Behavior preserved bit-for-bit. Two call sites in the orchestrator
- * (handleChatCompletion lines 950 + 1181) — one on the buffered final
- * output path, one on the streaming-buffered-text path.
- *
- * Robustness contract:
- *   - Multiple `<tool_calls>` blocks in one response → all merged
- *   - JSON parse fail on a block → that block kept as text content
- *   - `arguments` field as string or object → both normalized to string
- *   - `<tool_result>` echoes from the model → stripped from textContent
- */
-import type { OpenAIToolCall } from './openai-compat.js';
-export interface ParsedToolCalls {
-    textContent: string | null;
-    toolCalls: OpenAIToolCall[];
-}
-/**
- * Parse tool_calls from CLI text output.
- *
- * Looks for <tool_calls>[...]</tool_calls> tags in the response text.
- * Returns both the extracted text content (before/after tags) and any tool calls found.
- */
-export declare function parseToolCallsFromText(text: string): ParsedToolCalls;