@adminforth/agent 1.36.0 → 1.38.0

package/dist/agent/simpleAgent.js

@@ -19,8 +19,8 @@ export const contextSchema = z.object({
     userTimeZone: z.string(),
     sessionId: z.string(),
     turnId: z.string(),
+    abortSignal: z.custom().optional(),
     currentPage: z.custom().optional(),
-    httpExtra: z.custom().optional(),
     emitToolCallEvent: z.custom(),
 });
 function isLangChainAgentCompletionAdapter(adapter) {
@@ -132,7 +132,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, currentPage, httpExtra, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
+        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, sessionId, turnId, currentPage, userTimeZone, abortSignal, emitToolCallEvent, sequenceDebugSink, } = params;
         const tools = yield createAgentTools(customComponentsDir, apiBasedTools);
         const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
         const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
@@ -158,6 +158,7 @@ export function callAgent(params) {
             streamMode: "messages",
             recursionLimit: 100,
             callbacks: [createAgentLlmMetricsLogger()],
+            signal: abortSignal,
             configurable: {
                 thread_id: sessionId,
             },
@@ -166,8 +167,8 @@ export function callAgent(params) {
                 userTimeZone,
                 sessionId,
                 turnId,
+                abortSignal,
                 currentPage,
-                httpExtra,
                 emitToolCallEvent,
             },
         });

package/dist/agent/systemPrompt.js

@@ -8,7 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { listBundledSkillManifests, listProjectSkillManifests, } from "./skills/registry.js";
-import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./tools/index.js";
 export const DEFAULT_AGENT_SYSTEM_PROMPT = [
     "You are helpful AI Assistant for Admin Panel.",
     // about admin
@@ -38,6 +37,30 @@ export function appendCustomSystemPrompt(systemPrompt, customSystemPrompt) {
     }
     return `${systemPrompt}\n\n${normalizedCustomSystemPrompt}`;
 }
+function formatLanguagePrompt(language) {
+    if (!language) {
+        return "Respond in the user's language.";
+    }
+    return `Respond in ${language.language} (${language.code}).`;
+}
+function formatAdminUserPrompt(adminUser, usernameField) {
+    const adminUserContext = {
+        id: adminUser.pk,
+        email: adminUser.dbUser[usernameField],
+    };
+    return [
+        "Current admin user context:",
+        JSON.stringify(adminUserContext, null, 2),
+        "Use this admin user email when the user asks to send information to themselves, the current admin, or the logged-in user.",
+    ].join("\n");
+}
+export function buildAgentTurnSystemPrompt(input) {
+    return [
+        input.agentSystemPrompt,
+        formatAdminUserPrompt(input.adminUser, input.usernameField),
+        formatLanguagePrompt(input.userLanguage),
+    ].join("\n\n");
+}
 function formatResources(resources) {
     return resources
         .map((resource) => `- resourceId: ${resource.resourceId}\n  label: ${resource.label}`)
@@ -54,7 +77,6 @@ export function buildAgentSystemPrompt(adminforth_1) {
             listProjectSkillManifests(adminforth.config.customization.customComponentsDir),
             listBundledSkillManifests(),
         ]);
-        const alwaysAvailableTools = ALWAYS_AVAILABLE_API_TOOL_NAMES.join(", ");
         const adminBasePath = adminforth.config.baseUrlSlashed;
         const hiddenResourceIdSet = new Set(hiddenResourceIds);
         const visibleResources = adminforth.config.resources.filter((resource) => !hiddenResourceIdSet.has(resource.resourceId));
@@ -62,7 +84,6 @@ export function buildAgentSystemPrompt(adminforth_1) {
             DEFAULT_AGENT_SYSTEM_PROMPT,
             `ADMIN_BASE_PATH: ${adminBasePath}`,
             `List of resources:\n${formatResources(visibleResources)}`,
-            `You have always-available base tools: ${alwaysAvailableTools}.`,
             primarySkills.length > 0
                 ? `You have primary skills set:\n${formatSkills(primarySkills, "skill_name")}`
                 : "",

package/dist/agent/toolCallEvents.js

@@ -1,6 +1,5 @@
 import { randomUUID } from "crypto";
 import YAML from "yaml";
-import { serializeUnknownError } from "../apiBasedTools.js";
 const TOOL_MESSAGE_DEBUG_KEYS = new Set([
     "metadata",
     "additional_kwargs",
@@ -29,6 +28,29 @@ function sanitizeToolCallOutputForDebug(output) {
     }
     return Object.fromEntries(Object.entries(debugPayload).filter(([key]) => !TOOL_MESSAGE_DEBUG_KEYS.has(key)));
 }
+function serializeErrorForDebug(error) {
+    if (!(error instanceof Error)) {
+        return error;
+    }
+    const errorWithCause = error;
+    const serialized = {
+        name: error.name,
+        message: error.message,
+    };
+    if (error.stack) {
+        serialized.stack = error.stack;
+    }
+    if (errorWithCause.cause !== undefined) {
+        serialized.cause = serializeErrorForDebug(errorWithCause.cause);
+    }
+    for (const key of Object.getOwnPropertyNames(error)) {
+        if (key in serialized) {
+            continue;
+        }
+        serialized[key] = error[key];
+    }
+    return serialized;
+}
 export function createToolCallTracker(params) {
     var _a, _b;
     const toolCallId = (_a = params.toolCallId) !== null && _a !== void 0 ? _a : randomUUID();
@@ -61,7 +83,7 @@ export function createToolCallTracker(params) {
                 phase: "end",
                 durationMs: Date.now() - startedAt,
                 output: null,
-                error: YAML.stringify(serializeUnknownError(error)).trimEnd(),
+                error: YAML.stringify(serializeErrorForDebug(error)).trimEnd(),
             });
         },
     };

