@bubblebrain-ai/bubble 0.0.19 → 0.0.21

package/dist/network/system-proxy.js

@@ -0,0 +1,175 @@
+import { execFileSync } from "node:child_process";
+const CACHE_TTL_MS = 30_000;
+const FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+let cache;
+/**
+ * Resolves the OS-level proxy for a request URL. Used as a fallback when no
+ * proxy environment variables are set, so Bubble follows the same proxy that
+ * browsers and other GUI apps use (e.g. Clash/Surge "system proxy" mode).
+ * Reads `scutil --proxy` on macOS and the Internet Settings registry key on
+ * Windows. Returns undefined on other platforms, when disabled via
+ * BUBBLE_SYSTEM_PROXY=0, or when the URL matches the OS proxy bypass list.
+ */
+export function getSystemProxyForUrl(url, env = process.env) {
+    if (!url || isSystemProxyDisabled(env))
+        return undefined;
+    const settings = readSystemProxySettings();
+    if (!settings)
+        return undefined;
+    return systemProxyForUrl(url, settings);
+}
+export function systemProxyForUrl(url, settings) {
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        return undefined;
+    const hostname = url.hostname.toLowerCase();
+    if (isLoopbackHostname(hostname))
+        return undefined;
+    if (settings.exceptions.some((entry) => systemExceptionMatches(entry, hostname)))
+        return undefined;
+    if (url.protocol === "https:")
+        return settings.httpsProxy ?? settings.httpProxy;
+    return settings.httpProxy ?? settings.httpsProxy;
+}
+export function parseScutilProxyOutput(output) {
+    const settings = {
+        httpProxy: proxyUrlFromKeys(output, "HTTP"),
+        httpsProxy: proxyUrlFromKeys(output, "HTTPS"),
+        exceptions: parseExceptionsList(output),
+    };
+    if (!settings.httpProxy && !settings.httpsProxy)
+        return undefined;
+    return settings;
+}
+export function parseWindowsProxyOutput(output) {
+    const enable = readRegistryValue(output, "ProxyEnable", "REG_DWORD");
+    if (!enable || Number.parseInt(enable, 16) !== 1)
+        return undefined;
+    const server = readRegistryValue(output, "ProxyServer", "REG_SZ");
+    if (!server)
+        return undefined;
+    const { httpProxy, httpsProxy } = parseWindowsProxyServer(server);
+    if (!httpProxy && !httpsProxy)
+        return undefined;
+    const override = readRegistryValue(output, "ProxyOverride", "REG_SZ") ?? "";
+    const exceptions = override
+        .split(";")
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean);
+    return { httpProxy, httpsProxy, exceptions };
+}
+// ProxyServer is either "host:port" (all protocols) or per-protocol
+// "http=host:port;https=host:port;ftp=...;socks=..." — ftp/socks are ignored.
+function parseWindowsProxyServer(value) {
+    if (!value.includes("=")) {
+        const url = normalizeProxyHostPort(value);
+        return { httpProxy: url, httpsProxy: url };
+    }
+    const result = {};
+    for (const part of value.split(";")) {
+        const [protocol, hostPort] = part.split("=").map((item) => item.trim());
+        if (!protocol || !hostPort)
+            continue;
+        const url = normalizeProxyHostPort(hostPort);
+        if (!url)
+            continue;
+        if (protocol.toLowerCase() === "http")
+            result.httpProxy = url;
+        if (protocol.toLowerCase() === "https")
+            result.httpsProxy = url;
+    }
+    return result;
+}
+function normalizeProxyHostPort(value) {
+    const trimmed = value.trim().replace(/^https?:\/\//i, "");
+    const match = trimmed.match(/^([^\s:]+):(\d+)$/);
+    if (!match)
+        return undefined;
+    const port = Number(match[2]);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return undefined;
+    return `http://${match[1]}:${port}`;
+}
+function readRegistryValue(output, key, type) {
+    const match = output.match(new RegExp(`^\\s*${key}\\s+${type}\\s+(.+?)\\s*$`, "m"));
+    return match?.[1];
+}
+export function resetSystemProxyCacheForTests() {
+    cache = undefined;
+}
+function isSystemProxyDisabled(env) {
+    const value = env.BUBBLE_SYSTEM_PROXY?.trim().toLowerCase();
+    return !!value && FALSE_VALUES.has(value);
+}
+function readSystemProxySettings() {
+    if (process.platform !== "darwin" && process.platform !== "win32")
+        return undefined;
+    const now = Date.now();
+    if (cache && now - cache.at < CACHE_TTL_MS)
+        return cache.settings;
+    let settings;
+    try {
+        settings = process.platform === "darwin" ? readMacProxySettings() : readWindowsProxySettings();
+    }
+    catch {
+        settings = undefined;
+    }
+    cache = { at: now, settings };
+    return settings;
+}
+function readMacProxySettings() {
+    const output = execFileSync("scutil", ["--proxy"], { encoding: "utf-8", timeout: 2000 });
+    return parseScutilProxyOutput(output);
+}
+function readWindowsProxySettings() {
+    const output = execFileSync("reg", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], { encoding: "utf-8", timeout: 2000, windowsHide: true });
+    return parseWindowsProxyOutput(output);
+}
+function proxyUrlFromKeys(output, prefix) {
+    if (readScalar(output, `${prefix}Enable`) !== "1")
+        return undefined;
+    const host = readScalar(output, `${prefix}Proxy`);
+    const port = Number(readScalar(output, `${prefix}Port`));
+    if (!host || !Number.isInteger(port) || port <= 0 || port > 65535)
+        return undefined;
+    return `http://${host}:${port}`;
+}
+function readScalar(output, key) {
+    const match = output.match(new RegExp(`^\\s*${key}\\s*:\\s*(\\S+)`, "m"));
+    return match?.[1];
+}
+function parseExceptionsList(output) {
+    const match = output.match(/ExceptionsList\s*:\s*<array>\s*\{([\s\S]*?)\}/);
+    if (!match)
+        return [];
+    return [...match[1].matchAll(/^\s*\d+\s*:\s*(\S+)/gm)].map((item) => item[1].toLowerCase());
+}
+function systemExceptionMatches(entry, hostname) {
+    if (entry === "<local>")
+        return !hostname.includes(".");
+    // CIDR entries (e.g. 192.168.0.0/16) would need the resolved IP to match;
+    // skip them so we never wrongly bypass the proxy for public hostnames.
+    if (entry.includes("/"))
+        return false;
+    if (entry.startsWith("*."))
+        return hostname === entry.slice(2) || hostname.endsWith(entry.slice(1));
+    // Windows ProxyOverride allows wildcards anywhere, e.g. 127.* or 192.168.*
+    if (entry.includes("*"))
+        return wildcardMatches(entry, hostname);
+    if (entry.startsWith("."))
+        return hostname.endsWith(entry);
+    return entry === hostname;
+}
+function wildcardMatches(pattern, hostname) {
+    const regex = new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`);
+    return regex.test(hostname);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "localhost"
+        || hostname === "::1"
+        || hostname === "[::1]"
+        || hostname.startsWith("127.")
+        || hostname.endsWith(".localhost");
+}

package/dist/provider-anthropic.d.ts

@@ -79,6 +79,7 @@ export declare function buildAnthropicRequest(options: AnthropicProviderOptions,
     thinkingLevel?: ThinkingLevel;
     stream?: boolean;
 }): AnthropicRequest;
+export declare function resolveAnthropicMaxTokens(options: AnthropicProviderOptions, model: string): number;
 export declare function supportsAnthropicPromptCache(options: AnthropicProviderOptions, model: string): boolean;
 export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
     system: string;

package/dist/provider-anthropic.js

@@ -1,6 +1,10 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./provider-transform.js";
+import { isProviderTransportError, normalizeProviderNetworkError, providerFetch } from "./network/provider-transport.js";
+import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
 const ANTHROPIC_VERSION = "2023-06-01";
 const DEFAULT_MAX_TOKENS = 8192;
+const ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS = 128000;
+const ANTHROPIC_LONG_OUTPUT_MAX_TOKENS = 64000;
 const ANTHROPIC_PROMPT_CACHE_CONTROL = { type: "ephemeral" };
 const MINIMAX_PROMPT_CACHE_MODELS = new Set([
     "minimax-m2.7",
@@ -22,14 +26,14 @@ export function createAnthropicMessagesProvider(options) {
             thinkingLevel: chatOptions.thinkingLevel,
             stream: true,
         });
-        const response = await fetchAnthropicResponseWithRetry(options, {
+        const events = streamAnthropicEventsWithRetry(options, {
             url: resolveAnthropicMessagesUrl(options.baseURL),
             stream: true,
             method: "POST",
             body: JSON.stringify(body),
             signal: chatOptions.abortSignal,
         });
-        yield* translateAnthropicStream(readSseEvents(response));
+        yield* translateAnthropicStream(events);
         yield { type: "done" };
     }
     async function complete(messages, chatOptions) {
@@ -65,24 +69,37 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
             cache_control: ANTHROPIC_PROMPT_CACHE_CONTROL,
         };
     }
+    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
     const body = {
         model: chatOptions.model,
-        max_tokens: DEFAULT_MAX_TOKENS,
+        max_tokens: resolveAnthropicMaxTokens(options, chatOptions.model),
         system: buildAnthropicSystem(system, enablePromptCache),
         messages: anthropicMessages,
         tools: tools && tools.length > 0 ? tools : undefined,
         tool_choice: tools && tools.length > 0 ? { type: chatOptions.toolChoice ?? "auto" } : undefined,
         stream: chatOptions.stream || undefined,
     };
-    if (typeof chatOptions.temperature === "number") {
+    if (typeof chatOptions.temperature === "number"
+        && shouldSendTemperature(options, chatOptions.model, effectiveThinkingLevel)) {
         body.temperature = chatOptions.temperature;
     }
-    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
     if (effectiveThinkingLevel !== "off") {
         body.thinking = { type: "adaptive" };
     }
     return body;
 }
+export function resolveAnthropicMaxTokens(options, model) {
+    if (!isOfficialAnthropicBaseUrl(options.baseURL)) {
+        return DEFAULT_MAX_TOKENS;
+    }
+    if (isFableModelWith128kOutput(model) || isOpusModelWith128kOutput(model)) {
+        return ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS;
+    }
+    if (isSonnetOrHaikuModelWith64kOutput(model)) {
+        return ANTHROPIC_LONG_OUTPUT_MAX_TOKENS;
+    }
+    return DEFAULT_MAX_TOKENS;
+}
 function buildAnthropicSystem(system, enablePromptCache) {
     if (!system)
         return undefined;
@@ -352,27 +369,71 @@ export async function* readSseEvents(response) {
         reader.releaseLock();
     }
 }
+async function* streamAnthropicEventsWithRetry(options, request) {
+    const maxRetries = getProviderMaxRetries();
+    for (let attempt = 0;; attempt++) {
+        // Connection-level failures and retryable HTTP statuses are retried
+        // inside fetchAnthropicResponseWithRetry; an error thrown from it has
+        // already exhausted its budget, so it propagates without another loop.
+        const response = await fetchAnthropicResponseWithRetry(options, request);
+        let sawSseEvent = false;
+        try {
+            for await (const event of readSseEvents(response)) {
+                sawSseEvent = true;
+                yield event;
+            }
+            return;
+        }
+        catch (error) {
+            const normalized = normalizeAnthropicTransportError(error, request.url);
+            if (sawSseEvent) {
+                // Partial content already surfaced — only the agent loop can discard
+                // the half-built assistant message and safely re-issue the request.
+                if (!request.signal?.aborted && isProviderTransportError(error)) {
+                    throw new ProviderStreamInterruptedError(normalized.message, { cause: normalized });
+                }
+                throw normalized;
+            }
+            if (request.signal?.aborted || attempt >= maxRetries || !isProviderTransportError(error)) {
+                throw normalized;
+            }
+            await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), request.signal);
+        }
+    }
+}
 async function fetchAnthropicResponseWithRetry(options, request) {
-    const maxAttempts = shouldRetryMiniMaxAnthropic(options) ? 2 : 1;
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        const response = await fetch(request.url, {
-            method: request.method,
-            headers: buildAnthropicHeaders(options, request.stream),
-            body: request.body,
-            signal: request.signal,
-        });
+    const maxRetries = getProviderMaxRetries();
+    for (let attempt = 0;; attempt++) {
+        let response;
+        try {
+            response = await providerFetch(request.url, {
+                method: request.method,
+                headers: buildAnthropicHeaders(options, request.stream),
+                body: request.body,
+                signal: request.signal,
+                keepalive: false,
+            }, {
+                providerName: "Anthropic",
+                verboseEnvVar: "BUBBLE_ANTHROPIC_FETCH_VERBOSE",
+            });
+        }
+        catch (error) {
+            // No response received, so the request is safe to re-issue.
+            if (request.signal?.aborted || attempt >= maxRetries || !isProviderTransportError(error)) {
+                throw normalizeAnthropicTransportError(error, request.url);
+            }
+            await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), request.signal);
+            continue;
+        }
         if (response.ok)
             return response;
         const detail = await readAnthropicErrorDetail(response);
         const error = new Error(`Anthropic Messages API error ${response.status}: ${detail || response.statusText}`);
-        lastError = error;
-        if (attempt >= maxAttempts || !isRetryableMiniMaxAnthropicError(response.status, detail)) {
+        if (request.signal?.aborted || attempt >= maxRetries || !isRetryableAnthropicHttpError(response.status, detail)) {
             throw error;
         }
-        await sleepBeforeRetry(getAnthropicRetryDelayMs(), request.signal);
+        await sleepBeforeRetry(computeRetryDelayMs(attempt + 1, { retryAfterMs: retryAfterMsFromResponse(response) }), request.signal);
     }
-    throw lastError ?? new Error("Anthropic Messages API request failed");
 }
 function resolveAnthropicMessagesUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
@@ -403,42 +464,18 @@ async function readAnthropicErrorDetail(response) {
         return response.statusText;
     }
 }
-function shouldRetryMiniMaxAnthropic(options) {
-    const providerId = (options.providerId || "").toLowerCase();
-    const baseURL = options.baseURL.toLowerCase();
-    return providerId.startsWith("minimax") || baseURL.includes("api.minimaxi.com") || baseURL.includes("api.minimax.io");
-}
-function isRetryableMiniMaxAnthropicError(status, detail) {
-    return status === 500
-        || status === 502
-        || status === 503
-        || status === 504
-        || detail.includes("714 (1000)");
-}
-function getAnthropicRetryDelayMs() {
-    if (process.env.NODE_ENV === "test")
-        return 0;
-    return 800 + Math.floor(Math.random() * 700);
-}
-function sleepBeforeRetry(ms, signal) {
-    if (signal?.aborted) {
-        return Promise.reject(toAbortError(signal));
-    }
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
-            clearTimeout(timeout);
-            reject(toAbortError(signal));
-        }, { once: true });
+function normalizeAnthropicTransportError(error, url) {
+    if (!isProviderTransportError(error)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    return normalizeProviderNetworkError(error, {
+        providerName: "Anthropic",
+        input: url,
     });
 }
-function toAbortError(signal) {
-    const reason = signal?.reason;
-    if (reason instanceof Error)
-        return reason;
-    const error = new Error("Anthropic request retry aborted.");
-    error.name = "AbortError";
-    return error;
+function isRetryableAnthropicHttpError(status, detail) {
+    // "714 (1000)" is a transient MiniMax backend error surfaced as a 500.
+    return isRetryableHttpStatus(status) || detail.includes("714 (1000)");
 }
 function parseSseEvent(raw) {
     const dataLines = [];
@@ -573,6 +610,44 @@ function shouldEchoThinking(providerId) {
 function shouldSendBearerAuth(options) {
     return !isOfficialAnthropicBaseUrl(options.baseURL) || options.providerId?.startsWith("minimax") === true;
 }
+function shouldSendTemperature(options, model, thinkingLevel) {
+    if (!isOfficialAnthropicBaseUrl(options.baseURL))
+        return true;
+    if (thinkingLevel !== "off")
+        return false;
+    return !isOpusModelWithoutSamplingControls(model);
+}
+function isOpusModelWith128kOutput(model) {
+    return isClaudeFamilyVersionAtLeast(model, "opus", 4, 6);
+}
+function isFableModelWith128kOutput(model) {
+    return model.toLowerCase().startsWith("claude-fable-5");
+}
+function isSonnetOrHaikuModelWith64kOutput(model) {
+    const normalized = model.toLowerCase();
+    return normalized.startsWith("claude-sonnet-4-6")
+        || normalized.startsWith("claude-haiku-4-5");
+}
+function isOpusModelWithoutSamplingControls(model) {
+    return isClaudeFamilyVersionAtLeast(model, "opus", 4, 7);
+}
+function isClaudeFamilyVersionAtLeast(model, family, minMajor, minMinor) {
+    const normalized = model.toLowerCase();
+    if (!normalized.startsWith(`claude-${family}-`))
+        return false;
+    const [, , majorSegment, minorSegment] = normalized.split("-");
+    const major = Number(majorSegment);
+    if (!Number.isFinite(major))
+        return false;
+    if (major > minMajor)
+        return true;
+    if (major < minMajor)
+        return false;
+    if (!minorSegment || minorSegment.length > 2)
+        return false;
+    const minor = Number(minorSegment);
+    return Number.isFinite(minor) && minor >= minMinor;
+}
 function isMiniMaxAnthropicEndpoint(options) {
     const providerId = (options.providerId ?? "").toLowerCase();
     if (providerId !== "minimax" && providerId !== "minimax-anthropic")

package/dist/provider-openai-codex.js

@@ -2,11 +2,10 @@ import { createHash } from "node:crypto";
 import { listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { chatGptFetch } from "./network/chatgpt-transport.js";
+import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, sleepBeforeRetry, } from "./network/retry.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const OPENAI_BETA_RESPONSES = "responses=experimental";
 const TOKEN_REFRESH_GRACE_MS = 5 * 60 * 1000;
-const CODEX_TRANSPORT_MAX_RETRIES = 2;
-const CODEX_TRANSPORT_RETRY_BASE_DELAY_MS = 250;
 // OpenAI gates new codex models server-side by client_version (each model carries a
 // `minimal_client_version`). Track a recent real Codex CLI release; override via env
 // when OpenAI lifts the gate again before we cut a new release.
@@ -221,6 +220,13 @@ export function createOpenAICodexProvider(options) {
                 return;
             }
             catch (error) {
+                if (sawParsedSseEvent
+                    && !chatOptions.abortSignal?.aborted
+                    && isTransientCodexTransportError(error)) {
+                    // Partial content already surfaced — the agent loop discards the
+                    // half-built assistant message and re-issues the whole request.
+                    throw new ProviderStreamInterruptedError(error instanceof Error ? error.message : String(error), { cause: error });
+                }
                 if (!shouldRetryCodexTransportError({
                     error,
                     attempt,
@@ -229,7 +235,7 @@ export function createOpenAICodexProvider(options) {
                 })) {
                     throw error;
                 }
-                await sleepBeforeCodexRetry(codexRetryDelayMs(attempt), chatOptions.abortSignal);
+                await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), chatOptions.abortSignal);
             }
         }
     }
@@ -439,9 +445,17 @@ function shouldRetryCodexTransportError(input) {
         return false;
     if (input.sawParsedSseEvent)
         return false;
-    if (input.attempt >= CODEX_TRANSPORT_MAX_RETRIES)
+    if (input.attempt >= getProviderMaxRetries())
+        return false;
+    return isTransientCodexTransportError(input.error) || isRetryableCodexHttpError(input.error);
+}
+function isRetryableCodexHttpError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const match = error.message.match(/^(\d{3}) status code/);
+    if (!match)
         return false;
-    return isTransientCodexTransportError(input.error);
+    return isRetryableHttpStatus(Number(match[1]));
 }
 function isTransientCodexTransportError(error) {
     const text = errorMessageChain(error).join("\n");
@@ -487,30 +501,6 @@ function errorMessageChain(error) {
     }
     return messages;
 }
-function codexRetryDelayMs(attempt) {
-    return CODEX_TRANSPORT_RETRY_BASE_DELAY_MS * Math.pow(3, attempt);
-}
-function sleepBeforeCodexRetry(ms, signal) {
-    if (signal?.aborted)
-        return Promise.reject(toAbortError(signal));
-    return new Promise((resolve, reject) => {
-        const onAbort = () => {
-            clearTimeout(timeout);
-            signal?.removeEventListener("abort", onAbort);
-            reject(toAbortError(signal));
-        };
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function toAbortError(signal) {
-    if (signal?.reason instanceof Error)
-        return signal.reason;
-    return new DOMException(typeof signal?.reason === "string" ? signal.reason : "Aborted", "AbortError");
-}
 function buildBaseHeaders(accessToken, accountId, sessionId, extraHeaders) {
     const headers = new Headers(extraHeaders);
     headers.set("Authorization", `Bearer ${accessToken}`);

package/dist/session-log.js

@@ -1,4 +1,4 @@
-import { sanitizeAssistantProviderMetadata, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
+import { sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
 export class SessionLog {
     entries = [];
     load(lines) {
@@ -130,7 +130,7 @@ export class SessionLog {
                         role: "assistant",
                         content: sanitizeInternalReminderBlocks(entry.message.content),
                         reasoning: entry.message.reasoning !== undefined
-                            ? sanitizeInternalReminderBlocks(entry.message.reasoning)
+                            ? sanitizeInternalReasoningText(entry.message.reasoning)
                             : undefined,
                         providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(entry.message.providerMetadata)),
                     });
@@ -197,7 +197,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     role: "assistant",
                     content: sanitizeInternalReminderBlocks(message.content),
                     reasoning: message.reasoning !== undefined
-                        ? sanitizeInternalReminderBlocks(message.reasoning)
+                        ? sanitizeInternalReasoningText(message.reasoning)
                         : undefined,
                     model: message.model,
                     providerId: message.providerId,

package/dist/session.d.ts

@@ -1,6 +1,7 @@
 /**
  * Session Manager - Append-only JSONL persistence over a structured session log.
  */
+import { CheckpointStore } from "./checkpoints.js";
 import { type CompactOptions, type CompactResult } from "./context/compact.js";
 import type { Message, Todo } from "./types.js";
 import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
@@ -16,9 +17,25 @@ export interface SessionSummary {
     mtime: number;
 }
 export type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+export interface UserTurn {
+    /** Session log entry id of the user message that starts the turn. */
+    id: string;
+    /** Single-line preview of the user message. */
+    preview: string;
+    /** Full text of the user message. */
+    text: string;
+    timestamp: number;
+}
+export interface RewindResult {
+    /** Number of log entries removed. */
+    removedEntries: number;
+    /** Full text of the user message the session was rewound to (for re-editing). */
+    targetText: string;
+}
 export declare class SessionManager {
     private sessionFile;
     private log;
+    private checkpoints?;
     constructor(sessionFile: string);
     static create(cwd: string, sessionName?: string): SessionManager;
     static resume(cwd: string, sessionName?: string): SessionManager | undefined;
@@ -41,6 +58,20 @@ export declare class SessionManager {
     getTodos(): Todo[];
     compact(options?: CompactOptions): CompactResult;
     getMessages(): Message[];
+    /**
+     * Pre-edit file snapshot store for this session, used by /rewind.
+     * Lives next to the session JSONL as `<session>.checkpoints/`.
+     */
+    getCheckpoints(): CheckpointStore;
+    /** Entry id of the most recent user message, or "0" before the first one. */
+    lastUserEntryId(): string;
+    /** User messages after the latest /clear, oldest first — the valid rewind anchors. */
+    listUserTurns(): UserTurn[];
+    /**
+     * Truncate the session to just before the user message with the given
+     * entry id. Returns undefined when the id does not name a user message.
+     */
+    rewindToEntry(entryId: string): RewindResult | undefined;
     getEntries(): SessionLogEntry[];
     getSessionFile(): string;
     private maybeAutoCompact;