@a1hvdy/cc-openclaw 0.8.0 → 0.9.0

package/dist/src/openai-compat/message-extractor.js

@@ -0,0 +1,134 @@
+/**
+ * Cluster B — Message extractor.
+ *
+ * Extracted verbatim from `openai-compat.ts:177-301` (Phase 4 Cluster B
+ * Module D). Single function that converts an OpenAI `messages[]` array
+ * into the inputs Claude CLI's bridge expects:
+ *
+ *   - systemPrompt          — joined `role:system` content, undefined if none
+ *   - userMessage           — last user message (with skill-inline applied)
+ *                             OR XML-wrapped tool-result block when the
+ *                             last non-system message is `role:tool`
+ *   - userMessageBlocks     — tool-stream mode only: native Anthropic
+ *                             content blocks (tool_result + text) for the
+ *                             stream-json input path
+ *   - isNewConversation     — drives session-create vs session-append
+ *
+ * Single call site in the orchestrator (handleChatCompletion line 482).
+ * The two types `UserMessageBlock` and `ExtractedMessage` are also re-
+ * exported from openai-compat.ts for callers across the orchestrator
+ * (formatCompletionResponse + helpers all consume them as parameters).
+ *
+ * Session-reset semantics:
+ *   - X-Session-Reset: 1|true  → always treated as new conversation
+ *   - OPENAI_COMPAT_NEW_CONVO_HEURISTIC=1 (env) → legacy
+ *     "system + single user ⇒ new conversation" rule, opt-in for
+ *     callers that re-send the full transcript every turn
+ *   - Default (env unset)       → only the explicit header creates a new
+ *     conversation; persistent CLI sessions survive across turns and
+ *     benefit from Anthropic prompt caching (PR #40)
+ */
+import { serializeToolResults, serializeToolResultsAsBlocks, } from './tool-results-serializer.js';
+import { isToolStreamMode } from './mode-flags.js';
+import { maybeInlineSkill } from './skill-resolver.js';
+import { isOpenaiCompatNewConvoHeuristic } from '../lib/config.js';
+/**
+ * Extract the relevant parts from an OpenAI messages array.
+ *
+ * Sessions are stateful — we only need the last user message. The tricky
+ * question is whether to start a fresh session or append to the existing one.
+ *
+ * Default mode (no env var): only honor an explicit `X-Session-Reset: 1`
+ * header. This is correct for clients that maintain their own conversation
+ * transcript and forward only the latest user turn (OpenClaw main agent
+ * loop, cron jobs, subagents). The previous heuristic
+ * (`nonSystemMessages.length <= 1`) fired on every such request, killing the
+ * persistent CLI every turn and preventing Anthropic prompt caching from
+ * ever warming. Originally diagnosed in PR #40 by @megayounus786.
+ *
+ * Legacy mode (`OPENAI_COMPAT_NEW_CONVO_HEURISTIC=1`): restore the old
+ * `system + single user ⇒ new conversation` rule, for clients that re-send
+ * the full transcript on every turn (ChatGPT-Next-Web, Open WebUI, data
+ * labeling tools, etc). They use the transcript shape itself as their only
+ * "start a new conversation" signal.
+ *
+ * The env var is read on every call so ops can flip it via launchctl setenv
+ * without restarting the server.
+ */
+export function extractUserMessage(messages, headers) {
+    if (!messages || messages.length === 0) {
+        throw new Error('messages array is empty');
+    }
+    // Normalize content from any message: OpenAI API allows content as a string
+    // OR an array of content parts (e.g. multimodal messages with text + images).
+    // We need a string for the CLI, so arrays are joined.
+    const textOf = (m) => {
+        if (typeof m.content === 'string')
+            return m.content;
+        if (Array.isArray(m.content)) {
+            return m.content
+                .map((p) => p.text || '')
+                .filter(Boolean)
+                .join('');
+        }
+        return m.content != null ? String(m.content) : '';
+    };
+    // Extract system prompt if present
+    const systemMessages = messages.filter((m) => m.role === 'system');
+    const systemPrompt = systemMessages.length > 0 ? systemMessages.map(textOf).join('\n') : undefined;
+    // Handle tool result messages — only when the LAST non-system message is
+    // a tool role (meaning we're in an active tool-use cycle). If the last
+    // message is a user role, it's a follow-up in an existing conversation
+    // and the old tool results are already in the CLI's history.
+    const lastNonSystem = [...messages].reverse().find((m) => m.role !== 'system');
+    if (lastNonSystem?.role === 'tool') {
+        const userMessages = messages.filter((m) => m.role === 'user');
+        const lastUserText = userMessages.length > 0 ? textOf(userMessages[userMessages.length - 1]) : '';
+        // Phase 2 R4 wire-up: in tool-stream mode, emit native Anthropic
+        // tool_result blocks instead of XML-wrapped text. Claude CLI's
+        // stream-json input accepts content arrays directly.
+        if (isToolStreamMode()) {
+            const toolBlocks = serializeToolResultsAsBlocks(messages);
+            const userMessageBlocks = [...toolBlocks];
+            if (lastUserText) {
+                userMessageBlocks.push({ type: 'text', text: lastUserText });
+            }
+            // Keep userMessage populated as the legacy XML form for callers
+            // that don't yet handle the structured path. Both fields agree in
+            // intent; consumers should prefer userMessageBlocks when present.
+            const fallback = serializeToolResults(messages);
+            const userMessage = lastUserText ? `${fallback}\n\n${lastUserText}` : fallback;
+            return { systemPrompt, userMessage, userMessageBlocks, isNewConversation: false };
+        }
+        const toolResultBlock = serializeToolResults(messages);
+        const userMessage = lastUserText ? `${toolResultBlock}\n\n${lastUserText}` : toolResultBlock;
+        return { systemPrompt, userMessage, isNewConversation: false };
+    }
+    // Find last user message
+    const userMessages = messages.filter((m) => m.role === 'user');
+    if (userMessages.length === 0) {
+        throw new Error('No user message found in messages array');
+    }
+    const rawUserMessage = textOf(userMessages[userMessages.length - 1]);
+    // Workspace skill auto-inline: if the last user message is /<skill> [args]
+    // and ~/.openclaw/workspace/skills/*/SKILL.md has a matching `name:` in
+    // frontmatter, replace the user message with the SKILL.md body so the
+    // model has full skill context without needing the Read tool (cc-openclaw
+    // disables built-in tools by design — see the `sessionConfig.tools = ''`
+    // line below).
+    const userMessage = maybeInlineSkill(rawUserMessage) ?? rawUserMessage;
+    // 1. Explicit reset header — honored in both modes. Normalize trim+lowercase
+    //    so callers using `TRUE`, ` 1 `, etc. don't silently fail.
+    const rawReset = headers?.['x-session-reset'];
+    const resetHeader = typeof rawReset === 'string' ? rawReset.trim().toLowerCase() : '';
+    if (resetHeader === 'true' || resetHeader === '1') {
+        return { systemPrompt, userMessage, isNewConversation: true };
+    }
+    // 2. Legacy heuristic — only when explicitly opted in via env var.
+    if (isOpenaiCompatNewConvoHeuristic()) {
+        const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+        return { systemPrompt, userMessage, isNewConversation: nonSystemMessages.length <= 1 };
+    }
+    return { systemPrompt, userMessage, isNewConversation: false };
+}
+//# sourceMappingURL=message-extractor.js.map

