@adminforth/agent 1.37.0 → 1.38.0

package/dist/index.js

@@ -18,68 +18,44 @@ import { AdminForthPlugin, logger, Filters, Sorts } from "adminforth";
 import { randomUUID } from 'crypto';
 import { HumanMessage, SystemMessage } from "langchain";
 import { MemorySaver } from "@langchain/langgraph";
-import { createAgentChatModel, callAgent, } from "./agent/simpleAgent.js";
+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, formatLanguagePrompt, } from "./agent/languageDetect.js";
-import { prepareApiBasedTools as buildApiBasedTools, } from './apiBasedTools.js';
-import { appendCustomSystemPrompt, 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 formatAgentResponseError(error) {
-    if (isAggregateErrorLike(error)) {
-        const nestedErrors = error.errors.map(formatAgentResponseError);
-        if (nestedErrors.length) {
-            return nestedErrors.join("\n");
+import { detectUserLanguage } from "./agent/languageDetect.js";
+import { prepareApiBasedTools as buildApiBasedTools } from './apiBasedTools.js';
+import { createAgentEventStream } from "./agentResponseEvents.js";
+import { appendCustomSystemPrompt, buildAgentSystemPrompt, buildAgentTurnSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./agent/systemPrompt.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();
+export default class AdminForthAgentPlugin extends AdminForthPlugin {
+    parseBody(schema, body, response) {
+        const parsed = schema.safeParse(body !== null && body !== void 0 ? body : {});
+        if (!parsed.success) {
+            response.setStatus(422, parsed.error.message);
+            return null;
         }
-        return error.message || "Agent response failed";
-    }
-    if (error instanceof Error) {
-        return error.toString();
+        return parsed.data;
     }
-    return String(error);
-}
-function formatAdminUserPrompt(adminUser, usernameField) {
-    const dbUser = adminUser.dbUser;
-    const adminUserContext = {
-        id: adminUser.pk,
-        email: 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");
-}
-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();
@@ -93,20 +69,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             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 };
-        });
-    }
-    updateSessionDate(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.adminforth.resource(this.options.sessionResource.resourceId).update(sessionId, {
-                [this.options.sessionResource.createdAtField]: new Date().toISOString(),
-            });
-            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)]);
@@ -116,42 +78,9 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             }));
         });
     }
-    getModeModels(mode, maxTokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cachedModels = this.modelsByModeName.get(mode.name);
-            if (cachedModels) {
-                return yield cachedModels;
-            }
-            const modelsPromise = Promise.all([
-                createAgentChatModel({
-                    adapter: mode.completionAdapter,
-                    maxTokens,
-                    purpose: "primary",
-                }),
-                createAgentChatModel({
-                    adapter: mode.completionAdapter,
-                    maxTokens,
-                    purpose: "summary",
-                }),
-            ]).then(([primaryModel, summaryModel]) => ({
-                model: primaryModel.model,
-                summaryModel: summaryModel.model,
-                modelMiddleware: primaryModel.middleware,
-            }));
-            this.modelsByModeName.set(mode.name, modelsPromise);
-            try {
-                return yield modelsPromise;
-            }
-            catch (error) {
-                this.modelsByModeName.delete(mode.name);
-                throw error;
-            }
-        });
-    }
     getCheckpointer() {
-        if (this.checkpointer) {
+        if (this.checkpointer)
             return this.checkpointer;
-        }
         this.checkpointer = this.options.checkpointResource
             ? new AdminForthCheckpointSaver(this.adminforth, this.options)
             : new MemorySaver();
@@ -167,9 +96,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     }
     constructor(options) {
         super(options, import.meta.url);
-        this.apiBasedTools = {};
         this.checkpointer = null;
-        this.modelsByModeName = new Map();
         this.options = options;
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
@@ -197,7 +124,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                     hasAudioAdapter: Boolean(this.options.audioAdapter),
                 }
             });
-            if (!this.pluginOptions.sessionResource) {
+            if (!this.options.sessionResource) {
                 throw new Error("sessionResource is required for AdminForthAgentPlugin");
             }
         });
