@vincemakes/kiso-runtime 0.39.1 → 0.40.0

package/dist/summarize.d.ts

@@ -13,7 +13,7 @@
  * unchanged ("nothing happened"). Only the generated `summarized` event
  * lands on disk; the original events stay there forever.
  */
-import type { AbortSignalLike, Adapter } from "@vincemakes/kiso-core";
+import type { AbortSignalLike, Adapter, RetryInfo, ToolSpec } from "@vincemakes/kiso-core";
 import type { Event } from "@vincemakes/kiso-core";
 import type { Message } from "@vincemakes/kiso-core";
 import type { RawUsage } from "./usage/canonical.js";
@@ -44,7 +44,56 @@ export declare const SUMMARY_RESULT_MAX_CHARS = 2000;
 export declare const SUMMARY_MAX_OUTPUT = 4000;
 export declare const KEEP_TOKENS_DEFAULT = 20000;
 export declare const IN_FLIGHT_HEADROOM = 8000;
+/** ONE NUMBER, TWO CONSUMERS. `SUMMARY_MAX_OUTPUT` is both the summary
+ *  call's output budget AND a term of this reserve — the reserve buys
+ *  back room for exactly that much summary. Change one and you have
+ *  changed the other; see `MANUAL_SUMMARY_BUDGET` for why the manual
+ *  gesture's larger budget does NOT reach the auto policy that reads this. */
 export declare const POLICY_RESERVE: number;
+/**
+ * 0.39.2 — the output budget of a MANUAL `/compact`, and it is MEASURED.
+ *
+ * The fixed 4,000 failed live sessions: `the summary turn ended with
+ * max_tokens`. On the failing profile (an unregistered DeepSeek model
+ * behind a gateway), a covered range the size of the reported one —
+ * ~100k tokens of real source — was run three ways:
+ *
+ *   budget  4,000  → max_tokens   reasoning 3,093   checkpoint    828   3 of 7 sections
+ *   budget  8,391  → max_tokens   reasoning 1,613   checkpoint  6,544   4 of 7
+ *   budget 32,000  → end_turn     reasoning 3,557   checkpoint 15,261   7 of 7
+ *
+ * A complete checkpoint took 18,837 output tokens. At 4,000 the reasoning
+ * LOOKED like the cause (77% of the budget) only because the budget was
+ * too small for the checkpoint to get going; with room, reasoning is a
+ * fifth and the checkpoint itself is the size. A rule scaled from the
+ * covered estimate (a twelfth: 8,391, doubling to 16,782 on retry) was
+ * built first and failed BOTH attempts on this data — it was a guess, and
+ * the measurement is what falsified it.
+ *
+ * So the budget is not scaled; it is a generous flat CAP, because a cap
+ * is not a charge — the model is billed for what it writes, and a higher
+ * limit costs nothing unless the output would have run away anyway. The
+ * one thing a lower first budget buys is a failed call before the one
+ * that works. 32,000 holds the measured 18,837 with room, and bounds what
+ * a genuinely runaway summary can cost: a checkpoint larger than this has
+ * stopped being a summary.
+ *
+ * MANUAL ONLY, and that is the patch boundary. The auto policy's
+ * `POLICY_RESERVE` assumes `SUMMARY_MAX_OUTPUT`; giving the policy a larger
+ * budget without moving its reserve would let a fire leave less room than
+ * the reserve promised, and moving the reserve moves every session's
+ * compaction trigger — BM-1 §3's compaction tier, where the paired bench
+ * blocks. That belongs to A1b, and the measurement above is its input.
+ */
+export declare const MANUAL_SUMMARY_BUDGET = 32000;
+/** Thrown by an attempt that stopped on `max_tokens`, and it NAMES the
+ *  budget: "not a complete turn" alone told the person nothing about what
+ *  ran out. Still an `Error`, and still carries the `max_tokens … not a
+ *  complete turn` wording the CX-1 F3 gate matches. */
+export declare class SummaryBudgetExhausted extends Error {
+    readonly budget: number | undefined;
+    constructor(budget: number | undefined);
+}
 /** The reference context-window scale (the flash-family window); the
  *  env overrides. The default arming point is 120,000 − 32,000 =
  *  88,000 — a post-fire projection (≥ 24k) can never re-cross it, so
@@ -90,6 +139,12 @@ export declare function serializeCovered(options: SerializeCoveredOptions): stri
  * (the loop's system prompt is the harness's business, never the kernel's).
  */
 export declare const SUMMARY_PROMPT = "Only output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it in the model's context. The next turn must be able\nto continue the work without reading the originals.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user message in the covered range, enumerated one by one, each\nwith what it asked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
