@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/config.d.ts

@@ -0,0 +1,96 @@
+/**
+ * User-level configuration manager.
+ *
+ * Uses a single JSON file in Bubble home, normally ~/.bubble/config.json.
+ */
+import { type AgentCategoriesConfig } from "./agent/categories.js";
+import { type AgentRoutingConfig } from "./agent/routing-catalog.js";
+import type { ProviderProfile } from "./provider-registry.js";
+import type { ThinkingLevel } from "./types.js";
+export type ThemeMode = "auto" | "light" | "dark";
+export interface ThemeConfig {
+    mode: ThemeMode;
+    overrides?: Record<string, string>;
+    explicit?: boolean;
+}
+export interface UserConfigData {
+    defaultModel?: string;
+    defaultThinkingLevel?: ThinkingLevel;
+    skillPaths?: string[];
+    /** Skill names disabled from invocation/search until re-enabled in /skills. */
+    skills?: {
+        disabled?: string[];
+        catalogChars?: number;
+    };
+    /**
+     * Three shapes are accepted on disk so we can evolve without breaking
+     * existing configs:
+     *   - `"auto" | "light" | "dark"` — mode only
+     *   - `{ mode, overrides? }` — mode + optional per-key palette overrides
+     *   - `Record<string, string>` (legacy) — treated as `{ mode: "dark", overrides }`
+     *     so users who customized colors before light-mode existed keep their
+     *     palette and stay on dark, which was the only palette at the time.
+     */
+    theme?: ThemeMode | ThemeConfig | Record<string, string>;
+    recentModels?: string[];
+    apiKey?: string;
+    providers?: ProviderProfile[];
+    defaultProvider?: string;
+    agentCategories?: AgentCategoriesConfig;
+    /** Subagent model-routing knobs: autoTier (default true), allowCrossProvider (default true). */
+    agentRouting?: Partial<AgentRoutingConfig>;
+    subagents?: SubagentsUserConfig;
+    /** Background tasks: completion wakes and Grok-style foreground demotion. */
+    tasks?: {
+        /** Auto-resume the Agent when an owned task finishes. Defaults ON. */
+        autoResume?: boolean;
+        /** Move long foreground Execute calls into Tasks automatically. Defaults ON. */
+        autoBackground?: boolean;
+        /** Foreground wait budget before automatic demotion. Defaults to 15 seconds. */
+        foregroundWaitMs?: number;
+    };
+}
+export interface SubagentsUserConfig {
+    /** Global cap on concurrently running children. Default 8. */
+    maxActiveSubagents?: number;
+}
+export declare class UserConfig {
+    private data;
+    constructor();
+    private load;
+    private save;
+    getDefaultModel(): string | undefined;
+    setDefaultModel(model: string): void;
+    getDefaultThinkingLevel(): ThinkingLevel | undefined;
+    setDefaultThinkingLevel(level: ThinkingLevel): void;
+    getRecentModels(): string[];
+    /** Auto-resume on background-task completion (design §2.3b). Default ON. */
+    getTasksAutoResume(): boolean;
+    /** Grok-style foreground wait budget. `false` disables automatic demotion. */
+    getTasksAutoBackgroundAfterMs(): number | false;
+    pushRecentModel(model: string): void;
+    getApiKey(): string | undefined;
+    setApiKey(key: string): void;
+    getProviders(): ProviderProfile[];
+    setProviders(providers: ProviderProfile[]): void;
+    getDefaultProvider(): string | undefined;
+    setDefaultProvider(id: string): void;
+    getSkillPaths(): string[];
+    setSkillPaths(paths: string[]): void;
+    /** Skill catalog budget in characters; undefined uses the default, 0 turns the catalog off. */
+    getSkillCatalogChars(): number | undefined;
+    getDisabledSkills(): string[];
+    setDisabledSkills(names: string[]): void;
+    getTheme(): ThemeConfig;
+    getThemeMode(): ThemeMode;
+    getThemeOverrides(): Record<string, string>;
+    setThemeMode(mode: ThemeMode): void;
+    setThemeOverrides(overrides: Record<string, string>): void;
+    getAgentCategories(): AgentCategoriesConfig;
+    getAgentRouting(): AgentRoutingConfig;
+    getSubagents(): SubagentsUserConfig;
+}
+export declare function shouldProbeTerminalTheme(_config: ThemeConfig): boolean;
+export declare function effectiveThemeModeForTerminal(config: ThemeConfig, detectedTheme: Exclude<ThemeMode, "auto">): ThemeMode;
+/** Mask an API key for safe display. */
+export declare function maskKey(key: string): string;