@@ -216,25 +143,35 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             var _a, e_1, _b, _c;
             var _d, _e, _f, _g;
             let fullResponse = "";
-            const maxTokens = (_d = this.options.maxTokens) !== null && _d !== void 0 ? _d : 10000;
+            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 { model, summaryModel, modelMiddleware } = yield this.getModeModels(selectedMode, maxTokens);
+            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)
                 .catch((error) => {
-                logger.warn(`Failed to detect user language: ${error instanceof Error ? error.message : String(error)}`);
+                logger.warn(`Failed to detect user language: ${error.message}`);
                 return null;
             });
-            const systemPrompt = [
-                yield this.agentSystemPromptPromise,
-                formatAdminUserPrompt(input.adminUser, this.adminforth.config.auth.usernameField),
-                formatLanguagePrompt(userLanguage),
-            ].join("\n\n");
+            const systemPrompt = buildAgentTurnSystemPrompt({
+                agentSystemPrompt: yield this.agentSystemPromptPromise,
+                adminUser: input.adminUser,
+                usernameField: this.adminforth.config.auth.usernameField,
+                userLanguage,
+            });
             const apiBasedTools = buildApiBasedTools(this.adminforth, this.getInternalAgentResourceIds());
-            for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
-                assertRequiredApiTool(apiBasedTools, toolName);
-            }
-            assertRequiredApiTool(apiBasedTools, "update_record");
-            this.apiBasedTools = apiBasedTools;
             const stream = yield callAgent({
                 name: `adminforth-agent-${this.pluginInstanceId}`,
                 model,
@@ -252,8 +189,8 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                 sessionId: input.sessionId,
                 turnId: input.turnId,
                 currentPage: input.currentPage,
-                httpExtra: input.httpExtra,
                 userTimeZone: input.userTimeZone,
+                abortSignal: input.abortSignal,
                 emitToolCallEvent: (event) => {
                     var _a;
                     input.sequenceDebugCollector.handleToolCallEvent(event);
@@ -307,11 +244,67 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             };
         });
     }
