@msm-core/mini 0.4.1 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,68 @@ Follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.5.0] — 2026-06-30
+
+Brain-parity + guard-integrity release from the 2026-06 SDK audit (H1, H2, H10, M1).
+Every fix ships with a test.
+
+### Fixed
+
+- **(H1) The Anthropic brain now folds prior tool results into the turn.** Only
+  OpenAI/Gemini did this; Anthropic re-sent just the raw message, so Claude never
+  saw what its tool calls returned, re-emitted `use_tool` every iteration to the
+  guard cap, and the loop's force-finalize answer was ungrounded. All four brains
+  now share one helper (`brain/tool-context.ts`) for both the fold+finalize-nudge
+  and the tool→JSON-Schema mapping. The Anthropic mapping also **no longer drops
+  `enum`** — enum-constrained parameters were previously unconstrained there.
+- **(H2) The Ollama brain now supports tools.** It ignored `input.tools` entirely
+  and hard-coded `action:"respond"`, so tool-capable agents on `provider:"ollama"`
+  silently never called a tool — a capability loss precisely on the sovereign /
+  air-gapped path. It now sends the OpenAI-style `tools` schema to `/api/chat` and
+  parses `message.tool_calls` into a `use_tool` orchestration.
+- **(H10) Guard limits no longer silently disable on `NaN`/garbage.** `resolveGuards`
+  merged with `??`, which only falls back on null/undefined — so a `NaN` (e.g. a
+  typo'd agent.md limit → `Number("foo")`), `Infinity`, or a non-number slipped
+  through, and `iteration >= NaN` / `cost > NaN` / `timeout > NaN` are all `false`,
+  turning those caps OFF. Values are now coerced with `Number.isFinite`, fall back
+  to the default when non-finite, and are **clamped to sane bounds** (so an absurd
+  override — in-process or over HTTP — can't remove a cap either). The definition
+  parser hardens its `## Limits` numbers the same way (`safeNum`).
+
+### Changed
+
+- **(M1) The agent.md `## Limits` block is now applied.** It was parsed into
+  `AgentDefinition.limits` but never reached the runtime guards (`resolveGuards`
+  read only `config.guards`), so documented limits silently no-op'd. Guard
+  precedence is now: **defaults < `## Limits` < explicit `config.guards` <
+  per-event `guardsOverride`**. ⚠️ Behavior change: an agent.md that declares a
+  `## Limits` value not also set in `config.guards` will now have that limit take
+  effect. Set the same field in `config.guards` to override.
+
+### Added
+
+- **(H11) `InMemoryRedis` — a correct single-node `RedisLike`** for local /
+  no-Redis / sovereign / air-gapped deploys, exported from `@msm-core/mini/adapters`
+  (`createInMemoryRedis()`). The SDK previously shipped only Redis-backed adapters,
+  forcing consumers to hand-roll a shim — and those shims returned `"OK"` on every
+  `set` and ignored `NX`/`PX`, so the per-session `RedisDistributedLock` ALWAYS
+  "succeeded" and two concurrent turns on one session ran against shared history.
+  This adapter honors `SET … NX/XX/PX/EX`, lazily expires keys, and implements the
+  lock's compare-and-del / compare-and-pexpire `eval` scripts, so the single-flight
+  lock actually holds. (One process only; use real Redis for multi-replica.)
+- **`{ substituteParams }` onBeforeTool directive** — the hook can now run the tool
+  with overridden, re-validated params (dedup keys off the new params). This is what
+  lets `@msm-core/gate`'s `approved_with_edits` apply an operator's edits in-flight;
+  previously the hook could only `proceed` (original params) or `substituteResult`.
+- `brain/tool-context.ts` — `foldToolResults()` + `toolParamsToJsonSchema()`, the
+  shared per-provider tool-context helpers.
+- Tests: Ollama tool-calling + fold (mocked fetch), the shared helpers, `resolveGuards`
+  NaN/Infinity/clamp/deliberate-0 cases, a loop-level proof that `## Limits` applies
+  (and `config.guards` overrides it), and `InMemoryRedis` incl. lock mutual exclusion.
+  78 → **103** tests.
+
+---
+
 ## [0.4.0] — 2026-06-10
 
 Production-hardening release — the sdk is now the default in-house agent runtime.

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2026 MSM / UTS. All rights reserved.
+
+PROPRIETARY AND CONFIDENTIAL
+
+This package (@msm-core/mini) and its contents (the "Software") are the proprietary and
+confidential property of MSM / UTS ("the Owner").
+
+No license, right, or permission is granted to any party to use, copy, modify,
+merge, publish, distribute, sublicense, sell, or create derivative works of the
+Software, in whole or in part, except under a separate written agreement signed
+by the Owner.
+
+This package is published to the public npm registry solely to enable
+installation as a runtime dependency. Such publication is NOT a grant of any
+license to its source. The package is "UNLICENSED" (proprietary) as declared in
+its manifest. Reproducing, reverse engineering, or redistributing it is not
+permitted.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.

package/dist/adapters/index.d.ts

@@ -6,6 +6,7 @@ export type { SessionMetadata } from "./redis-memory.js";
 export { RedisControlBus } from "./redis-control.js";
 export { RedisDistributedLock } from "./redis-lock.js";
 export type { LockHandle } from "./redis-lock.js";
+/** Correct single-node RedisLike for local / no-Redis / sovereign deploys + tests. */
+export { InMemoryRedis, createInMemoryRedis } from "./memory-redis.js";
 /** The client shape RedisConfig.client expects — for wiring a custom client. */
 export type { RedisLike } from "./redis-types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.js

@@ -4,4 +4,5 @@
 export { RedisMemory, connectRedis } from "./redis-memory.js";
 export { RedisControlBus } from "./redis-control.js";
 export { RedisDistributedLock } from "./redis-lock.js";
-//# sourceMappingURL=index.js.map
+/** Correct single-node RedisLike for local / no-Redis / sovereign deploys + tests. */
+export { InMemoryRedis, createInMemoryRedis } from "./memory-redis.js";

package/dist/adapters/memory-redis.d.ts

@@ -0,0 +1,38 @@
+/**
+ * In-memory RedisLike — a CORRECT single-node implementation of the subset of
+ * Redis that @msm-core/mini uses, for local / no-Redis / sovereign / air-gapped
+ * deploys and for tests. It exists because the SDK previously shipped ONLY
+ * Redis-backed adapters, forcing consumers to hand-roll a `RedisLike` shim — and
+ * those shims got the lock wrong: they returned "OK" on every `set` and ignored
+ * `NX`/`PX`, so `RedisDistributedLock.acquire()` ALWAYS succeeded and two
+ * concurrent turns on the same session ran against shared history (the exact race
+ * the per-session lock exists to prevent).
+ *
+ * This implementation honors `SET ... NX/XX/PX/EX`, lazily expires keys, and
+ * implements the lock's compare-and-del / compare-and-pexpire `eval` scripts —
+ * so the single-flight session lock actually holds.
+ *
+ * Scope: ONE process. It is not distributed (no cross-process mutual exclusion);
+ * for multi-replica deployments use a real Redis. Within a process it is correct.
+ */
+import type { RedisLike } from "./redis-types.js";
+export declare class InMemoryRedis implements RedisLike {
+    private kv;
+    private lists;
+    private hashes;
+    /** Return the live entry for a key, lazily evicting it if its TTL has passed. */
+    private alive;
+    get(key: string): Promise<string | null>;
+    set(...args: unknown[]): Promise<unknown>;
+    setex(key: string, seconds: number, value: string): Promise<unknown>;
+    del(key: string | string[]): Promise<unknown>;
+    rpush(key: string, ...values: string[]): Promise<unknown>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    ltrim(key: string, start: number, stop: number): Promise<unknown>;
+    expire(key: string, seconds: number): Promise<unknown>;
+    hget(key: string, field: string): Promise<string | null>;
+    hset(key: string, field: string, value: string): Promise<unknown>;
+    eval(script: string, numkeys: number, ...args: unknown[]): Promise<unknown>;
+}
+/** Convenience factory — `redis: { client: createInMemoryRedis() }`. */
+export declare function createInMemoryRedis(): InMemoryRedis;

package/dist/adapters/memory-redis.js

@@ -0,0 +1,131 @@
+/** Normalize Redis-style list indices (supports negatives) to a slice range. */
+function sliceRange(len, start, stop) {
+    let s = start < 0 ? Math.max(len + start, 0) : start;
+    let e = stop < 0 ? len + stop : Math.min(stop, len - 1);
+    if (s < 0)
+        s = 0;
+    return [s, e];
+}
+export class InMemoryRedis {
+    kv = new Map();
+    lists = new Map();
+    hashes = new Map();
+    /** Return the live entry for a key, lazily evicting it if its TTL has passed. */
+    alive(key) {
+        const e = this.kv.get(key);
+        if (!e)
+            return null;
+        if (e.expiresAt !== null && e.expiresAt <= Date.now()) {
+            this.kv.delete(key);
+            return null;
+        }
+        return e;
+    }
+    async get(key) {
+        return this.alive(key)?.value ?? null;
+    }
+    // Supports `set(k, v)`, `set(k, v, "EX", s)`, `set(k, v, "PX", ms)`, and the
+    // lock's `set(k, token, "PX", ms, "NX")`. Flags may appear in any order.
+    async set(...args) {
+        const [key, value, ...opts] = args;
+        let px = null;
+        let nx = false;
+        let xx = false;
+        for (let i = 0; i < opts.length; i++) {
+            const flag = String(opts[i]).toUpperCase();
+            if (flag === "PX")
+                px = Number(opts[++i]);
+            else if (flag === "EX")
+                px = Number(opts[++i]) * 1000;
+            else if (flag === "NX")
+                nx = true;
+            else if (flag === "XX")
+                xx = true;
+        }
+        const existing = this.alive(key);
+        if (nx && existing)
+            return null; // NX: set only if absent → acquire fails when held
+        if (xx && !existing)
+            return null; // XX: set only if present
+        this.kv.set(key, { value, expiresAt: px !== null && Number.isFinite(px) ? Date.now() + px : null });
+        return "OK";
+    }
+    async setex(key, seconds, value) {
+        this.kv.set(key, { value, expiresAt: Date.now() + seconds * 1000 });
+        return "OK";
+    }
+    async del(key) {
+        let n = 0;
+        for (const k of Array.isArray(key) ? key : [key]) {
+            if (this.kv.delete(k))
+                n++;
+            this.lists.delete(k);
+            this.hashes.delete(k);
+        }
+        return n;
+    }
+    async rpush(key, ...values) {
+        const list = this.lists.get(key) ?? [];
+        list.push(...values);
+        this.lists.set(key, list);
+        return list.length;
+    }
+    async lrange(key, start, stop) {
+        const list = this.lists.get(key) ?? [];
+        const [s, e] = sliceRange(list.length, start, stop);
+        if (s > e || s >= list.length)
+            return [];
+        return list.slice(s, e + 1);
+    }
+    async ltrim(key, start, stop) {
+        const list = this.lists.get(key) ?? [];
+        const [s, e] = sliceRange(list.length, start, stop);
+        this.lists.set(key, s > e || s >= list.length ? [] : list.slice(s, e + 1));
+        return "OK";
+    }
+    async expire(key, seconds) {
+        const e = this.alive(key);
+        if (!e)
+            return 0;
+        e.expiresAt = Date.now() + seconds * 1000;
+        return 1;
+    }
+    async hget(key, field) {
+        return this.hashes.get(key)?.get(field) ?? null;
+    }
+    async hset(key, field, value) {
+        const h = this.hashes.get(key) ?? new Map();
+        const isNew = !h.has(field);
+        h.set(field, value);
+        this.hashes.set(key, h);
+        return isNew ? 1 : 0;
+    }
+    // The two Lua scripts the lock uses are compare-and-act on a single key. We
+    // recognize them by content (the only eval the runtime issues) and implement
+    // the same check-token-then-act semantics so release()/extend() are safe.
+    async eval(script, numkeys, ...args) {
+        const keys = args.slice(0, numkeys);
+        const argv = args.slice(numkeys);
+        const key = keys[0];
+        if (!key)
+            return 0;
+        const token = argv[0];
+        const current = this.alive(key)?.value ?? null;
+        if (current !== token)
+            return 0; // token mismatch → not our lock; do nothing
+        if (script.includes("pexpire")) {
+            // EXTEND: compare-and-pexpire
+            const entry = this.kv.get(key);
+            if (entry)
+                entry.expiresAt = Date.now() + Number(argv[1]);
+            return 1;
+        }
+        // RELEASE: compare-and-del
+        this.kv.delete(key);
+        return 1;
+    }
+}
+/** Convenience factory — `redis: { client: createInMemoryRedis() }`. */
+export function createInMemoryRedis() {
+    return new InMemoryRedis();
+}

package/dist/adapters/redis-control.d.ts

@@ -22,4 +22,3 @@ export declare class RedisControlBus {
     /** Returns the disabled tool name if the command is disable, else null */
     static disabledTool(command: string | null): string | null;
 }
-//# sourceMappingURL=redis-control.d.ts.map

package/dist/adapters/redis-control.js

@@ -45,4 +45,3 @@ export class RedisControlBus {
         return command.slice("disabled:".length);
     }
 }
-//# sourceMappingURL=redis-control.js.map

package/dist/adapters/redis-lock.d.ts

@@ -28,4 +28,3 @@ export declare class RedisDistributedLock {
      */
     acquireWithRetry(sessionId: string, ttlMs: number, waitMs?: number, retryInterval?: number): Promise<LockHandle>;
 }
-//# sourceMappingURL=redis-lock.d.ts.map

package/dist/adapters/redis-lock.js

@@ -70,4 +70,3 @@ export class RedisDistributedLock {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=redis-lock.js.map

package/dist/adapters/redis-memory.d.ts

@@ -42,4 +42,3 @@ export declare class RedisMemory {
 }
 /** Connect to Redis using ioredis (peer dependency) */
 export declare function connectRedis(url: string): Promise<RedisLike>;
-//# sourceMappingURL=redis-memory.d.ts.map

package/dist/adapters/redis-memory.js

@@ -90,4 +90,3 @@ export async function connectRedis(url) {
     const Redis = (mod.default ?? mod);
     return new Redis(url);
 }
-//# sourceMappingURL=redis-memory.js.map

package/dist/adapters/redis-types.d.ts

@@ -16,4 +16,3 @@ export interface RedisLike {
     hset(key: string, field: string, value: string): Promise<unknown>;
     eval(script: string, numkeys: number, ...args: any[]): Promise<unknown>;
 }
-//# sourceMappingURL=redis-types.d.ts.map

package/dist/adapters/redis-types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=redis-types.js.map

package/dist/brain/anthropic.d.ts

@@ -7,4 +7,3 @@ export declare function createAnthropicBrain(opts: {
     apiKey?: string;
     model?: string;
 }): Brain;
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/brain/anthropic.js

@@ -4,6 +4,7 @@
  */
 import { computeCostUsd } from "./pricing.js";
 import { withRetry } from "./retry.js";
+import { foldToolResults, toolParamsToJsonSchema } from "./tool-context.js";
 export function createAnthropicBrain(opts) {
     // claude-3-5-sonnet-20241022 was retired (2025-10-28); claude-sonnet-4-6 is
     // its current drop-in replacement.
@@ -27,21 +28,16 @@ export function createAnthropicBrain(opts) {
                 role: m.role === "assistant" ? "assistant" : "user",
                 content: m.content,
             }));
-            messages.push({ role: "user", content: input.raw });
+            // Fold prior tool results into the current turn so Claude sees what its
+            // tool calls returned (and is nudged to finalize) — without this it
+            // re-emits use_tool every iteration until the guard cap (H1).
+            messages.push({ role: "user", content: foldToolResults(input.raw, input.tool_results) });
             const tools = input.tools.length > 0
                 ? input.tools.map((t) => ({
                     name: t.name,
                     description: t.description,
-                    input_schema: {
-                        type: "object",
-                        properties: Object.fromEntries(Object.entries(t.parameters).map(([k, v]) => [
-                            k,
-                            { type: v.type, description: v.description },
-                        ])),
-                        required: Object.entries(t.parameters)
-                            .filter(([, v]) => v.required)
-                            .map(([k]) => k),
-                    },
+                    // toolParamsToJsonSchema keeps `enum` (the inline mapping dropped it).
+                    input_schema: toolParamsToJsonSchema(t.parameters),
                 }))
                 : undefined;
             const baseParams = {
@@ -87,4 +83,3 @@ export function createAnthropicBrain(opts) {
         },
     };
 }
