@a1hvdy/cc-openclaw 0.30.0 → 0.31.0

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

@@ -1,30 +0,0 @@
-/**
- * factory.ts — Bridge factory: reads env flags and returns the active IToolBridge.
- *
- * Mode precedence (highest wins):
- *   CC_OPENCLAW_NATIVE_TOOLS=1  → OpenClawNative  (v0.11.0, default OFF)
- *   CC_OPENCLAW_TOOL_STREAM=1   → NativeStream
- *   OPENAI_COMPAT_TOOLS_PER_MESSAGE=1 → PerMessage
- *   (default)                   → Embedded
- *
- * The three existing modes (Embedded, PerMessage, NativeStream) are NOT
- * implemented as full IToolBridge classes in this PR — their logic lives
- * inside openai-compat.ts. The factory stubs them as thin wrappers that
- * satisfy IToolBridge so callers can type-check against the interface.
- * Only OpenClawNativeBridge is a real implementation here.
- *
- * Coexistence rule: existing flag readers (`isToolsPerMessageModeEnabled`,
- * `isToolStreamMode`) are not touched — factory reads them via the same
- * env vars, not via those helpers, to avoid coupling factory → mode-flags.
- */
-import type { IToolBridge } from '../../types/tool-bridge.js';
-import { ToolMode } from '../../types/tool-bridge.js';
-/**
- * Return the active IToolBridge based on env flags.
- *
- * Call once per request — bridges are lightweight and stateless (except
- * OpenClawNativeToolsBridge which caches the gateway config read).
- */
-export declare function makeToolBridge(): IToolBridge;
-/** Read the active mode without constructing a bridge. Useful for logging. */
-export declare function activeToolMode(): ToolMode;

package/dist/src/openai-compat/bridges/media-bridge.d.ts

@@ -1,34 +0,0 @@
-/**
- * media-bridge.ts — Shared contract for media delivery bridges.
- *
- * `MediaBridge` is the interface all media-type sub-bridges implement.
- * `TtsMediaBridge` (tts-media-bridge.ts) is the v0.11.0 concrete impl.
- * Future: `ImageMediaBridge`, `FileMediaBridge` for v0.12.0.
- */
-/** Structured result from a media bridge execution. */
-export interface MediaBridgeResult {
-    /** Text to inject into the SSE stream in place of the tool_call. */
-    readonly text: string;
-    /** Whether the bridge produced output via the native channel. */
-    readonly delivered: boolean;
-    /** Delivery channel used. Informational — not load-bearing. */
-    readonly via: string;
-}
-/** Every media sub-bridge must satisfy this contract. */
-export interface MediaBridge {
-    /** Canonical tool name this bridge handles (e.g. `message.voice`). */
-    readonly toolName: string;
-    /**
-     * Execute the media delivery. `args` is the raw JSON-parsed tool arguments
-     * from the model's tool_call. Returns a `MediaBridgeResult` — never throws;
-     * fallback text is always produced on error.
-     */
-    execute(args: Record<string, unknown>): Promise<MediaBridgeResult>;
-}
-/** Thrown by bridge internals for structured error propagation.
- *  Caught at the `OpenClawNativeToolsBridge` boundary — never escapes to callers. */
-export declare class MediaBridgeError extends Error {
-    readonly toolName: string;
-    readonly cause?: unknown | undefined;
-    constructor(message: string, toolName: string, cause?: unknown | undefined);
-}

package/dist/src/openai-compat/bridges/openclaw-api-shim.d.ts

