melchizedek-agents 1.15.0 → 1.15.1

package/CHANGELOG.md

@@ -4,6 +4,21 @@ Consumers of the package read this file; it records changes to the
 **published API surface** (the exports map in `package.json`, the bins,
 the starter pack and the templates), not the repo's full history.
 
+## 1.15.1 — 2026-11-06
+
+**Fixed: a conversation stuck on Anthropic after an approval** (ADR 0155).
+When one model step made several tool calls and one of them required
+approval, the calls beside it ran but their results were never stored. After
+the approval the history held the step's calls with only the approved one
+answered, and Anthropic refused every later request with `tool_use ids were
+found without tool_result blocks immediately after`. The loop now stores the
+other calls' results before the approval request. The request builder also
+gives any call the history leaves unanswered an error result: an approval
+the person moved on from by typing a new message, a run that ended between a call and its
+result, and sessions stored before this release, which recover without
+editing. Gemini, which accepted the unanswered calls, sees the same history
+plus those results.
+
 ## 1.15.0 — 2026-11-02
 
 **Breaking — read before upgrading**

package/dist/lib/runtime/native/agentLoop.d.ts

@@ -47,8 +47,11 @@
  *      mergeParallelFunctionResponseEvents). ADK runs the calls one after
  *      another and lets a call read the state an earlier call of the same
  *      step wrote; here each call reads the state as the step left it.
- *   3. An approval request ends the run: the response is NOT stored; in its
- *      place the event ADK stores, a call to `adk_request_confirmation`
+ *   3. An approval request ends the run: the gated calls' answers are NOT
+ *      stored. The step's other calls ran, and their answers are stored
+ *      first, as their own event with no actions (answeredBesideGates): a
+ *      provider other than Gemini refuses a call with no result. Then, in
+ *      the gated calls' place, the event ADK stores, a call to `adk_request_confirmation`
  *      (args: the original call and the confirmation; an `adk-` id listed in
  *      longRunningToolIds), carrying the response's actions. The answer
  *      resumes it: before each step, lib/runtime/native/interrupts.ts runs

package/dist/lib/runtime/native/agentLoop.js

@@ -47,8 +47,11 @@
  *      mergeParallelFunctionResponseEvents). ADK runs the calls one after
  *      another and lets a call read the state an earlier call of the same
  *      step wrote; here each call reads the state as the step left it.
- *   3. An approval request ends the run: the response is NOT stored; in its
- *      place the event ADK stores, a call to `adk_request_confirmation`
+ *   3. An approval request ends the run: the gated calls' answers are NOT
+ *      stored. The step's other calls ran, and their answers are stored
+ *      first, as their own event with no actions (answeredBesideGates): a
+ *      provider other than Gemini refuses a call with no result. Then, in
+ *      the gated calls' place, the event ADK stores, a call to `adk_request_confirmation`
  *      (args: the original call and the confirmation; an `adk-` id listed in
  *      longRunningToolIds), carrying the response's actions. The answer
  *      resumes it: before each step, lib/runtime/native/interrupts.ts runs
@@ -515,6 +518,25 @@ function confirmationEvent(scope, modelEvent, response) {
         longRunningToolIds: parts.map((p) => p.functionCall?.id),
     });
 }
+/**
+ * The answers of a step that paused on an approval, beside its gated calls:
+ * the response's parts without the gated calls' stand-ins, and without the
+ * actions, which the confirmation event carries. Undefined when every call
+ * waits on the approval. Every provider but Gemini refuses a call with no
+ * result, so a call that already ran keeps its result through the pause.
+ */
+function answeredBesideGates(scope, response) {
+    const gated = new Set(Object.keys(response.actions.requestedToolConfirmations ?? {}));
+    const parts = (response.content?.parts ?? []).filter((p) => !(p.functionResponse?.id && gated.has(p.functionResponse.id)));
+    if (!parts.some((p) => p.functionResponse))
+        return undefined;
+    return createTurnEvent({
+        invocationId: scope.ctx.invocationId,
+        author: scope.agent.name,
+        branch: scope.ctx.branch,
+        content: { parts, role: response.content?.role ?? 'user' },
+    });
+}
 /**
  * ADK's request-confirmation processor, before a step: the pinned calls the
  * latest user message approves or refuses run with the answer in their
@@ -801,6 +823,9 @@ async function* agentLoop(agent, ctx) {
                 const authIds = auth ? [...(lastEvent.longRunningToolIds ?? [])] : [];
                 const confirmation = confirmationEvent(scope, modelEvent, response);
                 if (confirmation) {
+                    const answered = answeredBesideGates(scope, response);
+                    if (answered)
+                        yield await store(answered);
                     lastEvent = await store(confirmation);
                     yield lastEvent;
                     return { reason: 'paused', steps, lastEvent, pending: [...(lastEvent.longRunningToolIds ?? []), ...delegated] };

package/dist/lib/runtime/native/request.d.ts

@@ -69,7 +69,7 @@
  * yielded by a toolset or passed in `extraTools`, is refused, naming 1.0.0
  * and defineTool, as registerTool refuses one (ADR 0107).
  */