+    runAndPersistAgentResponse(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            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,
+                    modeName: input.modeName,
+                    userTimeZone: input.userTimeZone,
+                    currentPage: input.currentPage,
+                    abortSignal: input.abortSignal,
+                    adminUser: input.adminUser,
+                    sequenceDebugCollector,
+                    emitToolCallEvent: input.emitToolCallEvent,
+                    emitReasoningDelta: input.emitReasoningDelta,
+                    emitTextDelta: input.emitTextDelta,
+                });
+                fullResponse = agentResponse.text;
+            }
+            catch (error) {
+                if ((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                    aborted = true;
+                    logger.info(input.abortLogMessage);
+                }
+                else {
+                    failed = true;
+                    logger.error(`${input.failureLogMessage}:\n${error.message}`);
+                    fullResponse = error.message;
+                    (_b = input.emitErrorResponse) === null || _b === void 0 ? void 0 : _b.call(input, 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,
+            };
+        });
+    }
     setupEndpoints(server) {
         server.endpoint({
             method: 'POST',
             path: `/agent/get-placeholder-messages`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, query, headers, cookies, adminUser, response, requestUrl }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ headers, adminUser }) {
                 if (!this.options.placeholderMessages) {
                     return {
                         messages: [],
@@ -319,14 +312,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                 }
                 const messages = yield this.options.placeholderMessages({
                     adminUser,
-                    httpExtra: {
-                        body,
-                        query,
-                        headers,
-                        cookies,
-                        requestUrl,
-                        response,
-                    },
+                    headers,
                 });
                 return {
                     messages,
@@ -336,330 +322,230 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         server.endpoint({
             method: 'POST',
             path: `/agent/response`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, query, headers, cookies, adminUser, response, requestUrl, _raw_express_res, abortSignal }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response, _raw_express_res, abortSignal }) {
                 var _b;
-                const res = _raw_express_res;
+                const data = this.parseBody(agentResponseBodySchema, body, response);
+                if (!data)
+                    return;
+                const stream = createAgentEventStream(_raw_express_res, { vercelAiUiMessageStream: true, closeActiveBlockOnToolStart: true });
                 const messageId = randomUUID();
-                const prompt = body.message;
-                const userTimeZone = (_b = body.timeZone) !== null && _b !== void 0 ? _b : 'UTC';
-                const currentPage = body.currentPage;
-                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);
-                yield this.updateSessionDate(sessionId);
-                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',
+                stream.start(messageId);
+                yield this.runAndPersistAgentResponse({
+                    prompt: data.message,
+                    sessionId: data.sessionId,
+                    modeName: data.mode,
+                    userTimeZone: (_b = data.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
+                    currentPage: data.currentPage,
+                    abortSignal,
+                    adminUser,
+                    emitToolCallEvent: stream.toolCall,
+                    emitReasoningDelta: stream.reasoningDelta,
+                    emitTextDelta: stream.textDelta,
+                    emitErrorResponse: stream.textDelta,
+                    failureLogMessage: "Agent response streaming failed",
+                    abortLogMessage: "Agent response streaming aborted by the client",
                 });
-                const send = (obj) => {
-                    if (isStreamClosed || res.writableEnded || res.destroyed) {
-                        return;
-                    }
-                    res.write(`data: ${JSON.stringify(obj)}\n\n`);
-                };
-                const emitToolCallEvent = (event) => {
-                    if (event.phase === "start") {
-                        endActiveBlock();
-                    }
-                    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 agentResponse = yield this.runAgentTurn({
-                        prompt,
-                        sessionId,
-                        turnId,
-                        modeName: body.mode,
-                        userTimeZone,
-                        currentPage,
-                        adminUser,
-                        httpExtra: {
-                            body,
-                            query,
-                            headers,
-                            cookies,
-                            requestUrl,
-                            response,
-                        },
-                        sequenceDebugCollector,
-                        emitToolCallEvent,
-                        emitReasoningDelta: (reasoningDelta) => {
-                            const reasoningId = startBlock('reasoning');
-                            send({
-                                type: 'reasoning-delta',
-                                id: reasoningId,
-                                delta: reasoningDelta,
-                            });
-                        },
-                        emitTextDelta: (textDelta) => {
-                            const textId = startBlock('text');
-                            fullResponse += textDelta;
-                            send({
-                                type: 'text-delta',
-                                id: textId,
-                                delta: textDelta,
-                            });
-                        },
-                    });
-                    fullResponse = agentResponse.text;
-                }
-                catch (error) {
-                    logger.error(`Agent response streaming failed:\n${formatAgentError(error)}`);
-                    sequenceDebugCollector.flush();
-                    fullResponse = formatAgentResponseError(error);
-                    const textId = startBlock('text');
-                    send({
-                        type: 'text-delta',
-                        id: textId,
-                        delta: fullResponse,
-                    });
-                }
-                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();
+                stream.end();
                 return null;
             })
         });
         server.endpoint({
             method: 'POST',
             path: `/agent/speech-response`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, query, headers, cookies, adminUser, response, requestUrl }) {
+            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 = this.options.audioAdapter;
                 if (!audioAdapter) {
                     response.setStatus(400, undefined);
-                    return {
-                        error: "Audio adapter is not configured for AdminForth Agent",
-                    };
+                    return { error: "Audio adapter is not configured for AdminForth Agent" };
                 }
-                const speechBody = body;
+                const data = this.parseBody(agentSpeechResponseBodySchema, body, response);
+                if (!data)
+                    return;
+                if (!req.file) {
+                    response.setStatus(400, undefined);
+                    return { error: "Audio file is required" };
+                }
+                const stream = createAgentEventStream(_raw_express_res);
                 let transcription;
                 try {
                     transcription = yield audioAdapter.transcribe({
-                        buffer: Buffer.from(speechBody.audioBase64, "base64"),
-                        filename: speechBody.filename,
-                        mimeType: speechBody.mimeType,
+                        buffer: req.file.buffer,
+                        filename: req.file.originalname,
+                        mimeType: req.file.mimetype,
                         language: "auto",
-                        prompt: speechBody.prompt,
                     });
                 }
                 catch (error) {
-                    logger.error(`Agent speech transcription failed:\n${formatAgentError(error)}`);
-                    response.setStatus(500, undefined);
-                    return {
-                        error: "Speech transcription failed. Check server logs for details.",
-                    };
+                    logger.error(`Agent speech transcription failed:\n${error.message}`);
+                    stream.error("Speech transcription failed. Check server logs for details.");
+                    stream.end();
+                    return null;
                 }
                 const prompt = transcription.text;
                 if (!prompt) {
-                    response.setStatus(400, undefined);
-                    return {
-                        error: "Speech transcription is empty",
-                    };
+                    stream.error("Speech transcription is empty");
+                    stream.end();
+                    return null;
+                }
+                stream.transcript(transcription.text, 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,
+                    emitToolCallEvent: stream.toolCall,
+                    failureLogMessage: "Agent speech response failed",
+                    abortLogMessage: "Agent speech response aborted by the client",
+                });
+                if (agentResponse.aborted) {
+                    stream.end();
+                    return null;
+                }
+                if (agentResponse.failed) {
+                    stream.error(agentResponse.text);
+                    stream.end();
+                    return null;
                 }
