@adminforth/agent 1.44.2 → 1.45.1

package/dist/index.js

@@ -7,64 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 { AdminForthPlugin } from "adminforth";
 import { MemorySaver } from "@langchain/langgraph";
-import { z } from "zod";
-import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
 import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
-import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
-import { detectUserLanguage } from "./agent/languageDetect.js";
-import { prepareApiBasedTools as buildApiBasedTools } from './apiBasedTools.js';
-import { createSseEventEmitter } from "./surfaces/web-sse/createSseEventEmitter.js";
-import { appendCustomSystemPrompt, buildAgentSystemPrompt, buildAgentTurnSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./agent/systemPrompt.js";
-import { sanitizeSpeechText } from "./sanitizeSpeechText.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 });
-const addSystemMessageBodySchema = z.object({
-    sessionId: z.string(),
-    systemMessage: z.string(),
-}).strict();
-const getSessionsBodySchema = z.object({
-    limit: z.number().optional(),
-}).strict();
-const sessionIdBodySchema = z.object({
-    sessionId: z.string(),
-}).strict();
-const createSessionBodySchema = z.object({
-    triggerMessage: z.string().optional(),
-}).strict();
-const VEGA_LITE_FENCE_START = "```vega-lite";
-const COMPLETE_VEGA_LITE_BLOCK_RE = /```vega-lite[\s\S]*?```/;
-function isAbortError(error) {
-    return (error instanceof DOMException && error.name === "AbortError") || (typeof error === "object" &&
-        error !== null &&
-        "name" in error &&
-        (error.name === "AbortError" || error.name === "APIUserAbortError"));
-}
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function requireAdminUser(adminUser) {
-    if (!adminUser) {
-        throw new Error("AdminForth Agent endpoint requires an authenticated admin user");
-    }
-    return adminUser;
-}
+import { appendCustomSystemPrompt, buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./agent/systemPrompt.js";
+import { setupCoreEndpoints } from "./endpoints/core.js";
+import { setupSessionEndpoints } from "./endpoints/sessions.js";
+import { setupChatSurfaceEndpoints } from "./endpoints/chatSurfaces.js";
+import { AgentSessionStore } from "./sessionStore.js";
+import { ChatSurfaceService } from "./chatSurfaceService.js";
+import { AgentTurnService } from "./agentTurnService.js";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     parseBody(schema, body, response) {
         const parsed = schema.safeParse(body !== null && body !== void 0 ? body : {});
@@ -74,57 +26,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         }
         return parsed.data;
     }
-    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];
-        });
-    }
-    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],
-            }));
-        });
-    }
-    getPreviousUserMessages(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)], 2, undefined, [Sorts.DESC(this.options.turnResource.createdAtField)]);
-            return turns
-                .reverse()
-                .map((turn) => ({
-                text: turn[this.options.turnResource.promptField],
-            }));
-        });
-    }
-    getChatSurfaceSessionId(incoming) {
-        return `${incoming.surface}:${incoming.externalConversationId}`;
-    }
-    getOrCreateChatSurfaceSession(incoming, adminUser) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sessionId = this.getChatSurfaceSessionId(incoming);
-            const sessionResource = this.adminforth.resource(this.options.sessionResource.resourceId);
-            const session = yield sessionResource.get([Filters.EQ(this.options.sessionResource.idField, sessionId)]);
-            if (session) {
-                return sessionId;
-            }
-            yield sessionResource.create({
-                [this.options.sessionResource.idField]: sessionId,
-                [this.options.sessionResource.titleField]: incoming.prompt.slice(0, 40) || "New Session",
-                [this.options.sessionResource.askerIdField]: adminUser.pk,
-            });
-            return sessionId;
-        });
-    }
     getCheckpointer() {
         if (this.checkpointer)
             return this.checkpointer;
@@ -144,7 +45,19 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     constructor(options) {
         super(options, import.meta.url);
         this.checkpointer = null;
+        this.chatSurfaceSettingsPageRegistered = false;
         this.options = options;
+        this.sessionStore = new AgentSessionStore(() => this.adminforth, this.options);
+        this.agentTurnService = new AgentTurnService({
+            getAdminforth: () => this.adminforth,
+            getPluginInstanceId: () => this.pluginInstanceId,
+            options: this.options,
+            sessionStore: this.sessionStore,
+            getCheckpointer: this.getCheckpointer.bind(this),
+            getInternalAgentResourceIds: this.getInternalAgentResourceIds.bind(this),
+            getAgentSystemPrompt: () => this.agentSystemPromptPromise,
+        });
+        this.chatSurfaceService = new ChatSurfaceService(() => this.adminforth, this.options, this.sessionStore, this.agentTurnService.handleTurn.bind(this.agentTurnService));
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
     }
@@ -171,6 +84,19 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                     hasAudioAdapter: Boolean(this.options.audioAdapter),
                 }
             });