-import type { ModelRequest } from '../../models/contract.ts';
+import type { Message, ModelRequest } from '../../models/contract.ts';
 import type { MemoryService } from '../memoryService.ts';
 import type { TurnContent, TurnEvent } from '../events.ts';
 import type { Session } from '../sessions.ts';
@@ -230,4 +230,17 @@ export declare function isToolset(value: unknown): value is {
  * request: a required state key that is absent, a
  * Gemini-only tool on another model, a config field LlmAgent refuses.
  */
+/** What a call with no stored result reads as: it never answered. */
+export declare const UNANSWERED_CALL = "This call has no result: it never ran, or the run ended before it answered.";
+/**
+ * Every assistant message's tool calls answered in the message right after
+ * it, as the contract's ToolMessage holds them (one result per call).
+ * A call the history leaves unanswered (an approval the person moved on
+ * from, a run that ended between a call and its result) gets an error
+ * result saying it never answered. Anthropic and OpenAI refuse a request
+ * that leaves a call unanswered, and every later request replays it, so
+ * without this one such call ends the conversation. Results already there
+ * stay as they are, in their order; the stand-ins follow them.
+ */
+export declare function answerEveryCall(messages: Message[]): Message[];
 export declare function buildModelRequest(agent: NativeAgent, ctx: RequestContext): Promise<BuiltRequest>;

package/dist/lib/runtime/native/request.js

@@ -448,6 +448,45 @@ function placementOf(native, model, configTools) {
  * request: a required state key that is absent, a
  * Gemini-only tool on another model, a config field LlmAgent refuses.
  */
+/** What a call with no stored result reads as: it never answered. */
+export const UNANSWERED_CALL = 'This call has no result: it never ran, or the run ended before it answered.';
+/**
+ * Every assistant message's tool calls answered in the message right after
+ * it, as the contract's ToolMessage holds them (one result per call).
+ * A call the history leaves unanswered (an approval the person moved on
+ * from, a run that ended between a call and its result) gets an error
+ * result saying it never answered. Anthropic and OpenAI refuse a request
+ * that leaves a call unanswered, and every later request replays it, so
+ * without this one such call ends the conversation. Results already there
+ * stay as they are, in their order; the stand-ins follow them.
+ */
+export function answerEveryCall(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        out.push(message);
+        if (message.role !== 'assistant')
+            continue;
+        const calls = message.parts.filter((p) => p.type === 'toolCall');
+        if (calls.length === 0)
+            continue;
+        const next = messages[i + 1];
+        const results = next?.role === 'tool' ? next.parts : [];
+        const answered = new Set(results.map((r) => r.id));
+        const missing = calls
+            .filter((c) => !answered.has(c.id))
+            .map((c) => ({ type: 'toolResult', id: c.id, name: c.name, result: UNANSWERED_CALL, isError: true }));
+        if (missing.length === 0)
+            continue;
+        if (next?.role === 'tool') {
+            out.push({ role: 'tool', parts: [...next.parts, ...missing] });
+            i += 1;
+        }
+        else
+            out.push({ role: 'tool', parts: missing });
+    }
+    return out;
+}
 export async function buildModelRequest(agent, ctx) {
     const model = agent.model;
     const cfg = { ...(agent.generateContentConfig ?? {}) };
@@ -621,7 +660,7 @@ export async function buildModelRequest(agent, ctx) {
     const reasoning = reasoningOf(cfg);
     const sampling = samplingOf(cfg);
     const systemPrompt = systemText(system);
-    const messages = contentsToMessages(contents).messages;
+    const messages = answerEveryCall(contentsToMessages(contents).messages);
     const request = {
         model,
         ...(systemPrompt !== undefined ? { system: systemPrompt } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melchizedek-agents",
-  "version": "1.15.0",
+  "version": "1.15.1",
   "description": "A multi-model, multi-agent orchestration framework — YAML-defined syndicates on the engine's own agent loop, Supabase or Postgres session persistence, pgvector long-term memory. Companion repo to the lyceumagents.com curriculum.",
   "type": "module",
   "license": "MIT",