-//# sourceMappingURL=anthropic.js.map

package/dist/brain/factory.d.ts

@@ -4,4 +4,3 @@
  */
 import type { Brain, AgentDefinition } from "../core/types.js";
 export declare function buildBrain(def: AgentDefinition): Brain;
-//# sourceMappingURL=factory.d.ts.map

package/dist/brain/factory.js

@@ -21,4 +21,3 @@ export function buildBrain(def) {
             throw new Error(`msm-mini: unknown brain provider "${String(provider)}". Pass a Brain instance directly to createAgent().`);
     }
 }
-//# sourceMappingURL=factory.js.map

package/dist/brain/gemini.d.ts

@@ -7,4 +7,3 @@ export declare function createGeminiBrain(opts: {
     apiKey?: string;
     model?: string;
 }): Brain;
-//# sourceMappingURL=gemini.d.ts.map

package/dist/brain/gemini.js

@@ -3,6 +3,7 @@
  * Peer dependency: @google/generative-ai >= 0.14.0
  */
 import { withRetry } from "./retry.js";
+import { foldToolResults } from "./tool-context.js";
 export function createGeminiBrain(opts) {
     const model = opts.model ?? "gemini-2.5-flash";
     return {
@@ -40,6 +41,7 @@ export function createGeminiBrain(opts) {
                                         type: v.type.toUpperCase(),
                                         description: v.description,
                                         ...(v.enum ? { enum: v.enum } : {}),
+                                        ...(v.items ? { items: { type: v.items.type.toUpperCase() } } : {}),
                                     },
                                 ])),
                                 required: Object.entries(t.parameters)
