@adminforth/agent 1.0.0 → 1.1.0

package/agent/middleware/apiBasedTools.ts

@@ -1,7 +1,11 @@
 import { ToolMessage } from "@langchain/core/messages";
 import { createMiddleware } from "langchain";
 import { logger } from "adminforth";
-import type { ApiBasedTool } from "../../apiBasedTools.js";
+import { type ApiBasedTool } from "../../apiBasedTools.js";
+import {
+  createToolCallTracker,
+  type ToolCallEventSink,
+} from "../toolCallEvents.js";
 import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../tools/index.js";
 import { createApiTool } from "../tools/apiTool.js";
 
@@ -67,30 +71,46 @@ export function createApiBasedToolsMiddleware(
     async wrapToolCall(request, handler) {
       const startedAt = Date.now();
       const toolInput = JSON.stringify(request.toolCall.args ?? {});
+      const { emitToolCallEvent } = request.runtime.context as {
+        emitToolCallEvent: ToolCallEventSink;
+      };
+      const toolCallTracker = createToolCallTracker({
+        emit: emitToolCallEvent,
+        toolCallId: request.toolCall.id,
+        toolName: request.toolCall.name,
+        input: (request.toolCall.args ?? {}) as Record<string, unknown>,
+        startedAt,
+      });
+      toolCallTracker.start();
       logger.info(
         `Invoking tool "${request.toolCall.name}" with input: ${toolInput}`,
       );
 
       try {
-        if (request.tool) {
-          return await handler(request);
-        }
+        let result;
 
-        const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
+        if (request.tool) {
+          result = await handler(request);
+        } else {
+          const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
 
-        if (enabledApiToolNames.has(request.toolCall.name)) {
-          return await handler({
-            ...request,
-            tool: dynamicTools[request.toolCall.name],
-          });
+          if (enabledApiToolNames.has(request.toolCall.name)) {
+            result = await handler({
+              ...request,
+              tool: dynamicTools[request.toolCall.name],
+            });
+          } else {
+            result = new ToolMessage({
+              content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
+              tool_call_id: request.toolCall.id ?? "",
+              name: request.toolCall.name,
+              status: "error",
+            });
+          }
         }
 
-        return new ToolMessage({
-          content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
-          tool_call_id: request.toolCall.id ?? "",
-          name: request.toolCall.name,
-          status: "error",
-        });
+        toolCallTracker.finishSuccess(result);
+        return result;
       } catch (error) {
         const errorDetails =
           error instanceof Error ? error.stack ?? error.message : String(error);
@@ -98,6 +118,7 @@ export function createApiBasedToolsMiddleware(
         logger.error(
           `Tool "${request.toolCall.name}" failed after ${Date.now() - startedAt}ms with input: ${toolInput}\n${errorDetails}`,
         );
+        toolCallTracker.finishError(error);
         throw error;
       } finally {
         logger.info(

package/agent/toolCallEvents.ts

@@ -1,3 +1,7 @@
+import { randomUUID } from "crypto";
+import YAML from "yaml";
+import { serializeUnknownError } from "../apiBasedTools.js";
+
 export type ToolCallEvent =
   | {
       toolCallId: string;
@@ -15,3 +19,45 @@ export type ToolCallEvent =
     };
 
 export type ToolCallEventSink = (event: ToolCallEvent) => void;
+
+export function createToolCallTracker(params: {
+  emit: ToolCallEventSink;
+  toolCallId?: string;
+  toolName: string;
+  input?: Record<string, unknown>;
+  startedAt?: number;
+}) {
+  const toolCallId = params.toolCallId ?? randomUUID();
+  const startedAt = params.startedAt ?? Date.now();
+
+  return {
+    start() {
+      params.emit({
+        toolCallId,
+        toolName: params.toolName,
+        phase: "start",
+        input: YAML.stringify(params.input ?? {}),
+      });
+    },
+    finishSuccess(output: unknown) {
+      params.emit({
+        toolCallId,
+        toolName: params.toolName,
+        phase: "end",
+        durationMs: Date.now() - startedAt,
+        output: YAML.stringify(output).trimEnd(),
+        error: null,
+      });
+    },
+    finishError(error: unknown) {
+      params.emit({
+        toolCallId,
+        toolName: params.toolName,
+        phase: "end",
+        durationMs: Date.now() - startedAt,
+        output: null,
+        error: YAML.stringify(serializeUnknownError(error)).trimEnd(),
+      });
+    },
+  };
+}

package/agent/tools/apiTool.ts

@@ -1,8 +1,5 @@
 import { tool } from "langchain";
-import { randomUUID } from "crypto";
-import YAML from "yaml";
 import type { ApiBasedTool } from "../../apiBasedTools.js";
-import { serializeUnknownError } from "../../apiBasedTools.js";
 
 const emptyToolSchema = {
   type: "object",
@@ -52,43 +49,11 @@ export function createApiTool(toolName: string, apiBasedTool: ApiBasedTool) {
   return tool(
     async (input, runtime) => {
       const normalizedInput = (input ?? {}) as Record<string, unknown>;
-      const toolCallId = randomUUID();
-      const startedAt = Date.now();
-      runtime.context.emitToolCallEvent({
-        toolCallId,
-        toolName,
-        phase: "start",
-        input: YAML.stringify(normalizedInput),
+      return apiBasedTool.call({
+        adminUser: runtime.context.adminUser,
+        inputs: normalizedInput,
+        userTimeZone: runtime.context.userTimeZone,
       });
-
-      try {
-        const output = await apiBasedTool.call({
-          adminUser: runtime.context.adminUser,
-          inputs: normalizedInput,
-          userTimeZone: runtime.context.userTimeZone,
-        });
-
-        runtime.context.emitToolCallEvent({
-          toolCallId,
-          toolName,
-          phase: "end",
-          durationMs: Date.now() - startedAt,
-          output,
-          error: null,
-        });
-
-        return output;
-      } catch (error) {
-        runtime.context.emitToolCallEvent({
-          toolCallId,
-          toolName,
-          phase: "end",
-          durationMs: Date.now() - startedAt,
-          output: null,
-          error: YAML.stringify(serializeUnknownError(error)),
-        });
-        throw error;
-      }
     },
     {
       name: toolName,

package/build.log

@@ -26,5 +26,5 @@ custom/skills/fetch_data/SKILL.md
 custom/skills/mutate_data/
 custom/skills/mutate_data/SKILL.md
 
-sent 136,251 bytes  received 367 bytes  273,236.00 bytes/sec
+sent 136,273 bytes  received 367 bytes  273,280.00 bytes/sec
 total size is 134,767  speedup is 0.99

package/dist/agent/middleware/apiBasedTools.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ToolMessage } from "@langchain/core/messages";
 import { createMiddleware } from "langchain";
 import { logger } from "adminforth";
+import { createToolCallTracker, } from "../toolCallEvents.js";
 import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../tools/index.js";
 import { createApiTool } from "../tools/apiTool.js";
 function getEnabledApiToolNames(messages) {
@@ -58,28 +59,45 @@ export function createApiBasedToolsMiddleware(apiBasedTools) {
         },
         wrapToolCall(request, handler) {
             return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
+                var _a, _b, _c, _d;
                 const startedAt = Date.now();
                 const toolInput = JSON.stringify((_a = request.toolCall.args) !== null && _a !== void 0 ? _a : {});
+                const { emitToolCallEvent } = request.runtime.context;
+                const toolCallTracker = createToolCallTracker({
+                    emit: emitToolCallEvent,
+                    toolCallId: request.toolCall.id,
+                    toolName: request.toolCall.name,
+                    input: ((_b = request.toolCall.args) !== null && _b !== void 0 ? _b : {}),
+                    startedAt,
+                });
+                toolCallTracker.start();
                 logger.info(`Invoking tool "${request.toolCall.name}" with input: ${toolInput}`);
                 try {
+                    let result;
                     if (request.tool) {
-                        return yield handler(request);
+                        result = yield handler(request);
                     }
-                    const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
-                    if (enabledApiToolNames.has(request.toolCall.name)) {
-                        return yield handler(Object.assign(Object.assign({}, request), { tool: dynamicTools[request.toolCall.name] }));
+                    else {
+                        const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
+                        if (enabledApiToolNames.has(request.toolCall.name)) {
+                            result = yield handler(Object.assign(Object.assign({}, request), { tool: dynamicTools[request.toolCall.name] }));
+                        }
+                        else {
+                            result = new ToolMessage({
+                                content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
+                                tool_call_id: (_c = request.toolCall.id) !== null && _c !== void 0 ? _c : "",
+                                name: request.toolCall.name,
+                                status: "error",
+                            });
+                        }
                     }
-                    return new ToolMessage({
-                        content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
-                        tool_call_id: (_b = request.toolCall.id) !== null && _b !== void 0 ? _b : "",
-                        name: request.toolCall.name,
-                        status: "error",
-                    });
+                    toolCallTracker.finishSuccess(result);
+                    return result;
                 }
                 catch (error) {
-                    const errorDetails = error instanceof Error ? (_c = error.stack) !== null && _c !== void 0 ? _c : error.message : String(error);
+                    const errorDetails = error instanceof Error ? (_d = error.stack) !== null && _d !== void 0 ? _d : error.message : String(error);
                     logger.error(`Tool "${request.toolCall.name}" failed after ${Date.now() - startedAt}ms with input: ${toolInput}\n${errorDetails}`);
+                    toolCallTracker.finishError(error);
                     throw error;
                 }
                 finally {

package/dist/agent/toolCallEvents.js

@@ -1 +1,39 @@
-export {};
+import { randomUUID } from "crypto";
+import YAML from "yaml";
+import { serializeUnknownError } from "../apiBasedTools.js";
+export function createToolCallTracker(params) {
+    var _a, _b;
+    const toolCallId = (_a = params.toolCallId) !== null && _a !== void 0 ? _a : randomUUID();
+    const startedAt = (_b = params.startedAt) !== null && _b !== void 0 ? _b : Date.now();
+    return {
+        start() {
+            var _a;
+            params.emit({
+                toolCallId,
+                toolName: params.toolName,
+                phase: "start",
+                input: YAML.stringify((_a = params.input) !== null && _a !== void 0 ? _a : {}),
+            });
+        },
+        finishSuccess(output) {
+            params.emit({
+                toolCallId,
+                toolName: params.toolName,
+                phase: "end",
+                durationMs: Date.now() - startedAt,
+                output: YAML.stringify(output).trimEnd(),
+                error: null,
+            });
+        },
+        finishError(error) {
+            params.emit({
+                toolCallId,
+                toolName: params.toolName,
+                phase: "end",
+                durationMs: Date.now() - startedAt,
+                output: null,
+                error: YAML.stringify(serializeUnknownError(error)).trimEnd(),
+            });
+        },
+    };
+}

package/dist/agent/tools/apiTool.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { tool } from "langchain";
-import { randomUUID } from "crypto";
-import YAML from "yaml";
-import { serializeUnknownError } from "../../apiBasedTools.js";
 const emptyToolSchema = {
     type: "object",
     properties: {},
@@ -50,41 +47,11 @@ export function createApiTool(toolName, apiBasedTool) {
     var _a;
     return tool((input, runtime) => __awaiter(this, void 0, void 0, function* () {
         const normalizedInput = (input !== null && input !== void 0 ? input : {});
-        const toolCallId = randomUUID();
-        const startedAt = Date.now();
-        runtime.context.emitToolCallEvent({
-            toolCallId,
-            toolName,
-            phase: "start",
-            input: YAML.stringify(normalizedInput),
+        return apiBasedTool.call({
+            adminUser: runtime.context.adminUser,
+            inputs: normalizedInput,
+            userTimeZone: runtime.context.userTimeZone,
         });
-        try {
-            const output = yield apiBasedTool.call({
-                adminUser: runtime.context.adminUser,
-                inputs: normalizedInput,
-                userTimeZone: runtime.context.userTimeZone,
-            });
-            runtime.context.emitToolCallEvent({
-                toolCallId,
-                toolName,
-                phase: "end",
-                durationMs: Date.now() - startedAt,
-                output,
-                error: null,
-            });
-            return output;
-        }
-        catch (error) {
-            runtime.context.emitToolCallEvent({
-                toolCallId,
-                toolName,
-                phase: "end",
-                durationMs: Date.now() - startedAt,
-                output: null,
-                error: YAML.stringify(serializeUnknownError(error)),
-            });
-            throw error;
-        }
     }), {
         name: toolName,
         description: (_a = apiBasedTool.description) !== null && _a !== void 0 ? _a : `${toolName} tool`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",