@adminforth/agent 1.49.0 → 1.49.2

package/agent/middleware/apiBasedTools.ts

@@ -47,70 +47,6 @@ function getEnabledApiToolNames(messages: unknown[]) {
   return enabledToolNames;
 }
 
-const loadedApiToolNamesBySession = new Map<string, Set<string>>();
-
-function getSessionLoadedApiToolNames(sessionId: string) {
-  let toolNames = loadedApiToolNamesBySession.get(sessionId);
-
-  if (!toolNames) {
-    toolNames = new Set<string>();
-    loadedApiToolNamesBySession.set(sessionId, toolNames);
-  }
-
-  return toolNames;
-}
-
-function getEnabledApiToolNamesForSession(messages: unknown[], sessionId?: string) {
-  const enabledToolNames = getEnabledApiToolNames(messages);
-
-  if (!sessionId) {
-    return enabledToolNames;
-  }
-
-  for (const toolName of getSessionLoadedApiToolNames(sessionId)) {
-    enabledToolNames.add(toolName);
-  }
-
-  return enabledToolNames;
-}
-
-function getToolMessageContent(message: unknown) {
-  if (!ToolMessage.isInstance(message)) {
-    return "";
-  }
-
-  return typeof message.content === "string"
-    ? message.content
-    : Array.isArray(message.content)
-      ? message.content
-          .map((block) =>
-            typeof block === "string"
-              ? block
-              : "text" in block
-                ? block.text
-                : "",
-          )
-          .join("")
-      : "";
-}
-
-function rememberLoadedToolFromFetchResult(sessionId: string, result: unknown) {
-  if (!ToolMessage.isInstance(result) || result.name !== "fetch_tool_schema") {
-    return;
-  }
-
-  try {
-    const parsed = JSON.parse(getToolMessageContent(result)) as {
-      status?: number;
-      name?: string;
-    };
-
-    if (parsed.status === 200 && parsed.name) {
-      getSessionLoadedApiToolNames(sessionId).add(parsed.name);
-    }
-  } catch {}
-}
-
 export function createApiBasedToolsMiddleware(
   apiBasedTools: Record<string, ApiBasedTool>,
   adminforth: IAdminForth,
@@ -126,11 +62,7 @@ export function createApiBasedToolsMiddleware(
   return createMiddleware({
     name: "ApiBasedToolsMiddleware",
     async wrapModelCall(request, handler) {
-      const { sessionId } = request.runtime.context as { sessionId?: string };
-      const enabledApiToolNames = getEnabledApiToolNamesForSession(
-        request.state.messages,
-        sessionId,
-      );
+      const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
       const tools = [...enabledApiToolNames]
         .filter((toolName) => !alwaysAvailableApiToolNames.has(toolName))
         .map((toolName) => dynamicTools[toolName]);
@@ -148,10 +80,9 @@ export function createApiBasedToolsMiddleware(
     async wrapToolCall(request, handler) {
       const startedAt = Date.now();
       const toolInput = JSON.stringify(request.toolCall.args ?? {});
-      const { adminUser, emitToolCallEvent, sessionId, userTimeZone } = request.runtime.context as {
+      const { adminUser, emitToolCallEvent, userTimeZone } = request.runtime.context as {
         adminUser: AdminUser;
         emitToolCallEvent: ToolCallEventSink;
-        sessionId: string;
         userTimeZone: string;
       };
       const toolArgs = (request.toolCall.args ?? {}) as Record<string, unknown>;
@@ -189,10 +120,7 @@ export function createApiBasedToolsMiddleware(
         if (request.tool) {
           result = await handler(request);
         } else {
-          const enabledApiToolNames = getEnabledApiToolNamesForSession(
-            request.state.messages,
-            sessionId,
-          );
+          const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
 
           if (enabledApiToolNames.has(request.toolCall.name)) {
             result = await handler({
@@ -209,10 +137,6 @@ export function createApiBasedToolsMiddleware(
           }
         }
 
-        if (sessionId) {
-          rememberLoadedToolFromFetchResult(sessionId, result);
-        }
-
         toolCallTracker.finishSuccess(result);
         return result;
       } catch (error) {

package/agent/tools/fetchToolSchema.ts

@@ -1,9 +1,6 @@
 import { tool } from "langchain";
 import { z } from "zod";
-import {
-  serializeApiBasedTool,
-  type ApiBasedTool,
-} from "../../apiBasedTools.js";
+import type { ApiBasedTool } from "../../apiBasedTools.js";
 
 const fetchToolSchemaSchema = z.object({
   toolName: z
@@ -34,7 +31,7 @@ export async function createFetchToolSchemaTool(
         {
           status: 200,
           name: toolName,
-          ...serializeApiBasedTool(toolDefinition),
+          loaded: true,
         },
         null,
         2,

package/apiBasedTools.ts

@@ -175,7 +175,6 @@ export type ApiBasedToolCallParams = {
 export type ApiBasedTool = {
   description?: string;
   input_schema?: unknown;
-  output_schema?: unknown;
   call: (params?: ApiBasedToolCallParams) => Promise<string>;
 };
 
@@ -616,7 +615,6 @@ export function prepareApiBasedTools(
     apiBasedTools[toolName] = {
       description: schema.description,
       input_schema: schema.request_schema,
-      output_schema: schema.response_schema,
       call: async ({ adminUser, adminuser, abortSignal, inputs, userTimeZone, acceptLanguage } = {}) => {
         if (isHiddenResourceCall(hiddenResourceIdSet, inputs)) {
           return YAML.stringify({
@@ -652,16 +650,3 @@ export function prepareApiBasedTools(
 
   return apiBasedTools;
 }
-
-export function serializeApiBasedTool(tool: ApiBasedTool | undefined) {
-  if (!tool) {
-    return null;
-  }
-
-  return {
-    description: tool.description,
-    input_schema: tool.input_schema,
-    output_schema: tool.output_schema,
-    call: '[Function]',
-  };
-}

package/dist/agent/middleware/apiBasedTools.js

@@ -41,53 +41,6 @@ function getEnabledApiToolNames(messages) {
     }
     return enabledToolNames;
 }
-const loadedApiToolNamesBySession = new Map();
-function getSessionLoadedApiToolNames(sessionId) {
-    let toolNames = loadedApiToolNamesBySession.get(sessionId);
-    if (!toolNames) {
-        toolNames = new Set();
-        loadedApiToolNamesBySession.set(sessionId, toolNames);
-    }
-    return toolNames;
-}
-function getEnabledApiToolNamesForSession(messages, sessionId) {
-    const enabledToolNames = getEnabledApiToolNames(messages);
-    if (!sessionId) {
-        return enabledToolNames;
-    }
-    for (const toolName of getSessionLoadedApiToolNames(sessionId)) {
-        enabledToolNames.add(toolName);
-    }
-    return enabledToolNames;
-}
-function getToolMessageContent(message) {
-    if (!ToolMessage.isInstance(message)) {
-        return "";
-    }
-    return typeof message.content === "string"
-        ? message.content
-        : Array.isArray(message.content)
-            ? message.content
-                .map((block) => typeof block === "string"
-                ? block
-                : "text" in block
-                    ? block.text
-                    : "")
-                .join("")
-            : "";
-}
-function rememberLoadedToolFromFetchResult(sessionId, result) {
-    if (!ToolMessage.isInstance(result) || result.name !== "fetch_tool_schema") {
-        return;
-    }
-    try {
-        const parsed = JSON.parse(getToolMessageContent(result));
-        if (parsed.status === 200 && parsed.name) {
-            getSessionLoadedApiToolNames(sessionId).add(parsed.name);
-        }
-    }
-    catch (_a) { }
-}
 export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
     const alwaysAvailableApiToolNames = new Set(ALWAYS_AVAILABLE_API_TOOL_NAMES);
     const dynamicTools = Object.fromEntries(Object.entries(apiBasedTools).map(([toolName, apiBasedTool]) => [
@@ -98,8 +51,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
         name: "ApiBasedToolsMiddleware",
         wrapModelCall(request, handler) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { sessionId } = request.runtime.context;
-                const enabledApiToolNames = getEnabledApiToolNamesForSession(request.state.messages, sessionId);
+                const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
                 const tools = [...enabledApiToolNames]
                     .filter((toolName) => !alwaysAvailableApiToolNames.has(toolName))
                     .map((toolName) => dynamicTools[toolName]);
@@ -113,7 +65,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                 var _a, _b, _c, _d;
                 const startedAt = Date.now();
                 const toolInput = JSON.stringify((_a = request.toolCall.args) !== null && _a !== void 0 ? _a : {});
-                const { adminUser, emitToolCallEvent, sessionId, userTimeZone } = request.runtime.context;
+                const { adminUser, emitToolCallEvent, userTimeZone } = request.runtime.context;
                 const toolArgs = ((_b = request.toolCall.args) !== null && _b !== void 0 ? _b : {});
                 let toolInfo;
                 if (request.toolCall.name === "fetch_skill") {
@@ -147,7 +99,7 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                         result = yield handler(request);
                     }
                     else {
-                        const enabledApiToolNames = getEnabledApiToolNamesForSession(request.state.messages, sessionId);
+                        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] }));
                         }
@@ -160,9 +112,6 @@ export function createApiBasedToolsMiddleware(apiBasedTools, adminforth) {
                             });
                         }
                     }
-                    if (sessionId) {
-                        rememberLoadedToolFromFetchResult(sessionId, result);
-                    }
                     toolCallTracker.finishSuccess(result);
                     return result;
                 }

package/dist/agent/tools/fetchToolSchema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type ApiBasedTool } from "../../apiBasedTools.js";
+import type { ApiBasedTool } from "../../apiBasedTools.js";
 export declare function createFetchToolSchemaTool(apiBasedTools: Record<string, ApiBasedTool>): Promise<import("langchain").DynamicStructuredTool<z.ZodObject<{
     toolName: z.ZodString;
 }, z.core.$strip>, {

package/dist/agent/tools/fetchToolSchema.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { tool } from "langchain";
 import { z } from "zod";
-import { serializeApiBasedTool, } from "../../apiBasedTools.js";
 const fetchToolSchemaSchema = z.object({
     toolName: z
         .string()
@@ -26,7 +25,11 @@ export function createFetchToolSchemaTool(apiBasedTools) {
                     message: `Tool "${toolName}" not found.`,
                 }, null, 2);
             }
-            return JSON.stringify(Object.assign({ status: 200, name: toolName }, serializeApiBasedTool(toolDefinition)), null, 2);
+            return JSON.stringify({
+                status: 200,
+                name: toolName,
+                loaded: true,
+            }, null, 2);
         }), {
             name: "fetch_tool_schema",
             description: "Fetch the schema for an API-based AdminForth tool by name and load it for later use. Use this right after fetch_skill when the skill mentions non-base tools.",

package/dist/apiBasedTools.d.ts

@@ -10,7 +10,6 @@ export type ApiBasedToolCallParams = {
 export type ApiBasedTool = {
     description?: string;
     input_schema?: unknown;
-    output_schema?: unknown;
     call: (params?: ApiBasedToolCallParams) => Promise<string>;
 };
 export declare function formatApiBasedToolCall(params: {
@@ -21,9 +20,3 @@ export declare function formatApiBasedToolCall(params: {
     userTimeZone?: string;
 }): Promise<string | undefined>;
 export declare function prepareApiBasedTools(adminforth: IAdminForth, hiddenResourceIds?: Iterable<string>): Record<string, ApiBasedTool>;
-export declare function serializeApiBasedTool(tool: ApiBasedTool | undefined): {
-    description: string | undefined;
-    input_schema: unknown;
-    output_schema: unknown;
-    call: string;
-} | null;

package/dist/apiBasedTools.js

@@ -410,7 +410,6 @@ export function prepareApiBasedTools(adminforth, hiddenResourceIds = []) {
         apiBasedTools[toolName] = {
             description: schema.description,
             input_schema: schema.request_schema,
-            output_schema: schema.response_schema,
             call: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ adminUser, adminuser, abortSignal, inputs, userTimeZone, acceptLanguage } = {}) {
                 if (isHiddenResourceCall(hiddenResourceIdSet, inputs)) {
                     return YAML.stringify({
@@ -442,14 +441,3 @@ export function prepareApiBasedTools(adminforth, hiddenResourceIds = []) {
     }
     return apiBasedTools;
 }
-export function serializeApiBasedTool(tool) {
-    if (!tool) {
-        return null;
-    }
-    return {
-        description: tool.description,
-        input_schema: tool.input_schema,
-        output_schema: tool.output_schema,
-        call: '[Function]',
-    };
-}

package/package.json

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