@jaypie/llm 1.3.7 → 1.3.9

package/dist/cjs/index.d.cts

@@ -3,10 +3,10 @@ import { JsonObject, AnyValue, NaturalMap, NaturalSchema, JsonReturn } from '@ja
 import { z } from 'zod/v4';
 
 declare const MODEL: {
+    FABLE: string;
     OPUS: string;
     SONNET: string;
     HAIKU: string;
-    FABLE: string;
     MYTHOS: string;
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
@@ -113,7 +113,7 @@ declare const PROVIDER: {
         readonly BASE_URL: "https://api.x.ai/v1";
         readonly MODEL: {
             readonly DEFAULT: "grok-latest";
-            readonly LARGE: "grok-4.3-latest";
+            readonly LARGE: "grok-latest";
             readonly SMALL: "grok-4-1-fast-reasoning";
             readonly TINY: "grok-4-1-fast-non-reasoning";
         };
@@ -142,8 +142,8 @@ declare const DEFAULT: {
 };
 declare const ALL: {
     readonly BASE: readonly ["claude-sonnet-4-6", "gemini-3.1-pro-preview", "gpt-5.4", "grok-latest"];
-    readonly COMBINED: readonly ("claude-opus-4-8" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gemini-3.1-pro-preview" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "gpt-5.4" | "grok-4.3-latest" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
-    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-4.3-latest"];
+    readonly COMBINED: readonly ("claude-opus-4-8" | "claude-haiku-4-5" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gemini-3.1-pro-preview" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "claude-sonnet-4-6" | "gpt-5.4" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
+    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-latest"];
     readonly SMALL: readonly ["claude-sonnet-4-6", "gemini-3.5-flash", "gpt-5.4-mini", "grok-4-1-fast-reasoning"];
     readonly TINY: readonly ["claude-haiku-4-5", "gemini-3.1-flash-lite", "gpt-5.4-nano", "grok-4-1-fast-non-reasoning"];
 };
@@ -227,9 +227,21 @@ declare class Toolkit {
     private readonly log;
     constructor(tools: LlmTool[], options?: ToolkitOptions);
     get tools(): Omit<LlmTool, "call">[];
-    call({ name, arguments: args }: {
+    private parseArgs;
+    /**
+     * Resolve a tool's `message` (static string or function of args) without
+     * calling the tool. Returns undefined when the tool is missing or defines
+     * no message. Never throws; resolution errors log at warn.
+     */
+    resolveMessage({ name, arguments: args, }: {
+        name: string;
+        arguments: string;
+    }): Promise<string | undefined>;
+    call({ name, arguments: args, message: resolvedMessage, }: {
         name: string;
         arguments: string;
+        /** Pre-resolved tool message; skips re-resolving `tool.message` for logging */
+        message?: string;
     }): Promise<_jaypie_types.AnyValue>;
     extend(tools: LlmTool[], options?: {
         warn?: boolean;
@@ -415,6 +427,8 @@ declare enum LlmProgressEventType {
 interface LlmProgressToolCall {
     /** JSON string of arguments (tool_call events only) */
     arguments?: string;
+    /** Resolved `LlmTool.message`, when the tool defines one (tool_call events only) */
+    message?: string;
     /** Tool name */
     name: string;
 }
@@ -461,19 +475,23 @@ interface LlmOperateOptions {
             content: string | JsonObject;
             usage: LlmUsage;
         }) => unknown | Promise<unknown>;
-        afterEachTool?: ({ result, toolName, args, }: {
+        afterEachTool?: ({ result, toolName, args, message, }: {
             result: unknown;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         beforeEachModelRequest?: ({ input, options, providerRequest, }: {
             input: string | LlmHistory | LlmInputMessage;
             options?: LlmOperateOptions;
             providerRequest: any;
         }) => unknown | Promise<unknown>;
-        beforeEachTool?: ({ toolName, args, }: {
+        beforeEachTool?: ({ toolName, args, message, }: {
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onRetryableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;
@@ -481,10 +499,12 @@ interface LlmOperateOptions {
             providerRequest: any;
             error: any;
         }) => unknown | Promise<unknown>;
-        onToolError?: ({ error, toolName, args, }: {
+        onToolError?: ({ error, toolName, args, message, }: {
             error: Error;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onUnrecoverableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;

package/dist/{esm/src → cjs}/operate/hooks/HookRunner.d.ts

@@ -15,16 +15,19 @@ export interface AfterModelResponseContext {
 }
 export interface BeforeToolContext {
     args: string;
+    message?: string;
     toolName: string;
 }
 export interface AfterToolContext {
     args: string;
+    message?: string;
     result: unknown;
     toolName: string;
 }
 export interface ToolErrorContext {
     args: string;
     error: Error;
+    message?: string;
     toolName: string;
 }
 export interface RetryableErrorContext {

package/dist/cjs/{src/operate → operate}/types.d.ts

@@ -133,6 +133,8 @@ export interface OperateLoopState {
     maxTurns: number;
     /** Response builder instance */
     responseBuilder: ResponseBuilder;
+    /** Names of tool calls executed across all turns (report tally) */
+    toolCallNames: string[];
     /** The toolkit for tool calls */
     toolkit?: Toolkit;
 }

package/dist/{esm/src → cjs}/tools/Toolkit.class.d.ts

@@ -14,9 +14,21 @@ export declare class Toolkit {
     private readonly log;
     constructor(tools: LlmTool[], options?: ToolkitOptions);
     get tools(): Omit<LlmTool, "call">[];
-    call({ name, arguments: args }: {
+    private parseArgs;
+    /**
+     * Resolve a tool's `message` (static string or function of args) without
+     * calling the tool. Returns undefined when the tool is missing or defines
+     * no message. Never throws; resolution errors log at warn.
+     */
+    resolveMessage({ name, arguments: args, }: {
         name: string;
         arguments: string;
+    }): Promise<string | undefined>;
+    call({ name, arguments: args, message: resolvedMessage, }: {
+        name: string;
+        arguments: string;
+        /** Pre-resolved tool message; skips re-resolving `tool.message` for logging */
+        message?: string;
     }): Promise<import("@jaypie/types").AnyValue>;
     extend(tools: LlmTool[], options?: {
         warn?: boolean;

package/dist/{esm/src → cjs}/types/LlmProvider.interface.d.ts

@@ -179,6 +179,8 @@ export declare enum LlmProgressEventType {
 export interface LlmProgressToolCall {
     /** JSON string of arguments (tool_call events only) */
     arguments?: string;
+    /** Resolved `LlmTool.message`, when the tool defines one (tool_call events only) */
+    message?: string;
     /** Tool name */
     name: string;
 }
@@ -225,19 +227,23 @@ export interface LlmOperateOptions {
             content: string | JsonObject;
             usage: LlmUsage;
         }) => unknown | Promise<unknown>;
-        afterEachTool?: ({ result, toolName, args, }: {
+        afterEachTool?: ({ result, toolName, args, message, }: {
             result: unknown;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         beforeEachModelRequest?: ({ input, options, providerRequest, }: {
             input: string | LlmHistory | LlmInputMessage;
             options?: LlmOperateOptions;
             providerRequest: any;
         }) => unknown | Promise<unknown>;
-        beforeEachTool?: ({ toolName, args, }: {
+        beforeEachTool?: ({ toolName, args, message, }: {
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onRetryableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;
@@ -245,10 +251,12 @@ export interface LlmOperateOptions {
             providerRequest: any;
             error: any;
         }) => unknown | Promise<unknown>;
-        onToolError?: ({ error, toolName, args, }: {
+        onToolError?: ({ error, toolName, args, message, }: {
             error: Error;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onUnrecoverableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;

package/dist/cjs/{src/util → util}/index.d.ts

@@ -12,4 +12,5 @@ export * from "./naturalZodSchema.js";
 export * from "./random.js";
 export * from "./repairFormatKeys.js";
 export * from "./sse.js";
+export * from "./tallyOperate.js";
 export * from "./tryParseNumber.js";

package/dist/cjs/util/tallyOperate.d.ts

@@ -0,0 +1,14 @@
+import { LlmUsageItem } from "../types/LlmProvider.interface.js";
+interface TallyOperateOptions {
+    toolCallNames?: string[];
+    turns: number;
+    usage?: LlmUsageItem[];
+}
+/**
+ * Tally loop totals onto the root logger's report session so handlers
+ * (express, lambda) include llm activity in the report emitted at teardown.
+ * Silently no-ops outside an active session or when the logger predates
+ * tally support.
+ */
+export declare function tallyOperate({ toolCallNames, turns, usage, }: TallyOperateOptions): void;
+export {};

package/dist/esm/{src/constants.d.ts → constants.d.ts}

@@ -1,8 +1,8 @@
 export declare const MODEL: {
+    FABLE: string;
     OPUS: string;
     SONNET: string;
     HAIKU: string;
-    FABLE: string;
     MYTHOS: string;
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
@@ -109,7 +109,7 @@ export declare const PROVIDER: {
         readonly BASE_URL: "https://api.x.ai/v1";
         readonly MODEL: {
             readonly DEFAULT: "grok-latest";
-            readonly LARGE: "grok-4.3-latest";
+            readonly LARGE: "grok-latest";
             readonly SMALL: "grok-4-1-fast-reasoning";
             readonly TINY: "grok-4-1-fast-non-reasoning";
         };
@@ -138,8 +138,8 @@ export declare const DEFAULT: {
 };
 export declare const ALL: {
     readonly BASE: readonly ["claude-sonnet-4-6", "gemini-3.1-pro-preview", "gpt-5.4", "grok-latest"];
-    readonly COMBINED: readonly ("claude-sonnet-4-6" | "claude-opus-4-8" | "claude-haiku-4-5" | "gemini-3.1-pro-preview" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gpt-5.4" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "grok-4.3-latest" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
-    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-4.3-latest"];
+    readonly COMBINED: readonly ("claude-sonnet-4-6" | "claude-opus-4-8" | "claude-haiku-4-5" | "gemini-3.1-pro-preview" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gpt-5.4" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
+    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-latest"];
     readonly SMALL: readonly ["claude-sonnet-4-6", "gemini-3.5-flash", "gpt-5.4-mini", "grok-4-1-fast-reasoning"];
     readonly TINY: readonly ["claude-haiku-4-5", "gemini-3.1-flash-lite", "gpt-5.4-nano", "grok-4-1-fast-non-reasoning"];
 };

package/dist/esm/index.d.ts

@@ -3,10 +3,10 @@ import { JsonObject, AnyValue, NaturalMap, NaturalSchema, JsonReturn } from '@ja
 import { z } from 'zod/v4';
 
 declare const MODEL: {
+    FABLE: string;
     OPUS: string;
     SONNET: string;
     HAIKU: string;
-    FABLE: string;
     MYTHOS: string;
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
@@ -113,7 +113,7 @@ declare const PROVIDER: {
         readonly BASE_URL: "https://api.x.ai/v1";
         readonly MODEL: {
             readonly DEFAULT: "grok-latest";
-            readonly LARGE: "grok-4.3-latest";
+            readonly LARGE: "grok-latest";
             readonly SMALL: "grok-4-1-fast-reasoning";
             readonly TINY: "grok-4-1-fast-non-reasoning";
         };
@@ -142,8 +142,8 @@ declare const DEFAULT: {
 };
 declare const ALL: {
     readonly BASE: readonly ["claude-sonnet-4-6", "gemini-3.1-pro-preview", "gpt-5.4", "grok-latest"];
-    readonly COMBINED: readonly ("claude-opus-4-8" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gemini-3.1-pro-preview" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "gpt-5.4" | "grok-4.3-latest" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
-    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-4.3-latest"];
+    readonly COMBINED: readonly ("claude-opus-4-8" | "claude-haiku-4-5" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gemini-3.1-pro-preview" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "claude-sonnet-4-6" | "gpt-5.4" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
+    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-latest"];
     readonly SMALL: readonly ["claude-sonnet-4-6", "gemini-3.5-flash", "gpt-5.4-mini", "grok-4-1-fast-reasoning"];
     readonly TINY: readonly ["claude-haiku-4-5", "gemini-3.1-flash-lite", "gpt-5.4-nano", "grok-4-1-fast-non-reasoning"];
 };
@@ -227,9 +227,21 @@ declare class Toolkit {
     private readonly log;
     constructor(tools: LlmTool[], options?: ToolkitOptions);
     get tools(): Omit<LlmTool, "call">[];
-    call({ name, arguments: args }: {
+    private parseArgs;
+    /**
+     * Resolve a tool's `message` (static string or function of args) without
+     * calling the tool. Returns undefined when the tool is missing or defines
+     * no message. Never throws; resolution errors log at warn.
+     */
+    resolveMessage({ name, arguments: args, }: {
+        name: string;
+        arguments: string;
+    }): Promise<string | undefined>;
+    call({ name, arguments: args, message: resolvedMessage, }: {
         name: string;
         arguments: string;
+        /** Pre-resolved tool message; skips re-resolving `tool.message` for logging */
+        message?: string;
     }): Promise<_jaypie_types.AnyValue>;
     extend(tools: LlmTool[], options?: {
         warn?: boolean;
@@ -415,6 +427,8 @@ declare enum LlmProgressEventType {
 interface LlmProgressToolCall {
     /** JSON string of arguments (tool_call events only) */
     arguments?: string;
+    /** Resolved `LlmTool.message`, when the tool defines one (tool_call events only) */
+    message?: string;
     /** Tool name */
     name: string;
 }
@@ -461,19 +475,23 @@ interface LlmOperateOptions {
             content: string | JsonObject;
             usage: LlmUsage;
         }) => unknown | Promise<unknown>;
-        afterEachTool?: ({ result, toolName, args, }: {
+        afterEachTool?: ({ result, toolName, args, message, }: {
             result: unknown;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         beforeEachModelRequest?: ({ input, options, providerRequest, }: {
             input: string | LlmHistory | LlmInputMessage;
             options?: LlmOperateOptions;
             providerRequest: any;
         }) => unknown | Promise<unknown>;
-        beforeEachTool?: ({ toolName, args, }: {
+        beforeEachTool?: ({ toolName, args, message, }: {
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onRetryableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;
@@ -481,10 +499,12 @@ interface LlmOperateOptions {
             providerRequest: any;
             error: any;
         }) => unknown | Promise<unknown>;
-        onToolError?: ({ error, toolName, args, }: {
+        onToolError?: ({ error, toolName, args, message, }: {
             error: Error;
             toolName: string;
             args: string;
+            /** Resolved `LlmTool.message`, when the tool defines one */
+            message?: string;
         }) => unknown | Promise<unknown>;
         onUnrecoverableModelError?: ({ input, options, providerRequest, error, }: {
             input: string | LlmHistory | LlmInputMessage;

package/dist/esm/index.js

@@ -36,17 +36,17 @@ const FIRST_CLASS_PROVIDER = {
     // https://docs.x.ai/developers/models
     XAI: {
         DEFAULT: "grok-latest",
-        LARGE: "grok-4.3-latest",
+        LARGE: "grok-latest",
         SMALL: "grok-4-1-fast-reasoning",
         TINY: "grok-4-1-fast-non-reasoning",
     },
 };
 const MODEL = {
     // Anthropic
+    FABLE: "claude-fable-5",
     OPUS: "claude-opus-4-8",
-    SONNET: "claude-sonnet-4-6",
+    SONNET: "claude-sonnet-5",
     HAIKU: "claude-haiku-4-5",
-    FABLE: "claude-fable-5",
     MYTHOS: "claude-mythos-5",
     // Google
     GEMINI_FLASH: "gemini-3.5-flash",
@@ -1294,6 +1294,43 @@ async function* parseSseStream(body, { doneSentinel = DEFAULT_DONE_SENTINEL } =
     }
 }
 
+const UNKNOWN = "unknown";
+/**
+ * Tally loop totals onto the root logger's report session so handlers
+ * (express, lambda) include llm activity in the report emitted at teardown.
+ * Silently no-ops outside an active session or when the logger predates
+ * tally support.
+ */
+function tallyOperate({ toolCallNames = [], turns, usage = [], }) {
+    if (typeof log$2.tally !== "function")
+        return;
+    const llm = {
+        operates: 1,
+        toolCalls: toolCallNames.length,
+        turns,
+    };
+    if (toolCallNames.length > 0) {
+        const tools = {};
+        for (const name of toolCallNames) {
+            tools[name] = (tools[name] ?? 0) + 1;
+        }
+        llm.tools = tools;
+    }
+    if (usage.length > 0) {
+        const usageByModel = {};
+        for (const item of usage) {
+            const key = [item.provider, item.model].filter(Boolean).join(":") || UNKNOWN;
+            usageByModel[key] ?? (usageByModel[key] = { input: 0, output: 0, reasoning: 0, total: 0 });
+            usageByModel[key].input += item.input;
+            usageByModel[key].output += item.output;
+            usageByModel[key].reasoning += item.reasoning;
+            usageByModel[key].total += item.total;
+        }
+        llm.usage = usageByModel;
+    }
+    log$2.tally({ llm });
+}
+
 /**
  * Helper function to safely call a function that might throw
  * @param fn Function to call safely
@@ -5417,11 +5454,7 @@ class Toolkit {
             return toolCopy;
         });
     }
-    async call({ name, arguments: args }) {
-        const tool = this._tools.find((t) => t.name === name);
-        if (!tool) {
-            throw new Error(`Tool '${name}' not found`);
-        }
+    parseArgs(args) {
         let parsedArgs;
         try {
             parsedArgs = JSON.parse(args);
@@ -5432,35 +5465,53 @@ class Toolkit {
         catch {
             parsedArgs = args;
         }
+        return parsedArgs;
+    }
+    /**
+     * Resolve a tool's `message` (static string or function of args) without
+     * calling the tool. Returns undefined when the tool is missing or defines
+     * no message. Never throws; resolution errors log at warn.
+     */
+    async resolveMessage({ name, arguments: args, }) {
+        const tool = this._tools.find((t) => t.name === name);
+        if (!tool || !tool.message) {
+            return undefined;
+        }
+        try {
+            if (typeof tool.message === "string") {
+                return tool.message;
+            }
+            const parsedArgs = this.parseArgs(args);
+            if (typeof tool.message === "function") {
+                return await resolveValue(tool.message(parsedArgs, { name }));
+            }
+            log.warn("[Toolkit] Tool provided unknown message type");
+            return String(tool.message);
+        }
+        catch (error) {
+            log.warn("[Toolkit] Caught error resolving tool message");
+            log.var({ error });
+            return undefined;
+        }
+    }
+    async call({ name, arguments: args, message: resolvedMessage, }) {
+        const tool = this._tools.find((t) => t.name === name);
+        if (!tool) {
+            throw new Error(`Tool '${name}' not found`);
+        }
+        const parsedArgs = this.parseArgs(args);
         if (this.log !== false) {
             try {
                 const context = {
                     name,
                     args: parsedArgs,
                 };
-                let message;
                 if (this.explain) {
                     context.explanation = parsedArgs.__Explanation;
                 }
-                if (tool.message) {
-                    if (typeof tool.message === "string") {
-                        log.trace("[Toolkit] Tool provided string message");
-                        message = tool.message;
-                    }
-                    else if (typeof tool.message === "function") {
-                        log.trace("[Toolkit] Tool provided function message");
-                        log.trace("[Toolkit] Resolving message result");
-                        message = await resolveValue(tool.message(parsedArgs, { name }));
-                    }
-                    else {
-                        log.warn("[Toolkit] Tool provided unknown message type");
-                        message = String(tool.message);
-                    }
-                }
-                else {
-                    log.trace("[Toolkit] Log tool call with default message");
-                    message = `${tool.name}:${JSON.stringify(parsedArgs)}`;
-                }
+                const message = resolvedMessage ??
+                    (await this.resolveMessage({ arguments: args, name })) ??
+                    `${tool.name}:${JSON.stringify(parsedArgs)}`;
                 if (typeof this.log === "function") {
                     log.trace("[Toolkit] Log tool call with custom logger");
                     await resolveValue(this.log(message, context));
@@ -6638,6 +6689,11 @@ class OperateLoop {
                 metrics: usageToLlmObsMetrics(response.usage),
                 outputData: response.content,
             });
+            tallyOperate({
+                toolCallNames: state.toolCallNames,
+                turns: state.currentTurn,
+                usage: response.usage,
+            });
             await emitProgress({
                 event: {
                     content: response.content,
@@ -6707,6 +6763,7 @@ class OperateLoop {
             formattedTools,
             maxTurns,
             responseBuilder,
+            toolCallNames: [],
             toolkit,
         };
     }
@@ -6875,10 +6932,20 @@ class OperateLoop {
                 this.appendResponseItemsToRequest(currentProviderRequest, responseItems);
                 // Process each tool call
                 for (const toolCall of toolCalls) {
+                    state.toolCallNames.push(toolCall.name);
+                    // Resolved once per call; never throws (undefined when tool has no message)
+                    const toolMessage = await state.toolkit.resolveMessage({
+                        arguments: toolCall.arguments,
+                        name: toolCall.name,
+                    });
                     try {
                         await emitProgress({
                             event: {
-                                tool: { arguments: toolCall.arguments, name: toolCall.name },
+                                tool: {
+                                    arguments: toolCall.arguments,
+                                    message: toolMessage,
+                                    name: toolCall.name,
+                                },
                                 turn: state.currentTurn,
                                 type: LlmProgressEventType.ToolCall,
                             },
@@ -6887,6 +6954,7 @@ class OperateLoop {
                         // Execute beforeEachTool hook
                         await this.hookRunnerInstance.runBeforeTool(context.hooks, {
                             args: toolCall.arguments,
+                            message: toolMessage,
                             toolName: toolCall.name,
                         });
                         // Call the tool inside a child tool span (no-op when disabled)
@@ -6894,6 +6962,7 @@ class OperateLoop {
                         const result = await withLlmObsSpan({ kind: "tool", name: toolCall.name }, async () => {
                             const result = await state.toolkit.call({
                                 arguments: toolCall.arguments,
+                                message: toolMessage,
                                 name: toolCall.name,
                             });
                             annotateLlmObs({
@@ -6914,6 +6983,7 @@ class OperateLoop {
                         // Execute afterEachTool hook
                         await this.hookRunnerInstance.runAfterTool(context.hooks, {
                             args: toolCall.arguments,
+                            message: toolMessage,
                             result,
                             toolName: toolCall.name,
                         });
@@ -6947,6 +7017,7 @@ class OperateLoop {
                         await this.hookRunnerInstance.runOnToolError(context.hooks, {
                             args: toolCall.arguments,
                             error: error,
+                            message: toolMessage,
                             toolName: toolCall.name,
                         });
                         // Set error on response
@@ -7235,6 +7306,11 @@ class StreamLoop {
             }
         }
         // Emit final done chunk with accumulated usage
+        tallyOperate({
+            toolCallNames: state.toolCallNames,
+            turns: state.currentTurn,
+            usage: state.usageItems,
+        });
         yield {
             type: LlmStreamChunkType.Done,
             usage: state.usageItems,
@@ -7275,6 +7351,7 @@ class StreamLoop {
             formattedFormat,
             formattedTools,
             maxTurns,
+            toolCallNames: [],
             toolkit,
             usageItems: [],
         };
@@ -7457,10 +7534,17 @@ class StreamLoop {
     async *processToolCalls(toolCalls, state, context) {
         const log = getLogger$6();
         for (const toolCall of toolCalls) {
+            state.toolCallNames.push(toolCall.name);
+            // Resolved once per call; never throws (undefined when tool has no message)
+            const toolMessage = await state.toolkit.resolveMessage({
+                arguments: toolCall.arguments,
+                name: toolCall.name,
+            });
             try {
                 // Execute beforeEachTool hook
                 await this.hookRunnerInstance.runBeforeTool(context.hooks, {
                     args: toolCall.arguments,
+                    message: toolMessage,
                     toolName: toolCall.name,
                 });
                 // Call the tool inside a child tool span (no-op when disabled)
@@ -7468,6 +7552,7 @@ class StreamLoop {
                 const result = await withLlmObsSpan({ kind: "tool", name: toolCall.name }, async () => {
                     const result = await state.toolkit.call({
                         arguments: toolCall.arguments,
+                        message: toolMessage,
                         name: toolCall.name,
                     });
                     annotateLlmObs({
@@ -7480,6 +7565,7 @@ class StreamLoop {
                 // Execute afterEachTool hook
                 await this.hookRunnerInstance.runAfterTool(context.hooks, {
                     args: toolCall.arguments,
+                    message: toolMessage,
                     result,
                     toolName: toolCall.name,
                 });
@@ -7507,6 +7593,7 @@ class StreamLoop {
                 await this.hookRunnerInstance.runOnToolError(context.hooks, {
                     args: toolCall.arguments,
                     error: error,
+                    message: toolMessage,
                     toolName: toolCall.name,
                 });
                 // Yield error chunk