melchizedek-agents 1.15.0 → 1.15.2

package/CHANGELOG.md

@@ -4,6 +4,35 @@ 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.2 — 2026-11-06
+
+**Fixed: a turn's usage and cost left out `generate_image`.** The tool called
+Gemini's image model outside the tracer, so its tokens never reached the
+turn's usage or the ledger's `cost_usd`. The call is now an `llm.request`
+through `traceLlmGeneration`, like every other model call: its tokens count in
+the turn's usage, it counts against `max_steps`, and a cancelled turn stops it
+before the request. Migration 0024 adds the price row for
+`gemini-3.1-flash-image-preview` ($0.50 in, $60.00 out at the image rate,
+$3.00 thinking, from Google's page for `gemini-3.1-flash-image`;
+`verified_at` NULL, since the preview id is not listed). A typical image costs
+about $0.08. Apply it with `npx melchizedek-db apply` before upgrading; without it,
+a turn that made an image prices NULL.
+
+## 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/db/migrations/0024_image_model_pricing.sql

@@ -0,0 +1,28 @@
+-- ============================================================================
+-- 0024_image_model_pricing — a price row for the image model generate_image
+--                            calls (extends ADR 0136)
+-- ============================================================================
+-- Rows only, in 0017's column layout (USD per million tokens). generate_image
+-- (lib/tools/generateImageTool.ts) now traces its call as an llm.request, so
+-- the turn's usage holds gemini-3.1-flash-image-preview; without a row the
+-- whole turn prices NULL.
+--
+-- gemini-3.1-flash-image-preview: Google's Gemini API pricing page
+-- (aistudio.google.com/docs/pricing, checked 2026-11-06) lists the model as
+-- gemini-3.1-flash-image, standard tier: $0.50 in, $3.00 text and thinking
+-- out, $60.00 image out. The preview id is not on the page, so verified_at
+-- stays NULL (0015's convention). A flat row has one output rate: it holds
+-- the image rate, since nearly all of the call's output is the image, so the
+-- few text tokens beside it are overcounted. Thinking bills at $3.00.
+--
+-- New rows never overwrite a row that exists: an operator's own rates
+-- survive. Nothing secret, nothing personal. Idempotent; safe to re-run.
+-- ============================================================================
+
+INSERT INTO model_pricing (model, input_per_mtok, output_per_mtok, thinking_per_mtok, cache_read_per_mtok, cache_write_per_mtok, verified_at, source, note) VALUES
+  ('gemini-3.1-flash-image-preview', 0.50, 60.00, 3.00, NULL, NULL, NULL, 'aistudio.google.com/docs/pricing (as gemini-3.1-flash-image), checked 2026-11-06', 'output at the image rate; text output ($3.00) is overcounted; preview id not on the page')
+ON CONFLICT (model) DO NOTHING;
+
+INSERT INTO melchizedek_schema_version (version, name)
+VALUES (24, '0024_image_model_pricing')
+ON CONFLICT (version) DO NOTHING;

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/dist/lib/tools/generateImageTool.d.ts

@@ -14,7 +14,13 @@
  * The contract is an own Tool (lib/tools/tool.ts); `generateImageTool` is the
  * own Tool the registry lists, made from it by asTool.
  */
+import { GoogleGenAI } from '@google/genai';
 import { z } from 'zod';
+export declare const IMAGE_MODEL = "gemini-3.1-flash-image-preview";
+/** Makes the Gemini client; a test swaps it for a stub. */
+export declare const imageClient: {
+    create: (apiKey: string) => Pick<GoogleGenAI, 'models'>;
+};
 export declare const generateImageContract: import("./toolContract.ts").DefinedTool<z.ZodObject<{
     prompt: z.ZodString;
     style: z.ZodOptional<z.ZodString>;

package/dist/lib/tools/generateImageTool.js

@@ -21,7 +21,12 @@ import { z } from 'zod';
 import { asTool, defineTool } from './toolContract.js';
 import { outputsDir } from '../paths.js';
 import { credentialValue } from '../models/credentialSource.js';
-const IMAGE_MODEL = 'gemini-3.1-flash-image-preview';
+import { traceLlmGeneration } from '../observability/tracer.js';
+export const IMAGE_MODEL = 'gemini-3.1-flash-image-preview';
+/** Makes the Gemini client; a test swaps it for a stub. */
+export const imageClient = {
+    create: (apiKey) => new GoogleGenAI({ apiKey }),
+};
 export const generateImageContract = defineTool({
     name: 'generate_image',
     description: 'Generates a real image from a structured payload and saves it to the outputs/ directory. ' +
@@ -42,7 +47,7 @@ export const generateImageContract = defineTool({
         }
         // Sizes and which options are set, never their values: the prompt carries the person's words.
         console.log(`[ImageTool] Parameters - prompt ${prompt.length} chars; set: ${[style && 'style', aspect_ratio && 'aspect_ratio', color_palette && 'color_palette'].filter(Boolean).join(', ') || 'none'}`);
-        const ai = new GoogleGenAI({ apiKey });
+        const ai = imageClient.create(apiKey);
         // Build a rich prompt that bakes in the structured parameters.
         const parts = [prompt];
         if (style)
@@ -54,13 +59,28 @@ export const generateImageContract = defineTool({
         const fullPrompt = parts.join('. ');
         try {
             console.log(`[ImageTool] Sending generateContent request to Gemini API (Model: ${IMAGE_MODEL})...`);
-            const response = await ai.models.generateContent({
-                model: IMAGE_MODEL,
-                contents: [{ role: 'user', parts: [{ text: fullPrompt }] }],
-                config: {
-                    responseModalities: ['IMAGE', 'TEXT'],
-                },
-            });
+            // Traced as one llm.request like every other model call, so the image
+            // model's tokens reach the turn's usage and the ledger prices them
+            // (model_pricing); it also counts against the turn's step budget and stops on cancel.
+            let response;
+            async function* call() {
+                response = await ai.models.generateContent({
+                    model: IMAGE_MODEL,
+                    contents: [{ role: 'user', parts: [{ text: fullPrompt }] }],
+                    config: {
+                        responseModalities: ['IMAGE', 'TEXT'],
+                    },
+                });
+                yield { usageMetadata: response.usageMetadata };
+            }
+            const request = () => ({ model: IMAGE_MODEL, messages: [{ role: 'user', parts: [{ type: 'text', text: fullPrompt }] }] });
+            for await (const r of traceLlmGeneration({ provider: 'gemini', model: IMAGE_MODEL, request }, call())) {
+                // A refused call (the step budget, a cancelled turn) never reaches the API.
+                if (r.errorCode)
+                    return `[generate_image ERROR] Model: ${IMAGE_MODEL} - ${r.errorMessage || r.errorCode}`;
+            }
+            if (!response)
+                return `No image data returned. Model used: ${IMAGE_MODEL}`;
             console.log("[ImageTool] Received response from Gemini API.");
             const candidates = response.candidates ?? [];
             console.log(`[ImageTool] Candidates found: ${candidates.length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melchizedek-agents",
-  "version": "1.15.0",
+  "version": "1.15.2",
   "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",