@vincemakes/kiso-runtime 0.39.2 → 0.40.1

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. */
@@ -87,7 +87,7 @@ export const MANUAL_SUMMARY_BUDGET = 32_000;
  *  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. */
-class SummaryBudgetExhausted extends Error {
+export class SummaryBudgetExhausted extends Error {
     budget;
     constructor(budget) {
         super(budget === undefined
@@ -212,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
@@ -254,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
@@ -274,11 +291,18 @@ 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
@@ -290,18 +314,32 @@ export async function summarizeConversation(options) {
     // 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`).
-    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);
+    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;
+        }
     }
 }
 /**
@@ -323,18 +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") {
@@ -356,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)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.39.2",
+	"version": "0.40.1",
 	"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.2"
+		"@vincemakes/kiso-core": "0.40.1"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.39.2",
-		"@vincemakes/kiso-provider-openai": "0.39.2",
-		"@vincemakes/kiso-provider-openai-responses": "0.39.2"
+		"@vincemakes/kiso-provider-anthropic": "0.40.1",
+		"@vincemakes/kiso-provider-openai": "0.40.1",
+		"@vincemakes/kiso-provider-openai-responses": "0.40.1"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -44,7 +44,7 @@
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.39.2",
+		"@vincemakes/kiso-evals": "0.40.1",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"