package/dist/agent/tools/apiTool.js

@@ -49,7 +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,
+            abortSignal: runtime.context.abortSignal,
             inputs: normalizedInput,
             userTimeZone: runtime.context.userTimeZone,
         });

package/dist/agentResponseEvents.js

@@ -0,0 +1,141 @@
+import { randomUUID } from "crypto";
+export function createAgentEventStream(res, options = {}) {
+    let isStreamClosed = false;
+    let activeBlock = null;
+    res.writeHead(200, Object.assign({ "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }, (options.vercelAiUiMessageStream
+        ? { "x-vercel-ai-ui-message-stream": "v1" }
+        : {})));
+    const stream = {
+        send(obj) {
+            if (isStreamClosed || res.writableEnded || res.destroyed) {
+                return;
+            }
+            res.write(`data: ${JSON.stringify(obj)}\n\n`);
+        },
+        endActiveBlock() {
+            if (!activeBlock) {
+                return;
+            }
+            stream.send({
+                type: `${activeBlock.type}-end`,
+                id: activeBlock.id,
+            });
+            activeBlock = null;
+        },
+        startBlock(type) {
+            if ((activeBlock === null || activeBlock === void 0 ? void 0 : activeBlock.type) === type) {
+                return activeBlock.id;
+            }
+            stream.endActiveBlock();
+            const id = randomUUID();
+            activeBlock = { type, id };
+            stream.send({
+                type: `${type}-start`,
+                id,
+            });
+            return id;
+        },
+        start(messageId) {
+            stream.send({
+                type: "start",
+                messageId,
+            });
+        },
+        textDelta(delta) {
+            const textId = stream.startBlock("text");
+            stream.send({
+                type: "text-delta",
+                id: textId,
+                delta,
+            });
+        },
+        reasoningDelta(delta) {
+            const reasoningId = stream.startBlock("reasoning");
+            stream.send({
+                type: "reasoning-delta",
+                id: reasoningId,
+                delta,
+            });
+        },
+        toolCall(event) {
+            if (options.closeActiveBlockOnToolStart && event.phase === "start") {
+                stream.endActiveBlock();
+            }
+            stream.send({
+                type: "data-tool-call",
+                data: event,
+            });
+        },
+        transcript(text, language) {
+            stream.send({
+                type: "transcript",
+                data: {
+                    text,
+                    language,
+                },
+            });
+        },
+        response(text, sessionId, turnId) {
+            stream.send({
+                type: "response",
+                data: {
+                    text,
+                    sessionId,
+                    turnId,
+                },
+            });
+        },
+        speechResponse(transcript, response, sessionId, turnId) {
+            stream.send({
+                type: "speech-response",
+                data: {
+                    transcript,
+                    response,
+                    sessionId,
+                    turnId,
+                },
+            });
+        },
+        audioStart(mimeType, format) {
+            stream.send({
+                type: "audio-start",
+                data: {
+                    mimeType,
+                    format,
+                },
+            });
+        },
+        audioDelta(value) {
+            stream.send({
+                type: "audio-delta",
+                data: {
+                    base64: Buffer.from(value).toString("base64"),
+                },
+            });
+        },
+        audioDone() {
+            stream.send({
+                type: "audio-done",
+            });
+        },
+        error(error) {
+            stream.send({
+                type: "error",
+                error,
+            });
+        },
+        end() {
+            if (isStreamClosed || res.writableEnded || res.destroyed) {
+                return;
+            }
+            stream.endActiveBlock();
+            stream.send({
+                type: "finish",
+            });
+            res.write("data: [DONE]\n\n");
+            isStreamClosed = true;
+            res.end();
+        },
+    };
+    return stream;
+}