package/dist/config.js

@@ -0,0 +1,287 @@
+/**
+ * User-level configuration manager.
+ *
+ * Uses a single JSON file in Bubble home, normally ~/.bubble/config.json.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "./bubble-home.js";
+import { sanitizeAgentCategories } from "./agent/categories.js";
+import { sanitizeAgentRouting } from "./agent/routing-catalog.js";
+import { isProviderModelAllowed } from "./provider-model-policy.js";
+// openai-codex is an internal transport profile surfaced through the visible
+// OpenAI OAuth provider. OpenRouter is a regular user-configurable provider.
+const HIDDEN_PROVIDER_IDS = new Set(["openai-codex"]);
+function getConfigPath() {
+    return join(getBubbleHome(), "config.json");
+}
+function isHiddenProviderId(providerId) {
+    return !!providerId && HIDDEN_PROVIDER_IDS.has(providerId);
+}
+function modelProviderId(model) {
+    if (!model.includes(":"))
+        return undefined;
+    return model.split(":", 1)[0];
+}
+function isAllowedConfiguredModel(model) {
+    if (!model.includes(":"))
+        return true;
+    const [providerId, ...modelParts] = model.split(":");
+    return isProviderModelAllowed(providerId, modelParts.join(":"));
+}
+function sanitizeRecentModels(models) {
+    if (!models)
+        return undefined;
+    return models.filter((model) => !isHiddenProviderId(modelProviderId(model)) && isAllowedConfiguredModel(model));
+}
+function sanitizeProviders(providers) {
+    if (!providers)
+        return undefined;
+    return providers.filter((provider) => !isHiddenProviderId(provider.id));
+}
+function sanitizeDefaultModel(model) {
+    if (!model)
+        return undefined;
+    return isHiddenProviderId(modelProviderId(model)) || !isAllowedConfiguredModel(model)
+        ? undefined
+        : model;
+}
+function sanitizeDefaultProvider(providerId) {
+    return isHiddenProviderId(providerId) ? undefined : providerId;
+}
+function sanitizeSubagentsConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const out = {};
+    if (typeof raw.maxActiveSubagents === "number" && Number.isFinite(raw.maxActiveSubagents)) {
+        out.maxActiveSubagents = Math.max(1, Math.floor(raw.maxActiveSubagents));
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function sanitizeTheme(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string") {
+        return value === "auto" || value === "light" || value === "dark"
+            ? { mode: value, explicit: true }
+            : undefined;
+    }
+    if (typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    // Discriminate the new `{ mode, overrides }` shape from the legacy
+    // `Record<string, string>` shape. A legacy config has no `mode` key.
+    const maybeNew = value;
+    if (typeof maybeNew.mode === "string") {
+        const mode = maybeNew.mode;
+        if (mode !== "auto" && mode !== "light" && mode !== "dark")
+            return undefined;
+        const overrides = isStringMap(maybeNew.overrides) ? maybeNew.overrides : undefined;
+        const explicit = maybeNew.explicit === true ? true : undefined;
+        return {
+            mode,
+            ...(overrides ? { overrides } : {}),
+            ...(explicit ? { explicit } : {}),
+        };
+    }
+    const overrides = pickStringEntries(value);
+    if (Object.keys(overrides).length === 0)
+        return undefined;
+    return { mode: "dark", overrides };
+}
+function isStringMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.values(value).every((entry) => typeof entry === "string");
+}
+function pickStringEntries(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => typeof v === "string"));
+}
+export class UserConfig {
+    data = {};
+    constructor() {
+        this.load();
+    }
+    load() {
+        const configPath = getConfigPath();
+        if (!existsSync(configPath))
+            return;
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            this.data = {
+                ...parsed,
+                defaultModel: sanitizeDefaultModel(parsed.defaultModel),
+                recentModels: sanitizeRecentModels(parsed.recentModels),
+                providers: sanitizeProviders(parsed.providers),
+                defaultProvider: sanitizeDefaultProvider(parsed.defaultProvider),
+                agentCategories: sanitizeAgentCategories(parsed.agentCategories),
+                subagents: sanitizeSubagentsConfig(parsed.subagents),
+                theme: sanitizeTheme(parsed.theme),
+            };
+        }
+        catch {
+            this.data = {};
+        }
+    }
+    save() {
+        const configPath = getConfigPath();
+        const dir = dirname(configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(configPath, JSON.stringify(this.data, null, 2) + "\n");
+    }
+    getDefaultModel() {
+        return sanitizeDefaultModel(this.data.defaultModel)
+            ?? sanitizeRecentModels(this.data.recentModels)?.[0];
+    }
+    setDefaultModel(model) {
+        this.data.defaultModel = sanitizeDefaultModel(model);
+        this.save();
+    }
+    getDefaultThinkingLevel() {
+        return this.data.defaultThinkingLevel;
+    }
+    setDefaultThinkingLevel(level) {
+        this.data.defaultThinkingLevel = level;
+        this.save();
+    }
+    getRecentModels() {
+        return sanitizeRecentModels(this.data.recentModels)?.slice() ?? [];
+    }
+    /** Auto-resume on background-task completion (design §2.3b). Default ON. */
+    getTasksAutoResume() {
+        return this.data.tasks?.autoResume !== false;
+    }
+    /** Grok-style foreground wait budget. `false` disables automatic demotion. */
+    getTasksAutoBackgroundAfterMs() {
+        if (this.data.tasks?.autoBackground === false)
+            return false;
+        const configured = this.data.tasks?.foregroundWaitMs;
+        if (typeof configured !== "number" || !Number.isFinite(configured))
+            return 15_000;
+        return Math.max(1_000, Math.min(300_000, Math.floor(configured)));
+    }
+    pushRecentModel(model) {
+        if (isHiddenProviderId(modelProviderId(model)) || !isAllowedConfiguredModel(model)) {
+            return;
+        }
+        const recent = this.data.recentModels ?? [];
+        const uniq = [model, ...recent.filter((m) => m !== model)];
+        const sanitized = sanitizeRecentModels(uniq.slice(0, 10));
+        this.data.recentModels = sanitized;
+        this.data.defaultModel = sanitized?.[0];
+        this.save();
+    }
+    getApiKey() {
+        return this.data.apiKey;
+    }
+    setApiKey(key) {
+        this.data.apiKey = key;
+        this.save();
+    }
+    getProviders() {
+        return sanitizeProviders(this.data.providers)?.slice() ?? [];
+    }
+    setProviders(providers) {
+        this.data.providers = sanitizeProviders(providers);
+        this.save();
+    }
+    getDefaultProvider() {
+        return sanitizeDefaultProvider(this.data.defaultProvider);
+    }
+    setDefaultProvider(id) {
+        this.data.defaultProvider = sanitizeDefaultProvider(id);
+        this.save();
+    }
+    getSkillPaths() {
+        return Array.isArray(this.data.skillPaths) ? this.data.skillPaths.slice() : [];
+    }
+    setSkillPaths(paths) {
+        this.data.skillPaths = paths.slice();
+        this.save();
+    }
+    /** Skill catalog budget in characters; undefined uses the default, 0 turns the catalog off. */
+    getSkillCatalogChars() {
+        const value = this.data.skills?.catalogChars;
+        return typeof value === "number" && Number.isFinite(value) && value >= 0
+            ? Math.min(Math.floor(value), 200_000)
+            : undefined;
+    }
+    getDisabledSkills() {
+        const disabled = this.data.skills?.disabled;
+        if (!Array.isArray(disabled))
+            return [];
+        return [...new Set(disabled.filter((name) => (typeof name === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name))))].sort((a, b) => a.localeCompare(b));
+    }
+    setDisabledSkills(names) {
+        const disabled = [...new Set(names.filter((name) => (/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name))))].sort((a, b) => a.localeCompare(b));
+        if (disabled.length === 0) {
+            const next = { ...(this.data.skills ?? {}) };
+            delete next.disabled;
+            if (Object.keys(next).length === 0)
+                delete this.data.skills;
+            else
+                this.data.skills = next;
+        }
+        else {
+            this.data.skills = { ...(this.data.skills ?? {}), disabled };
+        }
+        this.save();
+    }
+    getTheme() {
+        const theme = sanitizeTheme(this.data.theme);
+        return theme ?? { mode: "auto" };
+    }
+    getThemeMode() {
+        return this.getTheme().mode;
+    }
+    getThemeOverrides() {
+        return this.getTheme().overrides ?? {};
+    }
+    setThemeMode(mode) {
+        const current = this.getTheme();
+        this.data.theme = current.overrides
+            ? { mode, overrides: current.overrides, explicit: true }
+            : { mode, explicit: true };
+        this.save();
+    }
+    setThemeOverrides(overrides) {
+        const current = this.getTheme();
+        this.data.theme = Object.keys(overrides).length === 0
+            ? { mode: current.mode, ...(current.explicit ? { explicit: true } : {}) }
+            : { mode: current.mode, overrides: { ...overrides }, ...(current.explicit ? { explicit: true } : {}) };
+        this.save();
+    }
+    getAgentCategories() {
+        return sanitizeAgentCategories(this.data.agentCategories);
+    }
+    getAgentRouting() {
+        return sanitizeAgentRouting(this.data.agentRouting);
+    }
+    getSubagents() {
+        return sanitizeSubagentsConfig(this.data.subagents) ?? {};
+    }
+}
+export function shouldProbeTerminalTheme(_config) {
+    // Always probe: even a forced theme needs the real terminal background to
+    // decide between inheriting it (theme matches the terminal) and painting
+    // its own canvas (forced theme mismatching the terminal, where the
+    // palette's foregrounds would otherwise be unreadable).
+    return true;
+}
+export function effectiveThemeModeForTerminal(config, detectedTheme) {
+    if (isLegacyBareDarkTheme(config) && detectedTheme === "light")
+        return "auto";
+    return config.mode;
+}
+function isLegacyBareDarkTheme(config) {
+    return config.mode === "dark" && config.explicit !== true && !config.overrides;
+}
+/** Mask an API key for safe display. */
+export function maskKey(key) {
+    if (key.length <= 12)
+        return "****";
+    return key.slice(0, 6) + "..." + key.slice(-4);
+}

