@jaypie/llm 1.3.7 → 1.3.8

package/dist/cjs/index.cjs

@@ -5420,11 +5420,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);
@@ -5435,35 +5431,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 kit.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 kit.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 kit.resolveValue(this.log(message, context));
@@ -6878,10 +6892,19 @@ class OperateLoop {
                 this.appendResponseItemsToRequest(currentProviderRequest, responseItems);
                 // Process each tool call
                 for (const toolCall of toolCalls) {
+                    // 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: exports.LlmProgressEventType.ToolCall,
                             },
@@ -6890,6 +6913,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)
@@ -6897,6 +6921,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({
@@ -6917,6 +6942,7 @@ class OperateLoop {
                         // Execute afterEachTool hook
                         await this.hookRunnerInstance.runAfterTool(context.hooks, {
                             args: toolCall.arguments,
+                            message: toolMessage,
                             result,
                             toolName: toolCall.name,
                         });
@@ -6950,6 +6976,7 @@ class OperateLoop {
                         await this.hookRunnerInstance.runOnToolError(context.hooks, {
                             args: toolCall.arguments,
                             error: error,
+                            message: toolMessage,
                             toolName: toolCall.name,
                         });
                         // Set error on response
@@ -7460,10 +7487,16 @@ class StreamLoop {
     async *processToolCalls(toolCalls, state, context) {
         const log = getLogger$6();
         for (const toolCall of toolCalls) {
+            // 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)
@@ -7471,6 +7504,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({
@@ -7483,6 +7517,7 @@ class StreamLoop {
                 // Execute afterEachTool hook
                 await this.hookRunnerInstance.runAfterTool(context.hooks, {
                     args: toolCall.arguments,
+                    message: toolMessage,
                     result,
                     toolName: toolCall.name,
                 });
@@ -7510,6 +7545,7 @@ class StreamLoop {
                 await this.hookRunnerInstance.runOnToolError(context.hooks, {
                     args: toolCall.arguments,
                     error: error,
+                    message: toolMessage,
                     toolName: toolCall.name,
                 });
                 // Yield error chunk