+            if (this.chatSurfaceService.getConnectActionAdapters().length && !this.chatSurfaceSettingsPageRegistered) {
+                if (!this.adminforth.config.auth.userMenuSettingsPages) {
+                    this.adminforth.config.auth.userMenuSettingsPages = [];
+                }
+                this.adminforth.config.auth.userMenuSettingsPages.push({
+                    icon: "flowbite:link-outline",
+                    pageLabel: "Chat Surfaces",
+                    slug: "chat-surfaces",
+                    component: this.componentPath("ChatSurfaceSettings.vue"),
+                    isVisible: () => true,
+                });
+                this.chatSurfaceSettingsPageRegistered = true;
+            }
             if (!this.adminforth.config.customization.customHeadItems) {
                 this.adminforth.config.customization.customHeadItems = [];
             }
@@ -202,707 +128,23 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     instanceUniqueRepresentation(pluginOptions) {
         return `single`;
     }
-    runAgentTurn(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            let fullResponse = "";
-            let bufferedTextDelta = "";
-            let isRenderingVegaLite = false;
-            const maxTokens = (_d = this.options.maxTokens) !== null && _d !== void 0 ? _d : 1000;
-            const selectedMode = (_e = this.options.modes.find((mode) => mode.name === input.modeName)) !== null && _e !== void 0 ? _e : this.options.modes[0];
-            const [primaryModelSpec, summaryModelSpec] = yield Promise.all([
-                createAgentChatModel({
-                    adapter: selectedMode.completionAdapter,
-                    maxTokens,
-                    purpose: "primary",
-                }),
-                createAgentChatModel({
-                    adapter: selectedMode.completionAdapter,
-                    maxTokens,
-                    purpose: "summary",
-                }),
-            ]);
-            const model = primaryModelSpec.model;
-            const summaryModel = summaryModelSpec.model;
-            const modelMiddleware = primaryModelSpec.middleware;
-            const userLanguage = yield detectUserLanguage(selectedMode.completionAdapter, input.prompt, input.previousUserMessages)
-                .catch((error) => {
-                var _a;
-                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
-                    throw error;
-                }
-                logger.warn(`Failed to detect user language: ${getErrorMessage(error)}`);
-                return null;
-            });
-            const systemPrompt = buildAgentTurnSystemPrompt({
-                agentSystemPrompt: yield this.agentSystemPromptPromise,
-                adminUser: input.adminUser,
-                usernameField: this.adminforth.config.auth.usernameField,
-                userLanguage,
-            });
-            const apiBasedTools = buildApiBasedTools(this.adminforth, this.getInternalAgentResourceIds());
-            const stream = yield callAgent({
-                name: `adminforth-agent-${this.pluginInstanceId}`,
-                model,
-                summaryModel,
-                modelMiddleware,
-                checkpointer: this.getCheckpointer(),
-                messages: [
-                    new SystemMessage(systemPrompt),
-                    new HumanMessage(input.prompt),
-                ],
-                adminUser: input.adminUser,
-                adminforth: this.adminforth,
-                apiBasedTools,
-                customComponentsDir: (_f = this.adminforth.config.customization.customComponentsDir) !== null && _f !== void 0 ? _f : "custom",
-                sessionId: input.sessionId,
-                turnId: input.turnId,
-                currentPage: input.currentPage,
-                userTimeZone: input.userTimeZone,
-                abortSignal: input.abortSignal,
-                emitToolCallEvent: (event) => {
-                    var _a;
-                    input.sequenceDebugCollector.handleToolCallEvent(event);
-                    void ((_a = input.emit) === null || _a === void 0 ? void 0 : _a.call(input, {
-                        type: "tool-call",
-                        data: event,
-                    }));
-                },
-                sequenceDebugSink: input.sequenceDebugCollector,
-            });
-            try {
-                for (var _p = true, _q = __asyncValues(stream), _r; _r = yield _q.next(), _a = _r.done, !_a; _p = true) {
-                    _c = _r.value;
-                    _p = false;
-                    const rawChunk = _c;
-                    if ((_g = input.abortSignal) === null || _g === void 0 ? void 0 : _g.aborted) {
-                        throw new DOMException("This operation was aborted", "AbortError");
-                    }
-                    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) {
-                        yield ((_h = input.emit) === null || _h === void 0 ? void 0 : _h.call(input, {
-                            type: "reasoning-delta",
-                            delta: reasoningDelta,
-                        }));
-                    }
-                    if (textDelta) {
-                        fullResponse += textDelta;
-                        bufferedTextDelta += textDelta;
-                        if (bufferedTextDelta.includes(VEGA_LITE_FENCE_START) &&
-                            !COMPLETE_VEGA_LITE_BLOCK_RE.test(bufferedTextDelta)) {
-                            if (!isRenderingVegaLite) {
-                                isRenderingVegaLite = true;
-                                yield ((_j = input.emit) === null || _j === void 0 ? void 0 : _j.call(input, {
-                                    type: "rendering",
-                                    phase: "start",
-                                    label: "Rendering...",
-                                }));
-                            }
-                            continue;
-                        }
-                        if (isRenderingVegaLite) {
-                            isRenderingVegaLite = false;
-                            yield ((_k = input.emit) === null || _k === void 0 ? void 0 : _k.call(input, {
-                                type: "rendering",
-                                phase: "end",
-                                label: "Rendering...",
-                            }));
-                        }
-                        const streamableLength = bufferedTextDelta.includes(VEGA_LITE_FENCE_START)
-                            ? bufferedTextDelta.length
-                            : bufferedTextDelta.length - getPartialVegaLiteFenceStartLength(bufferedTextDelta);
-                        if (!streamableLength) {
-                            continue;
-                        }
-                        yield ((_l = input.emit) === null || _l === void 0 ? void 0 : _l.call(input, {
-                            type: "text-delta",
-                            delta: bufferedTextDelta.slice(0, streamableLength),
-                        }));
-                        bufferedTextDelta = bufferedTextDelta.slice(streamableLength);
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_p && !_a && (_b = _q.return)) yield _b.call(_q);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            if (isRenderingVegaLite) {
-                yield ((_m = input.emit) === null || _m === void 0 ? void 0 : _m.call(input, {
-                    type: "rendering",
-                    phase: "end",
-                    label: "Rendering...",
-                }));
-            }
-            if (bufferedTextDelta) {
-                yield ((_o = input.emit) === null || _o === void 0 ? void 0 : _o.call(input, {
-                    type: "text-delta",
-                    delta: bufferedTextDelta,
-                }));
-            }
-            return {
-                text: fullResponse,
-            };
-        });
-    }
-    runAndPersistAgentResponse(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const previousUserMessages = yield this.getPreviousUserMessages(input.sessionId);
-            const turnId = yield this.createNewTurn(input.sessionId, input.prompt);
-            yield this.adminforth.resource(this.options.sessionResource.resourceId).update(input.sessionId, {
-                [this.options.sessionResource.createdAtField]: new Date().toISOString(),
-            });
-            const sequenceDebugCollector = createSequenceDebugCollector();
-            let fullResponse = "";
-            let aborted = false;
-            let failed = false;
-            try {
-                const agentResponse = yield this.runAgentTurn({
-                    prompt: input.prompt,
-                    sessionId: input.sessionId,
-                    turnId,
-                    previousUserMessages,
-                    modeName: input.modeName,
-                    userTimeZone: input.userTimeZone,
-                    currentPage: input.currentPage,
-                    abortSignal: input.abortSignal,
-                    adminUser: input.adminUser,
-                    sequenceDebugCollector,
-                    emit: input.emit,
-                });
-                fullResponse = agentResponse.text;
-            }
-            catch (error) {
-                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
-                    aborted = true;
-                    logger.info(input.abortLogMessage);
-                }
-                else {
-                    failed = true;
-                    fullResponse = getErrorMessage(error);
-                    logger.error(`${input.failureLogMessage}:\n${fullResponse}`);
-                }
-            }
-            sequenceDebugCollector.flush();
-            const turnUpdates = {
-                [this.options.turnResource.responseField]: fullResponse,
-            };
-            if (this.options.turnResource.debugField) {
-                turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
-            }
-            yield this.adminforth.resource(this.options.turnResource.resourceId).update(turnId, turnUpdates);
-            return {
-                text: fullResponse,
-                turnId,
-                aborted,
-                failed,
-            };
-        });
-    }
-    handleTurn(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            yield input.emit({
-                type: "turn-started",
-                messageId: randomUUID(),
-            });
-            const agentResponse = yield this.runAndPersistAgentResponse({
-                prompt: input.prompt,
-                sessionId: input.sessionId,
-                modeName: input.modeName,
-                userTimeZone: input.userTimeZone,
-                currentPage: input.currentPage,
-                abortSignal: input.abortSignal,
-                adminUser: input.adminUser,
-                emit: input.emit,
-                failureLogMessage: (_a = input.failureLogMessage) !== null && _a !== void 0 ? _a : "Agent response failed",
-                abortLogMessage: (_b = input.abortLogMessage) !== null && _b !== void 0 ? _b : "Agent response aborted",
-            });
-            if (agentResponse.failed) {
-                yield input.emit({
-                    type: "error",
-                    error: agentResponse.text,
-                });
-            }
-            else if (!agentResponse.aborted) {
-                yield input.emit({
-                    type: "response",
-                    text: agentResponse.text,
-                    sessionId: input.sessionId,
-                    turnId: agentResponse.turnId,
-                });
-            }
-            yield input.emit({
-                type: "finish",
-            });
-            return agentResponse;
-        });
-    }
-    createChatSurfaceEventEmitter(sink) {
-        return (event) => __awaiter(this, void 0, void 0, function* () {
-            if (event.type === "text-delta") {
-                yield sink.emit({
-                    type: "text_delta",
-                    delta: event.delta,
-                });
-                return;
-            }
-            if (event.type === "response") {
-                yield sink.emit({
-                    type: "done",
-                    text: event.text,
-                });
-                return;
-            }
-            if (event.type === "error") {
-                yield sink.emit({
-                    type: "error",
-                    message: event.error,
-                });
-            }
-        });
-    }
-    handleChatSurfaceMessage(adapter, incoming, sink) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const adminUser = yield adapter.resolveAdminUser({
-                adminforth: this.adminforth,
-                incoming,
-            });
-            if (!adminUser) {
-                yield sink.emit({
-                    type: "error",
-                    message: "This chat account is not authorized to use AdminForth Agent.",
-                });
-                return;
-            }
-            yield this.handleTurn({
-                prompt: incoming.prompt,
-                sessionId: yield this.getOrCreateChatSurfaceSession(incoming, adminUser),
-                modeName: incoming.modeName,
-                userTimeZone: (_a = incoming.userTimeZone) !== null && _a !== void 0 ? _a : "UTC",
-                adminUser,
-                emit: this.createChatSurfaceEventEmitter(sink),
-                failureLogMessage: `Agent ${incoming.surface} surface response failed`,
-                abortLogMessage: `Agent ${incoming.surface} surface response aborted`,
-            });
-        });
-    }
     setupEndpoints(server) {
-        var _a;
-        for (const adapter of (_a = this.options.chatSurfaceAdapters) !== null && _a !== void 0 ? _a : []) {
-            server.endpoint({
-                method: "POST",
-                noAuth: true,
-                path: `/agent/surface/${adapter.name}/webhook`,
-                handler: (ctx) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const surfaceContext = {
-                        body: ctx.body,
-                        headers: ctx.headers,
-                        abortSignal: ctx.abortSignal,
-                        rawRequest: ctx._raw_express_req,
-                        rawResponse: ctx._raw_express_res,
-                    };
-                    const incoming = yield adapter.parseIncomingMessage(surfaceContext);
-                    if (!incoming)
-                        return { ok: true };
-                    const sink = yield adapter.createEventSink(surfaceContext, incoming);
-                    try {
-                        yield this.handleChatSurfaceMessage(adapter, incoming, sink);
-                    }
-                    finally {
-                        yield ((_a = sink.close) === null || _a === void 0 ? void 0 : _a.call(sink));
-                    }
-                    return { ok: true };
-                }),
-            });
-        }
-        server.endpoint({
-            method: 'POST',
-            path: `/agent/get-placeholder-messages`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ headers, adminUser }) {
-                const currentAdminUser = requireAdminUser(adminUser);
-                if (!this.options.placeholderMessages) {
-                    return {
-                        messages: [],
-                    };
-                }
-                const messages = yield this.options.placeholderMessages({
-                    adminUser: currentAdminUser,
-                    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 currentAdminUser = requireAdminUser(adminUser);
-                const data = this.parseBody(agentResponseBodySchema, body, response);
-                if (!data)
-                    return;
-                const emit = createSseEventEmitter(_raw_express_res, {
-                    vercelAiUiMessageStream: true,
-                    closeActiveBlockOnToolStart: true,
-                });
-                yield this.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: currentAdminUser,
-                    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 currentAdminUser = requireAdminUser(adminUser);
-                const req = _raw_express_req;
-                const audioAdapter = this.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 = this.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);
-                let transcription;
-                try {
-                    transcription = yield audioAdapter.transcribe({
-                        buffer: req.file.buffer,
-                        filename: req.file.originalname,
-                        mimeType: req.file.mimetype,
-                        language: "auto",
-                        abortSignal,
-                    });
-                }
-                catch (error) {
-                    if (abortSignal.aborted || isAbortError(error)) {
-                        logger.info("Agent speech transcription aborted by the client");
-                        yield emit({ type: "finish" });
-                        return null;
-                    }
-                    logger.error(`Agent speech transcription failed:\n${getErrorMessage(error)}`);
-                    yield emit({
-                        type: "error",
-                        error: "Speech transcription failed. Check server logs for details.",
-                    });
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                if (abortSignal.aborted) {
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                const prompt = transcription.text;
-                if (!prompt) {
-                    yield emit({
-                        type: "error",
-                        error: "Speech transcription is empty",
-                    });
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                yield emit({
-                    type: "transcript",
-                    text: transcription.text,
-                    language: transcription.language,
-                });
-                const sessionId = data.sessionId;
-                const currentPage = data.currentPage;
-                const agentResponse = yield this.runAndPersistAgentResponse({
-                    prompt,
-                    sessionId,
-                    modeName: data.mode,
-                    userTimeZone: (_b = data.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
-                    currentPage,
-                    abortSignal,
-                    adminUser: currentAdminUser,
-                    emit: (event) => __awaiter(this, void 0, void 0, function* () {
-                        if (event.type === "tool-call") {
-                            yield emit(event);
-                        }
-                    }),
-                    failureLogMessage: "Agent speech response failed",
-                    abortLogMessage: "Agent speech response aborted by the client",
-                });
-                if (agentResponse.aborted) {
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                if (agentResponse.failed) {
-                    yield emit({
-                        type: "error",
-                        error: agentResponse.text,
-                    });
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                try {
-                    yield emit({
-                        type: "speech-response",
-                        transcript: {
-                            text: transcription.text,
-                            language: transcription.language,
-                        },
-                        response: {
-                            text: agentResponse.text,
-                        },
-                        sessionId,
-                        turnId: agentResponse.turnId,
-                    });
-                    const speech = yield audioAdapter.synthesize({
-                        text: sanitizeSpeechText(agentResponse.text),
-                        stream: true,
-                        streamFormat: "audio",
-                        format: "pcm",
-                        abortSignal,
-                    });
-                    yield emit({
-                        type: "audio-start",
-                        mimeType: speech.mimeType,
-                        format: speech.format,
-                        sampleRate: 24000,
-                        channelCount: 1,
-                        bitsPerSample: 16,
-                    });
-                    const reader = speech.audioStream.getReader();
-                    const cancelAudioStream = () => {
-                        void reader.cancel().catch(() => undefined);
-                    };
-                    try {
-                        abortSignal.addEventListener("abort", cancelAudioStream, { once: true });
-                        while (true) {
-                            if (abortSignal.aborted) {
-                                yield reader.cancel().catch(() => undefined);
-                                break;
-                            }
-                            const { value, done } = yield reader.read();
-                            if (done) {
-                                break;
-                            }
-                            if (abortSignal.aborted) {
-                                break;
-                            }
-                            yield emit({
-                                type: "audio-delta",
-                                value,
-                            });
-                        }
-                    }
-                    finally {
-                        abortSignal.removeEventListener("abort", cancelAudioStream);
-                        reader.releaseLock();
-                    }
-                    yield emit({ type: "audio-done" });
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-                catch (error) {
-                    if (abortSignal.aborted || isAbortError(error)) {
-                        logger.info("Agent speech audio streaming aborted by the client");
-                    }
-                    else {
-                        logger.error(`Agent speech audio streaming failed:\n${error}`);
-                        yield emit({
-                            type: "error",
-                            error: getErrorMessage(error),
-                        });
-                    }
-                    yield emit({ type: "finish" });
-                    return null;
-                }
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: `/agent/get-sessions`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
-                var _b;
-                const currentAdminUser = requireAdminUser(adminUser);
-                const data = this.parseBody(getSessionsBodySchema, body, response);
-                if (!data)
-                    return;
-                const userId = currentAdminUser.pk;
-                const limit = (_b = data.limit) !== null && _b !== void 0 ? _b : 20;
-                const sessions = yield this.adminforth.resource(this.options.sessionResource.resourceId).list([Filters.EQ(this.options.sessionResource.askerIdField, userId)], limit, undefined, [Sorts.DESC(this.options.sessionResource.createdAtField)]);
-                return {
-                    sessions: sessions.map((session) => ({
-                        sessionId: session[this.options.sessionResource.idField],
-                        title: session[this.options.sessionResource.titleField],
-                        timestamp: session[this.options.sessionResource.createdAtField],
-                    })),
-                };
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: `/agent/get-session-info`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
-                const currentAdminUser = requireAdminUser(adminUser);
-                const parsedBody = sessionIdBodySchema.safeParse(body);
-                if (!parsedBody.success) {
-                    response.setStatus(422, parsedBody.error.message);
-                    return;
-                }
-                const userId = currentAdminUser.pk;
-                const sessionId = parsedBody.data.sessionId;
-                const session = yield this.adminforth.resource(this.options.sessionResource.resourceId).get([Filters.EQ(this.options.sessionResource.idField, sessionId)]);
-                if (!session) {
-                    return {
-                        error: 'Session not found'
-                    };
-                }
-                if (session[this.options.sessionResource.askerIdField] !== userId) {
-                    return {
-                        error: 'Unauthorized'
-                    };
-                }
-                const turns = yield this.getSessionTurns(sessionId);
-                return {
-                    session: {
-                        sessionId,
-                        title: session[this.options.sessionResource.titleField],
-                        timestamp: session[this.options.sessionResource.createdAtField],
-                        messages: turns.flatMap(turn => {
-                            const 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 currentAdminUser = requireAdminUser(adminUser);
-                const data = this.parseBody(createSessionBodySchema, body, response);
-                if (!data)
-                    return;
-                const triggerMessage = data.triggerMessage;
-                const userId = currentAdminUser.pk;
-                const title = (triggerMessage === null || triggerMessage === void 0 ? void 0 : triggerMessage.slice(0, 40)) || "New Session";
-                const newSession = {
-                    [this.options.sessionResource.idField]: randomUUID(),
-                    [this.options.sessionResource.titleField]: title,
-                    [this.options.sessionResource.askerIdField]: userId,
-                };
-                yield this.adminforth.resource(this.options.sessionResource.resourceId).create(newSession);
-                return {
-                    sessionId: newSession[this.options.sessionResource.idField],
-                    title: newSession[this.options.sessionResource.titleField],
-                    timestamp: newSession[this.options.sessionResource.createdAtField],
-                    messages: []
-                };
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: `/agent/delete-session`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
-                const currentAdminUser = requireAdminUser(adminUser);
-                const data = this.parseBody(sessionIdBodySchema, body, response);
-                if (!data)
-                    return;
-                const sessionId = data.sessionId;
-                const userId = currentAdminUser.pk;
-                const session = yield this.adminforth.resource(this.options.sessionResource.resourceId).get([Filters.EQ(this.options.sessionResource.idField, sessionId)]);
-                if (!session) {
-                    return {
-                        error: 'Session not found'
-                    };
-                }
-                if (session[this.options.sessionResource.askerIdField] !== userId) {
-                    return {
-                        error: 'Unauthorized'
-                    };
-                }
-                yield this.adminforth.resource(this.options.sessionResource.resourceId).delete(sessionId);
-                const turns = yield this.adminforth.resource(this.options.turnResource.resourceId).list([Filters.EQ(this.options.turnResource.sessionIdField, sessionId)]);
-                for (const turn of turns) {
-                    yield this.adminforth.resource(this.options.turnResource.resourceId).delete(turn[this.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, response }) {
-                    const data = this.parseBody(addSystemMessageBodySchema, body, response);
-                    if (!data)
-                        return;
-                    yield this.createNewTurn(data.sessionId, data.systemMessage);
-                    return {
-                        ok: true
-                    };
-                })
-            });
-    }
-}
-function getPartialVegaLiteFenceStartLength(text) {
-    for (let length = Math.min(text.length, VEGA_LITE_FENCE_START.length - 1); length > 0; length -= 1) {
-        if (VEGA_LITE_FENCE_START.startsWith(text.slice(-length))) {
-            return length;
-        }
+        const endpointContext = {
+            adminforth: this.adminforth,
+            options: this.options,
+            parseBody: this.parseBody.bind(this),
+            handleTurn: this.agentTurnService.handleTurn.bind(this.agentTurnService),
+            handleSpeechTurn: this.agentTurnService.handleSpeechTurn.bind(this.agentTurnService),
+            runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
+            getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
+            createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),
+            createSystemTurn: this.sessionStore.createSystemTurn.bind(this.sessionStore),
+            getChatSurfaceConnectActionAdapters: this.chatSurfaceService.getConnectActionAdapters.bind(this.chatSurfaceService),
+            createChatSurfaceLinkToken: this.chatSurfaceService.createLinkToken.bind(this.chatSurfaceService),
+            handleChatSurfaceMessage: this.chatSurfaceService.handleMessage.bind(this.chatSurfaceService),
+        };
+        setupCoreEndpoints(endpointContext, server);
+        setupSessionEndpoints(endpointContext, server);
+        setupChatSurfaceEndpoints(endpointContext, server);
     }
-    return 0;
 }