package/dist/src/openai-compat/message-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-extractor.js","sourceRoot":"","sources":["../../../src/openai-compat/message-extractor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,34 @@
+/**
+ * Cluster B beachhead — tool-mode flag predicates.
+ *
+ * Extracted from `openai-compat.ts` so that `session-key-resolver.ts`
+ * (and future Cluster B modules) can read these flags without creating
+ * a circular import back into the orchestrator.
+ *
+ * Behavior preserved bit-for-bit from the original definitions in
+ * `openai-compat.ts:126-142`. openai-compat.ts re-exports both
+ * functions for any external caller that previously imported them
+ * from there (none exist today, but the re-export is cheap insurance).
+ *
+ * Cluster B follow-on will fold these into the `IToolBridge` strategy
+ * pattern (PRP §5 Cluster B `bridges/factory.ts`); for now they
+ * remain free-function predicates.
+ */
+/**
+ * Legacy mode: when set, tool definitions are prepended to every user
+ * message instead of being baked into the session system prompt. Defeats
+ * prompt caching but allows mutating the tool list mid-session.
+ *
+ * Truthy values: '1', 'true', 'yes' (case-insensitive, trimmed).
+ */
+export declare function isToolsPerMessageModeEnabled(): boolean;
+/**
+ * Phase 2 R5: tool-stream mode flag. When `CC_OPENCLAW_TOOL_STREAM=1`
+ * AND the caller provides `tools[]`, cc-openclaw skips the defensive
+ * "no tools" system prompt and does NOT clear `sessionConfig.tools`,
+ * allowing Claude CLI's native tool_use events to flow through the
+ * parser+translator pipeline.
+ *
+ * Strict opt-in: only true when env value is exactly `'1'`.
+ */
+export declare function isToolStreamMode(): boolean;