@@ -107,15 +109,8 @@ function buildGeminiContents(input) {
         const role = msg.role === "assistant" ? "model" : "user";
         contents.push({ role, parts: [{ text: msg.content }] });
     }
-    // Current user message
-    let userText = input.raw;
-    if (input.tool_results?.length) {
-        const resultSummary = input.tool_results
-            .map((r) => `[${r.tool}] ${r.status}: ${JSON.stringify(r.result ?? r.error)}`)
-            .join("\n");
-        userText = `Tool results:\n${resultSummary}\n\n${input.raw}`;
-    }
+    // Current user message — shared fold + finalize nudge (parity with all brains).
+    const userText = foldToolResults(input.raw, input.tool_results);
     contents.push({ role: "user", parts: [{ text: userText }] });
     return contents;
 }
-//# sourceMappingURL=gemini.js.map

package/dist/brain/ollama.d.ts

@@ -7,4 +7,3 @@ export declare function createOllamaBrain(opts: {
     endpoint?: string;
     model?: string;
 }): Brain;
-//# sourceMappingURL=ollama.d.ts.map

package/dist/brain/ollama.js

@@ -3,6 +3,7 @@
  * No peer dependencies — plain HTTP fetch.
  */
 import { withRetry } from "./retry.js";
+import { foldToolResults, toolParamsToJsonSchema } from "./tool-context.js";
 export function createOllamaBrain(opts) {
     const endpoint = opts.endpoint ?? process.env["OLLAMA_ENDPOINT"] ?? "http://localhost:11434";
     const model = opts.model ?? "llama3.2";
@@ -12,29 +13,61 @@ export function createOllamaBrain(opts) {
             const messages = [
                 { role: "system", content: input.system_context },
                 ...input.history.map((m) => ({ role: m.role, content: m.content })),
-                { role: "user", content: input.raw },
+                // Fold prior tool results into the turn (parity with the cloud brains).
+                { role: "user", content: foldToolResults(input.raw, input.tool_results) },
             ];
+            // Ollama's /api/chat speaks the OpenAI-style `tools` schema (Ollama ≥0.3).
+            // Without this, tool-capable agents on provider:'ollama' silently never
+            // call a tool — a capability loss precisely on the sovereign/air-gapped
+            // path this provider exists to serve (H2).
+            const tools = input.tools.length > 0
+                ? input.tools.map((t) => ({
+                    type: "function",
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: toolParamsToJsonSchema(t.parameters),
+                    },
+                }))
+                : undefined;
             const response = await withRetry(() => fetch(`${endpoint}/api/chat`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ model, messages, stream: false }),
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    stream: false,
+                    ...(tools ? { tools } : {}),
+                }),
                 ...(input.signal ? { signal: input.signal } : {}),
             }), input.signal ? { signal: input.signal } : {});
             if (!response.ok) {
                 throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
             }
             const data = (await response.json());
