@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

package/dist/src/observability/perf-telemetry.d.ts

@@ -1,65 +0,0 @@
-/**
- * Perf-baseline telemetry (M8 — cache-miss-telemetry).
- *
- * Appends structured perf events to `~/.openclaw/workspace/memory/sysprompt-cost.jsonl`
- * alongside the existing token-cost records. Every record carries an `event`
- * field so consumers can filter:
- *
- *   - "token_cost"  → legacy per-request sysprompt+user char/token estimate
- *                     (emitted by cwd-patch.ts; tagged by this module on read).
- *   - "cache_check" → outcome of the Track-B cache parity decision: hit/miss
- *                     with a structured `cause` (registry_empty | hash_mismatch
- *                     | session_unknown | disabled). Drives idea #8.
- *   - "first_byte"  → first user-visible content delta sent to the SSE client.
- *                     `elapsed_ms` is measured from request receive (turnStartMs
- *                     in streaming-handler.ts). This is the baseline for the
- *                     plan's ≥50% p50 latency drop exit criterion.
- *   - "turn_end"    → final SSE stop chunk written. `elapsed_ms` is total turn
- *                     wall-clock. Pair with first_byte to derive generation-vs-
- *                     latency split per turn.
- *
- * Flag: CC_OPENCLAW_PERF_CACHE_TELEMETRY (default ON; opt-out with 0/false/off).
- * Goes through the same shim pattern as the legacy telemetry getters
- * (ConfigService when present, env fallback for tests).
- *
- * Why same file as token_cost: the plan's verify query targets sysprompt-cost.jsonl
- * directly; splitting would require operators to remember two paths and would
- * break the single `jq` pipeline. The `event` field makes filtering trivial.
- */
-type PerfEventName = 'cache_check' | 'first_byte' | 'turn_end';
-type CacheCheckCause = 'hit' | 'warm_hash' | 'registry_empty' | 'hash_mismatch' | 'session_unknown' | 'disabled';
-interface PerfEventBase {
-    event: PerfEventName;
-    sessionKey?: string;
-}
-interface CacheCheckEvent extends PerfEventBase {
-    event: 'cache_check';
-    outcome: 'hit' | 'miss';
-    cause: CacheCheckCause;
-    sysHash?: string;
-}
-interface FirstByteEvent extends PerfEventBase {
-    event: 'first_byte';
-    elapsed_ms: number;
-    model?: string;
-    tool_stream?: boolean;
-}
-interface TurnEndEvent extends PerfEventBase {
-    event: 'turn_end';
-    elapsed_ms: number;
-    first_byte_ms?: number;
-    finish_reason?: 'stop' | 'tool_calls' | 'length' | string;
-    tool_calls?: number;
-    bytes_out?: number;
-}
-export type PerfEvent = CacheCheckEvent | FirstByteEvent | TurnEndEvent;
-/**
- * Append a perf event to sysprompt-cost.jsonl. No-op when the flag is off
- * or when an I/O error occurs — telemetry must never break a live turn.
- */
-export declare function writePerfEvent(event: PerfEvent): void;
-/** Test hook — replace the file-writing sink with an in-memory collector. */
-export declare function _setPerfWriterForTests(w: (line: string) => void): void;
-/** Test hook — restore the default file-writing sink. */
-export declare function _restorePerfWriterForTests(): void;
-export {};

package/dist/src/observability/subscribers/metrics.d.ts

@@ -1,11 +0,0 @@
-/**
- * MetricsSubscriber — collects per-session token and timing metrics.
- *
- * Replaces globalThis.__openclaw_perfMap (AS2).
- * Phase E wires real aggregation and exposes metrics via /enhancer/metrics.
- * Stub body here.
- */
-import type { EventBus } from '../event-bus.js';
-export declare class MetricsSubscriber {
-    register(bus: EventBus): void;
-}

package/dist/src/observability/subscribers/session-capture.d.ts

@@ -1,15 +0,0 @@
-/**
- * SessionCaptureSubscriber — replaces the 5s ultrareview poller (LP2).
- *
- * Wired in boot phase 5 (wire-handlers) BEFORE traffic starts.
- * Phase E implements the real capture logic (writing to SessionRegistry WAL,
- * updating live-card state, etc.). Stub body here.
- */
-import type { EventBus } from '../event-bus.js';
-export declare class SessionCaptureSubscriber {
-    /**
-     * Register listeners on the bus. Returns nothing; unsubscribe handles
-     * are held internally (Phase E: stored for clean shutdown).
-     */
-    register(bus: EventBus): void;
-}

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

@@ -1,26 +0,0 @@
-/**
- * AUTONOMY_RULE — "act, don't ask" posture injected into the Savvy chat path.
- *
- * Why: the openai-compat (Telegram) path does not reliably load the owner's
- * CLAUDE.md "Execute, don't discuss" rules (tmpdir CWD), so the model reverts to
- * Claude's base posture of asking on ambiguous forks. Combined with a Telegram
- * AskUserQuestion round-trip that silently drops answers, this made Savvy stall
- * and require many prods to finish one task. This rule restores the terminal-CLI
- * posture: decide and execute, complete the whole task in one turn.
- *
- * Gated by CC_OPENCLAW_AUTONOMY_RULE (default on; set '0' to disable). Prepended
- * at the same injection points as TTS_RULE in openai-compat.ts so it lands in
- * both the REPLACE (--system-prompt) and APPEND (--append-system-prompt) paths.
- *
- * Pure-string constant — no I/O, no module state.
- */
-export declare const AUTONOMY_RULE: string;
-/**
- * Merge AskUserQuestion into a session's disallowedTools when suppression is on.
- * The Telegram answer round-trip silently drops taps, so a question there stalls
- * the turn — suppressing the tool is the hard guarantee behind AUTONOMY_RULE's
- * "decide, do not ask" posture. Returns `prior` unchanged when suppression is
- * off (so callers only set disallowedTools when there's something to set). Pure
- * + dedup so it's unit-testable and idempotent across repeated session creates.
- */
-export declare function withAskUserSuppressed(prior: string[] | undefined, suppress: boolean): string[] | undefined;

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

@@ -1,19 +0,0 @@
-/**
- * OpenClaw native tool allowList — typed-config-driven (Phase E #1, Q1 resolution).
- *
- * Reads from `ConfigService.config.nativeToolsAllowList` when available;
- * falls back to the v0.11.x hardcoded default when `ConfigService` is unset
- * (tests, scripts run without a boot path). The hardcoded fallback is
- * intentionally identical to what shipped at v0.11.0 so existing tests that
- * import `OPENCLAW_TOOL_ALLOWLIST` keep passing without rewrite.
- *
- * Env override: `CC_OPENCLAW_NATIVE_TOOLS_ALLOWLIST="message.voice,message.image,..."`.
- * Q1 expanded default ships at v1.0.0-rc1 alongside the `CC_OPENCLAW_NATIVE_TOOLS=1` flip.
- */
-/**
- * v0.11.x default — kept exported for legacy callers and for the
- * `ConfigService`-unset fallback path. New code should call `isAllowedTool`.
- */
-export declare const OPENCLAW_TOOL_ALLOWLIST: ReadonlySet<string>;
-/** Return true when `toolName` is in the active allowList. */
-export declare function isAllowedTool(toolName: string): boolean;

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;