@adminforth/agent 1.45.0 → 1.45.1

package/dist/endpoints/chatSurfaces.js

@@ -0,0 +1,91 @@
+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());
+    });
+};
+const DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD = "externalUserId";
+export function setupChatSurfaceEndpoints(ctx, server) {
+    var _a;
+    if (ctx.getChatSurfaceConnectActionAdapters().length) {
+        server.endpoint({
+            method: "POST",
+            path: "/agent/surfaces/connectable",
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ adminUser }) {
+                var _b, _c;
+                const externalUserIdField = (_b = ctx.options.chatExternalIdsField) !== null && _b !== void 0 ? _b : DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
+                const externalIds = (_c = adminUser.dbUser[externalUserIdField]) !== null && _c !== void 0 ? _c : {};
+                return {
+                    surfaces: ctx.getChatSurfaceConnectActionAdapters().map((adapter) => {
+                        var _a;
+                        return ({
+                            name: adapter.name,
+                            externalUserId: (_a = externalIds[adapter.name]) !== null && _a !== void 0 ? _a : null,
+                        });
+                    }),
+                };
+            }),
+        });
+    }
+    for (const adapter of (_a = ctx.options.chatSurfaceAdapters) !== null && _a !== void 0 ? _a : []) {
+        const connectActionAdapter = adapter;
+        if (connectActionAdapter.createConnectAction) {
+            server.endpoint({
+                method: "POST",
+                path: `/agent/surface/${adapter.name}/connect-action`,
+                handler: (_a) => __awaiter(this, [_a], void 0, function* ({ adminUser }) {
+                    const token = ctx.createChatSurfaceLinkToken(adapter.name, adminUser);
+                    const action = yield connectActionAdapter.createConnectAction({ token });
+                    return {
+                        action,
+                    };
+                }),
+            });
+            server.endpoint({
+                method: "POST",
+                path: `/agent/surface/${adapter.name}/disconnect`,
+                handler: (_a) => __awaiter(this, [_a], void 0, function* ({ adminUser }) {
+                    var _b, _c;
+                    const externalUserIdField = (_b = ctx.options.chatExternalIdsField) !== null && _b !== void 0 ? _b : DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
+                    const externalIds = Object.assign({}, ((_c = adminUser.dbUser[externalUserIdField]) !== null && _c !== void 0 ? _c : {}));
+                    delete externalIds[adapter.name];
+                    yield ctx.adminforth.resource(ctx.adminforth.config.auth.usersResourceId).update(adminUser.pk, {
+                        [externalUserIdField]: externalIds,
+                    });
+                    return {
+                        ok: true,
+                    };
+                }),
+            });
+        }
+        server.endpoint({
+            method: "POST",
+            noAuth: true,
+            path: `/agent/surface/${adapter.name}/webhook`,
+            handler: (endpointInput) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const surfaceContext = {
+                    body: endpointInput.body,
+                    headers: endpointInput.headers,
+                    abortSignal: endpointInput.abortSignal,
+                    rawRequest: endpointInput._raw_express_req,
+                    rawResponse: endpointInput._raw_express_res,
+                };
+                const incoming = yield adapter.parseIncomingMessage(surfaceContext);
+                if (!incoming)
+                    return { ok: true };
+                const sink = yield adapter.createEventSink(surfaceContext, incoming);
+                try {
+                    yield ctx.handleChatSurfaceMessage(adapter, incoming, sink);
+                }
+                finally {
+                    yield ((_a = sink.close) === null || _a === void 0 ? void 0 : _a.call(sink));
+                }
+                return { ok: true };
+            }),
+        });
+    }
+}

package/dist/endpoints/context.d.ts

