whale-code 6.4.0

package/dist/shared/api-client.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Unified API Client — ONE server proxy caller with retry and config builder.
+ *
+ * Replaces proxy+direct call paths in agent-loop, subagent, teammate.
+ * CLI-only: always calls through server proxy (no direct Anthropic SDK usage).
+ */
+import type { ContextProfile, APIRequestConfig } from "./types.js";
+/**
+ * Build all Anthropic API config from a simple profile.
+ *
+ * Profiles:
+ * - 'main': clear at 80K/keep 3, compact at 120K (Opus only)
+ * - 'subagent': clear at 60K/keep 2, no compaction, 8192 max tokens
+ * - 'teammate': clear at 80K/keep 3, no compaction
+ */
+export declare function buildAPIRequest(opts: {
+    model: string;
+    contextProfile: ContextProfile;
+    thinkingEnabled?: boolean;
+    maxOutputTokens?: number;
+}): APIRequestConfig;
+export interface CallServerProxyConfig {
+    proxyUrl: string;
+    token: string;
+    model: string;
+    system: Array<Record<string, unknown>>;
+    messages: Array<Record<string, unknown>>;
+    tools: Array<Record<string, unknown>>;
+    apiConfig: APIRequestConfig;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    fallbackModel?: string;
+    storeId?: string;
+    onFallback?: (fromModel: string, toModel: string) => void;
+    onRetry?: (attempt: number, maxRetries: number, error: string) => void;
+    /** Called on 401 to refresh the auth token. Returns new token or null. */
+    onTokenRefresh?: () => Promise<string | null>;
+}
+/**
+ * Call server proxy endpoint and return raw SSE stream.
+ * Retries with exponential backoff on 429/500/529.
+ */
+export declare function callServerProxy(config: CallServerProxyConfig): Promise<ReadableStream<Uint8Array>>;
+/**
+ * Build system blocks with prompt caching.
+ * Cached system prompt + optional dynamic cost context (after cache breakpoint).
+ */
+export declare function buildSystemBlocks(systemPrompt: string, costContext?: string, enableCaching?: boolean): Array<Record<string, unknown>>;
+/**
+ * Prepare messages and tools with prompt caching.
+ * Skips cache_control injection for Gemini (uses implicit caching).
+ */
+export declare function prepareWithCaching(tools: Array<Record<string, unknown>>, messages: Array<Record<string, unknown>>, model?: string): {
+    tools: Array<Record<string, unknown>>;
+    messages: Array<Record<string, unknown>>;
+};
+/**
+ * Client-side context trimming for Gemini (no server-side context management).
+ * When estimated input tokens exceed threshold, replaces old tool result contents
+ * with "[trimmed]" to stay within Gemini's 1M context window.
+ */
+export declare function trimGeminiContext(messages: Array<Record<string, unknown>>, estimatedTokens: number, threshold?: number, keepRecent?: number): Array<Record<string, unknown>>;
+/**
+ * Client-side context trimming for OpenAI (no server-side context management).
+ * When estimated input tokens exceed threshold, replaces old tool result contents
+ * with "[trimmed]" to stay within OpenAI's 200K context window.
+ */
+/**
+ * Call server transcription endpoint (OpenAI Whisper via our Fly.io proxy).
+ * Used by tool-dispatch when __AUDIO__ marker is detected in tool results.
+ */
+export declare function callTranscribe(opts: {
+    proxyUrl: string;
+    token: string;
+    storeId: string;
+    audioBase64: string;
+    mediaType: string;
+}): Promise<string>;
+export declare function trimOpenAIContext(messages: Array<Record<string, unknown>>, estimatedTokens: number, threshold?: number, keepRecent?: number): Array<Record<string, unknown>>;
+/**
+ * Request conversation compaction from the server (Haiku summarization).
+ * Used by non-Anthropic providers (OpenAI, Gemini) that lack native compaction.
+ * Returns summary string or null on failure (caller keeps unsummarized history).
+ */
+export declare function requestProviderCompaction(opts: {
+    proxyUrl: string;
+    token: string;
+    messages: Array<Record<string, unknown>>;
+    systemPrompt: string;
+}): Promise<string | null>;