@@ -1,54 +0,0 @@
-/**
- * OpenClawApiShim — typed subset of the OpenClaw plugin API surface.
- *
- * Q2 resolution: the upstream OpenClaw plugin API has no semver contract.
- * Rather than depend on it directly, all native-tool calls go through this
- * shim which exposes only the methods cc-openclaw needs.
- *
- * `validateShape(api)` runs at boot phase 3 (`validate-upstream`) and is
- * registered as a `PatchSpec.expectedShape` probe. Failure → `DriftError`
- * and boot refuses (per PatchManifest atomic-install contract).
- *
- * Phase D: types + probe shipped; `dispatch` stubbed and throws
- * `NotImplemented` until Phase E wires the live OpenClaw `api.tool.dispatch`.
- */
-/**
- * Inbound dispatch types for the v1.0.0 ToolBridge strategy. These are
- * complementary to the existing `IToolBridge` at `src/types/tool-bridge.ts`
- * (which handles outbound tools-to-CLI wiring). Phase E consolidates the
- * two interfaces if a clean merge is possible.
- */
-export interface ToolUseCall {
-    readonly id: string;
-    readonly name: string;
-    readonly input: unknown;
-}
-export interface ToolUseResult {
-    readonly toolUseId: string;
-    readonly content: string;
-    readonly isError?: boolean;
-}
-/** Minimum surface area the shim requires from `openclaw.PluginApi`. */
-export interface OpenClawApiSurface {
-    readonly tool: {
-        readonly dispatch: (name: string, input: unknown) => Promise<unknown>;
-        readonly list: () => ReadonlyArray<{
-            readonly name: string;
-        }>;
-    };
-}
-export declare class OpenClawApiShim {
-    private readonly api;
-    constructor(api: OpenClawApiSurface);
-    /**
-     * Phase 3 probe — returns true when `api.tool.dispatch` and `api.tool.list`
-     * exist as callable methods. Used as a `PatchSpec.expectedShape` probe.
-     */
-    static validateShape(api: unknown): boolean;
-    /**
-     * Dispatch a Claude `tool_use` event to OpenClaw's plugin API. Phase D stub.
-     */
-    dispatch(_call: ToolUseCall): Promise<ToolUseResult>;
-    /** Phase D helper — exposes the underlying surface for tests. */
-    getApi(): OpenClawApiSurface;
-}

package/dist/src/openai-compat/bridges/openclaw-native-tools.d.ts

@@ -1,61 +0,0 @@
-/**
- * openclaw-native-tools.ts — IToolBridge impl for ToolMode.OpenClawNative.
- *
- * v0.11.0 investigation result: OpenClaw DOES expose `/tools/invoke` at
- * `http://127.0.0.1:18790` with Bearer token auth (confirmed in
- * extensions/cc-openclaw/openclaw-mcp-bridge.cjs). However, the gateway's
- * `tools.allow` list in openclaw.json only includes `claude_session_*` and
- * council/ultraplan commands — `message.voice` is NOT there. Invoking
- * `/tools/invoke` for voice would 404/401 at runtime.
- *
- * Decision: Path B (internal marker translation) for v0.11.0. `executeNative`
- * routes `message.voice` through TtsMediaBridge → `[[tts:text]]` markers.
- * OpenClaw's existing `maybeApplyTtsToPayload` picks them up downstream.
- * This is identical to the voice-recovery.ts rescue path — the difference is
- * the call site: here the model emits a proper tool_call, not raw text XML.
- *
- * Path A (real HTTP POST to `/tools/invoke`) is fully wired in `executeHttp`
- * and ready to activate in v0.12.0 when A1 adds `message.voice` to
- * `gateway.tools.allow` in openclaw.json.
- */
-import type { IToolBridge, ToolDefinition, TranslatedToolUseDelta } from '../../types/tool-bridge.js';
-import { ToolMode } from '../../types/tool-bridge.js';
-interface GatewayConfig {
-    url: string;
-    token: string;
-}
-export declare class OpenClawNativeToolsBridge implements IToolBridge {
-    readonly mode = ToolMode.OpenClawNative;
-    private readonly _gwConfig;
-    constructor(gwConfig?: GatewayConfig);
-    /**
-     * Build a minimal tool preamble listing only the tools the bridge can
-     * actually handle (allowlisted + registered). The full schema is omitted —
-     * the caller's system prompt already advertises it. This is a safety marker
-     * so Savvy knows the bridge is active.
-     */
-    buildToolPreamble(tools: ReadonlyArray<ToolDefinition> | undefined): string;
-    /**
-     * Translate a tool_use event from the Claude stream into an OpenAI delta.
-     * This bridge does NOT intercept mid-stream events — tool execution happens
-     * in `executeNative` after the full turn completes. Return null always.
-     */
-    translateToolUse(_event: unknown): TranslatedToolUseDelta;
-    /** Serialize a tool result back as XML for the next turn's user message. */
-    serializeToolResult(call: import('../../types/route.js').OpenAIToolCall, result: string): string;
-    /**
-     * Execute a `message.voice` (or other allowlisted) tool call.
-     *
-     * v0.11.0: routes through TtsMediaBridge (Path B — marker translation).
-     * Returns the TTS marker text to inject into the SSE stream.
-     *
-     * When `CC_OPENCLAW_NATIVE_TOOLS_HTTP=1` is set, falls through to Path A
-     * (real HTTP POST). Reserved for v0.12.0 activation.
-     */
-    executeNative(toolName: string, args: Record<string, unknown>): Promise<{
-        text: string;
-        delivered: boolean;
-        via: string;
-    }>;
-}
-export {};