-            const text = data.message?.content ?? "";
             const inputTokens = data.prompt_eval_count;
             const outputTokens = data.eval_count;
+            const usageBlock = inputTokens !== undefined || outputTokens !== undefined
+                ? { usage: { ...(inputTokens !== undefined ? { inputTokens } : {}), ...(outputTokens !== undefined ? { outputTokens } : {}) } }
+                : {};
+            // Tool call (Ollama returns arguments already parsed as an object, unlike
+            // OpenAI's JSON string).
+            const call = data.message?.tool_calls?.[0]?.function;
+            if (call?.name) {
+                const orchestration = {
+                    action: "use_tool",
+                    confidence: 0.9,
+                    tool_name: call.name,
+                    tool_params: call.arguments ?? {},
+                };
+                return { orchestration, ...usageBlock };
+            }
+            const text = data.message?.content ?? "";
             return {
                 generation: { response_text: text },
                 orchestration: { action: "respond", confidence: 0.85 },
-                ...(inputTokens !== undefined || outputTokens !== undefined
-                    ? { usage: { ...(inputTokens !== undefined ? { inputTokens } : {}), ...(outputTokens !== undefined ? { outputTokens } : {}) } }
-                    : {}),
+                ...usageBlock,
             };
         },
     };
 }
-//# sourceMappingURL=ollama.js.map