@@ -0,0 +1,30 @@
+import type { AdminUser, ChatSurfaceAdapter, ChatSurfaceEventSink, ChatSurfaceIncomingMessage, IAdminForth } from "adminforth";
+import type { ZodType } from "zod";
+import type { HandleSpeechTurnInput, HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "../agentTurnService.js";
+import type { ChatSurfaceAdapterWithConnectAction } from "../chatSurfaceService.js";
+import type { PluginOptions } from "../types.js";
+export type { ChatSurfaceAdapterWithConnectAction } from "../chatSurfaceService.js";
+export type EndpointResponse = {
+    setStatus: (code: number, message: string) => void;
+};
+export type SessionTurn = {
+    prompt: string;
+    response: string;
+};
+export type AgentEndpointsContext = {
+    adminforth: IAdminForth;
+    options: PluginOptions;
+    parseBody<T>(schema: ZodType<T>, body: unknown, response: EndpointResponse): T | null;
+    handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
+    handleSpeechTurn(input: HandleSpeechTurnInput): Promise<RunAndPersistAgentResponseResult | null>;
+    runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
+    getSessionTurns(sessionId: string): Promise<SessionTurn[]>;
+    createNewTurn(sessionId: string, prompt: string, response?: string): Promise<string>;
+    createSystemTurn(sessionId: string, systemMessage: string): Promise<string>;
+    getChatSurfaceConnectActionAdapters(): ChatSurfaceAdapterWithConnectAction[];
+    createChatSurfaceLinkToken(surface: string, adminUser: AdminUser): string;
+    handleChatSurfaceMessage(adapter: ChatSurfaceAdapter, incoming: ChatSurfaceIncomingMessage, sink: ChatSurfaceEventSink): Promise<void>;
+};
+export type CoreEndpointsContext = Pick<AgentEndpointsContext, "options" | "parseBody" | "handleTurn" | "handleSpeechTurn">;
+export type SessionEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "parseBody" | "getSessionTurns" | "createNewTurn" | "createSystemTurn">;
+export type ChatSurfaceEndpointsContext = Pick<AgentEndpointsContext, "adminforth" | "options" | "getChatSurfaceConnectActionAdapters" | "createChatSurfaceLinkToken" | "handleChatSurfaceMessage">;

package/dist/endpoints/context.js

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

package/dist/endpoints/core.d.ts

@@ -0,0 +1,3 @@
+import type { IHttpServer } from "adminforth";
+import type { CoreEndpointsContext } from "./context.js";
+export declare function setupCoreEndpoints(ctx: CoreEndpointsContext, server: IHttpServer): void;

package/dist/endpoints/core.js

@@ -0,0 +1,106 @@
+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());
+    });
+};
+import { z } from "zod";
+import { createSseEventEmitter } from "../surfaces/web-sse/createSseEventEmitter.js";
+const agentResponseBodySchema = z.object({
+    message: z.string(),
+    sessionId: z.string(),
+    mode: z.string().nullish(),
+    timeZone: z.string().optional(),
+    currentPage: z.custom().optional(),
+}).strict();
+const agentSpeechResponseBodySchema = agentResponseBodySchema.omit({ message: true });
+export function setupCoreEndpoints(ctx, server) {
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/get-placeholder-messages`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ headers, adminUser }) {
+            if (!ctx.options.placeholderMessages) {
+                return {
+                    messages: [],
+                };
+            }
+            const messages = yield ctx.options.placeholderMessages({
+                adminUser: adminUser,
+                headers,
+            });
+            return {
+                messages,
+            };
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/response`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response, _raw_express_res, abortSignal }) {
+            var _b;
+            const data = ctx.parseBody(agentResponseBodySchema, body, response);
+            if (!data)
+                return;
+            const emit = createSseEventEmitter(_raw_express_res, {
+                vercelAiUiMessageStream: true,
+                closeActiveBlockOnToolStart: true,
+            });
+            yield ctx.handleTurn({
+                prompt: data.message,
+                sessionId: data.sessionId,
+                modeName: data.mode,
+                userTimeZone: (_b = data.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
+                currentPage: data.currentPage,
+                abortSignal,
+                adminUser: adminUser,
+                emit,
+                failureLogMessage: "Agent response streaming failed",
+                abortLogMessage: "Agent response streaming aborted by the client",
+            });
+            return null;
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/speech-response`,
+        target: 'upload',
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response, _raw_express_req, _raw_express_res, abortSignal }) {
+            var _b;
+            const req = _raw_express_req;
+            const audioAdapter = ctx.options.audioAdapter;
+            if (!audioAdapter) {
+                response.setStatus(400, "Audio adapter is not configured for AdminForth Agent");
+                return { error: "Audio adapter is not configured for AdminForth Agent" };
+            }
+            const data = ctx.parseBody(agentSpeechResponseBodySchema, body, response);
+            if (!data)
+                return;
+            if (!req.file) {
+                response.setStatus(400, "Audio file is required");
+                return { error: "Audio file is required" };
+            }
+            const emit = createSseEventEmitter(_raw_express_res);
+            yield ctx.handleSpeechTurn({
+                audioAdapter,
+                audio: {
+                    buffer: req.file.buffer,
+                    filename: req.file.originalname,
+                    mimeType: req.file.mimetype,
+                },
+                sessionId: data.sessionId,
+                modeName: data.mode,
+                userTimeZone: (_b = data.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
+                currentPage: data.currentPage,
+                abortSignal,
+                adminUser: adminUser,
+                emit,
+                failureLogMessage: "Agent speech response failed",
+                abortLogMessage: "Agent speech response aborted by the client",
+            });
+            return null;
+        })
+    });
+}

package/dist/endpoints/sessions.d.ts

@@ -0,0 +1,3 @@
+import type { IHttpServer } from "adminforth";
+import type { SessionEndpointsContext } from "./context.js";
+export declare function setupSessionEndpoints(ctx: SessionEndpointsContext, server: IHttpServer): void;

package/dist/endpoints/sessions.js

@@ -0,0 +1,177 @@
+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());
+    });
+};
+import { Filters, Sorts } from "adminforth";
+import { randomUUID } from "crypto";
+import { z } from "zod";
+import { AGENT_SYSTEM_TURN_PROMPT } from "../sessionStore.js";
+const addSystemMessageBodySchema = z.object({
+    sessionId: z.string(),
+    systemMessage: z.string(),
+}).strict();
+const getSessionsBodySchema = z.object({
+    limit: z.number().int().min(1).max(100).optional(),
+}).strict();
+const sessionIdBodySchema = z.object({
+    sessionId: z.string(),
+}).strict();
+const createSessionBodySchema = z.object({
+    triggerMessage: z.string().optional(),
+}).strict();
+export function setupSessionEndpoints(ctx, server) {
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/get-sessions`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            var _b;
+            const data = ctx.parseBody(getSessionsBodySchema, body, response);
+            if (!data)
+                return;
+            const userId = adminUser.pk;
+            const limit = (_b = data.limit) !== null && _b !== void 0 ? _b : 20;
+            const sessions = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).list([Filters.EQ(ctx.options.sessionResource.askerIdField, userId)], limit, undefined, [Sorts.DESC(ctx.options.sessionResource.createdAtField)]);
+            return {
+                sessions: sessions.map((session) => ({
+                    sessionId: session[ctx.options.sessionResource.idField],
+                    title: session[ctx.options.sessionResource.titleField],
+                    timestamp: session[ctx.options.sessionResource.createdAtField],
+                })),
+            };
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/get-session-info`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            const data = ctx.parseBody(sessionIdBodySchema, body, response);
+            if (!data)
+                return;
+            const userId = adminUser.pk;
+            const sessionId = data.sessionId;
+            const session = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).get([Filters.EQ(ctx.options.sessionResource.idField, sessionId)]);
+            if (!session) {
+                return {
+                    error: 'Session not found'
+                };
+            }
+            if (session[ctx.options.sessionResource.askerIdField] !== userId) {
+                return {
+                    error: 'Unauthorized'
+                };
+            }
+            const turns = yield ctx.getSessionTurns(sessionId);
+            return {
+                session: {
+                    sessionId,
+                    title: session[ctx.options.sessionResource.titleField],
+                    timestamp: session[ctx.options.sessionResource.createdAtField],
+                    messages: turns.flatMap(turn => {
+                        const messages = [];
+                        if (turn.prompt === AGENT_SYSTEM_TURN_PROMPT) {
+                            messages.push({
+                                text: turn.response,
+                                role: 'system',
+                            });
+                            return messages;
+                        }
+                        if (turn.prompt) {
+                            messages.push({
+                                text: turn.prompt,
+                                role: 'user',
+                            });
+                        }
+                        if (turn.response && turn.response !== "not_finished") {
+                            messages.push({
+                                text: turn.response,
+                                role: 'assistant',
+                            });
+                        }
+                        return messages;
+                    }),
+                },
+            };
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/create-session`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            const data = ctx.parseBody(createSessionBodySchema, body, response);
+            if (!data)
+                return;
+            const triggerMessage = data.triggerMessage;
+            const userId = adminUser.pk;
+            const title = (triggerMessage === null || triggerMessage === void 0 ? void 0 : triggerMessage.slice(0, 40)) || "New Session";
+            const newSession = {
+                [ctx.options.sessionResource.idField]: randomUUID(),
+                [ctx.options.sessionResource.titleField]: title,
+                [ctx.options.sessionResource.askerIdField]: userId,
+            };
+            const { createdRecord } = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).create(newSession);
+            return {
+                sessionId: createdRecord[ctx.options.sessionResource.idField],
+                title: createdRecord[ctx.options.sessionResource.titleField],
+                timestamp: createdRecord[ctx.options.sessionResource.createdAtField],
+                messages: []
+            };
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/delete-session`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            const data = ctx.parseBody(sessionIdBodySchema, body, response);
+            if (!data)
+                return;
+            const sessionId = data.sessionId;
+            const userId = adminUser.pk;
+            const session = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).get([Filters.EQ(ctx.options.sessionResource.idField, sessionId)]);
+            if (!session) {
+                return {
+                    error: 'Session not found'
+                };
+            }
+            if (session[ctx.options.sessionResource.askerIdField] !== userId) {
+                return {
+                    error: 'Unauthorized'
+                };
+            }
+            yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).delete(sessionId);
+            const turns = yield ctx.adminforth.resource(ctx.options.turnResource.resourceId).list([Filters.EQ(ctx.options.turnResource.sessionIdField, sessionId)]);
+            yield Promise.all(turns.map(turn => ctx.adminforth.resource(ctx.options.turnResource.resourceId).delete(turn[ctx.options.turnResource.idField])));
+            return {
+                ok: true
+            };
+        })
+    });
+    server.endpoint({
+        method: 'POST',
+        path: `/agent/add-system-message-to-turns`,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            const data = ctx.parseBody(addSystemMessageBodySchema, body, response);
+            if (!data)
+                return;
+            const session = yield ctx.adminforth.resource(ctx.options.sessionResource.resourceId).get([Filters.EQ(ctx.options.sessionResource.idField, data.sessionId)]);
+            if (!session) {
+                return {
+                    error: 'Session not found'
+                };
+            }
+            if (session[ctx.options.sessionResource.askerIdField] !== adminUser.pk) {
+                return {
+                    error: 'Unauthorized'
+                };
+            }
+            yield ctx.createSystemTurn(data.sessionId, data.systemMessage);
+            return {
+                ok: true
+            };
+        })
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function isAbortError(error: unknown): boolean;
+export declare function getErrorMessage(error: unknown): string;

package/dist/errors.js

@@ -0,0 +1,9 @@
+export function isAbortError(error) {
+    return typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        (error.name === "AbortError" || error.name === "APIUserAbortError");
+}
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/index.d.ts

@@ -1,64 +1,21 @@
-import type { AdminUser, AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
+import type { AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
 import { AdminForthPlugin } from "adminforth";
 import type { PluginOptions } from './types.js';
-import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
-import { type PreviousUserMessage } from "./agent/languageDetect.js";
-import type { AgentEventEmitter } from "./agentEvents.js";
-import type { CurrentPageContext } from "./agent/tools/getUserLocation.js";
 export type { AgentEvent, AgentEventEmitter } from "./agentEvents.js";
-type AgentTurnRunInput = {
-    prompt: string;
-    sessionId: string;
-    turnId: string;
-    previousUserMessages: PreviousUserMessage[];
-    modeName?: string | null;
-    userTimeZone: string;
-    currentPage?: CurrentPageContext;
-    abortSignal?: AbortSignal;
-    adminUser: AdminUser;
-    sequenceDebugCollector: ReturnType<typeof createSequenceDebugCollector>;
-    emit?: AgentEventEmitter;
-};
-type RunAndPersistAgentResponseInput = Omit<AgentTurnRunInput, "turnId" | "sequenceDebugCollector" | "previousUserMessages"> & {
-    failureLogMessage: string;
-    abortLogMessage: string;
-};
-type HandleTurnInput = Omit<RunAndPersistAgentResponseInput, "failureLogMessage" | "abortLogMessage"> & {
-    emit: AgentEventEmitter;
-    failureLogMessage?: string;
-    abortLogMessage?: string;
-};
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     options: PluginOptions;
     agentSystemPromptPromise: Promise<string>;
     private checkpointer;
-    private chatSurfaceLinkTokens;
+    private sessionStore;
+    private agentTurnService;
+    private chatSurfaceService;
     private chatSurfaceSettingsPageRegistered;
     private parseBody;
-    private createNewTurn;
-    private getSessionTurns;
-    private getPreviousUserMessages;
-    private getChatSurfaceSessionId;
-    private getOrCreateChatSurfaceSession;
     private getCheckpointer;
     private getInternalAgentResourceIds;
-    private getChatSurfaceConnectActionAdapters;
     constructor(options: PluginOptions);
     modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource): Promise<void>;
     validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource): void;
     instanceUniqueRepresentation(pluginOptions: any): string;
-    private runAgentTurn;
-    private runAndPersistAgentResponse;
-    handleTurn(input: HandleTurnInput): Promise<{
-        text: string;
-        turnId: any;
-        aborted: boolean;
-        failed: boolean;
-    }>;
-    private createChatSurfaceEventEmitter;
-    private createChatSurfaceLinkToken;
-    private consumeChatSurfaceLinkToken;
-    private handleChatSurfaceLink;
-    private handleChatSurfaceMessage;
     setupEndpoints(server: IHttpServer): void;
 }