@vincemakes/kiso-runtime 0.26.3 → 0.28.0

package/dist/agent.d.ts

@@ -46,15 +46,6 @@ export interface AgentDefinition {
     readonly maxTurns?: number;
     readonly maxTokens?: number;
     readonly temperature?: number;
-    /**
-     * DEPRECATED (ADR-0044): the classic auto-compaction path is retired —
-     * the loop ignores this (microcompact absorbed the responsibility; old
-     * sessions' `compacted` events still replay). Kept so old definitions
-     * type-check; removed at 1.0.
-     */
-    readonly compaction?: {
-        readonly thresholdTokens: number;
-    };
     /** C area: microcompact threshold — passed through to every session. */
     readonly microcompact?: {
         readonly thresholdTokens: number;

package/dist/agent.js

@@ -139,7 +139,6 @@ export class AgentRuntime {
             ...(this.#definition.maxTurns !== undefined ? { maxTurns: this.#definition.maxTurns } : {}),
             ...(this.#definition.maxTokens !== undefined ? { maxTokens: this.#definition.maxTokens } : {}),
             ...(this.#definition.temperature !== undefined ? { temperature: this.#definition.temperature } : {}),
-            ...(this.#definition.compaction !== undefined ? { compaction: this.#definition.compaction } : {}),
             ...(this.#definition.microcompact !== undefined ? { microcompact: this.#definition.microcompact } : {}),
             ...(this.#definition.contextPolicy !== undefined ? { contextPolicy: this.#definition.contextPolicy } : {}),
             ...(this.#definition.maxRetries !== undefined ? { maxRetries: this.#definition.maxRetries } : {}),

package/dist/compose.js

@@ -73,7 +73,7 @@ export function composeHooks(existing, extensions) {
                 await h(payload, ctx);
         };
     };
-    for (const key of ["onPreLlm", "onEvent", "onPreCompact", "onPostCompact", "onPause", "onStop"]) {
+    for (const key of ["onPreLlm", "onEvent", "onPause", "onStop"]) {
         const handler = observers((h) => h[key]);
         if (handler !== undefined)
             out[key] = handler;

package/dist/provider/metadata.js

@@ -29,6 +29,74 @@ const DEEPSEEK_PRICING = {
     asOf: "2026-08-13",
     source: "https://api-docs.deepseek.com/quick_start/pricing",
 };
+/** PA-1a: the Anthropic rates as read on 2026-09-07 (base input, output,
+ *  cache read = "cache hits and refreshes", cache write = the 5-minute
+ *  write). The pricing page notes Sonnet 5's $2/$10 is the standard
+ *  price (the announced September increase did not occur). */
+const ANTHROPIC_PRICING_SOURCE = "https://platform.claude.com/docs/en/about-claude/pricing";
+const ANTHROPIC_MODELS_SOURCE = "https://platform.claude.com/docs/en/models/overview";
+const ANTHROPIC_EFFORT_SOURCE = "https://platform.claude.com/docs/en/build-with-claude/effort";
+const ANTHROPIC_ASOF = "2026-09-07";
+const anthropicPricing = (inputPerM, outputPerM, cacheReadPerM, cacheWritePerM) => ({
+    inputPerM,
+    outputPerM,
+    cacheReadPerM,
+    cacheWritePerM,
+    asOf: ANTHROPIC_ASOF,
+    source: ANTHROPIC_PRICING_SOURCE,
+});
+/** The 5-line's effort control: five native levels, default high, wire
+ *  output_config.effort (the effort page, read 2026-09-07). The thinking
+ *  table (https://platform.claude.com/docs/en/build-with-claude/thinking-troubleshooting)
+ *  gives the modes per model. */
+const FIVE_LEVELS = { levels: ["low", "medium", "high", "xhigh", "max"], default: "high", wire: "output_config.effort" };
+function anthropicLine() {
+    const row = (model, capabilities, pricing) => ({
+        model,
+        providerId: "anthropic",
+        capabilities,
+        capabilitiesAsOf: ANTHROPIC_ASOF,
+        capabilitiesSource: ANTHROPIC_MODELS_SOURCE,
+        pricing,
+    });
+    const fiveLine = (thinkingModes, forbidden) => ({
+        contextWindow: 1_000_000,
+        maxOutputTokens: 128_000,
+        promptCaching: "explicit",
+        reasoning: {
+            emitsThinkingStream: true,
+            thinking: { modes: thinkingModes, default: "adaptive" },
+            effort: FIVE_LEVELS,
+            ...(forbidden !== undefined ? { forbidden } : {}),
+            asOf: ANTHROPIC_ASOF,
+            source: ANTHROPIC_EFFORT_SOURCE,
+        },
+        inputModalities: ["text", "image"],
+    });
+    const haiku = {
+        contextWindow: 200_000,
+        maxOutputTokens: 64_000,
+        promptCaching: "explicit",
+        // Extended thinking only (budget_tokens; adaptive rejected) — the
+        // XP-1 setting has no budget axis, so the toggle is not driven;
+        // effort: "Not supported" on the models overview. Unknown stays null.
+        reasoning: { emitsThinkingStream: true, thinking: null, effort: null, asOf: ANTHROPIC_ASOF, source: ANTHROPIC_EFFORT_SOURCE },
+        inputModalities: ["text", "image"],
+    };
+    const haikuPricing = anthropicPricing(1, 5, 0.1, 1.25);
+    return [
+        // Fable 5.1: adaptive only, ALWAYS on — "enabled" and "disabled" both 400.
+        row("claude-fable-5-1", fiveLine(["adaptive"]), anthropicPricing(10, 50, 0.25, 12.5)),
+        // Opus 5: adaptive, on by default; "disabled" accepted at effort high
+        // or below — with xhigh or max it is a 400 (the forbidden pair).
+        row("claude-opus-5", fiveLine(["adaptive", "disabled"], [{ thinking: "disabled", effort: "xhigh" }, { thinking: "disabled", effort: "max" }]), anthropicPricing(5, 25, 0.5, 6.25)),
+        // Sonnet 5: adaptive, on by default; "disabled" accepted.
+        row("claude-sonnet-5", fiveLine(["adaptive", "disabled"]), anthropicPricing(2, 10, 0.2, 2.5)),
+        // Haiku 4.5: the pinned id and its alias (the registry matches exact ids).
+        row("claude-haiku-4-5-20251001", haiku, haikuPricing),
+        row("claude-haiku-4-5", haiku, haikuPricing),
+    ];
+}
 /** The v1 table. Nulls outnumber numbers ON PURPOSE: only values with a
  *  named source enter; everything else waits for one. */
 const ENTRIES = [
@@ -54,22 +122,16 @@ const ENTRIES = [
         capabilities: { contextWindow: null, maxOutputTokens: null, promptCaching: "automatic", reasoning: { emitsThinkingStream: true, thinking: null, effort: null, asOf: null, source: null }, inputModalities: null },
         pricing: DEEPSEEK_PRICING,
     },
-    {
-        model: "claude-sonnet-5",
-        providerId: "anthropic",
-        capabilities: { contextWindow: 200_000, maxOutputTokens: null, promptCaching: "explicit",
-            reasoning: {
-                emitsThinkingStream: true,
-                thinking: null,
-                effort: { levels: ["low", "medium", "high", "xhigh", "max"], default: "high", wire: "output_config.effort" },
-                asOf: "2026-08-26",
-                source: "https://platform.claude.com/docs/en/build-with-claude/effort",
-            },
-            inputModalities: null },
-        // Priced only when the rates are read from the live billing page
-        // and dated — never copied from memory (the review's boundary ②).
-        pricing: null,
-    },
+    // PA-1a (2026-09-07): the Anthropic first-party line, read from the live
+    // docs that day — the models overview (ids, context, max output,
+    // modalities, thinking type, default effort), the thinking table
+    // (accepted / rejected thinking.type per model, the Opus 5 forbidden
+    // pair), the effort page (levels), the pricing page (rates). Each row
+    // carries the dates; nothing here is from memory. Extended thinking
+    // (`enabled` + budget_tokens) is registered for NO model: the 5-line
+    // rejects it, and Haiku 4.5's manual-budget mode has no axis in the
+    // XP-1 setting — recorded as `thinking: null` on that row, never guessed.
+    ...anthropicLine(),
     {
         // XP-1: the current DeepSeek line — the model every RD-1 benchmark
         // artifact was produced with, previously ABSENT (null pricing and

package/dist/run.js

@@ -32,7 +32,6 @@ export class Run {
     #abort = new AbortController();
     #externalSignal;
     #decisionIds = [];
-    #uncertaintyIds = [];
     #started = false;
     constructor(store, adapter, config, session, input, externalSignal, resume, 
     // TV-1B: durable PROVENANCE for the input (e.g. the verification
@@ -129,7 +128,6 @@ export class Run {
                 ...(this.#config.maxTurns !== undefined ? { maxTurns: this.#config.maxTurns } : {}),
                 ...(this.#config.maxTokens !== undefined ? { maxTokens: this.#config.maxTokens } : {}),
                 ...(this.#config.temperature !== undefined ? { temperature: this.#config.temperature } : {}),
-                ...(this.#config.compaction !== undefined ? { compaction: this.#config.compaction } : {}),
                 ...(microcompact !== undefined ? { microcompact } : {}),
                 ...(this.#config.maxRetries !== undefined ? { maxRetries: this.#config.maxRetries } : {}),
                 // MG-1 (A5): the kernel stamps committed envelopes with this.
@@ -151,11 +149,6 @@ export class Run {
                 // the human gave in the same instant as the abort is
                 // recorded, exactly once.
                 approvalVerdict: (decisionId) => this.#session.approvalVerdict(decisionId),
-                uncertaintyVerdict: (executionId) => this.#session.uncertaintyVerdict(executionId),
-                resolveUncertainty: (executionId) => new Promise((resolve) => {
-                    this.#uncertaintyIds.push(executionId);
-                    this.#session.registerUncertaintyResolver(executionId, resolve);
-                }),
             });
             const self = this;
             const runLoop = async function* () {
@@ -287,9 +280,6 @@ export class Run {
             for (const decisionId of this.#decisionIds) {
                 this.#session.dropResolver(decisionId);
             }
-            for (const executionId of this.#uncertaintyIds) {
-                this.#session.dropUncertaintyResolver(executionId);
-            }
             // E1: the run's ledger story — the run_end lands synchronously
             // (a killed run leaves no run_end, and the next init marks it).
             tracer?.finishRun();

package/dist/session.d.ts

@@ -287,13 +287,9 @@ export declare class AgentSession {
     resolveUncertain(executionId: string, resolution: "rerun" | "abandoned"): Promise<void>;
     /** The runId that owns an execution — from its durable started record. */
     private runIdFor;
-    registerUncertaintyResolver(executionId: string, resolve: (resolution: "rerun" | "abandoned") => void): void;
-    dropUncertaintyResolver(executionId: string): void;
     registerResolver(decisionId: string, resolve: (decision: PermissionDecision) => void): void;
     /** round 4 (adversarial): a verdict the human already gave for a live decision. */
     approvalVerdict(decisionId: string): boolean | undefined;
-    /** round 4 (adversarial): a verdict the human already gave for a live execution. */
-    uncertaintyVerdict(executionId: string): "rerun" | "abandoned" | undefined;
     /**
      * round 5(P1-5): flush every verdict submitted to a live resolver that is
      * not yet durable. Called from the Run iterator's FINALLY — whether the
@@ -386,13 +382,6 @@ export interface SessionConfig {
     readonly maxTurns?: number;
     readonly maxTokens?: number;
     readonly temperature?: number;
-    /**
-     * DEPRECATED (ADR-0044): forwarded to the loop's deprecated field,
-     * which IGNORES it — kept for type compatibility, removed at 1.0.
-     */
-    readonly compaction?: {
-        readonly thresholdTokens: number;
-    };
     /** C area: microcompact threshold — passed through to the loop verbatim. */
     readonly microcompact?: {
         readonly thresholdTokens: number;

package/dist/session.js

@@ -93,26 +93,21 @@ export class AgentSession {
     // selection or first request — never eagerly at open.
     #profilePending;
     #pendingResolvers = new Map();
-    #uncertaintyResolvers = new Map();
     #answered = new Set();
-    /** round 7: verdicts already passed to a live resolver — the resolution event
-     *  lands in the log asynchronously (the loop owns it), so the ledger
-     *  alone cannot make resolveUncertain idempotent across the same tick. */
-    #uncertaintyAnswered = new Set();
     /** round 4 (adversarial): verdicts the human GAVE, recorded when passed to a live
      *  resolver. If an abort races the verdict, the loop / recovery queries
      *  these and records the decision (exactly once) instead of losing it. */
     #approvalVerdicts = new Map();
-    #uncertaintyVerdicts = new Map();
     /** round 5(P1-5): verdicts submitted to a LIVE resolver but not yet known
-     *  durable. An async generator only advances on next(), so approve()/
-     *  resolveUncertain() CANNOT wait for the loop to persist — that would
-     *  deadlock (the consumer waits while the generator needs a next()).
-     *  Instead the verdict is recorded here, and the Run's iterator FINALLY
-     *  flushes every not-yet-durable verdict to disk — an abandoned generator
-     *  can never lose a verdict the human gave. */
+     *  durable. An async generator only advances on next(), so approve()
+     *  CANNOT wait for the loop to persist — that would deadlock (the
+     *  consumer waits while the generator needs a next()). Instead the
+     *  verdict is recorded here, and the Run's iterator FINALLY flushes
+     *  every not-yet-durable verdict to disk — an abandoned generator can
+     *  never lose a verdict the human gave. (CT-1: uncertainty verdicts no
+     *  longer have a live resolver — the loop never took one since
+     *  ADR-0038 — so they always take the direct-persist path below.) */
     #pendingDurableApprovals = new Map();
-    #pendingDurableUncertainties = new Map();
     #poisoned = null;
     /** E6 (h): the circuit-breaker counter — consecutive auto-policy
      *  summary failures this session (a success resets it). */
@@ -668,30 +663,10 @@ export class AgentSession {
         if (!record)
             throw new Error(`no execution record for ${executionId}`);
         if (record.status !== "uncertain")
-            return; // idempotent + irreversible
-        // round 7: a verdict already passed to a live resolver is FINAL — the
-        // loop's resolution event lands asynchronously, so the ledger alone
-        // cannot make this idempotent across the same tick.
-        if (this.#uncertaintyAnswered.has(executionId))
-            return;
-        this.#uncertaintyAnswered.add(executionId);
-        // round 7: with a LIVE resolver, the active loop / recovery generator
-        // OWNS the resolution event — it appends, yields, and persists it
-        // through the Run, so the consumer's stream and the durable log
-        // stay identical. We only pass the verdict; a hidden append here
-        // would leave a seq gap. round 4 (adversarial): the verdict is recorded so an
-        // abort racing it cannot lose it.
-        const resolver = this.#uncertaintyResolvers.get(executionId);
-        if (resolver !== undefined) {
-            this.#uncertaintyVerdicts.set(executionId, resolution);
-            // round 5(P1-5): submitted — flushed to disk by the Run's finally
-            // if the generator never persists it.
-            this.#pendingDurableUncertainties.set(executionId, { resolution, callId: record.callId });
-            this.#uncertaintyResolvers.delete(executionId);
-            resolver(resolution);
-            return;
-        }
-        // round 7: OFFLINE verdict — no live resolver: persist directly.
+            return; // idempotent + irreversible (the append below is synchronous, so a same-tick second call sees it)
+        // CT-1 (ADR-0051 Amendment 6): the verdict is persisted directly — there
+        // is no live resolver to hand it to (the loop never read one since
+        // ADR-0038; the round-7 live branch that waited for it was unreachable).
         // round 4: the verdict is attributed to the ORIGINAL run of the execution
         // — never the fake runId "resolution".
         const runId = this.runIdFor(executionId);
@@ -738,12 +713,6 @@ export class AgentSession {
             throw new Error(`no durable execution record for ${executionId}`);
         return rec.runId;
     }
-    registerUncertaintyResolver(executionId, resolve) {
-        this.#uncertaintyResolvers.set(executionId, resolve);
-    }
-    dropUncertaintyResolver(executionId) {
-        this.#uncertaintyResolvers.delete(executionId);
-    }
     // ── internal: the resolver registry ──────────────────────────────────
     registerResolver(decisionId, resolve) {
         this.#pendingResolvers.set(decisionId, resolve);
@@ -752,10 +721,6 @@ export class AgentSession {
     approvalVerdict(decisionId) {
         return this.#approvalVerdicts.get(decisionId);
     }
-    /** round 4 (adversarial): a verdict the human already gave for a live execution. */
-    uncertaintyVerdict(executionId) {
-        return this.#uncertaintyVerdicts.get(executionId);
-    }
     /**
      * round 5(P1-5): flush every verdict submitted to a live resolver that is
      * not yet durable. Called from the Run iterator's FINALLY — whether the
@@ -777,19 +742,6 @@ export class AgentSession {
             }
             this.#pendingDurableApprovals.delete(decisionId);
         }
-        for (const [executionId, pending] of this.#pendingDurableUncertainties) {
-            const resolved = log.all.find((e) => e.type === "tool_execution_resolved" && e.executionId === executionId);
-            if (resolved === undefined) {
-                const app = log.append({
-                    type: "tool_execution_resolved",
-                    executionId,
-                    callId: pending.callId,
-                    resolution: pending.resolution,
-                });
-                await this.persist(runId, app);
-            }
-            this.#pendingDurableUncertainties.delete(executionId);
-        }
     }
     dropResolver(decisionId) {
         this.#pendingResolvers.delete(decisionId);

package/package.json

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