package/dist/brain/openai.d.ts

@@ -8,4 +8,3 @@ export declare function createOpenAIBrain(opts: {
     model?: string;
     baseURL?: string;
 }): Brain;
-//# sourceMappingURL=openai.d.ts.map

package/dist/brain/openai.js

@@ -4,6 +4,7 @@
  */
 import { computeCostUsd } from "./pricing.js";
 import { withRetry } from "./retry.js";
+import { foldToolResults, toolParamsToJsonSchema } from "./tool-context.js";
 export function createOpenAIBrain(opts) {
     const model = opts.model ?? "gpt-4o-mini";
     return {
@@ -14,20 +15,10 @@ export function createOpenAIBrain(opts) {
                 apiKey: opts.apiKey ?? process.env["OPENAI_API_KEY"],
                 ...(opts.baseURL ? { baseURL: opts.baseURL } : {}),
             });
-            // Fold prior tool results into the current user turn so the model can see
-            // what its tool calls returned. Without this the model never learns a tool
-            // already ran (or what it produced) and re-calls it forever — every model
-            // loops to the guard cap. The nudge steers it to answer once results suffice.
-            let userContent = input.raw;
-            if (input.tool_results?.length) {
-                const resultSummary = input.tool_results
-                    .map((r) => `[${r.tool}] ${r.status}: ${JSON.stringify(r.result ?? r.error)}`)
-                    .join("\n");
-                userContent =
-                    `Tool results so far:\n${resultSummary}\n\n` +
-                        `If these results are sufficient to answer, respond directly with a final ` +
-                        `answer and do NOT call any tool again.\n\nUser request: ${input.raw}`;
-            }
+            // Fold prior tool results into the current user turn (shared with all
+            // brains) so the model sees what its tool calls returned and is nudged to
+            // finalize rather than re-calling forever.
+            const userContent = foldToolResults(input.raw, input.tool_results);
             const messages = [
                 { role: "system", content: input.system_context },
                 ...input.history.map((m) => ({
@@ -42,20 +33,7 @@ export function createOpenAIBrain(opts) {
                     function: {
                         name: t.name,
                         description: t.description,
-                        parameters: {
-                            type: "object",
-                            properties: Object.fromEntries(Object.entries(t.parameters).map(([k, v]) => [
-                                k,
-                                {
-                                    type: v.type,
-                                    description: v.description,
-                                    enum: v.enum,
-                                },
-                            ])),
-                            required: Object.entries(t.parameters)
-                                .filter(([, v]) => v.required)
-                                .map(([k]) => k),
-                        },
+                        parameters: toolParamsToJsonSchema(t.parameters),
                     },
                 }))
                 : undefined;
@@ -112,4 +90,3 @@ export function createOpenAIBrain(opts) {
         },
     };
 }
-//# sourceMappingURL=openai.js.map

package/dist/brain/pricing.d.ts

@@ -25,4 +25,3 @@ export declare const PRICE_PER_MILLION: Record<string, TokenPrice>;
  * longest-prefix match against the table.
  */
 export declare function computeCostUsd(model: string, inputTokens?: number, outputTokens?: number): number;
-//# sourceMappingURL=pricing.d.ts.map

package/dist/brain/pricing.js

@@ -50,4 +50,3 @@ function resolvePrice(model) {
     }
     return best?.price;
 }