+/**
+ * ADR-0055 A2 — the IN-BAND form: the run's own request with this appended
+ * as the last user message, so everything before it reads at the cache-hit
+ * price. The same sections, the same validation; the guard sentence first.
+ */
+export declare const SUMMARY_IN_BAND = "Stop the task for this one reply and write a checkpoint of the conversation above instead.\n\nOnly output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it in the model's context. The next turn must be able\nto continue the work without reading the originals.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user message in the covered range, enumerated one by one, each\nwith what it asked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
 /**
  * E6 (b) — the output-side validation (the finding E6-F4/F5 follow-up):
  * a summary must be a complete checkpoint or NOTHING. The marker family
@@ -109,11 +164,55 @@ export declare function validateSummary(text: string): string | null;
 export interface SummarizeConversationOptions {
     readonly adapter: Adapter;
     readonly model: string;
+    /** ADR-0055 A2: send `messages` AS THE RUN SENT THEM, under the run's own
+     *  system prompt and tool table, with SUMMARY_IN_BAND appended — the
+     *  cache-hot form. Absent: `messages` is the serialized covered range
+     *  under SUMMARY_PROMPT, the cold form. */
+    readonly inBand?: {
+        readonly systemPrompt?: string;
+        readonly tools: readonly ToolSpec[];
+        readonly focus?: string;
+    };
     /** The covered conversation — the ONLY material the summary is about. */
     readonly messages: readonly Message[];
     readonly signal?: AbortSignalLike;
     /** E6 (g): the summary call's explicit output budget (adapter maxTokens). */
     readonly maxOutputTokens?: number;