package/dist/src/openai-compat/mode-flags.js

@@ -0,0 +1,44 @@
+/**
+ * Cluster B beachhead — tool-mode flag predicates.
+ *
+ * Extracted from `openai-compat.ts` so that `session-key-resolver.ts`
+ * (and future Cluster B modules) can read these flags without creating
+ * a circular import back into the orchestrator.
+ *
+ * Behavior preserved bit-for-bit from the original definitions in
+ * `openai-compat.ts:126-142`. openai-compat.ts re-exports both
+ * functions for any external caller that previously imported them
+ * from there (none exist today, but the re-export is cheap insurance).
+ *
+ * Cluster B follow-on will fold these into the `IToolBridge` strategy
+ * pattern (PRP §5 Cluster B `bridges/factory.ts`); for now they
+ * remain free-function predicates.
+ */
+import { getOpenaiCompatToolsPerMessage } from '../lib/config.js';
+/**
+ * Legacy mode: when set, tool definitions are prepended to every user
+ * message instead of being baked into the session system prompt. Defeats
+ * prompt caching but allows mutating the tool list mid-session.
+ *
+ * Truthy values: '1', 'true', 'yes' (case-insensitive, trimmed).
+ */
+export function isToolsPerMessageModeEnabled() {
+    const v = getOpenaiCompatToolsPerMessage();
+    if (!v)
+        return false;
+    const t = v.trim().toLowerCase();
+    return t === '1' || t === 'true' || t === 'yes';
+}
+/**
+ * Phase 2 R5: tool-stream mode flag. When `CC_OPENCLAW_TOOL_STREAM=1`
+ * AND the caller provides `tools[]`, cc-openclaw skips the defensive
+ * "no tools" system prompt and does NOT clear `sessionConfig.tools`,
+ * allowing Claude CLI's native tool_use events to flow through the
+ * parser+translator pipeline.
+ *
+ * Strict opt-in: only true when env value is exactly `'1'`.
+ */
+export function isToolStreamMode() {
+    return process.env.CC_OPENCLAW_TOOL_STREAM === '1';
+}
+//# sourceMappingURL=mode-flags.js.map

package/dist/src/openai-compat/mode-flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-flags.js","sourceRoot":"","sources":["../../../src/openai-compat/mode-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,UAAU,4BAA4B;IAC1C,MAAM,CAAC,GAAG,8BAA8B,EAAE,CAAC;IAC3C,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACrB,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACjC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,KAAK,CAAC;AAClD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,GAAG,CAAC;AACrD,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * 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): Promise<void>;

package/dist/src/openai-compat/non-streaming-handler.js