-//# sourceMappingURL=pricing.js.map

package/dist/brain/retry.d.ts

@@ -18,4 +18,3 @@ export interface RetryOpts {
 export declare function isTransientError(err: unknown): boolean;
 /** Run `fn`, retrying once (by default) on transient provider errors. */
 export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOpts): Promise<T>;
-//# sourceMappingURL=retry.d.ts.map

package/dist/brain/retry.js

@@ -60,4 +60,3 @@ export async function withRetry(fn, opts = {}) {
     }
     throw lastErr;
 }
-//# sourceMappingURL=retry.js.map

package/dist/brain/tool-context.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared brain helpers — the two things EVERY provider must do identically so
+ * tool-using agents behave the same across OpenAI / Anthropic / Gemini / Ollama.
+ * Previously each brain hand-rolled these (or skipped them), which is why the
+ * Anthropic and Ollama paths regressed (audit H1/H2):
+ *
+ *  1. foldToolResults() — splice the prior iteration's tool results into the
+ *     current user turn WITH a "don't call again if these suffice" nudge. Without
+ *     it the model never sees what its tool call returned, re-emits `use_tool`
+ *     every iteration until the guard cap, and the loop's force-finalize answer is
+ *     ungrounded. OpenAI/Gemini did this; Anthropic/Ollama did not.
+ *
+ *  2. toolParamsToJsonSchema() — map a tool's ToolParameter record to a JSON
+ *     Schema object INCLUDING `enum`. The Anthropic brain dropped `enum`, so an
+ *     enum-constrained parameter was silently unconstrained there.
+ */
+import type { ToolParameter, ToolResult } from "../core/types.js";
+/**
+ * Fold prior-iteration tool results into the user turn. Returns `raw` unchanged
+ * when there are none, so it is safe to call on the first iteration.
+ */
+export declare function foldToolResults(raw: string, toolResults?: ToolResult[]): string;
+export interface JsonSchemaObject {
+    type: "object";
+    properties: Record<string, {
+        type: string;
+        description: string;
+        enum?: string[];
+        items?: {
+            type: string;
+        };
+    }>;
+    required: string[];
+}
+/**
+ * Canonical JSON-Schema for a tool's parameters. Includes `enum` when present.
+ * Providers that need a different casing (e.g. Gemini's UPPERCASE types) adapt
+ * from this shape; the property/required/enum semantics stay identical.
+ */
+export declare function toolParamsToJsonSchema(parameters: Record<string, ToolParameter>): JsonSchemaObject;