@arnilo/prism 0.0.10 → 0.0.11

package/CHANGELOG.md

@@ -5,6 +5,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [0.0.11] - 2026-07-22
+
+### Added
+
+- Coding harness fundamentals for 0.0.11 (Plan 074): bounded `SessionIndex`/`searchSessions` (SQLite/Postgres FTS migration 004; memory linear|unsupported; JSONL unsupported), assembler `contextBudget` + omission reports, `@arnilo/prism-provider-anthropic` + `@arnilo/prism-provider-google`, mid-run `AgentSession.steer` / RPC steer, coding-agent `runCodingGoalVerify` and opt-in `ask_user_decision` (multi/free-text/durable suspend glue).
+- Opt-in `structuredOutputTiming: "final-turn-only"` on `generate-validate-revise` (default `"every-turn"`): tool-eligible turns omit native schema so models can call tools; artifact/revision turns attach schema and withdraw tools.
+
+### Changed
+
+- Versioned all 34 first-party manifests and exact internal ranges to `0.0.11` (adds `@arnilo/prism-provider-anthropic` + `@arnilo/prism-provider-google` to the publishable graph and `@arnilo/prism-providers` umbrella).
+- Network-free search/budget evidence: `scripts/benchmark-0.0.11.mjs`.
+
 ## [0.0.10] - 2026-07-21
 
 ### Changed

package/dist/agent-loops.d.ts