package/dist/context/budget.d.ts

@@ -0,0 +1,28 @@
+import type { Message, ToolDefinition } from "../types.js";
+export declare const OUTPUT_RESERVE_TOKENS = 20000;
+export declare const AUTOCOMPACT_BUFFER_TOKENS = 13000;
+export declare const PRUNE_BUFFER_TOKENS = 50000;
+export declare const MIN_WINDOW_FOR_RESERVE = 40000;
+export interface ContextBudget {
+    estimatedTokens: number;
+    contextWindow?: number;
+    percent?: number;
+    shouldPrune: boolean;
+    shouldCompact: boolean;
+}
+export interface ContextBudgetOptions {
+    /** Authoritative input-token count from the most recent response usage. */
+    usageAnchorTokens?: number;
+    /** Messages appended after the anchor (their tokens are estimated and added). */
+    tailMessages?: Message[];
+    /** Tokens outside the message list, primarily serialized tool definitions. */
+    additionalInputTokens?: number;
+}
+export declare function estimateMessageTokens(message: Message, providerId?: string): number;
+export declare function estimateContextTokens(messages: Message[], providerId?: string): number;
+export declare function getContextBudget(providerId: string, modelId: string, messages: Message[], options?: ContextBudgetOptions): ContextBudget;
+/** Estimate the request-space occupied by tool schemas sent on every turn. */
+export declare function estimateToolDefinitionsTokens(tools: ToolDefinition[], providerId?: string): number;
+/** Maximum estimated input size that still leaves useful room for an answer. */
+export declare function getMaxInputTokens(contextWindow: number | undefined): number | undefined;
+export declare function estimateTextTokens(text: string, providerId?: string): number;

