@adminforth/agent 1.24.14 → 1.26.0

package/custom/conversation_area/ConversationArea.vue

@@ -34,9 +34,10 @@
     > 
 
       <div 
-        v-for="(message, index) in props.messages" :key="message.id"
+        v-for="(message, index) in props.messages" :key="index"
         class="flex flex-col w-full mt-2"
         :class="message.role === 'user' ? 'self-end' : 'self-start'"
+        ref="messagesRefs"
       >
         <MessageRenderer :message="message" :isLastMessageInChat="index === props.messages.length - 1"/>
       </div>
@@ -50,7 +51,7 @@
         <p>{{ $t('Start the conversation') }}</p>
         <p class="tracking-normal text-base text">{{ $t('Give any input to begin') }}</p>
       </div>
-      <div></div>
+      <div v-if="showBottomSpacer" class="w-full" :style="{ height: spacerHeight + 'px' }"></div>
     </CustomAutoScrollContainer>
     <button @click="scrollContainer.scrollToBottom();">
       <IconArrowDownOutline 
@@ -64,8 +65,8 @@
 
 
 <script setup lang="ts">
-import type { IMessage, IPart } from '../types';
-import { useTemplateRef, ref, defineAsyncComponent, onMounted, onUnmounted, watch, computed, nextTick } from 'vue';
+import type { IMessage } from '../types';
+import { useTemplateRef, ref, onMounted, onUnmounted, watch, nextTick } from 'vue';
 import { IconArrowDownOutline } from '@iconify-prerendered/vue-flowbite';
 import SessionsHistory from '../SessionsHistory.vue';
 import { useAgentStore } from '../composables/useAgentStore';
@@ -77,18 +78,140 @@ const props = defineProps<{
   messages: IMessage[]
 }>();
 
+defineExpose({
+  handleSendMessage
+});
+
 const scrollContainer = useTemplateRef('scrollContainer');
 const showScrollToBottomButton = ref(false);
-const innerScrollContainerRef = ref(null);
+const innerScrollContainerRef = ref<HTMLElement | null>(null);
 const agentStore = useAgentStore();
 const agentTransitions = useAgentTransitions();
 const showScrollContainer = ref(true);
-const chatContainerRef = ref(null);
+const chatContainerRef = ref<HTMLElement | null>(null);
 
