@adminforth/agent 1.24.14 → 1.25.0

package/agent/simpleAgent.ts

@@ -4,6 +4,7 @@ import {
   logger,
   type AdminUser,
   type CompletionAdapter,
+  type HttpExtra,
   type IAdminForth,
 } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
@@ -24,6 +25,7 @@ export const contextSchema = z.object({
   userTimeZone: z.string(),
   sessionId: z.string(),
   turnId: z.string(),
+  httpExtra: z.custom<Partial<HttpExtra>>().optional(),
   emitToolCallEvent: z.custom<ToolCallEventSink>(),
 });
 
@@ -229,6 +231,7 @@ export async function callAgent(params: {
   customComponentsDir: string;
   sessionId: string;
   turnId: string;
+  httpExtra?: Partial<HttpExtra>;
   userTimeZone: string;
   emitToolCallEvent: ToolCallEventSink;
   sequenceDebugSink: SequenceDebugModelCallSink;
@@ -246,6 +249,7 @@ export async function callAgent(params: {
     customComponentsDir,
     sessionId,
     turnId,
+    httpExtra,
     userTimeZone,
     emitToolCallEvent,
     sequenceDebugSink,
@@ -289,6 +293,7 @@ export async function callAgent(params: {
       userTimeZone,
       sessionId,
       turnId,
+      httpExtra,
       emitToolCallEvent,
     },
   });

package/agent/tools/apiTool.ts

@@ -51,6 +51,7 @@ export function createApiTool(toolName: string, apiBasedTool: ApiBasedTool) {
       const normalizedInput = (input ?? {}) as Record<string, unknown>;
       return apiBasedTool.call({
         adminUser: runtime.context.adminUser,
+        httpExtra: runtime.context.httpExtra,
         inputs: normalizedInput,
         userTimeZone: runtime.context.userTimeZone,
       });

package/apiBasedTools.ts

@@ -1,16 +1,14 @@
 import {
   AdminForthDataTypes,
+  logger,
   type AdminUser,
   type HttpExtra,
   type IAdminForth,
-  type IAdminForthHttpResponse,
-  type IHttpServer,
   type IRegisteredApiSchema,
 } from 'adminforth';
 import dayjs from 'dayjs';
 import timezone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
-import { PassThrough } from 'stream';
 import { inspect } from 'util';
 import YAML from 'yaml';
 
@@ -22,47 +20,6 @@ type CookieItem = {
   value: string;
 };
 
-type CapturedEndpointHandlerInput = {
-  body: Record<string, unknown>;
-  adminUser?: AdminUser;
-  query: Record<string, string>;
-  headers: Record<string, any>;
-  cookies: CookieItem[];
-  response: IAdminForthHttpResponse;
-  requestUrl: string;
-  abortSignal: AbortSignal;
-  _raw_express_req: any;
-  _raw_express_res: any;
-  tr: (
-    msg: string,
-    category: string,
-    params: any,
-    pluralizationNumber?: number,
-  ) => Promise<string>;
-};
-
-type EndpointWithSchemas = {
-  method: string;
-  noAuth?: boolean;
-  path: string;
-  description?: string;
-  request_schema?: unknown;
-  response_schema?: unknown;
-  responce_schema?: unknown;
-  handler: (input: CapturedEndpointHandlerInput) => Promise<any> | any;
-};
-
-type CapturedEndpoint = EndpointWithSchemas & {
-  normalizedResponseSchema?: unknown;
-};
-
-type ToolHttpResponse = IAdminForthHttpResponse & {
-  headers: Array<[string, string]>;
-  jsonPayload?: unknown;
-  status: number;
-  message?: string;
-};
-
 type ToolOverrideCallParams = Pick<ApiBasedToolCallParams, 'httpExtra' | 'inputs' | 'userTimeZone'>;
 
 type ToolOverrideContext = {
@@ -388,9 +345,9 @@ function formatDateTimeColumns(
 async function applyToolOverride(params: {
   adminforth: IAdminForth;
   adminUser?: AdminUser;
-  capturedEndpointsByToolName: Record<string, CapturedEndpoint>;
   httpExtra?: Partial<HttpExtra>;
   inputs?: Record<string, unknown>;
+  invokeTool: (toolName: string, params?: ToolOverrideCallParams) => Promise<unknown>;
   output: unknown;
   toolName: string;
   userTimeZone?: string;
@@ -398,9 +355,9 @@ async function applyToolOverride(params: {
   const {
     adminforth,
     adminUser,
-    capturedEndpointsByToolName,
     httpExtra,
     inputs,
+    invokeTool,
     output,
     toolName,
     userTimeZone,
@@ -427,19 +384,10 @@ async function applyToolOverride(params: {
     inputs,
     userTimeZone,
     invokeTool: async (nestedToolName, nestedParams = {}) => {
-      const nestedEndpoint = capturedEndpointsByToolName[nestedToolName];
-
-      if (!nestedEndpoint) {
-        throw new Error(`Tool ${nestedToolName} is not registered`);
-      }
-
       const nestedInputs = nestedParams.inputs ?? inputs;
       const nestedHttpExtra = nestedParams.httpExtra ?? httpExtra;
       const nestedUserTimeZone = nestedParams.userTimeZone ?? userTimeZone;
-      const nestedOutput = await callCapturedEndpoint({
-        adminforth,
-        endpoint: nestedEndpoint,
-        adminUser,
+      const nestedOutput = await invokeTool(nestedToolName, {
         inputs: nestedInputs,
         httpExtra: nestedHttpExtra,
         userTimeZone: nestedUserTimeZone,
@@ -448,9 +396,9 @@ async function applyToolOverride(params: {
       return applyToolOverride({
         adminforth,
         adminUser,
-        capturedEndpointsByToolName,
         httpExtra: nestedHttpExtra,
         inputs: nestedInputs,
+        invokeTool,
         output: nestedOutput,
         toolName: nestedToolName,
         userTimeZone: nestedUserTimeZone,
@@ -487,6 +435,10 @@ function openApiSchemaPathToToolName(path: string, adminforth: IAdminForth) {
   return endpointPathToToolName(stripAdminApiPrefix(path, adminforth));
 }
 
+function formatLogNameList(names: string[]) {
+  return names.length ? names.join(', ') : '(none)';
+}
+
 export async function formatApiBasedToolCall(params: {
   adminforth: IAdminForth;
   adminUser?: AdminUser;
@@ -523,84 +475,6 @@ function normalizeCookies(
   return Object.entries(cookies).map(([key, value]) => ({ key, value }));
 }
 
-function createToolResponse(baseResponse?: IAdminForthHttpResponse): ToolHttpResponse {
-  return {
-    headers: [],
-    status: 200,
-    message: undefined,
-    setHeader(name, value) {
-      this.headers.push([name, value]);
-      baseResponse?.setHeader(name, value);
-    },
-    setStatus(code, message) {
-      this.status = code;
-      this.message = message;
-      baseResponse?.setStatus(code, message);
-    },
-    blobStream() {
-      return baseResponse?.blobStream() ?? new PassThrough();
-    },
-  };
-}
-
-function createRawExpressRequest(params: {
-  adminUser?: AdminUser;
-  body: Record<string, unknown>;
-  cookies: CookieItem[];
-  headers: Record<string, any>;
-  method: string;
-  query: Record<string, string>;
-  requestUrl: string;
-}) {
-  const cookieHeader = params.cookies
-    .map(({ key, value }) => `${key}=${value}`)
-    .join('; ');
-
-  return {
-    adminUser: params.adminUser,
-    body: params.body,
-    destroyed: false,
-    headers: {
-      ...params.headers,
-      ...(cookieHeader ? { cookie: cookieHeader } : {}),
-    },
-    method: params.method.toUpperCase(),
-    on: () => undefined,
-    query: params.query,
-    url: params.requestUrl,
-  };
-}
-
-function createRawExpressResponse(response: ToolHttpResponse) {
-  const rawResponse = {
-    destroyed: false,
-    on: () => undefined,
-    setHeader(name: string, value: string) {
-      response.setHeader(name, value);
-      return rawResponse;
-    },
-    status(code: number) {
-      response.status = code;
-      return rawResponse;
-    },
-    send(message: string) {
-      response.message = message;
-      return rawResponse;
-    },
-    json(payload: unknown) {
-      response.jsonPayload = payload;
-      response.message = JSON.stringify(payload);
-      return rawResponse;
-    },
-    write: () => true,
-    writeHead: () => rawResponse,
-    writableEnded: false,
-    end: () => rawResponse,
-  };
-
-  return rawResponse;
-}
-
 function normalizeDateTimeInputsToUtc(
   body: Record<string, unknown>,
   adminforth: IAdminForth,
@@ -679,100 +553,192 @@ function normalizeDateTimeInputsToUtc(
   return normalizeValue(body) as Record<string, unknown>;
 }
 
-async function callCapturedEndpoint(params: {
-  adminforth: IAdminForth;
-  adminUser?: AdminUser;
-  endpoint: CapturedEndpoint;
+const METHODS_WITHOUT_REQUEST_BODY = new Set(['GET', 'HEAD']);
+const HEADERS_NOT_FORWARDED_TO_API_TOOL = new Set([
+  'connection',
+  'content-length',
+  'host',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+]);
+
+function getHeaderValue(
+  headers: Partial<HttpExtra>['headers'] | undefined,
+  headerName: string,
+) {
+  const normalizedHeaderName = headerName.toLowerCase();
+  const value = Object.entries(headers ?? {}).find(
+    ([name]) => name.toLowerCase() === normalizedHeaderName,
+  )?.[1];
+
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  return value.split(',')[0].trim();
+}
+
+function isAbsoluteHttpUrl(value: string) {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'http:' || url.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function getRequestOrigin(httpExtra?: Partial<HttpExtra>) {
+  const requestUrl = httpExtra?.requestUrl;
+
+  if (requestUrl && isAbsoluteHttpUrl(requestUrl)) {
+    return new URL(requestUrl).origin;
+  }
+
+  const host = getHeaderValue(httpExtra?.headers, 'x-forwarded-host')
+    ?? getHeaderValue(httpExtra?.headers, 'host');
+
+  if (!host) {
+    return undefined;
+  }
+
+  const protocol = getHeaderValue(httpExtra?.headers, 'x-forwarded-proto') ?? 'http';
+  return `${protocol}://${host}`;
+}
+
+function resolveOpenApiRequestUrl(params: {
   httpExtra?: Partial<HttpExtra>;
-  inputs?: Record<string, unknown>;
-  userTimeZone?: string;
+  path: string;
+  toolName: string;
 }) {
-  const { adminforth, adminUser, endpoint, httpExtra, inputs, userTimeZone } = params;
-  const response = createToolResponse(httpExtra?.response);
-  const headers = {
-    'content-type': 'application/json',
-    'X-TimeZone': userTimeZone,
-    ...(httpExtra?.headers ?? {}),
-  };
-  const body = normalizeDateTimeInputsToUtc(
-    (inputs ?? httpExtra?.body ?? {}) as Record<string, unknown>,
-    adminforth,
-    headers['X-TimeZone'],
-  );
-  const query = httpExtra?.query ?? {};
-  const cookies = normalizeCookies(httpExtra?.cookies);
-  const requestUrl = httpExtra?.requestUrl ?? `${adminforth.config.baseUrl}/adminapi/v1${endpoint.path}`;
-  const abortController = new AbortController();
-  const rawRequest = createRawExpressRequest({
-    adminUser,
-    body,
-    cookies,
-    headers,
-    method: endpoint.method,
-    query,
-    requestUrl,
-  });
-  const rawResponse = createRawExpressResponse(response);
-  const acceptLanguage = headers['accept-language'];
-  const tr = (
-    msg: string,
-    category: string = 'default',
-    translationParams: any,
-    pluralizationNumber?: number,
-  ) => adminforth.tr(msg, category, acceptLanguage, translationParams, pluralizationNumber);
-
-  const output = await endpoint.handler({
-    body,
-    adminUser,
-    query,
-    headers,
-    cookies,
-    response,
-    requestUrl,
-    abortSignal: abortController.signal,
-    _raw_express_req: rawRequest,
-    _raw_express_res: rawResponse,
-    tr,
-  });
+  if (isAbsoluteHttpUrl(params.path)) {
+    return params.path;
+  }
+
+  const origin = getRequestOrigin(params.httpExtra);
+
+  if (!origin) {
+    throw new Error(
+      `Tool "${params.toolName}" has relative OpenAPI path "${params.path}" but request host header is unavailable.`,
+    );
+  }
+
+  return new URL(params.path, origin).toString();
+}
+
+function createToolRequestHeaders(
+  httpExtra: Partial<HttpExtra> | undefined,
+  userTimeZone?: string,
+) {
+  const headers: Record<string, string> = {};
 
-  if (output !== undefined && output !== null) {
-    return output;
+  for (const [name, value] of Object.entries(httpExtra?.headers ?? {})) {
+    const headerName = name.toLowerCase();
+
+    if (typeof value === 'string' && !HEADERS_NOT_FORWARDED_TO_API_TOOL.has(headerName)) {
+      headers[headerName] = value;
+    }
   }
 
-  if (response.jsonPayload !== undefined) {
-    return response.jsonPayload;
+  headers.accept = 'application/json';
+  headers['content-type'] = 'application/json';
+
+  if (userTimeZone) {
+    headers['x-timezone'] = userTimeZone;
   }
 
-  if (response.message !== undefined) {
-    return response.message;
+  const cookieHeader = normalizeCookies(httpExtra?.cookies)
+    .map(({ key, value }) => `${key}=${value}`)
+    .join('; ');
+
+  if (cookieHeader && !headers.cookie) {
+    headers.cookie = cookieHeader;
+  }
+
+  return headers;
+}
+
+function appendInputsToQueryString(url: string, inputs: Record<string, unknown>) {
+  const nextUrl = new URL(url);
+
+  for (const [key, value] of Object.entries(inputs)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        nextUrl.searchParams.append(
+          key,
+          typeof item === 'object' && item !== null ? JSON.stringify(item) : String(item),
+        );
+      }
+      continue;
+    }
+
+    nextUrl.searchParams.set(
+      key,
+      typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value),
+    );
+  }
+
+  return nextUrl.toString();
+}
+
+async function parseOpenApiToolResponse(response: Response) {
+  const responseText = await response.text();
+  const payload = responseText && response.headers.get('content-type')?.includes('application/json')
+    ? JSON.parse(responseText)
+    : responseText;
+
+  if (response.ok) {
+    return responseText ? payload : { status: response.status };
   }
 
   return {
-    headers: response.headers,
+    error: 'HTTP_ERROR',
     status: response.status,
+    statusText: response.statusText,
+    response: payload,
   };
 }
 
-export function prepareApiBasedTools(adminforth: IAdminForth): Record<string, ApiBasedTool> {
-  const capturedEndpoints: CapturedEndpoint[] = [];
-
-  const captureServer: IHttpServer = {
-    setupSpaServer() {},
-    endpoint: ((options: EndpointWithSchemas) => {
-      capturedEndpoints.push({
-        ...options,
-        response_schema: options.response_schema ?? options.responce_schema,
-        normalizedResponseSchema: options.response_schema ?? options.responce_schema,
-      });
-    }) as IHttpServer['endpoint'],
-  };
+async function callOpenApiSchema(params: {
+  adminforth: IAdminForth;
+  httpExtra?: Partial<HttpExtra>;
+  inputs?: Record<string, unknown>;
+  schema: IRegisteredApiSchema;
+  toolName: string;
+  userTimeZone?: string;
+}) {
+  const { adminforth, httpExtra, inputs, schema, toolName, userTimeZone } = params;
+  const method = schema.method.toUpperCase();
+  const body = normalizeDateTimeInputsToUtc(
+    (inputs ?? httpExtra?.body ?? {}) as Record<string, unknown>,
+    adminforth,
+    userTimeZone,
+  );
+  const requestUrl = resolveOpenApiRequestUrl({
+    httpExtra,
+    path: schema.path,
+    toolName,
+  });
+  const hasRequestBody = !METHODS_WITHOUT_REQUEST_BODY.has(method);
+  const response = await fetch(hasRequestBody ? requestUrl : appendInputsToQueryString(requestUrl, body), {
+    method,
+    headers: createToolRequestHeaders(httpExtra, userTimeZone),
+    body: hasRequestBody ? JSON.stringify(body) : undefined,
+  });
 
-  adminforth.setupEndpoints(captureServer);
+  return parseOpenApiToolResponse(response);
+}
 
+export function prepareApiBasedTools(adminforth: IAdminForth): Record<string, ApiBasedTool> {
   const apiBasedTools: Record<string, ApiBasedTool> = {};
-  const capturedEndpointsByToolName = Object.fromEntries(
-    capturedEndpoints.map((endpoint) => [endpointPathToToolName(endpoint.path), endpoint]),
-  );
   const openApiSchemas = adminforth.openApi.registeredSchemas.filter(
     (schema) => schema.request_schema || schema.response_schema,
   );
@@ -783,24 +749,43 @@ export function prepareApiBasedTools(adminforth: IAdminForth): Record<string, Ap
     openApiSchemasByToolName.set(toolName, schema);
   }
 
+  logger.info(
+    `AdminForth Agent OpenAPI APIs: ${formatLogNameList(
+      adminforth.openApi.registeredSchemas.map((schema) => openApiSchemaPathToToolName(schema.path, adminforth)),
+    )}`,
+  );
+  logger.info(
+    `AdminForth Agent OpenAPI tools connected: ${formatLogNameList([...openApiSchemasByToolName.keys()])}`,
+  );
+
   for (const [toolName, schema] of openApiSchemasByToolName.entries()) {
-    const endpoint = capturedEndpointsByToolName[toolName];
     apiBasedTools[toolName] = {
       description: schema.description,
       input_schema: schema.request_schema,
       input_schma: schema.request_schema,
       output_schema: schema.response_schema,
       call: async ({ adminUser, adminuser, inputs, httpExtra, userTimeZone } = {}) => {
-        if (!endpoint) {
-          throw new Error(
-            `Tool "${toolName}" is defined in OpenAPI but has no callable AdminForth endpoint handler.`,
-          );
-        }
-
-        const output = await callCapturedEndpoint({
-          adminforth,
-          endpoint,
-          adminUser: adminUser ?? adminuser,
+        const invokeTool = async (
+          nextToolName: string,
+          nextParams: ToolOverrideCallParams = {},
+        ) => {
+          const nextSchema = openApiSchemasByToolName.get(nextToolName);
+
+          if (!nextSchema) {
+            throw new Error(`Tool ${nextToolName} is not registered in OpenAPI`);
+          }
+
+          return callOpenApiSchema({
+            adminforth,
+            schema: nextSchema,
+            toolName: nextToolName,
+            inputs: nextParams.inputs,
+            httpExtra: nextParams.httpExtra,
+            userTimeZone: nextParams.userTimeZone,
+          });
+        };
+
+        const output = await invokeTool(toolName, {
           inputs,
           httpExtra,
           userTimeZone,
@@ -809,9 +794,9 @@ export function prepareApiBasedTools(adminforth: IAdminForth): Record<string, Ap
         const processedOutput = await applyToolOverride({
           adminforth,
           adminUser: adminUser ?? adminuser,
-          capturedEndpointsByToolName,
           httpExtra,
           inputs,
+          invokeTool,
           output,
           toolName,
           userTimeZone,

package/build.log

@@ -38,5 +38,5 @@ custom/skills/fetch_data/SKILL.md
 custom/skills/mutate_data/
 custom/skills/mutate_data/SKILL.md
 
-sent 202,033 bytes  received 566 bytes  405,198.00 bytes/sec
+sent 202,067 bytes  received 566 bytes  405,266.00 bytes/sec
 total size is 199,749  speedup is 0.99

package/dist/agent/simpleAgent.js

@@ -19,6 +19,7 @@ export const contextSchema = z.object({
     userTimeZone: z.string(),
     sessionId: z.string(),
     turnId: z.string(),
+    httpExtra: z.custom().optional(),
     emitToolCallEvent: z.custom(),
 });
 function isLangChainAgentCompletionAdapter(adapter) {
@@ -130,7 +131,7 @@ export function createAgentChatModel(params) {
 }
 export function callAgent(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, sessionId, turnId, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
+        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, sessionId, turnId, httpExtra, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
         const tools = yield createAgentTools(customComponentsDir, apiBasedTools);
         const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
         const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
@@ -164,6 +165,7 @@ export function callAgent(params) {
                 userTimeZone,
                 sessionId,
                 turnId,
+                httpExtra,
                 emitToolCallEvent,
             },
         });

package/dist/agent/tools/apiTool.js

@@ -49,6 +49,7 @@ export function createApiTool(toolName, apiBasedTool) {
         const normalizedInput = (input !== null && input !== void 0 ? input : {});
         return apiBasedTool.call({
             adminUser: runtime.context.adminUser,
+            httpExtra: runtime.context.httpExtra,
             inputs: normalizedInput,
             userTimeZone: runtime.context.userTimeZone,
         });

package/dist/apiBasedTools.js

@@ -7,11 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthDataTypes, } from 'adminforth';
+import { AdminForthDataTypes, logger, } from 'adminforth';
 import dayjs from 'dayjs';
 import timezone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
-import { PassThrough } from 'stream';
 import { inspect } from 'util';
 import YAML from 'yaml';
 dayjs.extend(utc);
@@ -230,7 +229,7 @@ function formatDateTimeColumns(rows, dateTimeColumnNames, userTimeZone) {
 function applyToolOverride(params) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
-        const { adminforth, adminUser, capturedEndpointsByToolName, httpExtra, inputs, output, toolName, userTimeZone, } = params;
+        const { adminforth, adminUser, httpExtra, inputs, invokeTool, output, toolName, userTimeZone, } = params;
         const sanitizedOutput = sanitizeForYaml(output);
         const override = TOOL_OVERRIDES[toolName];
         if (!override) {
@@ -250,17 +249,10 @@ function applyToolOverride(params) {
             userTimeZone,
             invokeTool: (nestedToolName_1, ...args_1) => __awaiter(this, [nestedToolName_1, ...args_1], void 0, function* (nestedToolName, nestedParams = {}) {
                 var _a, _b, _c;
-                const nestedEndpoint = capturedEndpointsByToolName[nestedToolName];
-                if (!nestedEndpoint) {
-                    throw new Error(`Tool ${nestedToolName} is not registered`);
-                }
                 const nestedInputs = (_a = nestedParams.inputs) !== null && _a !== void 0 ? _a : inputs;
                 const nestedHttpExtra = (_b = nestedParams.httpExtra) !== null && _b !== void 0 ? _b : httpExtra;
                 const nestedUserTimeZone = (_c = nestedParams.userTimeZone) !== null && _c !== void 0 ? _c : userTimeZone;
-                const nestedOutput = yield callCapturedEndpoint({
-                    adminforth,
-                    endpoint: nestedEndpoint,
-                    adminUser,
+                const nestedOutput = yield invokeTool(nestedToolName, {
                     inputs: nestedInputs,
                     httpExtra: nestedHttpExtra,
                     userTimeZone: nestedUserTimeZone,
@@ -268,9 +260,9 @@ function applyToolOverride(params) {
                 return applyToolOverride({
                     adminforth,
                     adminUser,
-                    capturedEndpointsByToolName,
                     httpExtra: nestedHttpExtra,
                     inputs: nestedInputs,
+                    invokeTool,
                     output: nestedOutput,
                     toolName: nestedToolName,
                     userTimeZone: nestedUserTimeZone,
@@ -301,6 +293,9 @@ function stripAdminApiPrefix(path, adminforth) {
 function openApiSchemaPathToToolName(path, adminforth) {
     return endpointPathToToolName(stripAdminApiPrefix(path, adminforth));
 }
+function formatLogNameList(names) {
+    return names.length ? names.join(', ') : '(none)';
+}
 export function formatApiBasedToolCall(params) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -326,69 +321,6 @@ function normalizeCookies(cookies) {
     }
     return Object.entries(cookies).map(([key, value]) => ({ key, value }));
 }
-function createToolResponse(baseResponse) {
-    return {
-        headers: [],
-        status: 200,
-        message: undefined,
-        setHeader(name, value) {
-            this.headers.push([name, value]);
-            baseResponse === null || baseResponse === void 0 ? void 0 : baseResponse.setHeader(name, value);
-        },
-        setStatus(code, message) {
-            this.status = code;
-            this.message = message;
-            baseResponse === null || baseResponse === void 0 ? void 0 : baseResponse.setStatus(code, message);
-        },
-        blobStream() {
-            var _a;
-            return (_a = baseResponse === null || baseResponse === void 0 ? void 0 : baseResponse.blobStream()) !== null && _a !== void 0 ? _a : new PassThrough();
-        },
-    };
-}
-function createRawExpressRequest(params) {
-    const cookieHeader = params.cookies
-        .map(({ key, value }) => `${key}=${value}`)
-        .join('; ');
-    return {
-        adminUser: params.adminUser,
-        body: params.body,
-        destroyed: false,
-        headers: Object.assign(Object.assign({}, params.headers), (cookieHeader ? { cookie: cookieHeader } : {})),
-        method: params.method.toUpperCase(),
-        on: () => undefined,
-        query: params.query,
-        url: params.requestUrl,
-    };
-}
-function createRawExpressResponse(response) {
-    const rawResponse = {
-        destroyed: false,
-        on: () => undefined,
-        setHeader(name, value) {
-            response.setHeader(name, value);
-            return rawResponse;
-        },
-        status(code) {
-            response.status = code;
-            return rawResponse;
-        },
-        send(message) {
-            response.message = message;
-            return rawResponse;
-        },
-        json(payload) {
-            response.jsonPayload = payload;
-            response.message = JSON.stringify(payload);
-            return rawResponse;
-        },
-        write: () => true,
-        writeHead: () => rawResponse,
-        writableEnded: false,
-        end: () => rawResponse,
-    };
-    return rawResponse;
-}
 function normalizeDateTimeInputsToUtc(body, adminforth, userTimeZone) {
     if (!userTimeZone || typeof body.resourceId !== 'string') {
         return body;
@@ -437,90 +369,168 @@ function normalizeDateTimeInputsToUtc(body, adminforth, userTimeZone) {
     };
     return normalizeValue(body);
 }
-function callCapturedEndpoint(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const { adminforth, adminUser, endpoint, httpExtra, inputs, userTimeZone } = params;
-        const response = createToolResponse(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.response);
-        const headers = Object.assign({ 'content-type': 'application/json', 'X-TimeZone': userTimeZone }, ((_a = httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.headers) !== null && _a !== void 0 ? _a : {}));
-        const body = normalizeDateTimeInputsToUtc(((_b = inputs !== null && inputs !== void 0 ? inputs : httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.body) !== null && _b !== void 0 ? _b : {}), adminforth, headers['X-TimeZone']);
-        const query = (_c = httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.query) !== null && _c !== void 0 ? _c : {};
-        const cookies = normalizeCookies(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.cookies);
-        const requestUrl = (_d = httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.requestUrl) !== null && _d !== void 0 ? _d : `${adminforth.config.baseUrl}/adminapi/v1${endpoint.path}`;
-        const abortController = new AbortController();
-        const rawRequest = createRawExpressRequest({
-            adminUser,
-            body,
-            cookies,
-            headers,
-            method: endpoint.method,
-            query,
-            requestUrl,
-        });
-        const rawResponse = createRawExpressResponse(response);
-        const acceptLanguage = headers['accept-language'];
-        const tr = (msg, category = 'default', translationParams, pluralizationNumber) => adminforth.tr(msg, category, acceptLanguage, translationParams, pluralizationNumber);
-        const output = yield endpoint.handler({
-            body,
-            adminUser,
-            query,
-            headers,
-            cookies,
-            response,
-            requestUrl,
-            abortSignal: abortController.signal,
-            _raw_express_req: rawRequest,
-            _raw_express_res: rawResponse,
-            tr,
-        });
-        if (output !== undefined && output !== null) {
-            return output;
+const METHODS_WITHOUT_REQUEST_BODY = new Set(['GET', 'HEAD']);
+const HEADERS_NOT_FORWARDED_TO_API_TOOL = new Set([
+    'connection',
+    'content-length',
+    'host',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+]);
+function getHeaderValue(headers, headerName) {
+    var _a;
+    const normalizedHeaderName = headerName.toLowerCase();
+    const value = (_a = Object.entries(headers !== null && headers !== void 0 ? headers : {}).find(([name]) => name.toLowerCase() === normalizedHeaderName)) === null || _a === void 0 ? void 0 : _a[1];
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    return value.split(',')[0].trim();
+}
+function isAbsoluteHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function getRequestOrigin(httpExtra) {
+    var _a, _b;
+    const requestUrl = httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.requestUrl;
+    if (requestUrl && isAbsoluteHttpUrl(requestUrl)) {
+        return new URL(requestUrl).origin;
+    }
+    const host = (_a = getHeaderValue(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.headers, 'x-forwarded-host')) !== null && _a !== void 0 ? _a : getHeaderValue(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.headers, 'host');
+    if (!host) {
+        return undefined;
+    }
+    const protocol = (_b = getHeaderValue(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.headers, 'x-forwarded-proto')) !== null && _b !== void 0 ? _b : 'http';
+    return `${protocol}://${host}`;
+}
+function resolveOpenApiRequestUrl(params) {
+    if (isAbsoluteHttpUrl(params.path)) {
+        return params.path;
+    }
+    const origin = getRequestOrigin(params.httpExtra);
+    if (!origin) {
+        throw new Error(`Tool "${params.toolName}" has relative OpenAPI path "${params.path}" but request host header is unavailable.`);
+    }
+    return new URL(params.path, origin).toString();
+}
+function createToolRequestHeaders(httpExtra, userTimeZone) {
+    var _a;
+    const headers = {};
+    for (const [name, value] of Object.entries((_a = httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.headers) !== null && _a !== void 0 ? _a : {})) {
+        const headerName = name.toLowerCase();
+        if (typeof value === 'string' && !HEADERS_NOT_FORWARDED_TO_API_TOOL.has(headerName)) {
+            headers[headerName] = value;
         }
-        if (response.jsonPayload !== undefined) {
-            return response.jsonPayload;
+    }
+    headers.accept = 'application/json';
+    headers['content-type'] = 'application/json';
+    if (userTimeZone) {
+        headers['x-timezone'] = userTimeZone;
+    }
+    const cookieHeader = normalizeCookies(httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.cookies)
+        .map(({ key, value }) => `${key}=${value}`)
+        .join('; ');
+    if (cookieHeader && !headers.cookie) {
+        headers.cookie = cookieHeader;
+    }
+    return headers;
+}
+function appendInputsToQueryString(url, inputs) {
+    const nextUrl = new URL(url);
+    for (const [key, value] of Object.entries(inputs)) {
+        if (value === undefined) {
+            continue;
         }
-        if (response.message !== undefined) {
-            return response.message;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                nextUrl.searchParams.append(key, typeof item === 'object' && item !== null ? JSON.stringify(item) : String(item));
+            }
+            continue;
+        }
+        nextUrl.searchParams.set(key, typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value));
+    }
+    return nextUrl.toString();
+}
+function parseOpenApiToolResponse(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const responseText = yield response.text();
+        const payload = responseText && ((_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json'))
+            ? JSON.parse(responseText)
+            : responseText;
+        if (response.ok) {
+            return responseText ? payload : { status: response.status };
         }
         return {
-            headers: response.headers,
+            error: 'HTTP_ERROR',
             status: response.status,
+            statusText: response.statusText,
+            response: payload,
         };
     });
 }
+function callOpenApiSchema(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { adminforth, httpExtra, inputs, schema, toolName, userTimeZone } = params;
+        const method = schema.method.toUpperCase();
+        const body = normalizeDateTimeInputsToUtc(((_a = inputs !== null && inputs !== void 0 ? inputs : httpExtra === null || httpExtra === void 0 ? void 0 : httpExtra.body) !== null && _a !== void 0 ? _a : {}), adminforth, userTimeZone);
+        const requestUrl = resolveOpenApiRequestUrl({
+            httpExtra,
+            path: schema.path,
+            toolName,
+        });
+        const hasRequestBody = !METHODS_WITHOUT_REQUEST_BODY.has(method);
+        const response = yield fetch(hasRequestBody ? requestUrl : appendInputsToQueryString(requestUrl, body), {
+            method,
+            headers: createToolRequestHeaders(httpExtra, userTimeZone),
+            body: hasRequestBody ? JSON.stringify(body) : undefined,
+        });
+        return parseOpenApiToolResponse(response);
+    });
+}
 export function prepareApiBasedTools(adminforth) {
-    const capturedEndpoints = [];
-    const captureServer = {
-        setupSpaServer() { },
-        endpoint: ((options) => {
-            var _a, _b;
-            capturedEndpoints.push(Object.assign(Object.assign({}, options), { response_schema: (_a = options.response_schema) !== null && _a !== void 0 ? _a : options.responce_schema, normalizedResponseSchema: (_b = options.response_schema) !== null && _b !== void 0 ? _b : options.responce_schema }));
-        }),
-    };
-    adminforth.setupEndpoints(captureServer);
     const apiBasedTools = {};
-    const capturedEndpointsByToolName = Object.fromEntries(capturedEndpoints.map((endpoint) => [endpointPathToToolName(endpoint.path), endpoint]));
     const openApiSchemas = adminforth.openApi.registeredSchemas.filter((schema) => schema.request_schema || schema.response_schema);
     const openApiSchemasByToolName = new Map();
     for (const schema of openApiSchemas) {
         const toolName = openApiSchemaPathToToolName(schema.path, adminforth);
         openApiSchemasByToolName.set(toolName, schema);
     }
+    logger.info(`AdminForth Agent OpenAPI APIs: ${formatLogNameList(adminforth.openApi.registeredSchemas.map((schema) => openApiSchemaPathToToolName(schema.path, adminforth)))}`);
+    logger.info(`AdminForth Agent OpenAPI tools connected: ${formatLogNameList([...openApiSchemasByToolName.keys()])}`);
     for (const [toolName, schema] of openApiSchemasByToolName.entries()) {
-        const endpoint = capturedEndpointsByToolName[toolName];
         apiBasedTools[toolName] = {
             description: schema.description,
             input_schema: schema.request_schema,
             input_schma: schema.request_schema,
             output_schema: schema.response_schema,
             call: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ adminUser, adminuser, inputs, httpExtra, userTimeZone } = {}) {
-                if (!endpoint) {
-                    throw new Error(`Tool "${toolName}" is defined in OpenAPI but has no callable AdminForth endpoint handler.`);
-                }
-                const output = yield callCapturedEndpoint({
-                    adminforth,
-                    endpoint,
-                    adminUser: adminUser !== null && adminUser !== void 0 ? adminUser : adminuser,
+                const invokeTool = (nextToolName_1, ...args_2) => __awaiter(this, [nextToolName_1, ...args_2], void 0, function* (nextToolName, nextParams = {}) {
+                    const nextSchema = openApiSchemasByToolName.get(nextToolName);
+                    if (!nextSchema) {
+                        throw new Error(`Tool ${nextToolName} is not registered in OpenAPI`);
+                    }
+                    return callOpenApiSchema({
+                        adminforth,
+                        schema: nextSchema,
+                        toolName: nextToolName,
+                        inputs: nextParams.inputs,
+                        httpExtra: nextParams.httpExtra,
+                        userTimeZone: nextParams.userTimeZone,
+                    });
+                });
+                const output = yield invokeTool(toolName, {
                     inputs,
                     httpExtra,
                     userTimeZone,
@@ -528,9 +538,9 @@ export function prepareApiBasedTools(adminforth) {
                 const processedOutput = yield applyToolOverride({
                     adminforth,
                     adminUser: adminUser !== null && adminUser !== void 0 ? adminUser : adminuser,
-                    capturedEndpointsByToolName,
                     httpExtra,
                     inputs,
+                    invokeTool,
                     output,
                     toolName,
                     userTimeZone,

package/dist/index.js

@@ -168,11 +168,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         });
     }
     validateConfigAfterDiscover(adminforth, resourceConfig) {
-        this.apiBasedTools = buildApiBasedTools(adminforth);
-        for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
-            assertRequiredApiTool(this.apiBasedTools, toolName);
-        }
-        assertRequiredApiTool(this.apiBasedTools, "update_record");
         this.agentSystemPromptPromise = buildAgentSystemPrompt(adminforth)
             .then((systemPrompt) => appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt));
     }
@@ -208,7 +203,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         server.endpoint({
             method: 'POST',
             path: `/agent/response`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, _raw_express_res }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, query, headers, cookies, adminUser, response, requestUrl, _raw_express_res }) {
                 var _b, e_1, _c, _d;
                 var _e, _f, _g;
                 const res = _raw_express_res;
@@ -288,6 +283,12 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                     const selectedMode = (_g = this.options.modes.find((mode) => mode.name === body.mode)) !== null && _g !== void 0 ? _g : this.options.modes[0];
                     const { model, summaryModel, modelMiddleware } = yield this.getModeModels(selectedMode, maxTokens);
                     const systemPrompt = yield this.agentSystemPromptPromise;
+                    const apiBasedTools = buildApiBasedTools(this.adminforth);
+                    for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
+                        assertRequiredApiTool(apiBasedTools, toolName);
+                    }
+                    assertRequiredApiTool(apiBasedTools, "update_record");
+                    this.apiBasedTools = apiBasedTools;
                     const stream = yield callAgent({
                         name: `adminforth-agent-${this.pluginInstanceId}`,
                         model,
@@ -300,10 +301,18 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                         ],
                         adminUser,
                         adminforth: this.adminforth,
-                        apiBasedTools: this.apiBasedTools,
+                        apiBasedTools,
                         customComponentsDir: this.adminforth.config.customization.customComponentsDir,
                         sessionId,
                         turnId,
+                        httpExtra: {
+                            body,
+                            query,
+                            headers,
+                            cookies,
+                            requestUrl,
+                            response,
+                        },
                         userTimeZone,
                         emitToolCallEvent,
                         sequenceDebugSink: sequenceDebugCollector,

package/index.ts

@@ -204,11 +204,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
   }
   
   validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
-    this.apiBasedTools = buildApiBasedTools(adminforth);
-    for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
-      assertRequiredApiTool(this.apiBasedTools, toolName);
-    }
-    assertRequiredApiTool(this.apiBasedTools, "update_record");
     this.agentSystemPromptPromise = buildAgentSystemPrompt(adminforth)
       .then((systemPrompt) => appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt));
   }
@@ -248,7 +243,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     server.endpoint({
       method: 'POST',
       path: `/agent/response`,
-      handler: async ({ body, adminUser, _raw_express_res }) => {
+      handler: async ({ body, query, headers, cookies, adminUser, response, requestUrl, _raw_express_res }) => {
         const res = _raw_express_res;
         const messageId = randomUUID();
         const prompt = body.message;
@@ -346,6 +341,12 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
           const { model, summaryModel, modelMiddleware } =
             await this.getModeModels(selectedMode, maxTokens);
           const systemPrompt = await this.agentSystemPromptPromise;
+          const apiBasedTools = buildApiBasedTools(this.adminforth);
+          for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
+            assertRequiredApiTool(apiBasedTools, toolName);
+          }
+          assertRequiredApiTool(apiBasedTools, "update_record");
+          this.apiBasedTools = apiBasedTools;
           const stream = await callAgent({
             name: `adminforth-agent-${this.pluginInstanceId}`,
             model,
@@ -358,10 +359,18 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             ],
             adminUser,
             adminforth: this.adminforth,
-            apiBasedTools: this.apiBasedTools,
+            apiBasedTools,
             customComponentsDir: this.adminforth.config.customization.customComponentsDir,
             sessionId,
             turnId,
+            httpExtra: {
+              body,
+              query,
+              headers,
+              cookies,
+              requestUrl,
+              response,
+            },
             userTimeZone,
             emitToolCallEvent,
             sequenceDebugSink: sequenceDebugCollector,

package/package.json

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