package/dist/context/budget.js

@@ -0,0 +1,130 @@
+import { getModelContextWindow } from "../model-catalog.js";
+import { getTokenEstimator } from "./token-estimator.js";
+export const OUTPUT_RESERVE_TOKENS = 20_000;
+export const AUTOCOMPACT_BUFFER_TOKENS = 13_000;
+export const PRUNE_BUFFER_TOKENS = 50_000;
+export const MIN_WINDOW_FOR_RESERVE = 40_000;
+// Safety margins applied to estimator-derived token counts. The estimator can
+// undercount on dense / CJK / tool-payload content; treating its output as a
+// hard floor means we'd routinely overshoot the real server-side count. These
+// multipliers bias the budget decision toward earlier compaction.
+const TAIL_SAFETY_MARGIN = 1.15; // applied to estimated tail when anchored
+const FIRST_TURN_SAFETY_MARGIN = 1.25; // applied when there's no anchor yet
+export function estimateMessageTokens(message, providerId) {
+    const estimate = (text) => estimateTextTokens(text, providerId);
+    switch (message.role) {
+        case "system":
+        case "meta":
+        case "tool":
+            return estimate(message.content);
+        case "assistant":
+            return estimate(message.content)
+                + estimate(message.reasoning ?? "")
+                + estimateProviderMetadataOverhead(message.providerMetadata, providerId)
+                + (message.toolCalls?.reduce((sum, toolCall) => sum + estimate(toolCall.arguments) + 12, 0) ?? 0)
+                + 8;
+        case "user":
+            if (typeof message.content === "string") {
+                return estimate(message.content) + 8;
+            }
+            return message.content.reduce((sum, part) => {
+                if (part.type === "text") {
+                    return sum + estimate(part.text);
+                }
+                return sum + 256;
+            }, 8);
+    }
+}
+function estimateProviderMetadataOverhead(metadata, providerId) {
+    const blocks = [
+        ...(metadata?.anthropic?.contentBlocks ?? []),
+        ...(metadata?.openai?.contentBlocks ?? []),
+    ];
+    if (blocks.length === 0)
+        return 0;
+    const estimate = (text) => estimateTextTokens(text, providerId);
+    return blocks.reduce((sum, block) => {
+        let overhead = 0;
+        if (typeof block.signature === "string")
+            overhead += estimate(block.signature);
+        if (block.type === "redacted_thinking" && typeof block.data === "string")
+            overhead += estimate(block.data);
+        if (block.type === "reasoning" && typeof block.encrypted_content === "string")
+            overhead += estimate(block.encrypted_content);
+        return sum + overhead;
+    }, 0);
+}
+export function estimateContextTokens(messages, providerId) {
+    return messages.reduce((sum, message) => sum + estimateMessageTokens(message, providerId), 0);
+}
+export function getContextBudget(providerId, modelId, messages, options = {}) {
+    const estimatedTokens = computeEstimatedTokens(providerId, messages, options);
+    const contextWindow = getModelContextWindow(providerId, modelId);
+    const percent = contextWindow ? Math.min(100, (estimatedTokens / contextWindow) * 100) : undefined;
+    return {
+        estimatedTokens,
+        contextWindow,
+        percent,
+        shouldPrune: shouldTriggerPrune(estimatedTokens, contextWindow),
+        shouldCompact: shouldTriggerCompact(estimatedTokens, contextWindow),
+    };
+}
+function computeEstimatedTokens(providerId, messages, options) {
+    const additionalInputTokens = Math.max(0, options.additionalInputTokens ?? 0);
+    if (options.usageAnchorTokens !== undefined && options.tailMessages) {
+        // Anchor is authoritative (server-reported input tokens from the last
+        // response). Tail goes through our estimator and may undercount on dense /
+        // tool-output content, so we inflate it by a small margin before adding.
+        const tailEstimate = estimateContextTokens(options.tailMessages, providerId);
+        return options.usageAnchorTokens
+            + Math.ceil(tailEstimate * TAIL_SAFETY_MARGIN)
+            + additionalInputTokens;
+    }
+    // First turn (or anchor lost): there's no server-reported baseline at all,
+    // so apply a larger safety margin to the pure estimate.
+    return Math.ceil((estimateContextTokens(messages, providerId) + additionalInputTokens)
+        * FIRST_TURN_SAFETY_MARGIN);
+}
+/** Estimate the request-space occupied by tool schemas sent on every turn. */
+export function estimateToolDefinitionsTokens(tools, providerId) {
+    if (tools.length === 0)
+        return 0;
+    // Providers wrap this array in their own function/tool envelope. The fixed
+    // per-entry allowance covers names, discriminator keys and separators not
+    // represented by the plain JSON payload.
+    return estimateTextTokens(JSON.stringify(tools), providerId) + tools.length * 16 + 16;
+}
+/** Maximum estimated input size that still leaves useful room for an answer. */
+export function getMaxInputTokens(contextWindow) {
+    if (!contextWindow)
+        return undefined;
+    return contextWindow >= MIN_WINDOW_FOR_RESERVE
+        ? Math.max(1, contextWindow
+            - OUTPUT_RESERVE_TOKENS
+            - Math.max(AUTOCOMPACT_BUFFER_TOKENS, Math.floor(contextWindow * 0.05)))
+        : Math.max(1, Math.floor(contextWindow * 0.75));
+}
+function shouldTriggerPrune(estimatedTokens, contextWindow) {
+    if (!contextWindow) {
+        return estimatedTokens >= 16_000;
+    }
+    const threshold = contextWindow >= MIN_WINDOW_FOR_RESERVE
+        ? contextWindow - OUTPUT_RESERVE_TOKENS - PRUNE_BUFFER_TOKENS
+        : contextWindow * 0.55;
+    return estimatedTokens >= threshold;
+}
+function shouldTriggerCompact(estimatedTokens, contextWindow) {
+    if (!contextWindow) {
+        return estimatedTokens >= 32_000;
+    }
+    const threshold = contextWindow >= MIN_WINDOW_FOR_RESERVE
+        ? contextWindow - OUTPUT_RESERVE_TOKENS - AUTOCOMPACT_BUFFER_TOKENS
+        : contextWindow * 0.75;
+    return estimatedTokens >= threshold;
+}
+export function estimateTextTokens(text, providerId) {
+    if (!text) {
+        return 0;
+    }
+    return getTokenEstimator(providerId).estimate(text);
+}