package/dist/src/openai-compat/bridges/openclaw-tool-registry.d.ts

@@ -1,26 +0,0 @@
-/**
- * openclaw-tool-registry.ts — Registry that maps allowed tool names to their
- * MediaBridge implementations.
- *
- * v0.11.0 only registers `message.voice` → TtsMediaBridge. The registry is
- * lazy-constructed per-request (stateless) so future parallel agents can add
- * bridges without contention.
- */
-import type { MediaBridge } from './media-bridge.js';
-/** Resolved bridge for a given tool name, or null when not in allowlist. */
-export interface ResolvedBridge {
-    readonly bridge: MediaBridge;
-    readonly toolName: string;
-}
-/**
- * Look up the MediaBridge for `toolName`.
- * Returns null when the tool is not in the v0.11.0 allowlist OR has no
- * registered implementation.
- */
-export declare function resolveToolBridge(toolName: string): ResolvedBridge | null;
-/**
- * Return every tool name currently in the registry (i.e. allowed + implemented).
- * Used by `OpenClawNativeToolsBridge.buildToolPreamble` to filter the caller's
- * tool list down to what the bridge can actually handle.
- */
-export declare function registeredToolNames(): ReadonlySet<string>;

package/dist/src/openai-compat/bridges/tts-media-bridge.d.ts

@@ -1,19 +0,0 @@
-/**
- * tts-media-bridge.ts — MediaBridge impl for `message.voice`.
- *
- * v0.11.0 Path B strategy: instead of POSTing to a TTS HTTP endpoint, this
- * bridge converts `message.voice` tool args into `[[tts:text]]` markers that
- * OpenClaw's existing `maybeApplyTtsToPayload` downstream picks up — the same
- * channel voice-recovery.ts uses. This gives the tool-boundary UX (Savvy sees
- * a proper tool interface; callers see tool_call deltas) without requiring a
- * new OpenClaw endpoint.
- *
- * The bridge imports from voice-recovery.ts and reuses its marker constants
- * and truncation logic. No logic is duplicated.
- */
-import type { MediaBridge, MediaBridgeResult } from './media-bridge.js';
-export declare const TTS_TOOL_NAME = "message.voice";
-export declare class TtsMediaBridge implements MediaBridge {
-    readonly toolName = "message.voice";
-    execute(args: Record<string, unknown>): Promise<MediaBridgeResult>;
-}

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

@@ -1,22 +0,0 @@
-/**
- * resolveChatCwd — working directory for an openai-compat (Telegram chat) session.
- *
- * Default: a neutral per-session tmpdir, so the claude CLI does NOT load
- * CLAUDE.md / git state / project context (keeps chat turns cheap and clean —
- * this is the deliberate v0.x choice).
- *
- * Opt-in (v0.27.12): set CC_OPENCLAW_CHAT_CWD to an existing directory and chat
- * sessions run there — the CLI then loads that project's CLAUDE.md + git context
- * like the terminal CLI does, and the CLI's "cwd reset" lands on the project dir
- * instead of a tmpdir. This closes the chat-vs-terminal project-context parity
- * gap as an explicit, per-deployment opt-in, so the default stays zero-token-
- * overhead. A blank/unset/nonexistent value falls back to the tmpdir, so a
- * misconfigured path can never break session creation.
- *
- * Pure (deps injectable) for unit-testing.
- */
-export declare function resolveChatCwd(sessionName: string, opts?: {
-    cwdOverride?: string;
-    dirExists?: (p: string) => boolean;
-    tmpDir?: string;
-}): string;

package/dist/src/openai-compat/cli-stream-parser.d.ts

