theorum 0.1.10 → 0.1.13

package/esm/src/kernel/engine/compaction.js

@@ -0,0 +1,141 @@
+/**
+ * Compaction helpers: history split + threshold metering.
+ *
+ * Pure and stateless. History lives on the request; the kernel does not store
+ * cross-turn session state.
+ *
+ * @module
+ */
+import { estimateHistoryTokens } from './history-tokens.js';
+export { estimateHistoryTokens, HISTORY_MEDIA_TOKENS, HISTORY_TEXT_ENCODING, } from './history-tokens.js';
+/** Effective meter; defaults to `'history'`. */
+export function compactionMeter(spec) {
+    return spec.meter ?? 'history';
+}
+/**
+ * Find exchange boundaries in a history array.
+ *
+ * An exchange starts at each `user` message and includes all subsequent
+ * messages until the next `user` message. System messages before the first
+ * user message are not part of any exchange.
+ *
+ * Returns the indices of each `user` message that starts an exchange.
+ */
+function findExchangeBoundaries(history) {
+    const boundaries = [];
+    for (let i = 0; i < history.length; i++) {
+        if (history[i].role === 'user') {
+            boundaries.push(i);
+        }
+    }
+    return boundaries;
+}
+/**
+ * History token count for `meter: 'history'`.
+ *
+ * Prefers host-supplied `input.historyTokens`. Otherwise estimates from
+ * `input.history` (tiktoken `o200k_base` + media stubs). Empty/missing → 0.
+ * The BPE import runs only when an estimate needs text encoding.
+ */
+export async function resolveHistoryTokens(input) {
+    if (input?.historyTokens != null) {
+        return input.historyTokens;
+    }
+    return await estimateHistoryTokens(input?.history ?? []);
+}
+/**
+ * Resolve the token count used for the compaction threshold.
+ *
+ * - `meter: 'history'` (default) — `historyTokens` or estimate of `history`.
+ * - `meter: 'input'` — prefer `promptTokens` (this turn's provider
+ *   `tokens.input`, for `timing: 'after'`), else host `input.inputTokens`
+ *   (previous turn, for `timing: 'before'`). Missing/non-positive → undefined
+ *   (do not fire).
+ *
+ * `meter: 'input'` never loads the history tokenizer.
+ */
+export async function resolveCompactionTokens(args) {
+    const meter = compactionMeter(args.spec);
+    if (meter === 'history') {
+        return { meter, tokens: await resolveHistoryTokens(args.input) };
+    }
+    const fromPrompt = args.promptTokens != null && args.promptTokens > 0 ? args.promptTokens : undefined;
+    const fromHost = args.input?.inputTokens != null && args.input.inputTokens > 0
+        ? args.input.inputTokens
+        : undefined;
+    const tokens = fromPrompt ?? fromHost;
+    if (tokens == null)
+        return undefined;
+    return { meter, tokens };
+}
+/** Whether compaction should fire for a resolved token count (token-threshold only). */
+export function compactionNeeded(tokens, spec) {
+    return tokens > spec.compactAt * spec.maxTokens;
+}
+/**
+ * Whether compaction should fire, respecting a custom trigger when provided.
+ *
+ * When `spec.trigger` is set, it is called with full context and its result
+ * is returned directly. Otherwise falls back to `compactionNeeded`.
+ */
+export async function shouldCompact(resolved, spec) {
+    if (spec.trigger) {
+        const ctx = {
+            tokens: resolved.tokens,
+            maxTokens: spec.maxTokens,
+            compactAt: spec.compactAt,
+            meter: resolved.meter,
+        };
+        return await spec.trigger(ctx);
+    }
+    return compactionNeeded(resolved.tokens, spec);
+}
+/**
+ * Split history into compactable and retained segments.
+ *
+ * `previousExchanges` semantics:
+ * - `0` — compact everything, retain nothing.
+ * - `≥ 1` (integer) — retain the last N exchanges.
+ * - `(0, 1)` — retain exchanges that fit within this fraction of `maxTokens`,
+ *   walking backwards from the most recent (always uses the history estimator).
+ */
+export async function splitForCompaction(history, spec) {
+    if (history.length === 0) {
+        return { toCompact: [], toRetain: [] };
+    }
+    if (spec.previousExchanges === 0) {
+        return { toCompact: [...history], toRetain: [] };
+    }
+    const boundaries = findExchangeBoundaries(history);
+    if (boundaries.length === 0) {
+        return { toCompact: [...history], toRetain: [] };
+    }
+    let cutIndex;
+    if (spec.previousExchanges >= 1) {
+        const keep = Math.min(spec.previousExchanges, boundaries.length);
+        cutIndex = boundaries[boundaries.length - keep];
+    }
+    else {
+        const budget = spec.previousExchanges * spec.maxTokens;
+        let accumulated = 0;
+        cutIndex = history.length;
+        for (let i = boundaries.length - 1; i >= 0; i--) {
+            const exchangeStart = boundaries[i];
+            const exchangeEnd = i < boundaries.length - 1 ? boundaries[i + 1] : history.length;
+            const exchangeMessages = history.slice(exchangeStart, exchangeEnd);
+            const exchangeTokens = await estimateHistoryTokens(exchangeMessages);
+            if (accumulated + exchangeTokens > budget) {
+                break;
+            }
+            accumulated += exchangeTokens;
+            cutIndex = exchangeStart;
+        }
+    }
+    if (cutIndex <= 0) {
+        return { toCompact: [], toRetain: [...history] };
+    }
+    return {
+        toCompact: history.slice(0, cutIndex),
+        toRetain: history.slice(cutIndex),
+    };
+}