-const scrollHeight = computed(() => {
-  return scrollContainer.value ? scrollContainer.value.scrollParams.scrollHeight : 0;
+const messagesRefs = ref<Array<HTMLElement | null>>([]);
+const showBottomSpacer = ref(false);
+const spacerHeight = ref(0);
+const MASK_HEIGHT = 20;
+const EMPTY_MESSAGE_HEIGHT = 18;
+let messageResizeObserver: ResizeObserver | null = null;
+let observedLastUserMessageElement: HTMLElement | null = null;
+let observedLastAgentMessageElement: HTMLElement | null = null;
+
+function resetSpacer() {
+  showBottomSpacer.value = false;
+  spacerHeight.value = 0;
+}
+
+watch(() => agentStore.activeSessionId, () => {
+  resetSpacer();
 });
 
+function getLastMessageElement(role: 'user' | 'assistant') {
+  const lastMessageIndex = props.messages.findLastIndex((message: IMessage) => message.role === role);
+  return messagesRefs.value[lastMessageIndex] ?? null;
+}
+
+function getHeightOfLastUserMessage() {
+  return getLastMessageElement('user')?.clientHeight ?? 0;
+}
+
+function getHeightOfLastAgentMessage() {
+  return getLastMessageElement('assistant')?.clientHeight ?? 0;
+}
+
+function getScrollClientHeight() {
+  return scrollContainer.value?.container.scrollEl.clientHeight ?? scrollContainer.value?.scrollParams.clientHeight ?? 0;
+}
+
+async function waitForRealHeight(role: 'user' | 'assistant'): Promise<number> {
+  return new Promise((resolve) => {
+    const interval = setInterval(() => {
+      const height = role === 'user' ? getHeightOfLastUserMessage() : getHeightOfLastAgentMessage();
+
+      if (height > EMPTY_MESSAGE_HEIGHT) {
+        clearInterval(interval);
+        resolve(height);
+      }
+    }, 50);
+  });
+}
+
+const useWaitingForHeight = ref(false);
+async function updateSpacerHeight() {
+  if (!showBottomSpacer.value) {
+    return;
+  }
+
+  const clientHeight = getScrollClientHeight();
+
+  if (!clientHeight) {
+    return;
+  }
+
+  const lastUserMessageHeight = useWaitingForHeight.value ? await waitForRealHeight('user') : getHeightOfLastUserMessage();
+  const lastAgentMessageHeight = useWaitingForHeight.value ? await waitForRealHeight('assistant') : getHeightOfLastAgentMessage();
+
+  spacerHeight.value = Math.max(0, clientHeight - (lastUserMessageHeight + MASK_HEIGHT + lastAgentMessageHeight));
+}
+
+function stopObservingLastMessages() {
+  if (!messageResizeObserver) {
+    return;
+  }
+
+  if (observedLastUserMessageElement) {
+    messageResizeObserver.unobserve(observedLastUserMessageElement);
+    observedLastUserMessageElement = null;
+  }
+
+  if (observedLastAgentMessageElement) {
+    messageResizeObserver.unobserve(observedLastAgentMessageElement);
+    observedLastAgentMessageElement = null;
+  }
+}
+
+function observeLastMessages() {
+  if (!messageResizeObserver) {
+    return;
+  }
+
+  stopObservingLastMessages();
+
+  observedLastUserMessageElement = getLastMessageElement('user');
+  observedLastAgentMessageElement = getLastMessageElement('assistant');
+
+  if (observedLastUserMessageElement) {
+    messageResizeObserver.observe(observedLastUserMessageElement);
+  }
+
+  if (observedLastAgentMessageElement) {
+    messageResizeObserver.observe(observedLastAgentMessageElement);
+  }
+}
+
+async function refreshSpacerTracking() {
+  await nextTick();
+  observeLastMessages();
+  await updateSpacerHeight();
+}
+
+async function handleSendMessage() {
+  const clientHeight = getScrollClientHeight();
+
+  if (clientHeight) {
+    showBottomSpacer.value = true;
+    useWaitingForHeight.value = true;
+    setTimeout(() => {
+      useWaitingForHeight.value = false;
+    }, 1000);
+    await updateSpacerHeight();
+    await nextTick();
+    scrollContainer.value?.scrollToBottom();
+  }
+}
+
 function recalculateScroll() {
   if (scrollContainer.value) {
     scrollContainer.value.handleScroll(false);
@@ -101,26 +224,44 @@ watch(() => agentStore.activeSessionId, async () => {
   showScrollContainer.value = false;
   await nextTick();
   showScrollContainer.value = true;
-  await nextTick();
+  await refreshSpacerTracking();
   recalculateScroll();
 });
 
+watch(() => props.messages.length, async () => {
+  await refreshSpacerTracking();
+});
+
 onMounted(async () => {
+  messageResizeObserver = new ResizeObserver(() => {
+    updateSpacerHeight();
+  });
+
   await import('@incremark/theme/styles.css')
   await agentStore.fetchPlaceholderMessages()
+  await refreshSpacerTracking();
 });
 
 onUnmounted(() => {
+  if (innerScrollContainerRef.value) {
+    innerScrollContainerRef.value.removeEventListener('scroll', recalculateScroll);
+  }
+
+  stopObservingLastMessages();
+  messageResizeObserver?.disconnect();
   agentStore.stopPlaceholderAnimation();
 });
 
-watch(scrollContainer, () => {
+watch(scrollContainer, async () => {
+  if (innerScrollContainerRef.value) {
+    innerScrollContainerRef.value.removeEventListener('scroll', recalculateScroll);
+  }
+
   if (scrollContainer.value) {
     innerScrollContainerRef.value = scrollContainer.value.container.scrollEl;
 
-    innerScrollContainerRef.value.addEventListener('scroll', () => {
-      recalculateScroll();
-    });
+    innerScrollContainerRef.value.addEventListener('scroll', recalculateScroll);
+    await refreshSpacerTracking();
   }
 })
 

package/custom/conversation_area/TextRenderer.vue

@@ -17,7 +17,7 @@
       :incremark-options="incremarkOptions"
     />
     <p v-else class="text-red-500 py-2">
-      Error occured
+      Error occurred
     </p>
   </div>
 </template>

package/custom/types.ts

@@ -25,7 +25,6 @@ export interface IToolGroup {
 }
 
 export interface IMessage {
-  id: string;
   role: 'user' | 'assistant';
   metadata?: any,
   parts: IPart[];

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,