+    /** 0.39.2: the RESOLVED reasoning for the summary call — native wire
+     *  values from `resolveReasoning`, never a raw field. Absent sends
+     *  nothing, and the provider's default applies. */
+    readonly reasoning?: {
+        readonly thinking?: "adaptive" | "enabled" | "disabled";
+        readonly effort?: string;
+    };
+    /** ADR-0005 Amendment 2: the kernel's retry budget, applied to this
+     *  off-loop call. Absent, the kernel's default. */
+    readonly maxRetries?: number;
+    /** ADR-0005 Amendment 2: announced before each wait, as the kernel
+     *  announces its own. Observation only — a throw is swallowed. */
+    readonly onRetry?: (info: RetryInfo) => Promise<void> | void;
+    /** 0.40.0: how much of the OUTPUT budget the call has spent so far —
+     *  reported at each attempt's start (zero) and as text, reasoning and
+     *  the final usage arrive. Observation only: a throw is swallowed, and
+     *  the request is identical with or without it. */
+    readonly onProgress?: (progress: SummaryProgress) => void;
+}
+/**
+ * 0.40.0 — the summary call's progress against its output budget.
+ *
+ * `produced` counts streamed text AND streamed reasoning (owner's ruling —
+ * a bar over text alone sits low while thinking spends the budget, and the
+ * call then fails at "full"), by the session's chars/4 proxy, until the
+ * provider reports its output total, which replaces the estimate
+ * (`reported`). `reasoningUnseen`: the provider billed reasoning that never
+ * streamed, so the jump to the reported total has a named cause.
+ */
+export interface SummaryProgress {
+    readonly produced: number;
+    /** the call's output budget; null when the call carries none */
+    readonly budget: number | null;
+    readonly reasoningUnseen: boolean;
+    readonly reported: boolean;
 }
 /** The summary call's result — the text PLUS the provider-reported usage
  *  (E6: the honest accounting — the summary call's cost rides the trace
@@ -124,7 +223,7 @@ export interface SummarizeConversationResult {
     readonly usage: RawUsage | null;
 }
 /**
- * The summary call, with ONE retry.
+ * The summary call, retried under the KERNEL'S policy.
  *
  * 0.39.1: `/compact` had no retry at all. The kernel owns retries
  * (ADR-0005) and this path does not go through the kernel — it calls the
@@ -134,11 +233,18 @@ export interface SummarizeConversationResult {
  * (the transport-failure-after-headers class); here is the only place
  * that can act on it.
  *
- * ONE retry, not a loop, and not the kernel's budget: a summary re-pays
- * its whole input, which on the sessions that need compacting is the
- * most expensive request the session makes. A permanent error still
- * throws on the first attempt — the retry is keyed on the classification
- * the adapter already made, never on the fact that something failed.
+ * 0.39.1 gave it ONE retry after 250 ms. ADR-0005 Amendment 2 gives it the
+ * kernel's rule instead, because a dropped summary stream is the same
+ * failure as a dropped turn and meets the same gateway: the same curve,
+ * the same budget (the same `maxRetries` knob), Retry-After as a floor and
+ * a wait beyond RETRY_AFTER_MAX_MS as an explicit stop — never a retry
+ * that comes early — and the same announcement before each wait. Each
+ * retry re-pays the summary's input, exactly as each turn retry re-pays
+ * the turn's; the budget that bounds one bounds the other.
+ *
+ * A permanent error still throws on the first attempt — the retry is
+ * keyed on the classification the adapter already made, never on the
+ * fact that something failed.
  */
 export declare function summarizeConversation(options: SummarizeConversationOptions): Promise<SummarizeConversationResult>;
 /** E6 — the crux-experiment drop arm: the covered turns are replaced by

package/dist/summarize.js

@@ -13,7 +13,7 @@
  * unchanged ("nothing happened"). Only the generated `summarized` event
  * lands on disk; the original events stay there forever.
  */
-import { estimateTokens, DO_NOT_COMPACT } from "@vincemakes/kiso-core";
+import { estimateTokens, DO_NOT_COMPACT, DEFAULT_MAX_RETRIES, RETRY_AFTER_MAX_MS, retryDelayMs } from "@vincemakes/kiso-core";
 /** K (ADR-0044): the recent ROUNDS kept intact by /compact — a constant,
  *  not a knob. The covered range ends just before the K-th most recent
  *  round, so the model still reasons over the recent conversation. */
@@ -41,7 +41,61 @@ export const SUMMARY_RESULT_MAX_CHARS = 2000;
 export const SUMMARY_MAX_OUTPUT = 4000;
 export const KEEP_TOKENS_DEFAULT = 20000;
 export const IN_FLIGHT_HEADROOM = 8000;
+/** ONE NUMBER, TWO CONSUMERS. `SUMMARY_MAX_OUTPUT` is both the summary
+ *  call's output budget AND a term of this reserve — the reserve buys
+ *  back room for exactly that much summary. Change one and you have
+ *  changed the other; see `MANUAL_SUMMARY_BUDGET` for why the manual
+ *  gesture's larger budget does NOT reach the auto policy that reads this. */
 export const POLICY_RESERVE = SUMMARY_MAX_OUTPUT + KEEP_TOKENS_DEFAULT + IN_FLIGHT_HEADROOM;