package/esm/src/kernel/engine/delta.js

@@ -1,3 +1,4 @@
+import { turnStopFromInteractionStatus } from '../stop.js';
 import { asRecord } from './record.js';
 function deltaText(delta) {
     if (typeof delta.text === 'string') {
@@ -359,25 +360,47 @@ function extractTokenEvent(event, interaction) {
 }
 function eventsFromComplete(event, alreadyText) {
     const interaction = asRecord(event.interaction) ?? event;
-    const outputText = interaction.output_text;
     const events = [];
+    const outputText = interaction.output_text;
     if (!alreadyText && typeof outputText === 'string' && outputText) {
         events.push({ type: 'text', text: outputText });
     }
     const media = mediaFromComplete(event);
-    if (media) {
+    if (media)
         events.push(media);
-    }
     const tokenEvent = extractTokenEvent(event, interaction);
-    if (tokenEvent) {
+    if (tokenEvent)
         events.push(tokenEvent);
-    }
     const groundingEvent = groundingFromEvent(event);
-    if (groundingEvent) {
+    if (groundingEvent)
         events.push(groundingEvent);
-    }
+    const done = doneFromInteractionStatus(interaction, event);
+    if (done)
+        events.push(done);
     return events;
 }
+const TERMINAL_INTERACTION_STATUSES = new Set([
+    'completed',
+    'incomplete',
+    'budget_exceeded',
+    'failed',
+    'cancelled',
+    'requires_action',
+]);
+function doneFromInteractionStatus(interaction, event) {
+    const status = typeof interaction.status === 'string'
+        ? interaction.status
+        : typeof event.status === 'string'
+            ? event.status
+            : undefined;
+    if (!status || !TERMINAL_INTERACTION_STATUSES.has(status.toLowerCase()))
+        return undefined;
+    return {
+        type: 'done',
+        stop: turnStopFromInteractionStatus(status),
+        ...(typeof interaction.id === 'string' ? { interactionId: interaction.id } : {}),
+    };
+}
 function tryStructured(text) {
     try {
         return { type: 'structured', structured: JSON.parse(text) };

package/esm/src/kernel/engine/history-tokens.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Local estimate of conversational history tokens (compaction `meter: 'history'`).
+ *
+ * **Text** — tiktoken `o200k_base` via `gpt-tokenizer` (GPT-4o / GPT-5 / o-series
+ * default encoding). This is THEORUM's declared local BPE counter. Gemini has
+ * no open JS tokenizer; hosts that need Gemini `countTokens` pass
+ * `TurnInput.historyTokens`.
+ *
+ * The BPE ranks are loaded lazily on first text encode — not at module import.
+ * Hosts that pass `historyTokens`, use `meter: 'input'`, or never estimate
+ * history text never pay for the import.
+ *
+ * **Media** — not payload bytes. Current-turn files belong on `attachments` /
+ * `voice` and are outside this meter. History media parts use published
+ * Gemini multimodal *rates as minimum stubs* when dimensions / duration are
+ * not on the part:
+ * - image / document: one still-image tile (258) — Gemini 2.x small-image /
+ *   one-page unit. Larger images are 258×tiles; Gemini 3 uses
+ *   `media_resolution` budgets (often 560–1120), not a flat 258.
+ * - audio: 32 tokens (1s @ 32/s). Longer clips scale with seconds.
+ * - video: 263 tokens (1s @ 263/s). Longer clips scale with seconds.
+ *
+ * These stubs are intentional minima for “media is present in history,” not
+ * billing-grade multimodal accounting. Prefer `historyTokens` when the host
+ * knows better.
+ *
+ * @module
+ */
+import type { TurnHistoryMessage } from '../types.js';
+/** Tiktoken encoding used for history text. */
+export declare const HISTORY_TEXT_ENCODING = "o200k_base";
+/**
+ * Minimum media stubs when size/duration are unknown.
+ * See module doc — not “every image costs 258 forever.”
+ */
+export declare const HISTORY_MEDIA_TOKENS: {
+    readonly image: 258;
+    readonly document: 258;
+    readonly audio: 32;
+    readonly video: 263;
+};
+/** BPE-count conversational history (text + media stubs). Lazy-loads o200k. */
+export declare function estimateHistoryTokens(messages: TurnHistoryMessage[]): Promise<number>;

package/esm/src/kernel/engine/history-tokens.js

@@ -0,0 +1,100 @@
+/**
+ * Local estimate of conversational history tokens (compaction `meter: 'history'`).
+ *
+ * **Text** — tiktoken `o200k_base` via `gpt-tokenizer` (GPT-4o / GPT-5 / o-series
+ * default encoding). This is THEORUM's declared local BPE counter. Gemini has
+ * no open JS tokenizer; hosts that need Gemini `countTokens` pass
+ * `TurnInput.historyTokens`.
+ *
+ * The BPE ranks are loaded lazily on first text encode — not at module import.
+ * Hosts that pass `historyTokens`, use `meter: 'input'`, or never estimate
+ * history text never pay for the import.
+ *
+ * **Media** — not payload bytes. Current-turn files belong on `attachments` /
+ * `voice` and are outside this meter. History media parts use published
+ * Gemini multimodal *rates as minimum stubs* when dimensions / duration are
+ * not on the part:
+ * - image / document: one still-image tile (258) — Gemini 2.x small-image /
+ *   one-page unit. Larger images are 258×tiles; Gemini 3 uses
+ *   `media_resolution` budgets (often 560–1120), not a flat 258.
+ * - audio: 32 tokens (1s @ 32/s). Longer clips scale with seconds.
+ * - video: 263 tokens (1s @ 263/s). Longer clips scale with seconds.
+ *
+ * These stubs are intentional minima for “media is present in history,” not
+ * billing-grade multimodal accounting. Prefer `historyTokens` when the host
+ * knows better.
+ *
+ * @module
+ */
+/** Tiktoken encoding used for history text. */
+export const HISTORY_TEXT_ENCODING = 'o200k_base';
+/**
+ * Minimum media stubs when size/duration are unknown.
+ * See module doc — not “every image costs 258 forever.”
+ */
+export const HISTORY_MEDIA_TOKENS = {
+    image: 258,
+    document: 258,
+    audio: 32,
+    video: 263,
+};
+let encodePromise = null;
+function loadEncode() {
+    encodePromise ??= import('gpt-tokenizer/encoding/o200k_base').then((m) => m.encode);
+    return encodePromise;
+}
+function mediaTokens(kind) {
+    return HISTORY_MEDIA_TOKENS[kind];
+}
+function partNeedsText(part) {
+    return part.type === 'text' && Boolean(part.text);
+}
+function messageNeedsText(msg) {
+    if (msg.content)
+        return true;
+    if (msg.parts?.some(partNeedsText))
+        return true;
+    return Boolean(msg.tool_calls?.some((tc) => tc.function.arguments));
+}
+function needsTextEncode(messages) {
+    return messages.some(messageNeedsText);
+}
+function sumMediaStubs(messages) {
+    let tokens = 0;
+    for (const msg of messages) {
+        for (const part of msg.parts ?? []) {
+            if (part.type !== 'text')
+                tokens += mediaTokens(part.type);
+        }
+    }
+    return tokens;
+}
+async function countMessageTokens(msg, countText) {
+    let tokens = 0;
+    if (msg.content)
+        tokens += await countText(msg.content);
+    for (const part of msg.parts ?? []) {
+        tokens += part.type === 'text' ? await countText(part.text) : mediaTokens(part.type);
+    }
+    for (const tc of msg.tool_calls ?? []) {
+        tokens += await countText(tc.function.arguments);
+    }
+    return tokens;
+}
+/** BPE-count conversational history (text + media stubs). Lazy-loads o200k. */
+export async function estimateHistoryTokens(messages) {
+    if (!needsTextEncode(messages))
+        return sumMediaStubs(messages);
+    let encode;
+    const countText = async (text) => {
+        if (!text)
+            return 0;
+        encode ??= await loadEncode();
+        return encode(text).length;
+    };
+    let tokens = 0;
+    for (const msg of messages) {
+        tokens += await countMessageTokens(msg, countText);
+    }
+    return tokens;
+}

package/esm/src/kernel/engine/runner/mod.js

@@ -12,11 +12,87 @@ import { sanitizeTurnRequest } from '../../../guardrails/sanitize.js';
 import { noopSink, writeTrace } from '../../../observability/trace.js';
 import { buildRecord } from '../../../observability/trace-record.js';
 import { pickSystemRole, resolveTurn } from '../../registry/resolve.js';
+import { CONTINUE_INSTRUCTION } from '../../stop.js';
 import { bindCanary } from '../boundary.js';
+import { resolveCompactionTokens, shouldCompact, splitForCompaction } from '../compaction.js';
 import { runAttemptsWithValidation } from './gates.js';
 import { shouldSkipStreamEvent, systemFromProfile } from './stream.js';
 import { calculateFallbackTokens } from './tokens.js';
 import { invokeFromUi } from './tools.js';
+function getCompactionSpec(profile, modelId) {
+    return profile.model.config[modelId]?.compaction;
+}
+async function runCompactionTurn(toCompact, spec, provider, signal) {
+    const compactText = toCompact
+        .map((m) => {
+        const content = m.content ?? m.parts?.map((p) => ('text' in p ? p.text : '')).join('') ?? '';
+        return `[${m.role}]: ${content}`;
+    })
+        .join('\n');
+    const events = [];
+    for await (const event of runTurn({
+        profile: spec.profile,
+        input: { text: compactText },
+        signal,
+        metadata: { _compacting: true },
+    }, provider)) {
+        events.push(event);
+    }
+    const structured = events.find((e) => e.type === 'structured')?.structured;
+    const text = structured
+        ? JSON.stringify(structured)
+        : events
+            .filter((e) => e.type === 'text')
+            .map((e) => e.text ?? '')
+            .join('');
+    return {
+        role: 'assistant',
+        content: text,
+        metadata: { compactionSummary: true },
+    };
+}
+function lastTokensFromEvents(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const input = events[i]?.tokens?.input;
+        if (input)
+            return input;
+    }
+    return 0;
+}
+async function compactHistoryBeforeTurn(args) {
+    const decision = await resolveCompactionTokens({
+        spec: args.spec,
+        input: args.input,
+    });
+    if (!(decision && (await shouldCompact(decision, args.spec))))
+        return args.history;
+    const { toCompact, toRetain } = await splitForCompaction(args.history, args.spec);
+    if (toCompact.length === 0)
+        return args.history;
+    const summaryMessage = await runCompactionTurn(toCompact, args.spec, args.compactionProvider ?? args.provider, args.signal);
+    return [summaryMessage, ...toRetain];
+}
+async function attachAfterCompaction(event, args) {
+    if (args.history.length === 0)
+        return event;
+    const promptTokens = lastTokensFromEvents(args.seen);
+    const decision = await resolveCompactionTokens({
+        spec: args.spec,
+        input: args.input,
+        promptTokens,
+    });
+    if (!(decision && (await shouldCompact(decision, args.spec))))
+        return event;
+    const signal = {
+        needed: true,
+        meter: decision.meter,
+        tokens: decision.tokens,
+        history: args.history,
+    };
+    if (promptTokens > 0)
+        signal.promptTokens = promptTokens;
+    return { ...event, compaction: signal };
+}
 async function* emitTurn(args) {
     const { safe, profile, generation, system, provider, gemini } = args;
     if (safe.toolInvoke) {
@@ -34,75 +110,101 @@ async function* emitTurn(args) {
     if (!state.sawTokensEvent) {
         yield* calculateFallbackTokens(safe, system, state.allEmittedEvents);
     }
-    yield { type: 'done' };
+    yield {
+        type: 'done',
+        stop: state.lastStop ?? { kind: 'completed' },
+    };
+}
+async function flushTurnTrace(sink, ctx) {
+    await writeTrace(sink, buildRecord({
+        req: ctx.req,
+        events: ctx.seen,
+        started: ctx.started,
+        model: ctx.model,
+        bucket: ctx.bucket,
+        thrown: ctx.thrown,
+        gemini: ctx.gemini,
+        canary: ctx.canary,
+        system: ctx.system,
+        generation: ctx.generation,
+        sanitizedReq: ctx.safe,
+    }));
 }
 /** Execute one host turn against a provider adapter. */
 async function* runTurn(req, provider, sink = noopSink()) {
-    const started = Date.now();
-    const seen = [];
-    const gemini = [];
-    let model;
-    let bucket;
-    let canary = '';
-    let system;
-    let generation;
-    let safe;
+    const ctx = {
+        req,
+        seen: [],
+        started: Date.now(),
+        canary: '',
+        gemini: [],
+    };
     try {
-        safe = sanitizeTurnRequest(req);
-        throwIfAborted(safe.signal);
-        const { profile, generation: gen } = resolveTurn(safe);
-        generation = gen;
-        const { model: resolvedModel, geminiBucket, canary: turnCanary } = gen;
-        model = resolvedModel;
-        bucket = geminiBucket;
-        canary = turnCanary;
-        const role = pickSystemRole(profile, safe.input?.role);
-        const profileSys = systemFromProfile(profile, role);
-        const combinedSys = [profileSys, safe.system].filter(Boolean).join('\n\n');
-        const bound = bindCanary(combinedSys, turnCanary);
-        system = bound;
-        for await (const event of emitTurn({
-            safe,
-            profile,
-            generation: gen,
-            system: bound,
-            provider,
-            gemini,
-        })) {
-            seen.push(event);
-            if (shouldSkipStreamEvent(event, profile)) {
-                continue;
-            }
-            yield event;
-        }
+        yield* runTurnBody(ctx, provider);
     }
     catch (err) {
-        await writeTrace(sink, buildRecord({
-            req,
-            events: seen,
-            started,
-            model,
-            bucket,
-            thrown: err,
-            gemini,
-            canary,
-            system,
-            generation,
-            sanitizedReq: safe,
-        }));
+        await flushTurnTrace(sink, { ...ctx, thrown: err });
         throw err;
     }
-    await writeTrace(sink, buildRecord({
-        req,
-        events: seen,
-        started,
-        model,
-        bucket,
-        gemini,
-        canary,
-        system,
-        generation,
-        sanitizedReq: safe,
-    }));
+    await flushTurnTrace(sink, ctx);
+}
+async function* runTurnBody(ctx, provider) {
+    ctx.safe = sanitizeTurnRequest(ctx.req);
+    throwIfAborted(ctx.safe.signal);
+    const { profile, generation: gen } = resolveTurn(ctx.safe);
+    ctx.generation = gen;
+    ctx.model = gen.model;
+    ctx.bucket = gen.geminiBucket;
+    ctx.canary = gen.canary;
+    const isCompacting = ctx.req.metadata?._compacting === true;
+    const compactionSpec = isCompacting ? undefined : getCompactionSpec(profile, gen.model);
+    await maybeCompactBefore(ctx, gen, compactionSpec, provider);
+    const role = pickSystemRole(profile, ctx.safe.input?.role);
+    const continueSys = ctx.safe.continueFrom ? CONTINUE_INSTRUCTION : '';
+    const combinedSys = [systemFromProfile(profile, role), ctx.safe.system, continueSys]
+        .filter(Boolean)
+        .join('\n\n');
+    ctx.system = bindCanary(combinedSys, ctx.canary);
+    yield* streamTurnEvents(ctx, profile, gen, provider, compactionSpec, isCompacting);
+}
+async function maybeCompactBefore(ctx, gen, compactionSpec, provider) {
+    if (!(compactionSpec?.timing === 'before' && gen.history?.length && ctx.safe))
+        return;
+    gen.history = await compactHistoryBeforeTurn({
+        spec: compactionSpec,
+        history: gen.history,
+        input: ctx.safe.input,
+        provider,
+        compactionProvider: ctx.req.compactionProvider,
+        signal: ctx.safe.signal,
+    });
+}
+async function* streamTurnEvents(ctx, profile, gen, provider, compactionSpec, isCompacting) {
+    if (!ctx.safe || ctx.system === undefined)
+        return;
+    for await (const event of emitTurn({
+        safe: ctx.safe,
+        profile,
+        generation: gen,
+        system: ctx.system,
+        provider,
+        gemini: ctx.gemini,
+    })) {
+        const out = await maybeAttachAfter(event, ctx, gen, compactionSpec, isCompacting);
+        ctx.seen.push(out);
+        if (!shouldSkipStreamEvent(out, profile))
+            yield out;
+    }
+}
+async function maybeAttachAfter(event, ctx, gen, compactionSpec, isCompacting) {
+    if (!(event.type === 'done' && compactionSpec?.timing === 'after' && !isCompacting && ctx.safe)) {
+        return event;
+    }
+    return await attachAfterCompaction(event, {
+        spec: compactionSpec,
+        history: gen.history ?? [],
+        input: ctx.safe.input,
+        seen: ctx.seen,
+    });
 }
 export { runTurn };

package/esm/src/kernel/engine/runner/state.d.ts

@@ -1,10 +1,12 @@
-import type { ResolvedGeneration, TurnEvent, TurnHistoryMessage, TurnRequest } from '../../types.js';
+import type { ResolvedGeneration, TurnEvent, TurnHistoryMessage, TurnRequest, TurnStop } from '../../types.js';
 interface StepExecutionState {
     currentHistory: TurnHistoryMessage[];
     stepCount: number;
     sawTokensEvent: boolean;
     allEmittedEvents: TurnEvent[];
     attemptEvents: TurnEvent[];
+    /** Last provider stop from a discarded provider `done` event. */
+    lastStop?: TurnStop;
 }
 interface AttemptFlowState {
     currentAttempt: number;

package/esm/src/kernel/engine/runner/steps.js

@@ -28,6 +28,9 @@ async function* executeAutonomousStep(args, state, buffer = {
             latestStructured = event.structured;
         }
         if (event.type === 'done') {
+            if (event.stop) {
+                state.lastStop = event.stop;
+            }
             continue;
         }
         if (event.type === 'tool' && event.tool) {

package/esm/src/kernel/mod.d.ts

@@ -8,6 +8,8 @@
  * @module
  */
 import "../../_dnt.polyfills.js";
+export type { CompactionSplit, CompactionTokens } from './engine/compaction.js';
+export { compactionMeter, compactionNeeded, estimateHistoryTokens, HISTORY_MEDIA_TOKENS, HISTORY_TEXT_ENCODING, resolveCompactionTokens, resolveHistoryTokens, shouldCompact, splitForCompaction, } from './engine/compaction.js';
 export { runTurn } from './engine/runner.js';
 export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, geminiKindForMime, getTool, listBuiltinIds, mimeAllowed, mimeEssence, modelEntryByApiId, registerTools, requireModelSpec, resetTools, } from './registry/catalog.js';
 export type { ProfileDefinition } from './registry/profiles.js';
@@ -15,4 +17,6 @@ export { clearProfiles, defineProfile, getProfile, hasProfile, listProfiles, reg
 export { projectProfile, resolveTurn } from './registry/resolve.js';
 export { getStructured, registerStructured } from './registry/schemas.js';
 export { executeTool } from './registry/tools.js';
+export type { ProfileResumeSpec, TurnContinueFrom, TurnStop, TurnStopKind } from './stop.js';
+export { AUTO_CONTINUE_DELAY_MS, CONTINUE_INSTRUCTION, DEFAULT_AUTO_CONTINUE, GenerationStopError, isGenerationStopError, isResumeableStop, isUserCancelledStop, shouldAutoContinue, turnStopFromClientStreamEnd, turnStopFromInteractionStatus, turnStopFromOpenRouter, } from './stop.js';
 export type * from './types.js';

package/esm/src/kernel/mod.js

@@ -8,9 +8,11 @@
  * @module
  */
 import "../../_dnt.polyfills.js";
+export { compactionMeter, compactionNeeded, estimateHistoryTokens, HISTORY_MEDIA_TOKENS, HISTORY_TEXT_ENCODING, resolveCompactionTokens, resolveHistoryTokens, shouldCompact, splitForCompaction, } from './engine/compaction.js';
 export { runTurn } from './engine/runner.js';
 export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, geminiKindForMime, getTool, listBuiltinIds, mimeAllowed, mimeEssence, modelEntryByApiId, registerTools, requireModelSpec, resetTools, } from './registry/catalog.js';
 export { clearProfiles, defineProfile, getProfile, hasProfile, listProfiles, registerProfile, registerProfiles, } from './registry/profiles.js';
 export { projectProfile, resolveTurn } from './registry/resolve.js';
 export { getStructured, registerStructured } from './registry/schemas.js';
 export { executeTool } from './registry/tools.js';
+export { AUTO_CONTINUE_DELAY_MS, CONTINUE_INSTRUCTION, DEFAULT_AUTO_CONTINUE, GenerationStopError, isGenerationStopError, isResumeableStop, isUserCancelledStop, shouldAutoContinue, turnStopFromClientStreamEnd, turnStopFromInteractionStatus, turnStopFromOpenRouter, } from './stop.js';