@@ -7,6 +7,7 @@ export declare function generateValidateReviseLoop(opts: {
     readonly repairer?: ArtifactRepairer<unknown>;
     readonly maxRevisions?: number;
     readonly toolCalls?: "disabled" | "bounded";
+    readonly structuredOutputTiming?: "every-turn" | "final-turn-only";
 }): AgentLoopStrategy;
 export declare function resolveToolConcurrency(options: {
     loop?: AgentLoopStrategy | AgentLoopOptions;

package/dist/agent-loops.js

@@ -1,5 +1,6 @@
 import { inputMessages } from "./input.js";
 import { createId } from "./ids.js";
+import { artifactStructuredOutputRequest, withoutStructuredOutput } from "./structured-output.js";
 function throwIfAborted(signal) {
     if (signal.aborted)
         throw signal.reason instanceof Error ? signal.reason : new Error("Agent run aborted");
@@ -23,6 +24,7 @@ export const singleShotLoop = {
         let nextInput = ctx.input;
         for (let turn = 1;; turn += 1) {
             throwIfAborted(ctx.signal);
+            await ctx.applyPendingSteers?.();
             ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
             const request = await ctx.assemble(nextInput, undefined, turn);
             throwIfAborted(ctx.signal);
@@ -37,8 +39,14 @@ export const singleShotLoop = {
                 ctx.emit({ type: "message_finished", sessionId: ctx.sessionId, runId: ctx.runId, message });
             }
             ctx.emit({ type: "turn_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-            if (calls.length === 0 || toolRounds >= ctx.maxToolRounds)
+            if (calls.length === 0 || toolRounds >= ctx.maxToolRounds) {
+                // Soft-interrupt / late steer: keep same run going when queue still has text.
+                if (await ctx.applyPendingSteers?.()) {
+                    nextInput = [];
+                    continue;
+                }
                 break;
+            }
             toolRounds += 1;
             await dispatchToolCallsInOrder(calls, ctx);
             nextInput = [];
@@ -61,6 +69,7 @@ function defaultRepairer() {
 export function generateValidateReviseLoop(opts) {
     const max = opts.maxRevisions ?? 3;
     const repairer = opts.repairer ?? defaultRepairer();
+    const finalOnly = opts.structuredOutputTiming === "final-turn-only" && opts.toolCalls === "bounded";
     return {
         name: "generate-validate-revise",
         async run(ctx) {
@@ -69,10 +78,24 @@ export function generateValidateReviseLoop(opts) {
             let pendingHistory = [];
             let toolRounds = 0;
             let attempts = 0;
+            let artifactPhase = !finalOnly;
+            let savedSchema;
             for (let turn = 1; attempts <= max; turn += 1) {
                 throwIfAborted(ctx.signal);
+                await ctx.applyPendingSteers?.();
                 ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-                const request = await ctx.assemble(nextInput, undefined, turn);
+                let request = await ctx.assemble(nextInput, undefined, turn);
+                if (request.options?.structuredOutput)
+                    savedSchema ??= request.options.structuredOutput;
+                if (finalOnly) {
+                    if (!artifactPhase && toolRounds < ctx.maxToolRounds) {
+                        request = withoutStructuredOutput(request);
+                    }
+                    else {
+                        artifactPhase = true;
+                        request = artifactStructuredOutputRequest(request, savedSchema);
+                    }
+                }
                 throwIfAborted(ctx.signal);
                 const { content, calls, messageId, started, usage: turnUsage } = await ctx.generate(request);
                 usage = turnUsage ?? usage;
@@ -100,6 +123,17 @@ export function generateValidateReviseLoop(opts) {
                     nextInput = [];
                     continue;
                 }
+                // Soft-interrupt / late steer before treating empty/final output as artifact work.
+                if (await ctx.applyPendingSteers?.()) {
+                    nextInput = [];
+                    continue;
+                }
+                // Call-free during tool phase → one more turn with schema on / tools off.
+                if (finalOnly && !artifactPhase) {
+                    artifactPhase = true;
+                    nextInput = [];
+                    continue;
+                }
                 const artifactCtx = {
                     sessionId: ctx.sessionId,
                     runId: ctx.runId,
@@ -214,6 +248,7 @@ export function resolveLoop(options, config) {
                 repairer: loop.repairer,
                 maxRevisions: loop.maxRevisions,
                 toolCalls: loop.toolCalls,
+                structuredOutputTiming: loop.structuredOutputTiming,
             });
         }
         throw new Error(`Unknown agent loop strategy: ${strategy}`);

package/dist/agents.js

@@ -1,4 +1,4 @@
-import { AgentRunError, AgentRunStateError } from "./contracts.js";
+import { AgentRunError, AgentRunStateError, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, } from "./contracts.js";
 import { resolveLoop, resolveToolConcurrency } from "./agent-loops.js";
 import { createId } from "./ids.js";
 import { assertGuardrailsAllowed, GuardrailError, runGuardrails } from "./guardrails.js";
@@ -91,6 +91,11 @@ class RuntimeAgentSession {
     currentLeafId;
     history = [];
     activeRun;
+    activeRunId;
+    activeProviderTurnAbort;
+    pendingSoftInterrupt = false;
+    pendingSteers = [];
+    pendingSteerBytes = 0;
     activeRedactor;
     activeProvider;
     activeLedger;
@@ -124,6 +129,31 @@ class RuntimeAgentSession {
     async run(input, options = {}) {
         return this.runInternal(input, options, randomId("run"));
     }
+    steer(input, options = {}) {
+        if (!this.activeRun || !this.activeRunId)
+            throw new Error("Agent session has no active run to steer");
+        const messages = inputToMessages(input).map((message) => this.redact(message));
+        if (messages.length === 0)
+            throw new Error("steer requires non-empty input");
+        let addBytes = 0;
+        for (const message of messages)
+            addBytes += messageTextBytes(message);
+        if (this.pendingSteers.length + messages.length > DEFAULT_MAX_PENDING_STEERS) {
+            throw new Error(`steer queue exceeds max pending messages (${DEFAULT_MAX_PENDING_STEERS})`);
+        }
+        if (this.pendingSteerBytes + addBytes > DEFAULT_MAX_PENDING_STEER_BYTES) {
+            throw new Error(`steer queue exceeds max pending bytes (${DEFAULT_MAX_PENDING_STEER_BYTES})`);
+        }
+        this.pendingSteers.push(...messages);
+        this.pendingSteerBytes += addBytes;
+        this.emit({ type: "queue_updated", sessionId: this.id, runId: this.activeRunId, size: this.pendingSteers.length });
+        if (options.softInterrupt) {
+            if (this.activeProviderTurnAbort)
+                this.activeProviderTurnAbort.abort(new SteerSoftInterrupt());
+            else
+                this.pendingSoftInterrupt = true;
+        }
+    }
     async resumeDurable(state, runState, ownership) {
         return this.runInternal(state.input ?? [], { runState, ownership }, state.runId, { options: runState, state, version: state.version });
     }
@@ -165,6 +195,10 @@ class RuntimeAgentSession {
         const controller = new AbortController();
         const cleanupSignal = bridgeAbort(options.signal, controller);
         this.activeRun = controller;
+        this.activeRunId = runId;
+        this.pendingSteers = [];
+        this.pendingSteerBytes = 0;
+        this.pendingSoftInterrupt = false;
         this.activeRedactor = options.redactor ?? this.agent.config.redactor;
         this.activeLedger = options.runLedger ?? this.agent.config.runLedger;
         this.activeOwnership = options.ownership ?? this.agent.config.ownership;
@@ -327,7 +361,15 @@ class RuntimeAgentSession {
                     assembledTurn = false;
                     const policyResult = await this.applyProviderRequestPolicies(request, runId, options, metadata, controller.signal);
                     const middlewareRequest = await this.agent.config.middleware?.run("provider_request", policyResult.request) ?? policyResult.request;
-                    return this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
+                    try {
+                        return await this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
+                    }
+                    catch (error) {
+                        if (isSteerSoftInterrupt(error)) {
+                            return { content: [], calls: [], started: false, usage: undefined };
+                        }
+                        throw error;
+                    }
                 },
                 isToolCallExclusive: (call) => registry.get(call.name)?.exclusive === true,
                 dispatchToolCall: (call) => dispatchToolCall({
@@ -367,6 +409,8 @@ class RuntimeAgentSession {
                     validate,
                 }),
                 appendMessage: (message) => this.appendMessage(message, runId),
+                hasPendingSteers: () => this.pendingSteers.length > 0,
+                applyPendingSteers: () => this.applyPendingSteers(runId, metadata, controller.signal),
                 emit: (event) => {
                     if (event.type === "turn_started")
                         this.activeLoopTurn = event.turn;
@@ -443,6 +487,11 @@ class RuntimeAgentSession {
         finally {
             if (this.activeRun === controller)
                 this.activeRun = undefined;
+            this.activeRunId = undefined;
+            this.activeProviderTurnAbort = undefined;
+            this.pendingSoftInterrupt = false;
+            this.pendingSteers = [];
+            this.pendingSteerBytes = 0;
             try {
                 await this.drainLedger();
                 if (this.activeLedger) {
@@ -693,7 +742,7 @@ class RuntimeAgentSession {
                 return await this.generateProviderTurn(request, runId, signal, secrets, turn, attempt, recordUsage);
             }
             catch (error) {
-                if (error instanceof GuardrailError)
+                if (error instanceof GuardrailError || isSteerSoftInterrupt(error))
                     throw error;
                 const failure = error instanceof ProviderTurnFailure ? error : undefined;
                 const info = failure ? redactSecrets(failure.info, secrets) : errorToErrorInfo(error, secrets);
@@ -745,9 +794,18 @@ class RuntimeAgentSession {
             usageRecorded = true;
             await recordUsage?.(usage, turn, attempt);
         };
+        const turnAbort = new AbortController();
+        const cleanupTurn = bridgeAbort(signal, turnAbort);
+        this.activeProviderTurnAbort = turnAbort;
+        if (this.pendingSoftInterrupt) {
+            this.pendingSoftInterrupt = false;
+            turnAbort.abort(new SteerSoftInterrupt());
+        }
+        const turnRequest = { ...request, signal: turnAbort.signal };
         try {
-            for await (const event of this.activeProvider.generate(request)) {
-                throwIfAborted(signal);
+            throwIfAborted(turnAbort.signal);
+            for await (const event of this.activeProvider.generate(turnRequest)) {
+                throwIfAborted(turnAbort.signal);
                 this.activeLimits.charge("maxResponseBytes", jsonBytes(event));
                 if (event.type === "error")
                     throw new ProviderTurnFailure(event.error, started);
@@ -791,7 +849,7 @@ class RuntimeAgentSession {
                     stage: "output",
                     guardrails: this.activeGuardrails,
                     value: { content, calls, messageId, started, usage },
-                    context: { sessionId: this.id, runId, metadata: this.activeMetadata ?? {}, signal },
+                    context: { sessionId: this.id, runId, metadata: this.activeMetadata ?? {}, signal: turnAbort.signal },
                     redactor: this.activeRedactor,
                     emit: (event) => this.emit(event),
                 }));
@@ -811,6 +869,19 @@ class RuntimeAgentSession {
             return { content, calls, messageId, started, usage };
         }
         catch (error) {
+            if (isSteerSoftInterrupt(error) || isSteerSoftInterrupt(turnAbort.signal.reason)) {
+                await recordTurnUsage();
+                const latencyMs = Math.round(performance.now() - startedAt);
+                this.emit({
+                    type: "provider_turn_finished",
+                    sessionId: this.id,
+                    runId,
+                    turn,
+                    metadata: buildMetadata({ latencyMs }),
+                    usage,
+                });
+                throw new SteerSoftInterrupt();
+            }
             const latencyMs = Math.round(performance.now() - startedAt);
             const info = error instanceof ProviderTurnFailure ? redactSecrets(error.info, secrets) : errorToErrorInfo(error, secrets);
             await recordTurnUsage();
@@ -827,6 +898,33 @@ class RuntimeAgentSession {
                 throw error;
             throw new ProviderTurnFailure(info, started);
         }
+        finally {
+            cleanupTurn();
+            if (this.activeProviderTurnAbort === turnAbort)
+                this.activeProviderTurnAbort = undefined;
+        }
+    }
+    async applyPendingSteers(runId, metadata, signal) {
+        if (this.pendingSteers.length === 0)
+            return false;
+        const drained = this.pendingSteers.splice(0);
+        this.pendingSteerBytes = 0;
+        this.emit({ type: "queue_updated", sessionId: this.id, runId, size: 0 });
+        for (const message of drained) {
+            throwIfAborted(signal);
+            const inputGuardrails = await runGuardrails({
+                stage: "input",
+                guardrails: this.activeGuardrails,
+                value: [message],
+                context: { sessionId: this.id, runId, metadata, signal },
+                redactor: this.activeRedactor,
+                emit: (event) => this.emit(event),
+            });
+            assertGuardrailsAllowed(inputGuardrails);
+            this.history.push(message);
+            await this.appendMessage(message, runId);
+        }
+        return true;
     }
     async applyProviderRequestPolicies(request, runId, options, metadata, signal) {
         const policies = [...policyList(this.agent.config.providerRequestPolicies), ...policyList(options.providerRequestPolicies)];
@@ -987,6 +1085,27 @@ function inputToMessages(input) {
         return [input];
     return [...input];
 }
+const steerTextEncoder = new TextEncoder();
+function messageTextBytes(message) {
+    let total = 0;
+    for (const block of message.content) {
+        if (block.type === "text")
+            total += steerTextEncoder.encode(block.text).byteLength;
+    }
+    return total;
+}
+const STEER_SOFT_INTERRUPT_CODE = "steer_soft_interrupt";
+class SteerSoftInterrupt extends Error {
+    code = STEER_SOFT_INTERRUPT_CODE;
+    constructor() {
+        super("Provider turn soft-interrupted by steer");
+        this.name = "SteerSoftInterrupt";
+    }
+}
+function isSteerSoftInterrupt(error) {
+    return error instanceof SteerSoftInterrupt
+        || (typeof error === "object" && error !== null && error.code === STEER_SOFT_INTERRUPT_CODE);
+}
 function finalAssistantMessage(history) {
     for (let index = history.length - 1; index >= 0; index -= 1) {
         const message = history[index];

package/dist/context-budget.d.ts

@@ -0,0 +1,63 @@
+import type { ContextBlock, InputAssemblyLayout, Message, ProviderRequest, Skill, ToolDefinition } from "./contracts.js";
+/** Assembler-time input budget. At least one max required when present. */
+export interface ContextBudget {
+    readonly maxInputTokens?: number;
+    readonly maxInputBytes?: number;
+    readonly reportOmissions?: boolean;
+}
+export type ContextBudgetOmissionKind = "skills" | "context" | "history" | "tool_results" | "summaries" | "attachments" | "tools";
+export interface ContextBudgetOmission {
+    readonly kind: ContextBudgetOmissionKind;
+    readonly id?: string;
+    readonly tokenEstimate: number;
+    readonly byteLength: number;
+}
+export interface ContextBudgetReport {
+    readonly omitted: readonly ContextBudgetOmission[];
+    readonly keptTokens: number;
+    readonly keptBytes: number;
+    readonly maxInputTokens?: number;
+    readonly maxInputBytes?: number;
+    readonly truncated: boolean;
+}
+export interface ContextBudgetMessageGroups {
+    readonly instructions: readonly Message[];
+    readonly summaries: readonly Message[];
+    readonly history: readonly Message[];
+    readonly input: readonly Message[];
+    readonly attachments: readonly Message[];
+    readonly toolResults: readonly Message[];
+}
+export declare const CONTEXT_BUDGET_REPORT_METADATA_KEY: "contextBudgetReport";
+export declare const HARD_MAX_CONTEXT_BUDGET_TOKENS = 2000000;
+export declare const HARD_MAX_CONTEXT_BUDGET_BYTES: number;
+export declare const DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS = 256;
+export declare const HARD_MAX_CONTEXT_BUDGET_OMISSIONS = 1024;
+export declare const CONTEXT_BUDGET_ERROR_CODE: "context_budget_exceeded";
+export declare class ContextBudgetError extends Error {
+    readonly code: "context_budget_exceeded";
+    constructor(message?: string);
+}
+export declare function isContextBudgetError(error: unknown): error is ContextBudgetError;
+/** UTF-16 code units / 4. Estimate only — not billing. */
+export declare function estimateTextTokens(text: string): number;
+export declare function estimateTextBytes(text: string): number;
+export declare function estimateMessageTokens(message: Message): number;
+export declare function estimateMessageBytes(message: Message): number;
+export declare function estimateAssemblyTokens(messages: readonly Message[]): number;
+export declare function resolveContextBudget(budget: ContextBudget): Required<Pick<ContextBudget, "reportOmissions">> & ContextBudget;
+export declare function getContextBudgetReport(request: ProviderRequest): ContextBudgetReport | undefined;
+export declare function applyContextBudget(options: {
+    readonly groups: ContextBudgetMessageGroups;
+    readonly context?: readonly ContextBlock[];
+    readonly skills?: readonly Skill[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly budget: ContextBudget;
+    readonly layout?: InputAssemblyLayout;
+}): {
+    readonly groups: ContextBudgetMessageGroups;
+    readonly context: readonly ContextBlock[];
+    readonly skills: readonly Skill[];
+    readonly tools: readonly ToolDefinition[] | undefined;
+    readonly report: ContextBudgetReport;
+};

package/dist/context-budget.js

@@ -0,0 +1,235 @@
+export const CONTEXT_BUDGET_REPORT_METADATA_KEY = "contextBudgetReport";
+export const HARD_MAX_CONTEXT_BUDGET_TOKENS = 2_000_000;
+export const HARD_MAX_CONTEXT_BUDGET_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS = 256;
+export const HARD_MAX_CONTEXT_BUDGET_OMISSIONS = 1_024;
+export const CONTEXT_BUDGET_ERROR_CODE = "context_budget_exceeded";
+export class ContextBudgetError extends Error {
+    code = CONTEXT_BUDGET_ERROR_CODE;
+    constructor(message = "context budget exceeded: mandatory prefix cannot fit") {
+        super(message);
+        this.name = "ContextBudgetError";
+    }
+}
+export function isContextBudgetError(error) {
+    return error instanceof Error && error.code === CONTEXT_BUDGET_ERROR_CODE;
+}
+/** UTF-16 code units / 4. Estimate only — not billing. */
+export function estimateTextTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export function estimateTextBytes(text) {
+    return new TextEncoder().encode(text).byteLength;
+}
+export function estimateMessageTokens(message) {
+    return estimateTextTokens(messageText(message));
+}
+export function estimateMessageBytes(message) {
+    return estimateTextBytes(messageText(message));
+}
+export function estimateAssemblyTokens(messages) {
+    return messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+}
+export function resolveContextBudget(budget) {
+    const hasTokens = budget.maxInputTokens !== undefined;
+    const hasBytes = budget.maxInputBytes !== undefined;
+    if (!hasTokens && !hasBytes) {
+        throw new TypeError("contextBudget requires maxInputTokens and/or maxInputBytes");
+    }
+    if (hasTokens)
+        assertPositiveCap(budget.maxInputTokens, "maxInputTokens", HARD_MAX_CONTEXT_BUDGET_TOKENS);
+    if (hasBytes)
+        assertPositiveCap(budget.maxInputBytes, "maxInputBytes", HARD_MAX_CONTEXT_BUDGET_BYTES);
+    return { ...budget, reportOmissions: budget.reportOmissions === true };
+}
+export function getContextBudgetReport(request) {
+    const value = request.metadata?.[CONTEXT_BUDGET_REPORT_METADATA_KEY];
+    return isContextBudgetReport(value) ? value : undefined;
+}
+export function applyContextBudget(options) {
+    const budget = resolveContextBudget(options.budget);
+    const layout = options.layout ?? "legacy";
+    const groups = {
+        instructions: [...options.groups.instructions],
+        summaries: [...options.groups.summaries],
+        history: [...options.groups.history],
+        input: [...options.groups.input],
+        attachments: [...options.groups.attachments],
+        toolResults: [...options.groups.toolResults],
+    };
+    const context = [...(options.context ?? [])];
+    const skills = [...(options.skills ?? [])].filter((skill) => skill.instructions);
+    const tools = options.tools ? [...options.tools] : undefined;
+    const omitted = [];
+    const cost = () => measureAll(groups, context, skills, tools);
+    while (overBudget(cost(), budget)) {
+        const drop = dropNext(groups, context, skills, layout);
+        if (!drop) {
+            throw new ContextBudgetError();
+        }
+        if (omitted.length < HARD_MAX_CONTEXT_BUDGET_OMISSIONS)
+            omitted.push(drop);
+    }
+    const kept = cost();
+    const reportOmissions = omitted.slice(0, DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS);
+    return {
+        groups,
+        context,
+        skills,
+        tools,
+        report: {
+            omitted: budget.reportOmissions ? reportOmissions : [],
+            keptTokens: kept.tokens,
+            keptBytes: kept.bytes,
+            maxInputTokens: budget.maxInputTokens,
+            maxInputBytes: budget.maxInputBytes,
+            truncated: omitted.length > 0,
+        },
+    };
+}
+function dropNext(groups, context, skills, layout) {
+    // ponytail: drop from end of keep-stack (history/tool_results first). cache_aware keeps
+    // attachments longer so stable prefix stays intact while budget still allows it.
+    const order = layout === "cache_aware"
+        ? ["tool_results", "history", "summaries", "context", "skills", "attachments"]
+        : ["tool_results", "history", "summaries", "attachments", "context", "skills"];
+    for (const kind of order) {
+        if (kind === "tool_results" && groups.toolResults.length > 0) {
+            const message = groups.toolResults.pop();
+            return omission("tool_results", message.id ?? toolResultId(message), message);
+        }
+        if (kind === "history" && groups.history.length > 0) {
+            const message = groups.history.pop();
+            return omission("history", message.id, message);
+        }
+        if (kind === "summaries" && groups.summaries.length > 0) {
+            const message = groups.summaries.pop();
+            return omission("summaries", message.id, message);
+        }
+        if (kind === "attachments" && groups.attachments.length > 0) {
+            const message = groups.attachments.pop();
+            return omission("attachments", message.id, message);
+        }
+        if (kind === "context" && context.length > 0) {
+            const block = context.pop();
+            const text = `${block.title ? `${block.title}:\n` : "Context:\n"}${contextBlockText(block)}`;
+            return {
+                kind: "context",
+                id: block.id ?? block.title,
+                tokenEstimate: estimateTextTokens(text),
+                byteLength: estimateTextBytes(text),
+            };
+        }
+        if (kind === "skills" && skills.length > 0) {
+            const skill = skills.pop();
+            const text = `Skill ${skill.name}:\n${skill.instructions ?? ""}`;
+            return {
+                kind: "skills",
+                id: skill.name,
+                tokenEstimate: estimateTextTokens(text),
+                byteLength: estimateTextBytes(text),
+            };
+        }
+    }
+    return undefined;
+}
+function omission(kind, id, message) {
+    return {
+        kind,
+        id,
+        tokenEstimate: estimateMessageTokens(message),
+        byteLength: estimateMessageBytes(message),
+    };
+}
+function toolResultId(message) {
+    const block = message.content.find((part) => part.type === "tool_result");
+    return block && block.type === "tool_result" ? block.toolCallId : undefined;
+}
+function measureAll(groups, context, skills, tools) {
+    let tokens = 0;
+    let bytes = 0;
+    const addMessage = (message) => {
+        tokens += estimateMessageTokens(message);
+        bytes += estimateMessageBytes(message);
+    };
+    for (const message of groups.instructions)
+        addMessage(message);
+    for (const message of groups.summaries)
+        addMessage(message);
+    for (const message of groups.history)
+        addMessage(message);
+    for (const message of groups.input)
+        addMessage(message);
+    for (const message of groups.attachments)
+        addMessage(message);
+    for (const message of groups.toolResults)
+        addMessage(message);
+    for (const block of context) {
+        const text = `${block.title ? `${block.title}:\n` : "Context:\n"}${contextBlockText(block)}`;
+        tokens += estimateTextTokens(text);
+        bytes += estimateTextBytes(text);
+    }
+    for (const skill of skills) {
+        const text = `Skill ${skill.name}:\n${skill.instructions ?? ""}`;
+        tokens += estimateTextTokens(text);
+        bytes += estimateTextBytes(text);
+    }
+    if (tools?.length) {
+        const text = `Available tools:\n${tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ""}`).join("\n")}`;
+        tokens += estimateTextTokens(text);
+        bytes += estimateTextBytes(text);
+    }
+    return { tokens, bytes };
+}
+function overBudget(cost, budget) {
+    if (budget.maxInputTokens !== undefined && cost.tokens > budget.maxInputTokens)
+        return true;
+    if (budget.maxInputBytes !== undefined && cost.bytes > budget.maxInputBytes)
+        return true;
+    return false;
+}
+function assertPositiveCap(value, name, hardMax) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > hardMax) {
+        throw new TypeError(`contextBudget.${name} must be a safe integer from 1 to ${hardMax}`);
+    }
+}
+function isContextBudgetReport(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const report = value;
+    return Array.isArray(report.omitted)
+        && typeof report.keptTokens === "number"
+        && typeof report.keptBytes === "number"
+        && typeof report.truncated === "boolean";
+}
+function messageText(message) {
+    return message.content.map((part) => {
+        if (part.type === "text" || part.type === "thinking")
+            return part.text;
+        if (part.type === "tool_result")
+            return JSON.stringify(part.result ?? part.error ?? null);
+        if (part.type === "tool_call")
+            return `${part.name}(${JSON.stringify(part.arguments)})`;
+        if (part.type === "tool_call_delta")
+            return `${part.name ?? "tool"}(${part.argumentsText ?? ""})`;
+        if (part.type === "image")
+            return part.url ?? part.resourceUri ?? part.mimeType ?? "[image]";
+        if (part.type === "audio")
+            return part.transcript ?? part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[audio]";
+        if (part.type === "file")
+            return part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[file]";
+        if (part.type === "document")
+            return part.transcript ?? part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[document]";
+        return "[content]";
+    }).join("\n");
+}
+function contextBlockText(block) {
+    if (typeof block.content === "string")
+        return block.content;
+    return block.content.map((part) => {
+        if (part.type === "text" || part.type === "thinking")
+            return part.text;
+        return "[content]";
+    }).join("\n");
+}
+//# sourceMappingURL=context-budget.js.map