package/dist/shared/api-client.js

@@ -0,0 +1,379 @@
+/**
+ * Unified API Client — ONE server proxy caller with retry and config builder.
+ *
+ * Replaces proxy+direct call paths in agent-loop, subagent, teammate.
+ * CLI-only: always calls through server proxy (no direct Anthropic SDK usage).
+ */
+import { getContextManagement, getMaxOutputTokens, getThinkingConfig, isRetryableError, addPromptCaching, } from "./agent-core.js";
+import { getProvider } from "./constants.js";
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const MAX_RETRIES = 3;
+const RETRY_BASE_DELAY_MS = 1000;
+// ============================================================================
+// API REQUEST CONFIG BUILDER
+// ============================================================================
+/**
+ * Build all Anthropic API config from a simple profile.
+ *
+ * Profiles:
+ * - 'main': clear at 80K/keep 3, compact at 120K (Opus only)
+ * - 'subagent': clear at 60K/keep 2, no compaction, 8192 max tokens
+ * - 'teammate': clear at 80K/keep 3, no compaction
+ */
+export function buildAPIRequest(opts) {
+    const { model, contextProfile, thinkingEnabled = false, maxOutputTokens } = opts;
+    // Context management config per profile
+    // Non-Anthropic models (Gemini, OpenAI, etc.) don't support Anthropic betas or context management
+    const provider = getProvider(model);
+    const isAnthropicModel = provider === "anthropic" || provider === "bedrock";
+    let betas = isAnthropicModel ? ["context-management-2025-06-27"] : [];
+    let edits = [];
+    switch (contextProfile) {
+        case "main": {
+            const ctxMgmt = getContextManagement(model);
+            betas = [...ctxMgmt.betas];
+            edits = ctxMgmt.config.edits;
+            break;
+        }
+        case "subagent":
+            if (isAnthropicModel) {
+                edits = [
+                    {
+                        type: "clear_thinking_20251015",
+                        keep: { type: "thinking_turns", value: 1 },
+                    },
+                    {
+                        type: "clear_tool_uses_20250919",
+                        trigger: { type: "input_tokens", value: 60_000 },
+                        keep: { type: "tool_uses", value: 2 },
+                    },
+                ];
+            }
+            break;
+        case "teammate": {
+            const ctxMgmt = getContextManagement(model);
+            betas = [...ctxMgmt.betas];
+            edits = ctxMgmt.config.edits;
+            break;
+        }
+    }
+    // Thinking config
+    const thinkingCfg = getThinkingConfig(model, thinkingEnabled);
+    if (thinkingCfg.beta)
+        betas.push(thinkingCfg.beta);
+    // Max tokens — caller is responsible for setting appropriate limits per context
+    const maxTokens = getMaxOutputTokens(model, maxOutputTokens);
+    // Build thinking param (ensure budget < maxTokens)
+    // Only include for Anthropic/Bedrock — Gemini/OpenAI handle thinking internally
+    let thinking;
+    if (isAnthropicModel && thinkingCfg.thinking.type !== "disabled") {
+        thinking = thinkingCfg.thinking.budget_tokens
+            ? { ...thinkingCfg.thinking, budget_tokens: Math.min(thinkingCfg.thinking.budget_tokens, maxTokens - 1) }
+            : thinkingCfg.thinking;
+    }
+    // Strip clear_thinking edits when thinking is disabled — API requires thinking
+    // to be enabled or adaptive for clear_thinking_20251015 to be accepted
+    if (!thinking) {
+        edits = edits.filter(e => e.type !== "clear_thinking_20251015");
+    }
+    return {
+        betas,
+        contextManagement: { edits },
+        thinking,
+        maxTokens,
+    };
+}
+/**
+ * Call server proxy endpoint and return raw SSE stream.
+ * Retries with exponential backoff on 429/500/529.
+ */
+export async function callServerProxy(config) {
+    const { proxyUrl, signal, timeoutMs } = config;
+    let tokenRefreshed = false;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const body = {
+                mode: "proxy",
+                messages: config.messages,
+                system: config.system,
+                tools: config.tools,
+                model: config.model,
+                max_tokens: config.apiConfig.maxTokens,
+                stream: true,
+                betas: config.apiConfig.betas,
+                ...(config.apiConfig.contextManagement?.edits?.length
+                    ? { context_management: config.apiConfig.contextManagement }
+                    : {}),
+            };
+            if (config.apiConfig.thinking) {
+                body.thinking = config.apiConfig.thinking;
+            }
+            if (config.storeId) {
+                body.store_id = config.storeId;
+            }
+            const fetchOpts = {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${config.token}`,
+                },
+                body: JSON.stringify(body),
+                signal,
+            };
+            // Apply timeout if specified
+            let controller;
+            let timeout;
+            if (timeoutMs && !signal) {
+                controller = new AbortController();
+                timeout = setTimeout(() => controller.abort(), timeoutMs);
+                fetchOpts.signal = controller.signal;
+            }
+            try {
+                const response = await fetch(proxyUrl, fetchOpts);
+                if (timeout)
+                    clearTimeout(timeout);
+                if (response.ok && response.body) {
+                    return response.body;
+                }
+                const errorBody = await response.text();
+                // Auto-refresh on 401 (token invalidated server-side before local expiry)
+                if (response.status === 401 && config.onTokenRefresh && !tokenRefreshed) {
+                    const newToken = await config.onTokenRefresh();
+                    if (newToken) {
+                        tokenRefreshed = true;
+                        config.token = newToken;
+                        continue; // retry with new token
+                    }
+                }
+                throw Object.assign(new Error(`Proxy error (${response.status}): ${errorBody}`), { status: response.status });
+            }
+            catch (err) {
+                if (timeout)
+                    clearTimeout(timeout);
+                throw err;
+            }
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw err;
+            if (attempt < MAX_RETRIES && isRetryableError(err)) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                config.onRetry?.(attempt + 1, MAX_RETRIES, errMsg);
+                const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                // Fallback model on last retry
+                if (attempt === MAX_RETRIES - 1 && config.fallbackModel) {
+                    const fromModel = config.model;
+                    config.model = config.fallbackModel;
+                    config.onFallback?.(fromModel, config.model);
+                }
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new Error("Failed to get response after retries");
+}
+// ============================================================================
+// HELPERS — system prompt + caching setup
+// ============================================================================
+/**
+ * Build system blocks with prompt caching.
+ * Cached system prompt + optional dynamic cost context (after cache breakpoint).
+ */
+export function buildSystemBlocks(systemPrompt, costContext, enableCaching = true) {
+    const system = [];
+    if (enableCaching) {
+        system.push({
+            type: "text",
+            text: systemPrompt,
+            cache_control: { type: "ephemeral" },
+        });
+    }
+    else {
+        system.push({ type: "text", text: systemPrompt });
+    }
+    if (costContext) {
+        system.push({ type: "text", text: costContext });
+    }
+    return system;
+}
+/**
+ * Prepare messages and tools with prompt caching.
+ * Skips cache_control injection for Gemini (uses implicit caching).
+ */
+export function prepareWithCaching(tools, messages, model) {
+    if (model) {
+        const provider = getProvider(model);
+        if (provider === "gemini" || provider === "openai") {
+            return { tools, messages };
+        }
+    }
+    return addPromptCaching(tools, messages);
+}
+// ============================================================================
+// GEMINI CONTEXT TRIMMING
+// ============================================================================
+/**
+ * Client-side context trimming for Gemini (no server-side context management).
+ * When estimated input tokens exceed threshold, replaces old tool result contents
+ * with "[trimmed]" to stay within Gemini's 1M context window.
+ */
+export function trimGeminiContext(messages, estimatedTokens, threshold = 950_000, keepRecent = 5) {
+    if (estimatedTokens < threshold)
+        return messages;
+    // Find all tool_result blocks and trim oldest ones
+    let toolResultCount = 0;
+    for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === "tool_result")
+                    toolResultCount++;
+            }
+        }
+    }
+    if (toolResultCount <= keepRecent)
+        return messages;
+    const trimCount = toolResultCount - keepRecent;
+    let trimmed = 0;
+    return messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        const content = msg.content.map((block) => {
+            if (block.type === "tool_result" && trimmed < trimCount) {
+                trimmed++;
+                if (typeof block.content === "string") {
+                    return { ...block, content: "[trimmed]" };
+                }
+                else if (Array.isArray(block.content)) {
+                    return { ...block, content: [{ type: "text", text: "[trimmed]" }] };
+                }
+            }
+            return block;
+        });
+        return { ...msg, content };
+    });
+}
+// ============================================================================
+// OPENAI CONTEXT TRIMMING
+// ============================================================================
+/**
+ * Client-side context trimming for OpenAI (no server-side context management).
+ * When estimated input tokens exceed threshold, replaces old tool result contents
+ * with "[trimmed]" to stay within OpenAI's 200K context window.
+ */
+// ============================================================================
+// AUDIO TRANSCRIPTION CLIENT
+// ============================================================================
+/**
+ * Call server transcription endpoint (OpenAI Whisper via our Fly.io proxy).
+ * Used by tool-dispatch when __AUDIO__ marker is detected in tool results.
+ */
+export async function callTranscribe(opts) {
+    const { proxyUrl, token, storeId, audioBase64, mediaType } = opts;
+    // Use same server URL as proxy, just different mode
+    const response = await fetch(proxyUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            mode: "transcribe",
+            audio_base64: audioBase64,
+            media_type: mediaType,
+            store_id: storeId,
+        }),
+    });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`Transcription failed (${response.status}): ${errText}`);
+    }
+    const data = (await response.json());
+    if (!data.success || !data.transcript) {
+        throw new Error(data.error || "Transcription returned no transcript");
+    }
+    return data.transcript;
+}
+// ============================================================================
+// OPENAI CONTEXT TRIMMING
+// ============================================================================
+export function trimOpenAIContext(messages, estimatedTokens, threshold = 190_000, keepRecent = 5) {
+    if (estimatedTokens < threshold)
+        return messages;
+    // Find all tool_result blocks and trim oldest ones
+    let toolResultCount = 0;
+    for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === "tool_result")
+                    toolResultCount++;
+            }
+        }
+    }
+    if (toolResultCount <= keepRecent)
+        return messages;
+    const trimCount = toolResultCount - keepRecent;
+    let trimmed = 0;
+    return messages.map((msg) => {
+        if (!Array.isArray(msg.content))
+            return msg;
+        const content = msg.content.map((block) => {
+            if (block.type === "tool_result" && trimmed < trimCount) {
+                trimmed++;
+                if (typeof block.content === "string") {
+                    return { ...block, content: "[trimmed]" };
+                }
+                else if (Array.isArray(block.content)) {
+                    return { ...block, content: [{ type: "text", text: "[trimmed]" }] };
+                }
+            }
+            return block;
+        });
+        return { ...msg, content };
+    });
+}
+// ============================================================================
+// PROVIDER COMPACTION CLIENT
+// ============================================================================
+const COMPACTION_TIMEOUT_MS = 30_000;
+/**
+ * Request conversation compaction from the server (Haiku summarization).
+ * Used by non-Anthropic providers (OpenAI, Gemini) that lack native compaction.
+ * Returns summary string or null on failure (caller keeps unsummarized history).
+ */
+export async function requestProviderCompaction(opts) {
+    const { proxyUrl, token, messages, systemPrompt } = opts;
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), COMPACTION_TIMEOUT_MS);
+        try {
+            const response = await fetch(proxyUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({
+                    mode: "compact",
+                    messages,
+                    system_prompt: systemPrompt,
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok)
+                return null;
+            const data = (await response.json());
+            return data.success && data.compaction_content ? data.compaction_content : null;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    catch {
+        return null; // Graceful failure — caller keeps unsummarized history
+    }
+}

package/dist/shared/constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared constants — single source of truth for model IDs, thresholds, and limits.
+ */
+export type ModelProvider = "anthropic" | "bedrock" | "gemini" | "openai";
+export declare const MODELS: {
+    readonly OPUS: "claude-opus-4-6";
+    readonly SONNET: "claude-sonnet-4-6";
+    readonly SONNET_4: "claude-sonnet-4-20250514";
+    readonly HAIKU: "claude-haiku-4-5-20251001";
+    readonly BEDROCK_SONNET: "anthropic.claude-sonnet-4-6";
+    readonly BEDROCK_SONNET_4: "us.anthropic.claude-sonnet-4-20250514-v1:0";
+    readonly BEDROCK_SONNET_45: "us.anthropic.claude-sonnet-4-5-20250929-v1:0";
+    readonly BEDROCK_HAIKU: "us.anthropic.claude-haiku-4-5-20251001-v1:0";
+    readonly GEMINI_3_PRO: "gemini-3-pro-preview";
+    readonly GEMINI_3_FLASH: "gemini-3-flash-preview";
+    readonly GEMINI_25_PRO: "gemini-2.5-pro";
+    readonly GEMINI_25_FLASH: "gemini-2.5-flash";
+    readonly GEMINI_25_FLASH_LITE: "gemini-2.5-flash-lite";
+    readonly GPT_5: "gpt-5";
+    readonly GPT_5_MINI: "gpt-5-mini";
+    readonly GPT_5_NANO: "gpt-5-nano";
+    readonly O3: "o3";
+    readonly O4_MINI: "o4-mini";
+    readonly GPT_4O: "gpt-4o";
+};
+/** Maps short model aliases to full model IDs */
+export declare const MODEL_MAP: Record<string, string>;
+/** Allowed model IDs for server validation */
+export declare const ALLOWED_MODELS: string[];
+/** Detect provider from full model ID */
+export declare function getProvider(modelId: string): ModelProvider;
+/** Check if an OpenAI model is a reasoning model (o-series) */
+export declare function isOpenAIReasoningModel(modelId: string): boolean;

package/dist/shared/constants.js

@@ -0,0 +1,80 @@
+/**
+ * Shared constants — single source of truth for model IDs, thresholds, and limits.
+ */
+export const MODELS = {
+    // Anthropic (direct API)
+    OPUS: "claude-opus-4-6",
+    SONNET: "claude-sonnet-4-6",
+    SONNET_4: "claude-sonnet-4-20250514",
+    HAIKU: "claude-haiku-4-5-20251001",
+    // Bedrock (Claude on AWS)
+    BEDROCK_SONNET: "anthropic.claude-sonnet-4-6",
+    BEDROCK_SONNET_4: "us.anthropic.claude-sonnet-4-20250514-v1:0",
+    BEDROCK_SONNET_45: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+    BEDROCK_HAIKU: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    // Google Gemini
+    GEMINI_3_PRO: "gemini-3-pro-preview",
+    GEMINI_3_FLASH: "gemini-3-flash-preview",
+    GEMINI_25_PRO: "gemini-2.5-pro",
+    GEMINI_25_FLASH: "gemini-2.5-flash",
+    GEMINI_25_FLASH_LITE: "gemini-2.5-flash-lite",
+    // OpenAI
+    GPT_5: "gpt-5",
+    GPT_5_MINI: "gpt-5-mini",
+    GPT_5_NANO: "gpt-5-nano",
+    O3: "o3",
+    O4_MINI: "o4-mini",
+    GPT_4O: "gpt-4o",
+};
+/** Maps short model aliases to full model IDs */
+export const MODEL_MAP = {
+    // Auto-routing (resolved at runtime by model-router)
+    auto: "auto",
+    // Anthropic
+    "whale/agent": MODELS.OPUS, // OpenClaw bridge sends this model ID
+    opus: MODELS.OPUS,
+    sonnet: MODELS.SONNET,
+    "sonnet-4.6": MODELS.SONNET,
+    "sonnet-4": MODELS.SONNET_4,
+    haiku: MODELS.HAIKU,
+    // Bedrock
+    "bedrock-sonnet": MODELS.BEDROCK_SONNET,
+    "bedrock-sonnet-4": MODELS.BEDROCK_SONNET_4,
+    "bedrock-sonnet-4.5": MODELS.BEDROCK_SONNET_45,
+    "bedrock-haiku": MODELS.BEDROCK_HAIKU,
+    // Gemini
+    "gemini-3-pro": MODELS.GEMINI_3_PRO,
+    "gemini-3-flash": MODELS.GEMINI_3_FLASH,
+    "gemini-pro": MODELS.GEMINI_25_PRO,
+    "gemini-flash": MODELS.GEMINI_25_FLASH,
+    "gemini-flash-lite": MODELS.GEMINI_25_FLASH_LITE,
+    // OpenAI
+    "gpt-5": MODELS.GPT_5,
+    "5": MODELS.GPT_5,
+    "gpt-5-mini": MODELS.GPT_5_MINI,
+    "5-mini": MODELS.GPT_5_MINI,
+    "gpt-5-nano": MODELS.GPT_5_NANO,
+    "5-nano": MODELS.GPT_5_NANO,
+    "o3": MODELS.O3,
+    "o4-mini": MODELS.O4_MINI,
+    "gpt-4o": MODELS.GPT_4O,
+    "4o": MODELS.GPT_4O,
+};
+/** Allowed model IDs for server validation */
+export const ALLOWED_MODELS = [...Object.values(MODELS), "auto"];
+/** Detect provider from full model ID */
+export function getProvider(modelId) {
+    if (modelId === "auto")
+        return "anthropic"; // auto resolves to Claude models
+    if (modelId.includes(".anthropic.") || modelId.startsWith("anthropic."))
+        return "bedrock";
+    if (modelId.startsWith("gemini-"))
+        return "gemini";
+    if (modelId.startsWith("gpt-") || /^o\d/.test(modelId))
+        return "openai";
+    return "anthropic";
+}
+/** Check if an OpenAI model is a reasoning model (o-series) */
+export function isOpenAIReasoningModel(modelId) {
+    return /^o\d/.test(modelId);
+}

package/dist/shared/sse-parser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Unified SSE Parser — ONE implementation replacing 4 duplicates.
+ *
+ * Used by:
+ * - agent-loop.ts (processStreamWithCallbacks for real-time UI)
+ * - subagent.ts (collectStreamResult for batch collection)
+ * - teammate.ts (collectStreamResult for batch collection)
+ * - server-agent-loop.ts (processStreamWithCallbacks for SSE relay)
+ */
+import type { BetaStreamEvent } from "./anthropic-types.js";
+import type { StreamResult, StreamCallbacks } from "./types.js";
+/**
+ * Parse SSE stream from proxy HTTP response into typed events.
+ * Handles `data: {...}\n\n` format with [DONE] sentinel.
+ */
+export declare function parseSSEStream(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<BetaStreamEvent>;
+/**
+ * Collect all events into a StreamResult. No callbacks — used by
+ * subagent and teammate where real-time text isn't needed.
+ */
+export declare function collectStreamResult(events: AsyncIterable<BetaStreamEvent>): Promise<StreamResult>;
+/**
+ * Process streaming events with optional real-time callbacks.
+ * Used by agent-loop (needs onText for UI) and as internal impl for collect.
+ */
+export declare function processStreamWithCallbacks(events: AsyncIterable<BetaStreamEvent>, callbacks: StreamCallbacks, signal?: AbortSignal): Promise<StreamResult>;