@@ -1,134 +0,0 @@
-/**
- * Claude CLI streaming output parser.
- *
- * Reads NDJSON from `claude --output-format=stream-json --include-partial-messages`
- * and emits typed events. The CLI's stream-json wraps Anthropic Messages API
- * stream events inside an envelope:
- *
- *   {"type":"stream_event","event":{<anthropic_event>},...}
- *
- * Other envelope types include `system`, `assistant`, `rate_limit_event`,
- * `result`, plus hook lifecycle events.
- *
- * This module unwraps `stream_event` envelopes and emits the inner Anthropic
- * Messages API events directly. Other envelope types pass through with their
- * own ParsedEvent variants so downstream consumers can react (e.g. the budget
- * guard listens to `rate_limit_event` and `result`).
- *
- * Captured against Claude CLI v2.1.119. Fixture corpus lives at
- * tests/streaming/fixtures/*.ndjson.
- */
-export type AnthropicEvent = {
-    type: 'message_start';
-    message: AnthropicMessage;
-} | {
-    type: 'content_block_start';
-    index: number;
-    content_block: ContentBlockStart;
-} | {
-    type: 'content_block_delta';
-    index: number;
-    delta: ContentBlockDelta;
-} | {
-    type: 'content_block_stop';
-    index: number;
-} | {
-    type: 'message_delta';
-    delta: MessageDeltaBody;
-    usage?: MessageUsage;
-} | {
-    type: 'message_stop';
-} | {
-    type: 'error';
-    error: {
-        type: string;
-        message: string;
-    };
-};
-export interface AnthropicMessage {
-    id: string;
-    model: string;
-    role?: string;
-    content?: unknown[];
-    stop_reason?: string | null;
-    stop_sequence?: string | null;
-    usage?: MessageUsage;
-}
-export interface MessageUsage {
-    input_tokens?: number;
-    output_tokens?: number;
-    cache_creation_input_tokens?: number;
-    cache_read_input_tokens?: number;
-}
-export interface MessageDeltaBody {
-    stop_reason?: string;
-    stop_sequence?: string | null;
-    stop_details?: unknown;
-}
-export type ContentBlockStart = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'tool_use';
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-    caller?: unknown;
-} | {
-    type: 'thinking';
-    thinking: string;
-    signature: string;
-};
-export type ContentBlockDelta = {
-    type: 'text_delta';
-    text: string;
-} | {
-    type: 'input_json_delta';
-    partial_json: string;
-} | {
-    type: 'thinking_delta';
-    thinking: string;
-} | {
-    type: 'signature_delta';
-    signature: string;
-};
-export type ParsedEvent = AnthropicEvent | {
-    type: 'system';
-    subtype: string;
-    raw: Record<string, unknown>;
-} | {
-    type: 'assistant';
-    message: AnthropicMessage;
-    sessionId?: string;
-    parentToolUseId?: string | null;
-} | {
-    type: 'rate_limit_event';
-    rateLimitInfo: Record<string, unknown>;
-} | {
-    type: 'result';
-    subtype: string;
-    isError: boolean;
-    result?: string;
-    durationMs?: number;
-    usage?: MessageUsage;
-    totalCostUsd?: number;
-    raw: Record<string, unknown>;
-} | {
-    type: 'unknown';
-    raw: unknown;
-} | {
-    type: 'parse_error';
-    error: {
-        type: string;
-        message: string;
-    };
-    rawLine?: string;
-};
-export interface CliStreamParser {
-    /** Push a chunk of stdout. Returns events derivable from any complete lines.
-     *  Incomplete trailing line stays in the buffer for the next call. */
-    push(chunk: string): ParsedEvent[];
-    /** Flush any remaining buffered partial line. Returns final events (or empty). */
-    flush(): ParsedEvent[];
-}
-export declare function createCliStreamParser(): CliStreamParser;

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

@@ -1 +0,0 @@
-export * from './openai-compat.js';

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

@@ -1,84 +0,0 @@
-/**
- * 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 type { OpenAIChatMessage } from './openai-compat.js';
-import { type AnthropicToolResultBlock } from './tool-results-serializer.js';
-/**
- * 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;
-    /** v0.19.1 M3 — slash command detected at message start, for live-card pill. */
-    slashCommand?: {
-        cmd: string;
-        mode?: string;
-    };
-}
-/**
- * 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;

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

@@ -1,34 +0,0 @@
-/**
- * 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/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>;