@vincemakes/kiso-runtime 0.31.0 → 0.32.0

package/dist/agent.d.ts

@@ -65,6 +65,10 @@ export interface AgentDefinition {
     /** E6: the session context policy (run-start actions, injection-side only). */
     readonly contextPolicy?: import("./session.js").ContextPolicy;
     readonly maxRetries?: number;
+    /** LT-1: the stream watchdog — milliseconds between adapter events
+     *  before the request is aborted and retried (default 120 s; 0 off).
+     *  Type-only additive; read by the runtime's idle guard. */
+    readonly streamIdleMs?: number;
     /** E1: loaded extensions — their tools merge into the registry (a name
      *  collision with a built-in is a loud startup error), their hooks
      *  compose after the agent's own (the existing come first), their approvals join the

package/dist/agent.js

@@ -145,6 +145,7 @@ export class AgentRuntime {
             ...(this.#definition.microcompact !== undefined ? { microcompact: this.#definition.microcompact } : {}),
             ...(this.#definition.contextPolicy !== undefined ? { contextPolicy: this.#definition.contextPolicy } : {}),
             ...(this.#definition.maxRetries !== undefined ? { maxRetries: this.#definition.maxRetries } : {}),
+            ...(this.#definition.streamIdleMs !== undefined ? { streamIdleMs: this.#definition.streamIdleMs } : {}),
             ...(this.#definition.extensions !== undefined ? { extensions: this.#definition.extensions } : {}),
         };
         return new AgentSession(options.id, log, store, adapter, config);

package/dist/extensions.js

@@ -28,6 +28,27 @@ export async function loadProjectExtensions(dir, existing = []) {
     }
     return projectExts;
 }
+/**
+ * §2.5 — the load counter behind the import URL's `?load=` query.
+ *
+ * Node caches ESM modules by URL forever. Without a distinguishing query
+ * a second load of the same directory returns the FIRST load's modules,
+ * so `/reload` would report success and change nothing — and a
+ * module-level Set held across the boundary would be mutated by one side
+ * and read by the other.
+ *
+ * It is unconditional on purpose. A parameter would put a stale mode
+ * back within reach and would move `loadExtensions` in the public
+ * surface file for no gain: at startup this is one load and invisible,
+ * and on a reload it is the entire point.
+ *
+ * The cost, stated rather than hidden: Node has no module unloader, so
+ * each superseded module object stays allocated and unreachable for the
+ * life of the process — one per extension file per reload. The only
+ * real resources an extension holds are its MCP servers, and those are
+ * torn down by `disposeExtensions`, which whoever loaded them owes.
+ */
+let loadSerial = 0;
 export async function loadExtensions(dir) {
     let files;
     try {
@@ -39,10 +60,11 @@ export async function loadExtensions(dir) {
         throw err;
     }
     const out = [];
+    const serial = ++loadSerial; // one nonce per CALL — a directory's files load together
     for (const file of files) {
         let ext;
         try {
-            const mod = (await import(pathToFileURL(join(dir, file)).href));
+            const mod = (await import(`${pathToFileURL(join(dir, file)).href}?load=${serial}`));
             ext = mod.default;
             if (typeof ext === "function")
                 ext = await ext(); // a factory

package/dist/idle-guard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LT-1 — the stream watchdog (kiso-doc/kiso-lt1-mini-spec-2026-09-09.md).
+ *
+ * The third guard beside `truncationGuard` and `traceGuard`: it wraps the
+ * adapter's `stream()` so that a request whose events STOP ARRIVING is
+ * ended rather than waited on forever. Before this, a model stream that
+ * went silent — a hung socket, an upstream that stopped writing without
+ * closing — held the run open until a human pressed esc; the 0.31.0
+ * review filed it as the one long-task hazard nothing handled.
+ *
+ * The rule is per EVENT, not per request: a long think that keeps
+ * streaming is never tripped, a socket that stops is tripped `idleMs`
+ * after its last byte. On a trip the guard aborts the UNDERLYING request
+ * through a controller it owns (combined with the caller's signal, so
+ * esc still wins) and throws a retryable `network` StructuredError. From
+ * there the kernel's existing mid-stream retry does the rest: the
+ * attempt is voided (`model_output_abandoned` with this reason), the
+ * request is retried with backoff, and when the budget is spent the run
+ * ends in the error terminal the CLI prints (OR-5). Nothing new is
+ * written to the log; the kernel is untouched.
+ *
+ * `idleMs` ≤ 0 (or absent) returns the adapter itself: the guard is
+ * declared off, not silently ignored.
+ */
+import type { Adapter, StructuredError } from "@vincemakes/kiso-core";
+/** The default: 120 s between events. The ChatGPT backend at a high effort
+ *  can think without writing (no reasoning summaries are requested), and
+ *  no measured bound exists for an `ultra` turn — 120 s is the order of
+ *  magnitude the reference implementation allows a whole request, applied
+ *  here per event: stricter where it matters, looser where it should be.
+ *  A knob (`streamIdleMs` on the profile) because the first dogfood may
+ *  move it. */
+export declare const DEFAULT_STREAM_IDLE_MS = 120000;
+export declare function idleGuard(adapter: Adapter, idleMs: number | undefined): Adapter;
+/** The error the kernel receives on a trip — the same shape the adapters
+ *  produce for a connection failure, so the retry authority (ADR-0005)
+ *  treats a stall exactly like a dropped socket. */
+export declare function stalledError(idleMs: number, elapsedMs: number): StructuredError;

package/dist/idle-guard.js

@@ -0,0 +1,122 @@
+/**
+ * LT-1 — the stream watchdog (kiso-doc/kiso-lt1-mini-spec-2026-09-09.md).
+ *
+ * The third guard beside `truncationGuard` and `traceGuard`: it wraps the
+ * adapter's `stream()` so that a request whose events STOP ARRIVING is
+ * ended rather than waited on forever. Before this, a model stream that
+ * went silent — a hung socket, an upstream that stopped writing without
+ * closing — held the run open until a human pressed esc; the 0.31.0
+ * review filed it as the one long-task hazard nothing handled.
+ *
+ * The rule is per EVENT, not per request: a long think that keeps
+ * streaming is never tripped, a socket that stops is tripped `idleMs`
+ * after its last byte. On a trip the guard aborts the UNDERLYING request
+ * through a controller it owns (combined with the caller's signal, so
+ * esc still wins) and throws a retryable `network` StructuredError. From
+ * there the kernel's existing mid-stream retry does the rest: the
+ * attempt is voided (`model_output_abandoned` with this reason), the
+ * request is retried with backoff, and when the budget is spent the run
+ * ends in the error terminal the CLI prints (OR-5). Nothing new is
+ * written to the log; the kernel is untouched.
+ *
+ * `idleMs` ≤ 0 (or absent) returns the adapter itself: the guard is
+ * declared off, not silently ignored.
+ */
+/** The default: 120 s between events. The ChatGPT backend at a high effort
+ *  can think without writing (no reasoning summaries are requested), and
+ *  no measured bound exists for an `ultra` turn — 120 s is the order of
+ *  magnitude the reference implementation allows a whole request, applied
+ *  here per event: stricter where it matters, looser where it should be.
+ *  A knob (`streamIdleMs` on the profile) because the first dogfood may
+ *  move it. */
+export const DEFAULT_STREAM_IDLE_MS = 120_000;
+export function idleGuard(adapter, idleMs) {
+    if (idleMs === undefined || !(idleMs > 0))
+        return adapter;
+    return {
+        stream: (options) => guardStream(adapter, options, idleMs),
+    };
+}
+/** The error the kernel receives on a trip — the same shape the adapters
+ *  produce for a connection failure, so the retry authority (ADR-0005)
+ *  treats a stall exactly like a dropped socket. */
+export function stalledError(idleMs, elapsedMs) {
+    return {
+        code: "network",
+        retryable: true,
+        message: `stream stalled: no event for ${Math.round(idleMs / 1000)}s (${Math.round(elapsedMs / 1000)}s into the request)`,
+    };
+}
+/** The caller's abort, as the kernel's catch reads it: an error NAMED
+ *  AbortError with the signal set — `aborted by user`, never a stall. */
+function abortError() {
+    const err = new Error("stream aborted by the caller");
+    err.name = "AbortError";
+    return err;
+}
+async function* guardStream(adapter, options, idleMs) {
+    const own = new AbortController();
+    const caller = options.signal;
+    // the caller's abort (esc) reaches the adapter through OUR controller —
+    // one signal goes down — and it also settles OUR wait at once: an
+    // adapter that ignores its signal (a stub, a transport that only
+    // notices on the next write) must not turn the caller's abort into a
+    // stall by keeping the guard waiting until the idle timer fires.
+    let rejectOnCallerAbort = () => undefined;
+    const callerAborted = new Promise((_, reject) => {
+        rejectOnCallerAbort = reject;
+    });
+    callerAborted.catch(() => undefined); // settled only when raced; never an unhandled rejection
+    const onCallerAbort = () => {
+        own.abort();
+        rejectOnCallerAbort(abortError());
+    };
+    if (caller?.aborted === true)
+        onCallerAbort();
+    else
+        caller?.addEventListener("abort", onCallerAbort, { once: true });
+    const iterator = adapter.stream({ ...options, signal: own.signal })[Symbol.asyncIterator]();
+    const started = Date.now();
+    let tripped = false;
+    try {
+        for (;;) {
+            let timer;
+            const stall = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    if (caller?.aborted === true) {
+                        // the caller gave up first; the silence is theirs, not a stall
+                        reject(abortError());
+                        return;
+                    }
+                    tripped = true;
+                    own.abort();
+                    reject(stalledError(idleMs, Date.now() - started));
+                }, idleMs);
+            });
+            let next;
+            try {
+                next = await Promise.race([iterator.next(), stall, callerAborted]);
+            }
+            catch (err) {
+                // an abort the CALLER asked for is theirs (the kernel reads its
+                // own signal and records `aborted by user`); an abort WE caused
+                // is the stall, whatever shape the adapter turned it into
+                if (tripped && caller?.aborted !== true)
+                    throw stalledError(idleMs, Date.now() - started);
+                throw err;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    finally {
+        caller?.removeEventListener("abort", onCallerAbort);
+        // release the underlying generator whichever way this one ends
+        // (a trip, the caller's abort, or the consumer walking away)
+        await iterator.return?.().catch(() => undefined);
+    }
+}

package/dist/provider/metadata.d.ts

@@ -24,8 +24,15 @@ export interface ModelCapabilities {
     readonly maxOutputTokens: number | null;
     /** "automatic" — the provider caches without request markup (DeepSeek,
      *  OpenAI); "explicit" — the request must place cache_control
-     *  breakpoints (Anthropic); "none" — no caching; null = unknown. */
-    readonly promptCaching: "none" | "automatic" | "explicit" | null;
+     *  breakpoints (Anthropic); "none" — no caching; "unobservable" — the
+     *  endpoint answers a cache figure that carries no information (OR-10,
+     *  owner 2026-09-09: the ChatGPT backend reports `cached_tokens` 0 to
+     *  a third-party client on every request — three identical 1,922-token
+     *  requests, one prompt_cache_key, 0 at every attribution level — so
+     *  its 0 and "not reported" are one value; a display shows no cache
+     *  meter for such a row, while the record keeps what the backend
+     *  said); null = unknown. */
+    readonly promptCaching: "none" | "automatic" | "explicit" | "unobservable" | null;
     /** XP-1: the reasoning capability matrix — supersedes the pre-XP-1
      *  boolean IN PLACE (zero consumers existed, verified). null = unknown:
      *  no mode list, no effort levels, nothing downstream may guess. */
@@ -43,8 +50,10 @@ export interface ModelCapabilities {
  *  some model/effort combinations forbid thinking-disabled. */
 export type ThinkingMode = "default" | "adaptive" | "enabled" | "disabled";
 /** `none` is the OpenAI Responses dialect's zero-reasoning level — a NATIVE
- *  value a request carries, distinct from "default" (no field sent). */
-export type ReasoningEffort = "default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+ *  value a request carries, distinct from "default" (no field sent).
+ *  `ultra` (OR-6) is the vendor CLI presets' top rung for the ChatGPT
+ *  backend — native THERE only; the first-party model pages stop at `max`. */
+export type ReasoningEffort = "default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "ultra";
 export interface ReasoningSetting {
     readonly thinking: ThinkingMode;
     readonly effort: ReasoningEffort;

package/dist/provider/metadata.js

@@ -102,42 +102,45 @@ const OPENAI_MODELS_ASOF = "2026-09-08";
  *  subscription; a first-party model page says nothing about that backend). */
 const CHATGPT_PRESETS_SOURCE = "https://github.com/openai/codex/blob/37f4bb94c9f4e180535a12e3f2c2f93f4a773df0/codex-rs/models-manager/models.json";
 const RESPONSES_WIRE = "reasoning.effort";
-/** A first-party Responses row: the model page is the source for the
- *  levels, the window, the output cap and the price alike (read the same
- *  day). The adapter asks for no reasoning summaries (encrypted items
- *  only), so no thinking stream is emitted. */
-const openaiRow = (model, effortDefault, rate, page) => ({
+const openaiRow = (model, effortDefault, rate, page, opts = {}) => ({
     model,
     providerId: "openai",
     endpoint: "https://api.openai.com",
     capabilities: { contextWindow: 1_050_000, maxOutputTokens: 128_000, promptCaching: "automatic", reasoning: {
             emitsThinkingStream: false,
             thinking: null,
-            effort: { levels: ["none", "low", "medium", "high", "xhigh"], default: effortDefault, wire: RESPONSES_WIRE },
-            asOf: OPENAI_MODELS_ASOF,
+            effort: { levels: opts.levels ?? ["none", "low", "medium", "high", "xhigh"], default: effortDefault, wire: RESPONSES_WIRE },
+            asOf: opts.asOf ?? OPENAI_MODELS_ASOF,
             source: page,
         }, inputModalities: null },
-    capabilitiesAsOf: OPENAI_MODELS_ASOF,
+    capabilitiesAsOf: opts.asOf ?? OPENAI_MODELS_ASOF,
     capabilitiesSource: page,
-    pricing: { ...rate, cacheWritePerM: 0, asOf: OPENAI_MODELS_ASOF, source: page },
+    pricing: { ...rate, cacheWritePerM: 0, asOf: opts.asOf ?? OPENAI_MODELS_ASOF, source: page },
 });
 /** The subscription backend's row for the same id: the presets' four
- *  levels (no `none`), the presets' context window, no price. */
-const chatgptRow = (model) => ({
+ *  levels (no `none`), the presets' context window, no price, and a cache
+ *  figure no client can observe (OR-10 — see ModelCapabilities). */
+const chatgptRow = (model, opts = {}) => ({
     model,
     providerId: "chatgpt",
     endpoint: "https://chatgpt.com",
-    capabilities: { contextWindow: 272_000, maxOutputTokens: null, promptCaching: null, reasoning: {
+    capabilities: { contextWindow: 272_000, maxOutputTokens: null, promptCaching: "unobservable", reasoning: {
             emitsThinkingStream: false,
             thinking: null,
-            effort: { levels: ["low", "medium", "high", "xhigh"], default: "medium", wire: RESPONSES_WIRE },
-            asOf: OPENAI_MODELS_ASOF,
-            source: CHATGPT_PRESETS_SOURCE,
+            effort: { levels: opts.levels ?? ["low", "medium", "high", "xhigh"], default: opts.default ?? "medium", wire: RESPONSES_WIRE },
+            asOf: opts.asOf ?? OPENAI_MODELS_ASOF,
+            source: opts.source ?? CHATGPT_PRESETS_SOURCE,
         }, inputModalities: null },
-    capabilitiesAsOf: OPENAI_MODELS_ASOF,
-    capabilitiesSource: CHATGPT_PRESETS_SOURCE,
+    capabilitiesAsOf: opts.asOf ?? OPENAI_MODELS_ASOF,
+    capabilitiesSource: opts.source ?? CHATGPT_PRESETS_SOURCE,
     pricing: null,
 });
+/** OR-6 (2026-09-09): the newer line, read the same day — the model pages for
+ *  the first-party rows, the presets pinned to a later commit for the
+ *  subscription rows (both ids answered on the backend that day). */
+const OPENAI_MODELS_ASOF_2 = "2026-09-09";
+const CHATGPT_PRESETS_SOURCE_2 = "https://github.com/openai/codex/blob/634ebc1865c6ac840ed3ba118f040d527bf4b55d/codex-rs/models-manager/models.json";
+const ULTRA_LADDER = ["low", "medium", "high", "xhigh", "max", "ultra"];
 /** The v1 table. Nulls outnumber numbers ON PURPOSE: only values with a
  *  named source enter; everything else waits for one. */
 const ENTRIES = [
@@ -232,6 +235,47 @@ const ENTRIES = [
     openaiRow("gpt-5.4", "none", { inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 }, "https://developers.openai.com/api/docs/models/gpt-5.4"),
     chatgptRow("gpt-5.5"),
     chatgptRow("gpt-5.4"),
+    // OR-6 (2026-09-09): gpt-6-astra and gpt-5.6-sol. The astra page names
+    // no default, so the first-party default stays null (unknown is null);
+    // the presets say `low` at the subscription. `ultra` exists only there.
+    // The ordering keeps the first-party row first for endpoint-less
+    // callers; the run-side resolver passes the endpoint (45a9df5), so the
+    // two rows need not be nested — astra's subscription row has a level
+    // (ultra) its first-party row lacks.
+    openaiRow("gpt-6-astra", null, { inputPerM: 10, outputPerM: 50, cacheReadPerM: 1 }, "https://developers.openai.com/api/docs/models/gpt-6-astra", { levels: ["low", "medium", "high", "xhigh", "max"], asOf: OPENAI_MODELS_ASOF_2 }),
+    openaiRow("gpt-5.6-sol", "medium", { inputPerM: 4, outputPerM: 20, cacheReadPerM: 0.4 }, "https://developers.openai.com/api/docs/models/gpt-5.6-sol", { levels: ["none", "low", "medium", "high", "xhigh", "max"], asOf: OPENAI_MODELS_ASOF_2 }),
+    chatgptRow("gpt-6-astra", { levels: ULTRA_LADDER, default: "low", source: CHATGPT_PRESETS_SOURCE_2, asOf: OPENAI_MODELS_ASOF_2 }),
+    chatgptRow("gpt-5.6-sol", { levels: ULTRA_LADDER, default: "low", source: CHATGPT_PRESETS_SOURCE_2, asOf: OPENAI_MODELS_ASOF_2 }),
+    // The compat table's SECOND row (roadmap R3.2 §1a step 1): GLM 5.3 Flash
+    // through OpenRouter, read from OpenRouter's models API on 2026-09-09. The
+    // id is OpenRouter's, so the row is keyed to that origin; the
+    // continuation scope stamps such a profile `custom` at openrouter.ai
+    // (manifest.ts's KNOWN_ORIGINS is deliberately not widened — the scope
+    // identity is a durable fact and this row needs only the lookup). The
+    // window is the TOP provider's (1,048,576), not the listing's 1,310,720:
+    // what a request actually gets. No default effort — the page states
+    // none. `reasoning_effort` is in the model's supported parameters; the
+    // stream's think arrives as `reasoning` (GLM-F1, the compat adapter).
+    {
+        model: "z-ai/glm-5.3-flash",
+        endpoint: "https://openrouter.ai",
+        capabilities: {
+            contextWindow: 1_048_576,
+            maxOutputTokens: 131_072,
+            promptCaching: "automatic",
+            reasoning: {
+                emitsThinkingStream: true,
+                thinking: null,
+                effort: { levels: ["low", "medium", "high"], default: null, wire: "reasoning_effort" },
+                asOf: "2026-09-09",
+                source: "https://openrouter.ai/docs/use-cases/reasoning-tokens",
+            },
+            inputModalities: null,
+        },
+        capabilitiesAsOf: "2026-09-09",
+        capabilitiesSource: "https://openrouter.ai/api/v1/models",
+        pricing: { inputPerM: 0.075, outputPerM: 0.25, cacheReadPerM: 0.015, cacheWritePerM: 0, asOf: "2026-09-09", source: "https://openrouter.ai/api/v1/models" },
+    },
 ];
 /**
  * Look a model up. `endpoint` narrows: an entry WITH an endpoint only

package/dist/run.js

@@ -9,6 +9,7 @@ import { resolveReasoning } from "./provider/metadata.js";
 import { deriveRecoveryPlan, invocationSeqOf } from "./recovery-plan.js";
 import { composeApprovalChain, composeSystemPrompt, composeToolTable, microcompactFor } from "./compose.js";
 import { truncationGuard } from "./truncation-guard.js";
+import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { RequestTracer, traceGuard } from "./trace/guard.js";
 import { runtimeVersion } from "./trace/writer.js";
 import { ResumeBlockedError } from "./session.js";
@@ -121,7 +122,10 @@ export class Run {
             const loopConfig = () => ({
                 // 0.1.40 (R-C item 3): the truncation guard gates the model
                 // stream — a truncated turn's tool batch never executes.
-                adapter: traceGuard(tracer, truncationGuard(this.#adapter)), // tracer assigned above, before loopConfig
+                // LT-1: the idle guard sits closest to the adapter — a stall is
+                // aborted and thrown there, the truncation guard and the tracer see
+                // the same events and the same error every other transport failure shows them.
+                adapter: traceGuard(tracer, truncationGuard(idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS))), // tracer assigned above, before loopConfig
                 model: this.#config.model,
                 sessionId: this.#session.id, // P3: tools see their session (ToolContext.sessionId)
                 ...(systemPrompt !== undefined ? { systemPrompt } : {}),

package/dist/session.d.ts

@@ -414,6 +414,8 @@ export interface SessionConfig {
     /** E6: the session context policy (run-start actions, injection-side only). */
     readonly contextPolicy?: ContextPolicy;
     readonly maxRetries?: number;
+    /** LT-1: the stream watchdog's idle bound (ms); default 120 s, 0 off. */
+    readonly streamIdleMs?: number;
     /**
      * E1: loaded extensions — their tools join the registry (idempotently;
      * a collision with a built-in name was already rejected at agent

package/dist/session.js

@@ -47,6 +47,7 @@ import { Run } from "./run.js";
 // TUI2-R3v2 ③ — the side query rides the SAME tracer the runs ride; that
 // sameness is the whole point (one ledger, one shape, no second path).
 import { RequestTracer, traceGuard } from "./trace/guard.js";
+import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { runtimeVersion } from "./trace/writer.js";
 /** A session whose disk write was rejected (stale handle) is PERMANENTLY
  * poisoned: its in-memory log no longer matches the disk, so no further
@@ -338,7 +339,8 @@ export class AgentSession {
             rentParts: { base: options.systemPrompt, appends: [] },
         });
         tracer.init();
-        const guarded = traceGuard(tracer, this.#adapter);
+        // LT-1: the summary request is a model stream too — the same watchdog
+        const guarded = traceGuard(tracer, idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS));
         let text = "";
         try {
             for await (const ev of guarded.stream({

package/package.json

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