@@ -0,0 +1,108 @@
+/**
+ * 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 { reportStatus, getToolDescription } from './status-reporter.js';
+import { parseToolCallsFromText } from './tool-calls-parser.js';
+import { formatCompletionResponse } from './response-formatter.js';
+import { getSurfaceThinkingEnabled } from '../lib/config.js';
+import { emit as emitTrajectory } from '../lib/trajectory.js';
+import { formatError, ERROR_CODES } from '../lib/error-formatter.js';
+export async function handleNonStreaming(manager, sessionName, model, 
+// Phase 2 R4 wire-up: accepts native content-block arrays in tool-stream mode.
+userMessage, completionId, res, hasTools) {
+    try {
+        reportStatus('thinking', 'Processing request...');
+        // v0.7.1: accumulate thinking-block content when surfaceThinking is on.
+        // Default OFF for privacy — empty string means no `reasoning` field
+        // gets attached to the response.
+        const surfaceThinking = getSurfaceThinkingEnabled();
+        let thinkingBuffer = '';
+        const result = await manager.sendMessage(sessionName, userMessage, {
+            onEvent: (event) => {
+                if (event.type === 'tool_use' && event.tool?.name) {
+                    const desc = getToolDescription(event.tool.name, event.tool.input);
+                    reportStatus('working', desc, event.tool.name);
+                    // Pillar B v0.4.3: trajectory tool_use event. Emit tool name and
+                    // input-arg keys (not values — keys leak no sensitive content
+                    // while still letting offline analysis cluster tool-call shapes).
+                    emitTrajectory('tool_use', {
+                        name: event.tool.name,
+                        inputKeys: event.tool.input ? Object.keys(event.tool.input) : [],
+                    }, sessionName);
+                }
+                else if (event.type === 'tool_result') {
+                    emitTrajectory('tool_result', {}, sessionName);
+                }
+            },
+            // v0.7.1: when surfaceThinking is on, accumulate extended-thinking text
+            // for the `reasoning` field on the OpenAI response. Subscribing to the
+            // callback always (cheap closure cost ~ none); only buffering when
+            // the env flag is set so the privacy-default-OFF promise holds.
+            onThinking: surfaceThinking
+                ? (text) => {
+                    thinkingBuffer += text;
+                }
+                : undefined,
+        });
+        reportStatus('idle', 'Ready');
+        let tokensIn = 0;
+        let tokensOut = 0;
+        try {
+            const status = manager.getStatus(sessionName);
+            tokensIn = status.stats.tokensIn;
+            tokensOut = status.stats.tokensOut;
+        }
+        catch {
+            /* stats unavailable */
+        }
+        // v0.7.1: emit thinking_block trajectory event with token-count metadata
+        // only (never raw text). Fires when buffer is non-empty regardless of
+        // whether the response surfaces it — so observability is independent
+        // of the user-visible flag.
+        if (thinkingBuffer.length > 0) {
+            emitTrajectory('thinking_block', {
+                excerpt_chars: thinkingBuffer.length,
+                tokens_approx: Math.ceil(thinkingBuffer.length / 4),
+            }, sessionName);
+        }
+        // Parse tool_calls from response text when caller provided tools
+        if (hasTools) {
+            const parsed = parseToolCallsFromText(result.output);
+            const response = formatCompletionResponse(completionId, model, parsed.textContent ?? '', tokensIn, tokensOut, parsed.toolCalls.length > 0 ? parsed.toolCalls : undefined, surfaceThinking ? thinkingBuffer : undefined);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+        }
+        else {
+            const response = formatCompletionResponse(completionId, model, result.output, tokensIn, tokensOut, undefined, surfaceThinking ? thinkingBuffer : undefined);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+        }
+    }
+    catch (err) {
+        reportStatus('idle', 'Request failed');
+        // v0.4.3: route through formatError for errors_total + trajectory error.
+        formatError(err, { code: ERROR_CODES.SESSION_ERROR, sessionId: sessionName, details: { phase: 'handleNonStreaming' } });
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
+    }
+}
+//# sourceMappingURL=non-streaming-handler.js.map

package/dist/src/openai-compat/non-streaming-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-streaming-handler.js","sourceRoot":"","sources":["../../../src/openai-compat/non-streaming-handler.ts"],"names":[],"mappings":"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"}

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

@@ -6,6 +6,17 @@
  * 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';
 export interface OpenAIChatMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
     content: string | Array<{
@@ -96,171 +107,10 @@ export interface OpenAIChatCompletionChunk {
         total_tokens: number;
     };
 }