package/dist/context/checkpoint.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from "../types.js";
+/** A versioned, exact conversational projection. Never includes the host system prompt. */
+export interface ContextCheckpoint {
+    version: 1;
+    compactionId: string;
+    reason: "auto" | "manual" | "overflow" | "resident";
+    baseRevision?: string;
+    summary?: string;
+    messages: Message[];
+}
+export declare function createContextCheckpoint(messages: Message[], reason: ContextCheckpoint["reason"], summary?: string, baseRevision?: string): ContextCheckpoint;
+/** Live meta reminders may interleave results, but every canonical call needs a real result. */
+export declare function hasCompleteToolGroups(messages: Message[]): boolean;
+export declare function checkpointMessages(checkpoint: ContextCheckpoint): Message[];
+/** Replay-side read: a checkpoint this build cannot validate (a newer format,
+ * a hand-edited record) is not a boundary. Originals are retained, so callers
+ * fall back to an earlier boundary instead of failing the whole session. */
+export declare function tryCheckpointMessages(checkpoint: ContextCheckpoint): Message[] | undefined;

package/dist/context/checkpoint.js

@@ -0,0 +1,117 @@
+import { randomUUID } from "node:crypto";
+import { isClaudeWithBoundThinking } from "../anthropic-thinking.js";
+import { isInternalBlockOnlyContent, sanitizeInternalReminderBlocks, sanitizeInternalReasoningText, sanitizeAssistantProviderMetadata } from "../agent/internal-reminder-sanitizer.js";
+import { isCompactionSummaryMessage, splitLeadingContext } from "./compact.js";
+export function createContextCheckpoint(messages, reason, summary, baseRevision) {
+    const { body } = splitLeadingContext(messages);
+    // Runtime reminders must be recomputed by the host. Compaction summaries are
+    // first-class context, not ephemeral reminders, and must survive verbatim.
+    const durable = body.filter(message => {
+        if (isCompactionSummaryMessage(message))
+            return true;
+        if (message.role === "meta")
+            return false;
+        // Backstop for older histories containing provider-projected reminders.
+        // Never remove user prose merely because it mentions or quotes a block.
+        return !(message.role === "user" && typeof message.content === "string"
+            && isInternalBlockOnlyContent(message.content)
+            && !sanitizeInternalReminderBlocks(message.content).trim());
+    });
+    const sanitized = durable.map(sanitizeCheckpointMessage);
+    return { version: 1, compactionId: randomUUID(), reason, baseRevision,
+        summary: summary === undefined ? undefined : sanitizeInternalReminderBlocks(summary),
+        messages: structuredClone(sanitized) };
+}
+/** Live meta reminders may interleave results, but every canonical call needs a real result. */
+export function hasCompleteToolGroups(messages) {
+    const pending = new Set();
+    for (const message of messages) {
+        if (message.role === "meta")
+            continue;
+        if (message.role === "tool") {
+            if (!pending.delete(message.toolCallId))
+                return false;
+        }
+        else {
+            if (pending.size)
+                return false;
+            if (message.role === "assistant") {
+                for (const call of message.toolCalls ?? []) {
+                    // Ids only need to be unambiguous within their own group: providers
+                    // may scope them per response (`call_1` in every reply).
+                    if (!call.id || pending.has(call.id))
+                        return false;
+                    pending.add(call.id);
+                }
+            }
+        }
+    }
+    return pending.size === 0;
+}
+export function checkpointMessages(checkpoint) {
+    if (checkpoint?.version !== 1 || typeof checkpoint.compactionId !== "string" || !checkpoint.compactionId
+        || !Array.isArray(checkpoint.messages))
+        throw new Error("Unsupported context checkpoint");
+    const pending = new Set();
+    for (const message of checkpoint.messages) {
+        if (!message || !["user", "assistant", "tool", "system", "meta"].includes(message.role)
+            || !(typeof message.content === "string" || (message.role === "user" && Array.isArray(message.content)))) {
+            throw new Error("Invalid context checkpoint message");
+        }
+        if (message.role === "assistant") {
+            if (pending.size)
+                throw new Error("Incomplete checkpoint tool group");
+            for (const call of message.toolCalls ?? []) {
+                if (!call.id || pending.has(call.id))
+                    throw new Error("Invalid checkpoint tool call id");
+                pending.add(call.id);
+            }
+        }
+        else if (message.role === "tool") {
+            if (!pending.delete(message.toolCallId))
+                throw new Error("Orphan checkpoint tool result");
+        }
+        else if (pending.size)
+            throw new Error("Interrupted checkpoint tool group");
+    }
+    if (pending.size)
+        throw new Error("Incomplete checkpoint tool group");
+    // Also repairs checkpoints written by builds that retained now-invalid
+    // signatures. Messages appended AFTER this boundary are replayed normally.
+    return structuredClone(checkpoint.messages.map(sanitizeCheckpointMessage));
+}
+function sanitizeCheckpointMessage(message) {
+    if (message.role !== "assistant")
+        return message;
+    let metadata = message.providerMetadata;
+    const blocks = metadata?.anthropic?.contentBlocks;
+    if (blocks && isClaudeWithBoundThinking(message.modelId ?? message.model)) {
+        // A checkpoint rewrites the prefix. Remove the entire bound thinking run,
+        // including encrypted blocks, so the model can reason from the new context.
+        // Keep text, tool calls/results, and display reasoning; never mutate originals.
+        metadata = {
+            ...metadata,
+            anthropic: {
+                ...metadata?.anthropic,
+                contentBlocks: blocks.filter(block => block.type !== "thinking" && block.type !== "redacted_thinking"),
+            },
+        };
+    }
+    return {
+        ...message,
+        content: sanitizeInternalReminderBlocks(message.content),
+        ...(message.reasoning !== undefined ? { reasoning: sanitizeInternalReasoningText(message.reasoning) } : {}),
+        ...(metadata ? { providerMetadata: sanitizeAssistantProviderMetadata(metadata) } : {}),
+    };
+}
+/** Replay-side read: a checkpoint this build cannot validate (a newer format,
+ * a hand-edited record) is not a boundary. Originals are retained, so callers
+ * fall back to an earlier boundary instead of failing the whole session. */
+export function tryCheckpointMessages(checkpoint) {
+    try {
+        return checkpointMessages(checkpoint);
+    }
+    catch {
+        return undefined;
+    }
+}