+/**
+ * 0.39.2 — the output budget of a MANUAL `/compact`, and it is MEASURED.
+ *
+ * The fixed 4,000 failed live sessions: `the summary turn ended with
+ * max_tokens`. On the failing profile (an unregistered DeepSeek model
+ * behind a gateway), a covered range the size of the reported one —
+ * ~100k tokens of real source — was run three ways:
+ *
+ *   budget  4,000  → max_tokens   reasoning 3,093   checkpoint    828   3 of 7 sections
+ *   budget  8,391  → max_tokens   reasoning 1,613   checkpoint  6,544   4 of 7
+ *   budget 32,000  → end_turn     reasoning 3,557   checkpoint 15,261   7 of 7
+ *
+ * A complete checkpoint took 18,837 output tokens. At 4,000 the reasoning
+ * LOOKED like the cause (77% of the budget) only because the budget was
+ * too small for the checkpoint to get going; with room, reasoning is a
+ * fifth and the checkpoint itself is the size. A rule scaled from the
+ * covered estimate (a twelfth: 8,391, doubling to 16,782 on retry) was
+ * built first and failed BOTH attempts on this data — it was a guess, and
+ * the measurement is what falsified it.
+ *
+ * So the budget is not scaled; it is a generous flat CAP, because a cap
+ * is not a charge — the model is billed for what it writes, and a higher
+ * limit costs nothing unless the output would have run away anyway. The
+ * one thing a lower first budget buys is a failed call before the one
+ * that works. 32,000 holds the measured 18,837 with room, and bounds what
+ * a genuinely runaway summary can cost: a checkpoint larger than this has
+ * stopped being a summary.
+ *
+ * MANUAL ONLY, and that is the patch boundary. The auto policy's
+ * `POLICY_RESERVE` assumes `SUMMARY_MAX_OUTPUT`; giving the policy a larger
+ * budget without moving its reserve would let a fire leave less room than
+ * the reserve promised, and moving the reserve moves every session's
+ * compaction trigger — BM-1 §3's compaction tier, where the paired bench
+ * blocks. That belongs to A1b, and the measurement above is its input.
+ */
+export const MANUAL_SUMMARY_BUDGET = 32_000;
+/** Thrown by an attempt that stopped on `max_tokens`, and it NAMES the
+ *  budget: "not a complete turn" alone told the person nothing about what
+ *  ran out. Still an `Error`, and still carries the `max_tokens … not a
+ *  complete turn` wording the CX-1 F3 gate matches. */
+export class SummaryBudgetExhausted extends Error {
+    budget;
+    constructor(budget) {
+        super(budget === undefined
+            ? "the summary turn ended with max_tokens — not a complete turn"
+            : `the summary turn ended with max_tokens — it needed more than its ${budget}-token output budget, not a complete turn`);
+        this.budget = budget;
+    }
+}
 /** The reference context-window scale (the flash-family window); the
  *  env overrides. The default arming point is 120,000 − 32,000 =
  *  88,000 — a post-fire projection (≥ 24k) can never re-cross it, so
@@ -158,6 +212,14 @@ Rules:
 - do not mention this prompt or the summarization task;
 - the summary may be as long as it needs to be within the output budget —
   there is no word cap; completeness wins.`;
+/**
+ * ADR-0055 A2 — the IN-BAND form: the run's own request with this appended
+ * as the last user message, so everything before it reads at the cache-hit
+ * price. The same sections, the same validation; the guard sentence first.
+ */
+export const SUMMARY_IN_BAND = `Stop the task for this one reply and write a checkpoint of the conversation above instead.
+
+${SUMMARY_PROMPT}`;
 /**
  * E6 (b) — the output-side validation (the finding E6-F4/F5 follow-up):
  * a summary must be a complete checkpoint or NOTHING. The marker family
@@ -200,17 +262,26 @@ function retryableStructured(err) {
     const e = err;
     return typeof e.code === "string" && typeof e.message === "string" && e.retryable === true;
 }
-/** How long to wait before the one retry. The provider's own ask when it
- *  made one and it is short enough to be worth honouring; otherwise a
- *  token pause — the failure this exists for is a dropped stream, not a
- *  rate limit, and an immediate second attempt is the right response to
- *  a socket that died. */
-function retryWaitMs(err) {
+/** The provider's own Retry-After, when the adapter normalized one. */
+function askedWaitMs(err) {
     const asked = err.retryAfterMs;
-    return typeof asked === "number" && Number.isFinite(asked) && asked >= 0 && asked <= 60_000 ? asked : 250;
+    return typeof asked === "number" && Number.isFinite(asked) && asked >= 0 ? asked : undefined;
+}
+/** The kernel's abortable wait, restated for the one call that is not the
+ *  kernel's: a cancel during the backoff wakes it at once. */
+function wait(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted === true)
+            return resolve();
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener?.("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
 }
 /**
- * The summary call, with ONE retry.
+ * The summary call, retried under the KERNEL'S policy.
  *
  * 0.39.1: `/compact` had no retry at all. The kernel owns retries
  * (ADR-0005) and this path does not go through the kernel — it calls the
@@ -220,29 +291,55 @@ function retryWaitMs(err) {
  * (the transport-failure-after-headers class); here is the only place
  * that can act on it.
  *
- * ONE retry, not a loop, and not the kernel's budget: a summary re-pays
- * its whole input, which on the sessions that need compacting is the
- * most expensive request the session makes. A permanent error still
- * throws on the first attempt — the retry is keyed on the classification
- * the adapter already made, never on the fact that something failed.
+ * 0.39.1 gave it ONE retry after 250 ms. ADR-0005 Amendment 2 gives it the
+ * kernel's rule instead, because a dropped summary stream is the same
+ * failure as a dropped turn and meets the same gateway: the same curve,
+ * the same budget (the same `maxRetries` knob), Retry-After as a floor and
+ * a wait beyond RETRY_AFTER_MAX_MS as an explicit stop — never a retry
+ * that comes early — and the same announcement before each wait. Each
+ * retry re-pays the summary's input, exactly as each turn retry re-pays
+ * the turn's; the budget that bounds one bounds the other.
+ *
+ * A permanent error still throws on the first attempt — the retry is
+ * keyed on the classification the adapter already made, never on the
+ * fact that something failed.
  */
 export async function summarizeConversation(options) {
     // Asked as a CALL, twice, because `aborted` is a readonly property and
     // the narrowing from the first read would otherwise be carried across
     // the await — where the whole point is that it can have changed.
     const aborted = () => options.signal?.aborted === true;
-    try {
-        return await summaryAttempt(options);
-    }
-    catch (err) {
-        // The caller's cancel is the caller's: an aborted `/compact` must
-        // not spend a second call on its way out.
-        if (!retryableStructured(err) || aborted())
-            throw err;
-        await new Promise((r) => setTimeout(r, retryWaitMs(err)));
-        if (aborted())
-            throw err;
-        return await summaryAttempt(options);
+    // A `max_tokens` stop is NOT retried here. A retry at the same budget
+    // buys the same truncation, and a retry at a larger one is only worth
+    // having if the first budget was chosen small — which is why the manual
+    // gesture now asks for the whole measured budget up front instead
+    // (see `MANUAL_SUMMARY_BUDGET`).
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    for (let attempts = 0;; attempts += 1) {
+        try {
+            return await summaryAttempt(options);
+        }
+        catch (err) {
+            // The caller's cancel is the caller's: an aborted `/compact` must
+            // not spend another call on its way out.
+            if (!retryableStructured(err) || aborted() || attempts >= maxRetries)
+                throw err;
+            const asked = askedWaitMs(err);
+            const delay = retryDelayMs(attempts + 1, asked);
+            const e = err;
+            if (delay > RETRY_AFTER_MAX_MS) {
+                throw { ...e, retryable: false, message: `${e.message} (the provider asked to wait ${asked}ms — beyond the ${RETRY_AFTER_MAX_MS}ms cap; not retried)` };
+            }
+            try {
+                await options.onRetry?.({ attempt: attempts + 1, maxRetries, code: e.code, delayMs: delay, midStream: false });
+            }
+            catch {
+                // observation only
+            }
+            await wait(delay, options.signal);
+            if (aborted())
+                throw err;
+        }
     }
 }
 /**
@@ -264,17 +361,44 @@ async function summaryAttempt(options) {
     let stopReason;
     let toolCalls = 0;
     let afterStop;
+    // 0.40.0: the progress this attempt reports — it starts at zero, so a
+    // retry visibly starts the bar again
+    let streamedChars = 0;
+    let sawReasoning = false;
+    const report = (progress) => {
+        try {
+            options.onProgress?.(progress);
+        }
+        catch {
+            // observation only
+        }
+    };
+    const budget = options.maxOutputTokens ?? null;
+    report({ produced: 0, budget, reasoningUnseen: false, reported: false });
+    const inBand = options.inBand;
     for await (const ev of adapter.stream({
         model,
-        messages,
-        systemPrompt: SUMMARY_PROMPT,
+        ...(inBand === undefined
+            ? { messages, systemPrompt: SUMMARY_PROMPT }
+            : {
+                messages: [...messages, { role: "user", content: inBand.focus === undefined ? SUMMARY_IN_BAND : `${SUMMARY_IN_BAND}\n\nFocus the summary on: ${inBand.focus}` }],
+                ...(inBand.systemPrompt !== undefined ? { systemPrompt: inBand.systemPrompt } : {}),
+                tools: inBand.tools,
+            }),
         ...(options.signal !== undefined ? { signal: options.signal } : {}),
         ...(options.maxOutputTokens !== undefined ? { maxTokens: options.maxOutputTokens } : {}),
+        ...(options.reasoning !== undefined ? { reasoning: options.reasoning } : {}),
     })) {
         if (stops > 0 && ev.type !== "usage" && ev.type !== "stop" && afterStop === undefined)
             afterStop = ev.type;
-        if (ev.type === "text_delta")
-            text += ev.text;
+        if (ev.type === "text_delta" || ev.type === "thinking") {
+            if (ev.type === "text_delta")
+                text += ev.text;
+            else
+                sawReasoning = true;
+            streamedChars += ev.text.length;
+            report({ produced: Math.ceil(streamedChars / 4), budget, reasoningUnseen: false, reported: false });
+        }
         else if (ev.type === "tool_call_start" || ev.type === "tool_call_end" || ev.type === "tool_call_input_delta")
             toolCalls += 1;
         else if (ev.type === "stop") {
@@ -296,6 +420,9 @@ async function summaryAttempt(options) {
                 cacheWrite: ev.cacheWrite,
                 ...(ev.reasoningTokens !== undefined ? { reasoningTokens: ev.reasoningTokens } : {}),
             };
+            if (ev.outputTokens !== null) {
+                report({ produced: ev.outputTokens, budget, reasoningUnseen: !sawReasoning && (ev.reasoningTokens ?? 0) > 0, reported: true });
+            }
         }
     }
     if (stops === 0)
@@ -304,6 +431,9 @@ async function summaryAttempt(options) {
         throw new Error(`the summary turn stopped ${stops} times — not a complete turn`);
     if (toolCalls > 0)
         throw new Error("the summary turn called a tool — a summary is text, never a tool call");
+    // The one stop a larger budget can cure, told apart from the rest.
+    if (stopReason === "max_tokens")
+        throw new SummaryBudgetExhausted(options.maxOutputTokens);
     if (stopReason !== "end_turn")
         throw new Error(`the summary turn ended with ${String(stopReason)} — not a complete turn`);
     if (afterStop !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.39.1",
+	"version": "0.40.0",
 	"description": "kiso runtime \u2014 durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
 	"type": "module",
 	"license": "MIT",
@@ -25,12 +25,12 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.39.1"
+		"@vincemakes/kiso-core": "0.40.0"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.39.1",
-		"@vincemakes/kiso-provider-openai": "0.39.1",
-		"@vincemakes/kiso-provider-openai-responses": "0.39.1"
+		"@vincemakes/kiso-provider-anthropic": "0.40.0",
+		"@vincemakes/kiso-provider-openai": "0.40.0",
+		"@vincemakes/kiso-provider-openai-responses": "0.40.0"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -44,7 +44,7 @@
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.39.1",
+		"@vincemakes/kiso-evals": "0.40.0",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"