@adminforth/agent 1.0.0

package/dist/index.js

@@ -0,0 +1,415 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { AdminForthPlugin, logger, Filters, Sorts } from "adminforth";
+import { randomUUID } from 'crypto';
+import { HumanMessage, SystemMessage } from "langchain";
+import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
+import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
+import { prepareApiBasedTools as buildApiBasedTools, } from './apiBasedTools.js';
+import { buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT, } from "./agent/systemPrompt.js";
+import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./agent/tools/index.js";
+function isAggregateErrorLike(error) {
+    return typeof error === "object" && error !== null && Array.isArray(error.errors);
+}
+function formatAgentError(error) {
+    var _a, _b;
+    if (isAggregateErrorLike(error)) {
+        const nestedErrors = error.errors
+            .map((nestedError, index) => {
+            var _a;
+            if (nestedError instanceof Error) {
+                return `${index + 1}. ${(_a = nestedError.stack) !== null && _a !== void 0 ? _a : nestedError.message}`;
+            }
+            return `${index + 1}. ${String(nestedError)}`;
+        })
+            .join("\n");
+        return `${(_a = error.stack) !== null && _a !== void 0 ? _a : error.message}\nNested errors:\n${nestedErrors}`;
+    }
+    if (error instanceof Error) {
+        return (_b = error.stack) !== null && _b !== void 0 ? _b : error.message;
+    }
+    return String(error);
+}
+function assertRequiredApiTool(apiBasedTools, toolName) {
+    if (toolName in apiBasedTools) {
+        return;
+    }
+    const availableToolNames = Object.keys(apiBasedTools).sort().join(", ");
+    throw new Error(`Required API tool "${toolName}" is missing from AdminForth Agent tools. Available tools: ${availableToolNames}`);
+}
+export default class AdminForthAgentPlugin extends AdminForthPlugin {
+    createNewTurn(sessionId, prompt, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const turnId = randomUUID();
+            const turnRecord = {
+                [this.options.turnResource.idField]: turnId,
+                [this.options.turnResource.sessionIdField]: sessionId,
+                [this.options.turnResource.promptField]: prompt,
+                [this.options.turnResource.responseField]: response || "not_finished",
+            };
+            const newTurn = yield this.adminforth.resource(this.options.turnResource.resourceId).create(turnRecord);
+            return newTurn.createdRecord[this.options.turnResource.idField];
+        });
+    }
+    updateTurn(turnId, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adminforth.resource(this.options.turnResource.resourceId).update(turnId, updates);
+            return { ok: true };
+        });
+    }
+    getSessionTurns(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const turns = yield this.adminforth.resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)], undefined, undefined, [Sorts.ASC(this.options.turnResource.createdAtField)]);
+            return turns.map(turn => ({
+                prompt: turn[this.options.turnResource.promptField],
+                response: turn[this.options.turnResource.responseField],
+            }));
+        });
+    }
+    constructor(options) {
+        super(options, import.meta.url);
+        this.apiBasedTools = {};
+        this.agentSystemPromptPromise = Promise.resolve(DEFAULT_AGENT_SYSTEM_PROMPT);
+        this.options = options;
+        this.shouldHaveSingleInstancePerWholeApp = () => false;
+    }
+    modifyResourceConfig(adminforth, resourceConfig) {
+        const _super = Object.create(null, {
+            modifyResourceConfig: { get: () => super.modifyResourceConfig }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            if (!this.adminforth.config.customization.globalInjections.header) {
+                this.adminforth.config.customization.globalInjections.header = [];
+            }
+            this.adminforth.config.customization.globalInjections.header.push({
+                file: this.componentPath("ChatSurface.vue"),
+                meta: {
+                    pluginInstanceId: this.pluginInstanceId,
+                }
+            });
+            if (!this.pluginOptions.completionAdapter) {
+                throw new Error("CompletionAdapter is required for AdminForthAgentPlugin");
+            }
+            if (!this.pluginOptions.sessionResource) {
+                throw new Error("sessionResource is required for AdminForthAgentPlugin");
+            }
+        });
+    }
+    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);
+    }
+    instanceUniqueRepresentation(pluginOptions) {
+        return `single`;
+    }
+    setupEndpoints(server) {
+        server.endpoint({
+            method: 'POST',
+            path: `/agent/response`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, _raw_express_res }) {
+                var _b, e_1, _c, _d;
+                var _e, _f, _g;
+                const res = _raw_express_res;
+                const messageId = randomUUID();
+                const prompt = body.message;
+                const userTimeZone = (_e = body.timeZone) !== null && _e !== void 0 ? _e : 'UTC';
+                const sessionId = body.sessionId || (adminUser === null || adminUser === void 0 ? void 0 : adminUser.pk) || (adminUser === null || adminUser === void 0 ? void 0 : adminUser.username) || 'default';
+                const turnId = yield this.createNewTurn(sessionId, prompt);
+                let fullResponse = "";
+                let isStreamClosed = false;
+                const sequenceDebugCollector = createSequenceDebugCollector();
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'x-vercel-ai-ui-message-stream': 'v1',
+                });
+                const send = (obj) => {
+                    if (isStreamClosed || res.writableEnded || res.destroyed) {
+                        return;
+                    }
+                    res.write(`data: ${JSON.stringify(obj)}\n\n`);
+                };
+                const emitToolCallEvent = (event) => {
+                    sequenceDebugCollector.handleToolCallEvent(event);
+                    send({
+                        type: "data-tool-call",
+                        data: event,
+                    });
+                };
+                let activeBlock = null;
+                const endActiveBlock = () => {
+                    if (!activeBlock) {
+                        return;
+                    }
+                    send({
+                        type: `${activeBlock.type}-end`,
+                        id: activeBlock.id,
+                    });
+                    activeBlock = null;
+                };
+                const startBlock = (type) => {
+                    if ((activeBlock === null || activeBlock === void 0 ? void 0 : activeBlock.type) === type) {
+                        return activeBlock.id;
+                    }
+                    endActiveBlock();
+                    const id = randomUUID();
+                    activeBlock = { type, id };
+                    send({
+                        type: `${type}-start`,
+                        id,
+                    });
+                    return id;
+                };
+                const endStream = () => {
+                    if (isStreamClosed || res.writableEnded || res.destroyed) {
+                        return;
+                    }
+                    endActiveBlock();
+                    send({
+                        type: 'finish',
+                    });
+                    res.write(`data: [DONE]\n\n`);
+                    isStreamClosed = true;
+                    res.end();
+                };
+                try {
+                    send({
+                        type: 'start',
+                        messageId,
+                    });
+                    const maxTokens = (_f = this.options.maxTokens) !== null && _f !== void 0 ? _f : 10000;
+                    const reasoning = (_g = this.options.reasoning) !== null && _g !== void 0 ? _g : 'low';
+                    const summaryReasoning = 'low';
+                    const model = createAgentChatModel({
+                        adapter: this.options.completionAdapter,
+                        maxTokens,
+                        reasoning,
+                    });
+                    const summaryModel = createAgentChatModel({
+                        adapter: this.options.completionAdapter,
+                        maxTokens,
+                        reasoning: summaryReasoning,
+                    });
+                    const systemPrompt = yield this.agentSystemPromptPromise;
+                    const stream = yield callAgent({
+                        name: `adminforth-agent-${this.pluginInstanceId}`,
+                        model,
+                        summaryModel,
+                        messages: [
+                            new SystemMessage(systemPrompt),
+                            new HumanMessage(prompt),
+                        ],
+                        adminUser,
+                        apiBasedTools: this.apiBasedTools,
+                        customComponentsDir: this.adminforth.config.customization.customComponentsDir,
+                        sessionId,
+                        turnId,
+                        userTimeZone,
+                        emitToolCallEvent,
+                        sequenceDebugSink: sequenceDebugCollector,
+                    });
+                    try {
+                        for (var _h = true, _j = __asyncValues(stream), _k; _k = yield _j.next(), _b = _k.done, !_b; _h = true) {
+                            _d = _k.value;
+                            _h = false;
+                            const rawChunk = _d;
+                            const [token, metadata] = rawChunk;
+                            const nodeName = typeof (metadata === null || metadata === void 0 ? void 0 : metadata.langgraph_node) === "string"
+                                ? metadata.langgraph_node
+                                : "";
+                            if (nodeName && !["model", "model_request"].includes(nodeName)) {
+                                continue;
+                            }
+                            const blocks = Array.isArray(token === null || token === void 0 ? void 0 : token.contentBlocks)
+                                ? token.contentBlocks
+                                : Array.isArray(token === null || token === void 0 ? void 0 : token.content)
+                                    ? token.content
+                                    : [];
+                            const reasoningDelta = blocks
+                                .filter((b) => (b === null || b === void 0 ? void 0 : b.type) === "reasoning")
+                                .map((b) => { var _a; return String((_a = b.reasoning) !== null && _a !== void 0 ? _a : ""); })
+                                .join("");
+                            const textDelta = blocks
+                                .filter((b) => (b === null || b === void 0 ? void 0 : b.type) === "text")
+                                .map((b) => { var _a; return String((_a = b.text) !== null && _a !== void 0 ? _a : ""); })
+                                .join("");
+                            if (reasoningDelta) {
+                                const reasoningId = startBlock('reasoning');
+                                send({
+                                    type: 'reasoning-delta',
+                                    id: reasoningId,
+                                    delta: reasoningDelta,
+                                });
+                            }
+                            if (textDelta) {
+                                const textId = startBlock('text');
+                                fullResponse += textDelta;
+                                send({
+                                    type: 'text-delta',
+                                    id: textId,
+                                    delta: textDelta,
+                                });
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_h && !_b && (_c = _j.return)) yield _c.call(_j);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                catch (error) {
+                    logger.error(`Agent response streaming failed:\n${formatAgentError(error)}`);
+                    sequenceDebugCollector.flush();
+                    const textId = startBlock('text');
+                    send({
+                        type: 'text-delta',
+                        id: textId,
+                        delta: 'Agent response failed. Check server logs for details.',
+                    });
+                }
+                sequenceDebugCollector.flush();
+                const turnUpdates = {
+                    [this.options.turnResource.responseField]: fullResponse,
+                };
+                if (this.options.turnResource.debugField) {
+                    turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
+                }
+                yield this.updateTurn(turnId, turnUpdates);
+                endStream();
+                return null;
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/agent/get-sessions`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
+                const userId = adminUser.pk;
+                const sessions = yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).list([Filters.EQ(this.pluginOptions.sessionResource.askerIdField, userId)], undefined, undefined, [Sorts.DESC(this.pluginOptions.sessionResource.createdAtField)]);
+                const sessionsToReturn = [];
+                for (const session of sessions) {
+                    sessionsToReturn.push({
+                        sessionId: session[this.pluginOptions.sessionResource.idField],
+                        title: session[this.pluginOptions.sessionResource.titleField],
+                        timestamp: session[this.pluginOptions.sessionResource.createdAtField],
+                    });
+                }
+                return {
+                    sessions: sessionsToReturn
+                };
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/agent/get-session-info`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
+                const userId = adminUser.pk;
+                const sessionId = body.sessionId;
+                const session = yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).get([Filters.EQ(this.pluginOptions.sessionResource.idField, sessionId)]);
+                if (!session) {
+                    return {
+                        error: 'Session not found'
+                    };
+                }
+                if (session[this.pluginOptions.sessionResource.askerIdField] !== userId) {
+                    return {
+                        error: 'Unauthorized'
+                    };
+                }
+                const turns = yield this.getSessionTurns(sessionId);
+                const messagesToReturn = [];
+                for (const turn of turns) {
+                    messagesToReturn.push({
+                        text: turn.prompt,
+                        role: 'user',
+                    });
+                    if (turn.response !== "not_finished") {
+                        messagesToReturn.push({
+                            text: turn.response,
+                            role: 'assistant',
+                        });
+                    }
+                }
+                const sessionToReturn = {
+                    sessionId: session[this.pluginOptions.sessionResource.idField],
+                    title: session[this.pluginOptions.sessionResource.titleField],
+                    timestamp: session[this.pluginOptions.sessionResource.createdAtField],
+                    messages: messagesToReturn
+                };
+                return {
+                    session: sessionToReturn
+                };
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/agent/create-session`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
+                const triggerMessage = body.triggerMessage;
+                const userId = adminUser.pk;
+                const title = triggerMessage ? (triggerMessage.length > 40 ? triggerMessage.slice(0, 40) + '...' : triggerMessage) : 'New Session';
+                const newSession = {
+                    [this.pluginOptions.sessionResource.idField]: randomUUID(),
+                    [this.pluginOptions.sessionResource.titleField]: title,
+                    [this.pluginOptions.sessionResource.askerIdField]: userId,
+                };
+                yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).create(newSession);
+                return {
+                    sessionId: newSession[this.pluginOptions.sessionResource.idField],
+                    title: newSession[this.pluginOptions.sessionResource.titleField],
+                    timestamp: newSession[this.pluginOptions.sessionResource.createdAtField],
+                    messages: []
+                };
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/agent/delete-session`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
+                const sessionId = body.sessionId;
+                const userId = adminUser.pk;
+                const session = yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).get([Filters.EQ(this.pluginOptions.sessionResource.idField, sessionId)]);
+                if (!session) {
+                    return {
+                        error: 'Session not found'
+                    };
+                }
+                if (session[this.pluginOptions.sessionResource.askerIdField] !== userId) {
+                    return {
+                        error: 'Unauthorized'
+                    };
+                }
+                yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).delete(sessionId);
+                const turns = yield this.adminforth.resource(this.pluginOptions.turnResource.resourceId).list([Filters.EQ(this.pluginOptions.turnResource.sessionIdField, sessionId)]);
+                for (const turn of turns) {
+                    yield this.adminforth.resource(this.pluginOptions.turnResource.resourceId).delete(turn[this.pluginOptions.turnResource.idField]);
+                }
+                return {
+                    ok: true
+                };
+            })
+        });
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};