-                const sessionId = speechBody.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);
-                yield this.updateSessionDate(sessionId);
-                const sequenceDebugCollector = createSequenceDebugCollector();
-                let fullResponse = "";
                 try {
-                    const agentResponse = yield this.runAgentTurn({
-                        prompt,
-                        sessionId,
-                        turnId,
-                        modeName: speechBody.mode,
-                        userTimeZone: (_b = speechBody.timeZone) !== null && _b !== void 0 ? _b : 'UTC',
-                        currentPage: speechBody.currentPage,
-                        adminUser,
-                        httpExtra: {
-                            body,
-                            query,
-                            headers,
-                            cookies,
-                            requestUrl,
-                            response,
-                        },
-                        sequenceDebugCollector,
-                        emitTextDelta: (textDelta) => {
-                            fullResponse += textDelta;
-                        },
+                    stream.speechResponse({
+                        text: transcription.text,
+                        language: transcription.language,
+                    }, {
+                        text: agentResponse.text,
+                    }, sessionId, agentResponse.turnId);
+                    const speech = yield audioAdapter.synthesize({
+                        text: agentResponse.text,
+                        stream: true,
+                        streamFormat: "audio",
+                        format: "mp3",
                     });
-                    fullResponse = agentResponse.text;
-                    const speech = yield audioAdapter.synthesize(Object.assign({ text: fullResponse }, speechBody.tts));
-                    sequenceDebugCollector.flush();
-                    const turnUpdates = {
-                        [this.options.turnResource.responseField]: fullResponse,
-                    };
-                    if (this.options.turnResource.debugField) {
-                        turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
+                    stream.audioStart(speech.mimeType, speech.format);
+                    const reader = speech.audioStream.getReader();
+                    try {
+                        while (true) {
+                            const { value, done } = yield reader.read();
+                            if (done) {
+                                break;
+                            }
+                            stream.audioDelta(value);
+                        }
                     }
-                    yield this.updateTurn(turnId, turnUpdates);
-                    return {
-                        transcript: {
-                            text: transcription.text,
-                            language: transcription.language,
-                        },
-                        response: {
-                            text: fullResponse,
-                        },
-                        audio: {
-                            base64: speech.audio.toString("base64"),
-                            mimeType: speech.mimeType,
-                            format: speech.format,
-                        },
-                        sessionId,
-                        turnId,
-                    };
+                    finally {
+                        reader.releaseLock();
+                    }
+                    stream.audioDone();
+                    stream.end();
+                    return null;
                 }
                 catch (error) {
-                    logger.error(`Agent speech response failed:\n${formatAgentError(error)}`);
-                    sequenceDebugCollector.flush();
-                    fullResponse = formatAgentResponseError(error);
-                    const turnUpdates = {
-                        [this.options.turnResource.responseField]: fullResponse,
-                    };
-                    if (this.options.turnResource.debugField) {
-                        turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
+                    if (abortSignal.aborted) {
+                        logger.info("Agent speech audio streaming aborted by the client");
                     }
-                    yield this.updateTurn(turnId, turnUpdates);
-                    response.setStatus(500, undefined);
-                    return {
-                        error: fullResponse,
-                    };
+                    else {
+                        logger.error(`Agent speech audio streaming failed:\n${error}`);
+                        stream.error(error);
+                    }
+                    stream.end();
+                    return null;
                 }
             })
         });
         server.endpoint({
             method: 'POST',
             path: `/agent/get-sessions`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+                var _b;
+                const data = this.parseBody(getSessionsBodySchema, body, response);
+                if (!data)
+                    return;
                 const userId = adminUser.pk;
-                const limit = typeof body.limit === 'number' ? body.limit : 20;
-                const sessions = yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).list([Filters.EQ(this.pluginOptions.sessionResource.askerIdField, userId)], limit, 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],
-                    });
-                }
+                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: sessionsToReturn
+                    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 }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+                const parsedBody = sessionIdBodySchema.safeParse(body);
+                if (!parsedBody.success) {
+                    response.setStatus(422, parsedBody.error.message);
+                    return;
+                }
                 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)]);