-/**
- * Derive a session key from the request.
- * Priority: X-Session-Id header > user field > sha1(model + systemPrompt) > "default"
- *
- * The system-prompt-hash fallback prevents the bug where every caller without
- * X-Session-Id or `user` collapses onto a single shared "openai-default"
- * plugin session. In multi-caller setups (OpenClaw routing the main agent,
- * cron jobs, and subagents through the same gateway) that previously meant
- * every request serialized against every other and frequently picked up the
- * wrong session's appendSystemPrompt — also a privacy leak across callers.
- *
- * The model is mixed into the hash so that two callers with the same system
- * prompt but different requested models don't collide and silently get
- * responses from the wrong model. Originally diagnosed in PR #40 by
- * @megayounus786.
- */
-/**
- * When set (to '1', 'true', 'yes'), the proxy preserves the pre-fix behavior:
- *   - tools injected into every user message
- *   - session key NOT fingerprinted by tools (same session across tool changes)
- * Default (unset) is the new behavior: tools embedded in session system prompt
- * at create time + session key fingerprinted by tools. The new behavior
- * eliminates periodic latency spikes but does not support mutating the tool
- * list within a single session (a new session is created when tools change).
- */
-export declare function isToolsPerMessageModeEnabled(): boolean;
-/**
- * Phase 2 R5: tool-stream mode flag. When `CC_OPENCLAW_TOOL_STREAM=1` AND the
- * caller provides `tools[]`, cc-openclaw skips the defensive "no tools"
- * system prompt and does NOT clear `sessionConfig.tools`, allowing Claude
- * CLI's native tool_use events to flow through the new parser+translator
- * pipeline (Phase 4 Pillar 0.5). Default off; opt-in for the new path.
- */
-export declare function isToolStreamMode(): boolean;
-/**
- * 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;
-/**
- * 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;
-export declare function resolveSessionKey(body: OpenAIChatCompletionRequest, headers: http.IncomingHttpHeaders): string;
-/** Build the full session name from a key */
-export declare function sessionNameFromKey(key: string): 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;
-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;
-/**
- * Serialize tool result messages into a text block for the CLI model.
- * Converts OpenAI `tool` role messages into <tool_result> tags.
- *
- * Legacy path (CC_OPENCLAW_TOOL_STREAM=0). Used when the model receives
- * tool definitions via the system prompt's <available_tools> XML block
- * and emits <tool_calls> XML in response. Tool-stream mode (R4) uses
- * `serializeToolResultsAsBlocks()` instead, returning native Anthropic
- * `tool_result` content blocks that Claude CLI parses directly.
- */
-export declare function serializeToolResults(messages: OpenAIChatMessage[]): string;
-/**
- * Phase 2 R4: native Anthropic `tool_result` content blocks.
- *
- * In tool-stream mode (CC_OPENCLAW_TOOL_STREAM=1), this replaces
- * `serializeToolResults()` XML wrapping. Returns blocks shaped like:
- *
- *   { type: 'tool_result', tool_use_id: 'toolu_X', content: '...' }
- *
- * Claude CLI's stream-json input format accepts these as user-message
- * content arrays. The model then continues generation with the tool
- * result in context, emitting either more `tool_use` events or final
- * text — no XML round-tripping required.
- *
- * Wiring into the live request path lands with Phase 4 Pillar 0.5
- * tasks R1+R2 (parser+translator response-side integration), where
- * `extractUserMessage` produces structured content arrays in
- * tool-stream mode.
- */
-export interface AnthropicToolResultBlock {
-    type: 'tool_result';
-    tool_use_id: string;
-    content: string;
-}
-export declare function serializeToolResultsAsBlocks(messages: OpenAIChatMessage[]): AnthropicToolResultBlock[];
-/**
- * Phase 2 R4 wire-up: optional structured content for tool-stream mode.
- * When set, consumers should send this array to the subprocess instead of
- * the legacy XML-wrapped `userMessage` string. Each element is either a
- * native Anthropic `tool_result` block (for prior tool outputs) or a
- * `text` block (for the user's follow-up message).
- */
-export type UserMessageBlock = AnthropicToolResultBlock | {
-    type: 'text';
-    text: string;
-};
-export interface ExtractedMessage {
-    systemPrompt: string | undefined;
-    userMessage: string;
-    /**
-     * Populated only in tool-stream mode when the last non-system message
-     * is a tool-role result. Carries native Anthropic tool_result blocks
-     * + optional follow-up text. When undefined, consumers fall back to
-     * the string `userMessage` (legacy XML-wrapped path).
-     */
-    userMessageBlocks?: UserMessageBlock[];
-    isNewConversation: boolean;
-}
-/**
- * Extract the relevant parts from an OpenAI messages array.
- *
- * Sessions are stateful — we only need the last user message. The tricky
- * question is whether to start a fresh session or append to the existing one.
- *
- * Default mode (no env var): only honor an explicit `X-Session-Reset: 1`
- * header. This is correct for clients that maintain their own conversation
- * transcript and forward only the latest user turn (OpenClaw main agent
- * loop, cron jobs, subagents). The previous heuristic
- * (`nonSystemMessages.length <= 1`) fired on every such request, killing the
- * persistent CLI every turn and preventing Anthropic prompt caching from
- * ever warming. Originally diagnosed in PR #40 by @megayounus786.
- *
- * Legacy mode (`OPENAI_COMPAT_NEW_CONVO_HEURISTIC=1`): restore the old
- * `system + single user ⇒ new conversation` rule, for clients that re-send
- * the full transcript on every turn (ChatGPT-Next-Web, Open WebUI, data
- * labeling tools, etc). They use the transcript shape itself as their only
- * "start a new conversation" signal.
- *
- * The env var is read on every call so ops can flip it via launchctl setenv
- * without restarting the server.
- */
-export declare function extractUserMessage(messages: OpenAIChatMessage[], headers?: Record<string, string | string[] | undefined>): ExtractedMessage;
-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;
-/** SessionManager-like interface to avoid circular imports */
-interface SessionManagerLike {
+/** 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;
     }>;
@@ -283,4 +133,3 @@ interface SessionManagerLike {
     compactSession(name: string): Promise<unknown>;
 }
 export declare function handleChatCompletion(manager: SessionManagerLike, body: Record<string, unknown>, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;
-export {};