+                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.pluginOptions.sessionResource.askerIdField] !== userId) {
+                if (session[this.options.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
+                    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 }) {
-                const triggerMessage = body.triggerMessage;
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+                const data = this.parseBody(createSessionBodySchema, body, response);
+                if (!data)
+                    return;
+                const triggerMessage = data.triggerMessage;
                 const userId = adminUser.pk;
-                const title = triggerMessage ? (triggerMessage.length > 40 ? triggerMessage.slice(0, 40) : triggerMessage) : 'New Session';
+                const title = (triggerMessage === null || triggerMessage === void 0 ? void 0 : triggerMessage.slice(0, 40)) || "New Session";
                 const newSession = {
-                    [this.pluginOptions.sessionResource.idField]: randomUUID(),
-                    [this.pluginOptions.sessionResource.titleField]: title,
-                    [this.pluginOptions.sessionResource.askerIdField]: userId,
+                    [this.options.sessionResource.idField]: randomUUID(),
+                    [this.options.sessionResource.titleField]: title,
+                    [this.options.sessionResource.askerIdField]: userId,
                 };
-                yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).create(newSession);
+                yield this.adminforth.resource(this.options.sessionResource.resourceId).create(newSession);
                 return {
-                    sessionId: newSession[this.pluginOptions.sessionResource.idField],
-                    title: newSession[this.pluginOptions.sessionResource.titleField],
-                    timestamp: newSession[this.pluginOptions.sessionResource.createdAtField],
+                    sessionId: newSession[this.options.sessionResource.idField],
+                    title: newSession[this.options.sessionResource.titleField],
+                    timestamp: newSession[this.options.sessionResource.createdAtField],
                     messages: []
                 };
             })
@@ -667,24 +553,27 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         server.endpoint({
             method: 'POST',
             path: `/agent/delete-session`,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser }) {
-                const sessionId = body.sessionId;
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+                const data = this.parseBody(sessionIdBodySchema, body, response);
+                if (!data)
+                    return;
+                const sessionId = data.sessionId;
                 const userId = adminUser.pk;
-                const session = yield this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).get([Filters.EQ(this.pluginOptions.sessionResource.idField, 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.pluginOptions.sessionResource.askerIdField] !== userId) {
+                if (session[this.options.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)]);
+                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.pluginOptions.turnResource.resourceId).delete(turn[this.pluginOptions.turnResource.idField]);
+                    yield this.adminforth.resource(this.options.turnResource.resourceId).delete(turn[this.options.turnResource.idField]);
                 }
                 return {
                     ok: true
@@ -694,10 +583,11 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             server.endpoint({
                 method: 'POST',
                 path: `/agent/add-system-message-to-turns`,
-                handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, _raw_express_req }) {
-                    const sessionId = body.sessionId;
-                    const systemMessage = body.systemMessage;
-                    yield this.createNewTurn(sessionId, systemMessage);
+                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
                     };