@adminforth/agent 1.50.1 → 1.51.0

package/dist/agent/runtime/AgentContext.d.ts

@@ -0,0 +1,28 @@
+import type { AdminUser } from "adminforth";
+import { z } from "zod";
+import type { AgentEventEmitter } from "../../agentEvents.js";
+import type { SequenceDebugCollector } from "../middleware/sequenceDebug.js";
+import type { CurrentPageContext } from "../tools/getUserLocation.js";
+import type { AgentTurnContext } from "../turn/turnTypes.js";
+export declare const contextSchema: z.ZodObject<{
+    adminUser: z.ZodCustom<AdminUser, AdminUser>;
+    userTimeZone: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    abortSignal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+    currentPage: z.ZodOptional<z.ZodCustom<CurrentPageContext, CurrentPageContext>>;
+    chatSurface: z.ZodOptional<z.ZodString>;
+    adminBaseUrl: z.ZodOptional<z.ZodString>;
+    adminPublicOrigin: z.ZodOptional<z.ZodString>;
+    emit: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
+    sequenceDebugSink: z.ZodCustom<SequenceDebugCollector, SequenceDebugCollector>;
+}, z.core.$strip>;
+export declare function toLangchainAgentContext(context: AgentTurnContext & {
+    adminBaseUrl: string;
+    emit?: AgentEventEmitter;
+    sequenceDebugSink: SequenceDebugCollector;
+}): AgentTurnContext & {
+    adminBaseUrl: string;
+    emit?: AgentEventEmitter;
+    sequenceDebugSink: SequenceDebugCollector;
+};

package/dist/agent/runtime/AgentContext.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const contextSchema = z.object({
+    adminUser: z.custom(),
+    userTimeZone: z.string(),
+    sessionId: z.string(),
+    turnId: z.string(),
+    abortSignal: z.custom().optional(),
+    currentPage: z.custom().optional(),
+    chatSurface: z.string().optional(),
+    adminBaseUrl: z.string().optional(),
+    adminPublicOrigin: z.string().optional(),
+    emit: z.custom().optional(),
+    sequenceDebugSink: z.custom(),
+});
+export function toLangchainAgentContext(context) {
+    return context;
+}

package/dist/agent/runtime/AgentRuntime.d.ts

@@ -0,0 +1,15 @@
+import type { IAdminForth } from "adminforth";
+import type { BaseCheckpointSaver } from "@langchain/langgraph";
+import type { AgentToolProvider } from "../tools/AgentToolProvider.js";
+import type { AgentRuntimeRunInput } from "../turn/turnTypes.js";
+export type AgentRuntimeOptions = {
+    name: string;
+    getAdminforth: () => IAdminForth;
+    getCheckpointer: () => BaseCheckpointSaver;
+    toolProvider: AgentToolProvider;
+};
+export declare class AgentRuntime {
+    private readonly options;
+    constructor(options: AgentRuntimeOptions);
+    stream(input: AgentRuntimeRunInput): Promise<import("@langchain/core/utils/stream").IterableReadableStream<[import("langchain").BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>, Record<string, any>]>>;
+}

package/dist/agent/runtime/AgentRuntime.js

@@ -0,0 +1,57 @@
+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 { createAgent, summarizationMiddleware } from "langchain";
+import { createApiBasedToolsMiddleware } from "../middleware/apiBasedTools.js";
+import { createSequenceDebugMiddleware } from "../middleware/sequenceDebug.js";
+import { createAgentLlmMetricsLogger } from "../simpleAgent.js";
+import { contextSchema, toLangchainAgentContext } from "./AgentContext.js";
+export class AgentRuntime {
+    constructor(options) {
+        this.options = options;
+    }
+    stream(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const apiBasedTools = this.options.toolProvider.getApiBasedTools();
+            const tools = yield this.options.toolProvider.getTools(apiBasedTools);
+            const adminforth = this.options.getAdminforth();
+            const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
+            const sequenceDebugMiddleware = createSequenceDebugMiddleware(input.observability.sequenceDebugSink);
+            const middleware = [
+                apiBasedToolsMiddleware,
+                ...((_a = input.models.modelMiddleware) !== null && _a !== void 0 ? _a : []),
+                sequenceDebugMiddleware,
+                summarizationMiddleware({
+                    model: input.models.summaryModel,
+                    trigger: { tokens: 1024 * 64 },
+                    keep: { messages: 10 },
+                }),
+            ];
+            const agent = createAgent({
+                name: this.options.name,
+                model: input.models.model,
+                checkpointer: this.options.getCheckpointer(),
+                tools,
+                contextSchema,
+                middleware,
+            });
+            return agent.stream({ messages: input.messages }, {
+                streamMode: "messages",
+                recursionLimit: 100,
+                callbacks: [createAgentLlmMetricsLogger()],
+                signal: input.context.abortSignal,
+                configurable: {
+                    thread_id: input.context.sessionId,
+                },
+                context: toLangchainAgentContext(Object.assign(Object.assign({}, input.context), { adminBaseUrl: adminforth.config.baseUrlSlashed, emit: input.observability.emit, sequenceDebugSink: input.observability.sequenceDebugSink })),
+            });
+        });
+    }
+}

package/dist/agent/simpleAgent.d.ts

@@ -1,25 +1,8 @@
 import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { type AdminUser, type CompletionAdapter, type IAdminForth } from "adminforth";
-import { type BaseCheckpointSaver, type Messages } from "@langchain/langgraph";
-import { z } from "zod";
-import { createSequenceDebugMiddleware, type SequenceDebugModelCallSink } from "./middleware/sequenceDebug.js";
-import type { ApiBasedTool } from "../apiBasedTools.js";
-import type { ToolCallEventSink } from "./toolCallEvents.js";
-import type { CurrentPageContext } from "./tools/getUserLocation.js";
-import type { AgentEventEmitter } from "../agentEvents.js";
-export declare const contextSchema: z.ZodObject<{
-    adminUser: z.ZodCustom<AdminUser, AdminUser>;
-    userTimeZone: z.ZodString;
-    sessionId: z.ZodString;
-    turnId: z.ZodString;
-    abortSignal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
-    currentPage: z.ZodOptional<z.ZodCustom<CurrentPageContext, CurrentPageContext>>;
-    chatSurface: z.ZodOptional<z.ZodString>;
-    adminBaseUrl: z.ZodOptional<z.ZodString>;
-    adminPublicOrigin: z.ZodOptional<z.ZodString>;
-    emitToolCallEvent: z.ZodCustom<ToolCallEventSink, ToolCallEventSink>;
-    emitAgentEvent: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
-}, z.core.$strip>;
+import { type CompletionAdapter } from "adminforth";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import type { LLMResult } from "@langchain/core/outputs";
+import { createSequenceDebugMiddleware } from "./middleware/sequenceDebug.js";
 export type AgentChatModel = BaseChatModel<any, any>;
 export type AgentModelPurpose = "primary" | "summary";
 export type AgentModeCompletionAdapter = CompletionAdapter & {
@@ -34,37 +17,24 @@ export type AgentModeCompletionAdapter = CompletionAdapter & {
         middleware?: unknown[];
     };
 };
-type AgentMiddleware = ReturnType<typeof createSequenceDebugMiddleware>;
+export type AgentMiddleware = ReturnType<typeof createSequenceDebugMiddleware>;
 type AgentChatModelSpec = {
     model: AgentChatModel;
     middleware: AgentMiddleware[];
 };
+declare class AgentLlmMetricsLogger extends BaseCallbackHandler {
+    name: string;
+    lc_prefer_streaming: boolean;
+    private readonly pendingRuns;
+    handleLLMStart(_llm: unknown, _prompts: string[], runId: string): Promise<void>;
+    handleLLMNewToken(_token: string, _chunk: unknown, runId: string): Promise<void>;
+    handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
+    handleLLMError(_error: unknown, runId: string): Promise<void>;
+}
+export declare function createAgentLlmMetricsLogger(): AgentLlmMetricsLogger;
 export declare function createAgentChatModel(params: {
     adapter: CompletionAdapter;
     maxTokens: number;
     purpose: AgentModelPurpose;
 }): Promise<AgentChatModelSpec>;
-export declare function callAgent(params: {
-    name: string;
-    model: AgentChatModel;
-    summaryModel: AgentChatModel;
-    modelMiddleware?: AgentMiddleware[];
-    checkpointer?: BaseCheckpointSaver;
-    messages: Messages;
-    adminUser: AdminUser;
-    adminforth: IAdminForth;
-    apiBasedTools: Record<string, ApiBasedTool>;
-    customComponentsDir: string;
-    pluginCustomFolderPaths: string[];
-    sessionId: string;
-    turnId: string;
-    currentPage?: CurrentPageContext;
-    chatSurface?: string;
-    adminPublicOrigin?: string;
-    userTimeZone: string;
-    abortSignal?: AbortSignal;
-    emitToolCallEvent: ToolCallEventSink;
-    emitAgentEvent?: AgentEventEmitter;
-    sequenceDebugSink: SequenceDebugModelCallSink;
-}): Promise<import("@langchain/core/utils/stream").IterableReadableStream<[import("langchain").BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>, Record<string, any>]>>;
 export {};

package/dist/agent/simpleAgent.js

@@ -7,26 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAgent, summarizationMiddleware } from "langchain";
 import { logger, } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import { z } from "zod";
-import { createAgentTools } from "./tools/index.js";
-import { createApiBasedToolsMiddleware } from "./middleware/apiBasedTools.js";
-import { createSequenceDebugMiddleware, } from "./middleware/sequenceDebug.js";
-export const contextSchema = z.object({
-    adminUser: z.custom(),
-    userTimeZone: z.string(),
-    sessionId: z.string(),
-    turnId: z.string(),
-    abortSignal: z.custom().optional(),
-    currentPage: z.custom().optional(),
-    chatSurface: z.string().optional(),
-    adminBaseUrl: z.string().optional(),
-    adminPublicOrigin: z.string().optional(),
-    emitToolCallEvent: z.custom(),
-    emitAgentEvent: z.custom().optional(),
-});
 function isLangChainAgentCompletionAdapter(adapter) {
     return typeof adapter
         .getLangChainAgentSpec === "function";
@@ -119,7 +101,7 @@ class AgentLlmMetricsLogger extends BaseCallbackHandler {
         });
     }
 }
-function createAgentLlmMetricsLogger() {
+export function createAgentLlmMetricsLogger() {
     return new AgentLlmMetricsLogger();
 }
 export function createAgentChatModel(params) {
@@ -134,51 +116,3 @@ export function createAgentChatModel(params) {
         });
     });
 }
-export function callAgent(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, pluginCustomFolderPaths, sessionId, turnId, currentPage, chatSurface, adminPublicOrigin, userTimeZone, abortSignal, emitToolCallEvent, emitAgentEvent, sequenceDebugSink, } = params;
-        const tools = yield createAgentTools(customComponentsDir, apiBasedTools, pluginCustomFolderPaths);
-        const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
-        const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
-        const middleware = [
-            apiBasedToolsMiddleware,
-            ...modelMiddleware,
-            sequenceDebugMiddleware,
-            summarizationMiddleware({
-                model: summaryModel,
-                trigger: { tokens: 1024 * 64 },
-                keep: { messages: 10 },
-            }),
-        ];
-        const agent = createAgent({
-            name,
-            model,
-            checkpointer,
-            tools,
-            contextSchema,
-            middleware,
-        });
-        return yield agent.stream({ messages }, {
-            streamMode: "messages",
-            recursionLimit: 100,
-            callbacks: [createAgentLlmMetricsLogger()],
-            signal: abortSignal,
-            configurable: {
-                thread_id: sessionId,
-            },
-            context: {
-                adminUser,
-                userTimeZone,
-                sessionId,
-                turnId,
-                abortSignal,
-                currentPage,
-                chatSurface,
-                adminBaseUrl: adminforth.config.baseUrlSlashed,
-                adminPublicOrigin,
-                emitToolCallEvent,
-                emitAgentEvent,
-            },
-        });
-    });
-}

package/dist/agent/speech/SpeechTurnService.d.ts

@@ -0,0 +1,6 @@
+import type { RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult, SpeechAgentTurnInput } from "../turn/turnTypes.js";
+export declare class SpeechTurnService {
+    private readonly runAndPersistAgentResponse;
+    constructor(runAndPersistAgentResponse: (input: RunAndPersistAgentResponseInput) => Promise<RunAndPersistAgentResponseResult>);
+    handle(input: SpeechAgentTurnInput): Promise<RunAndPersistAgentResponseResult | null>;
+}

package/dist/agent/speech/SpeechTurnService.js

@@ -0,0 +1,168 @@
+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 { logger } from "adminforth";
+import { getErrorMessage, isAbortError } from "../../errors.js";
+import { sanitizeSpeechText } from "../../sanitizeSpeechText.js";
+export class SpeechTurnService {
+    constructor(runAndPersistAgentResponse) {
+        this.runAndPersistAgentResponse = runAndPersistAgentResponse;
+    }
+    handle(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            let transcription;
+            try {
+                transcription = yield input.audioAdapter.transcribe({
+                    buffer: input.audio.buffer,
+                    filename: input.audio.filename,
+                    mimeType: input.audio.mimeType,
+                    language: "auto",
+                    abortSignal: input.abortSignal,
+                });
+            }
+            catch (error) {
+                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
+                    logger.info("Agent speech transcription aborted by the client");
+                    yield input.emit({ type: "finish" });
+                    return null;
+                }
+                logger.error(`Agent speech transcription failed:\n${getErrorMessage(error)}`);
+                yield input.emit({
+                    type: "error",
+                    error: "Speech transcription failed. Check server logs for details.",
+                });
+                yield input.emit({ type: "finish" });
+                return null;
+            }
+            if ((_b = input.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                yield input.emit({ type: "finish" });
+                return null;
+            }
+            const prompt = transcription.text;
+            if (!prompt) {
+                yield input.emit({
+                    type: "error",
+                    error: "Speech transcription is empty",
+                });
+                yield input.emit({ type: "finish" });
+                return null;
+            }
+            yield input.emit({
+                type: "transcript",
+                text: transcription.text,
+                language: transcription.language,
+            });
+            const agentResponse = yield this.runAndPersistAgentResponse({
+                prompt,
+                sessionId: input.sessionId,
+                modeName: input.modeName,
+                userTimeZone: input.userTimeZone,
+                currentPage: input.currentPage,
+                chatSurface: input.chatSurface,
+                adminPublicOrigin: input.adminPublicOrigin,
+                abortSignal: input.abortSignal,
+                adminUser: input.adminUser,
+                emit: (event) => __awaiter(this, void 0, void 0, function* () {
+                    if (event.type === "tool-call") {
+                        yield input.emit(event);
+                    }
+                }),
+                failureLogMessage: (_c = input.failureLogMessage) !== null && _c !== void 0 ? _c : "Agent speech response failed",
+                abortLogMessage: (_d = input.abortLogMessage) !== null && _d !== void 0 ? _d : "Agent speech response aborted by the client",
+            });
+            if (agentResponse.aborted) {
+                yield input.emit({ type: "finish" });
+                return agentResponse;
+            }
+            if (agentResponse.failed) {
+                yield input.emit({
+                    type: "error",
+                    error: agentResponse.text,
+                });
+                yield input.emit({ type: "finish" });
+                return agentResponse;
+            }
+            try {
+                yield input.emit({
+                    type: "speech-response",
+                    transcript: {
+                        text: transcription.text,
+                        language: transcription.language,
+                    },
+                    response: {
+                        text: agentResponse.text,
+                    },
+                    sessionId: input.sessionId,
+                    turnId: agentResponse.turnId,
+                });
+                const speech = yield input.audioAdapter.synthesize({
+                    text: sanitizeSpeechText(agentResponse.text),
+                    stream: true,
+                    streamFormat: "audio",
+                    format: "pcm",
+                    abortSignal: input.abortSignal,
+                });
+                yield input.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 {
+                    (_e = input.abortSignal) === null || _e === void 0 ? void 0 : _e.addEventListener("abort", cancelAudioStream, { once: true });
+                    while (true) {
+                        if ((_f = input.abortSignal) === null || _f === void 0 ? void 0 : _f.aborted) {
+                            yield reader.cancel().catch(() => undefined);
+                            break;
+                        }
+                        const { value, done } = yield reader.read();
+                        if (done) {
+                            break;
+                        }
+                        if ((_g = input.abortSignal) === null || _g === void 0 ? void 0 : _g.aborted) {
+                            break;
+                        }
+                        yield input.emit({
+                            type: "audio-delta",
+                            value,
+                        });
+                    }
+                }
+                finally {
+                    (_h = input.abortSignal) === null || _h === void 0 ? void 0 : _h.removeEventListener("abort", cancelAudioStream);
+                    reader.releaseLock();
+                }
+                yield input.emit({ type: "audio-done" });
+                yield input.emit({ type: "finish" });
+                return agentResponse;
+            }
+            catch (error) {
+                if (((_j = input.abortSignal) === null || _j === void 0 ? void 0 : _j.aborted) || isAbortError(error)) {
+                    logger.info("Agent speech audio streaming aborted by the client");
+                }
+                else {
+                    logger.error(`Agent speech audio streaming failed:\n${getErrorMessage(error)}`);
+                    yield input.emit({
+                        type: "error",
+                        error: getErrorMessage(error),
+                    });
+                }
+                yield input.emit({ type: "finish" });
+                return agentResponse;
+            }
+        });
+    }
+}

package/dist/agent/tools/AgentToolProvider.d.ts

@@ -0,0 +1,9 @@
+import type { IAdminForth } from "adminforth";
+import type { ApiBasedTool } from "../../apiBasedTools.js";
+export declare class AgentToolProvider {
+    private readonly getAdminforth;
+    private readonly getInternalAgentResourceIds;
+    constructor(getAdminforth: () => IAdminForth, getInternalAgentResourceIds: () => string[]);
+    getApiBasedTools(): Record<string, ApiBasedTool>;
+    getTools(apiBasedTools: Record<string, ApiBasedTool>): Promise<import("@langchain/core/tools").ClientTool[]>;
+}

package/dist/agent/tools/AgentToolProvider.js

@@ -0,0 +1,27 @@
+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 { prepareApiBasedTools } from "../../apiBasedTools.js";
+import { createAgentTools } from "./index.js";
+export class AgentToolProvider {
+    constructor(getAdminforth, getInternalAgentResourceIds) {
+        this.getAdminforth = getAdminforth;
+        this.getInternalAgentResourceIds = getInternalAgentResourceIds;
+    }
+    getApiBasedTools() {
+        return prepareApiBasedTools(this.getAdminforth(), this.getInternalAgentResourceIds());
+    }
+    getTools(apiBasedTools) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const adminforth = this.getAdminforth();
+            return createAgentTools((_a = adminforth.config.customization.customComponentsDir) !== null && _a !== void 0 ? _a : "custom", apiBasedTools, adminforth.activatedPlugins.map((plugin) => plugin.customFolderPath));
+        });
+    }
+}

package/dist/agent/tools/navigateUser.js

@@ -145,7 +145,7 @@ export function createNavigateUserTool() {
                 message: `Send this link to the user: ${url}`,
             }, null, 2);
         }
-        yield ((_a = context.emitAgentEvent) === null || _a === void 0 ? void 0 : _a.call(context, {
+        yield ((_a = context.emit) === null || _a === void 0 ? void 0 : _a.call(context, {
             type: "open-page",
             targetPath,
         }));

package/dist/agent/turn/TurnContextBuilder.d.ts

@@ -0,0 +1,14 @@
+import type { AdminUser, IAdminForth } from "adminforth";
+import type { AgentTurnContext, BaseAgentTurnInput } from "./turnTypes.js";
+export type UserContextProvider = {
+    getUserTimeZone(adminUser: AdminUser): Promise<string | null | undefined> | string | null | undefined;
+};
+export declare class TurnContextBuilder {
+    private readonly getAdminforth;
+    private readonly userContextProvider?;
+    constructor(getAdminforth: () => IAdminForth, userContextProvider?: UserContextProvider | undefined);
+    build(input: {
+        base: BaseAgentTurnInput;
+        turnId: string;
+    }): Promise<AgentTurnContext>;
+}

package/dist/agent/turn/TurnContextBuilder.js

@@ -0,0 +1,31 @@
+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());
+    });
+};
+export class TurnContextBuilder {
+    constructor(getAdminforth, userContextProvider) {
+        this.getAdminforth = getAdminforth;
+        this.userContextProvider = userContextProvider;
+    }
+    build(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const adminforth = this.getAdminforth();
+            return {
+                adminUser: input.base.adminUser,
+                sessionId: input.base.sessionId,
+                turnId: input.turnId,
+                abortSignal: input.base.abortSignal,
+                currentPage: input.base.currentPage,
+                chatSurface: input.base.chatSurface,
+                userTimeZone: (_c = (_a = input.base.userTimeZone) !== null && _a !== void 0 ? _a : yield ((_b = this.userContextProvider) === null || _b === void 0 ? void 0 : _b.getUserTimeZone(input.base.adminUser))) !== null && _c !== void 0 ? _c : "UTC",
+                adminPublicOrigin: (_d = input.base.adminPublicOrigin) !== null && _d !== void 0 ? _d : adminforth.config.baseUrlSlashed,
+            };
+        });
+    }
+}

package/dist/agent/turn/TurnLifecycleService.d.ts

@@ -0,0 +1,17 @@
+import type { AgentSessionStore } from "../../sessionStore.js";
+import type { BaseAgentTurnInput } from "./turnTypes.js";
+import { TurnPersistenceService } from "./TurnPersistenceService.js";
+export declare class TurnLifecycleService {
+    private readonly sessionStore;
+    private readonly persistence;
+    constructor(sessionStore: AgentSessionStore, persistence: TurnPersistenceService);
+    start(input: BaseAgentTurnInput): Promise<{
+        turnId: any;
+        previousUserMessages: import("../languageDetect.js").PreviousUserMessage[];
+    }>;
+    finish(input: {
+        turnId: string;
+        responseText: string;
+        debugHistory?: unknown;
+    }): Promise<void>;
+}

package/dist/agent/turn/TurnLifecycleService.js

@@ -0,0 +1,31 @@
+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());
+    });
+};
+export class TurnLifecycleService {
+    constructor(sessionStore, persistence) {
+        this.sessionStore = sessionStore;
+        this.persistence = persistence;
+    }
+    start(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const previousUserMessages = yield this.sessionStore.getPreviousUserMessages(input.sessionId);
+            const turnId = yield this.sessionStore.createNewTurn(input.sessionId, input.prompt);
+            yield this.persistence.touchSession(input.sessionId);
+            return {
+                turnId,
+                previousUserMessages,
+            };
+        });
+    }
+    finish(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.persistence.saveTurnResponse(input);
+        });
+    }
+}

package/dist/agent/turn/TurnPersistenceService.d.ts

@@ -0,0 +1,13 @@
+import type { IAdminForth } from "adminforth";
+import type { PluginOptions } from "../../types.js";
+export declare class TurnPersistenceService {
+    private readonly getAdminforth;
+    private readonly options;
+    constructor(getAdminforth: () => IAdminForth, options: PluginOptions);
+    touchSession(sessionId: string): Promise<void>;
+    saveTurnResponse(input: {
+        turnId: string;
+        responseText: string;
+        debugHistory?: unknown;
+    }): Promise<void>;
+}

package/dist/agent/turn/TurnPersistenceService.js

@@ -0,0 +1,35 @@
+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());
+    });
+};
+export class TurnPersistenceService {
+    constructor(getAdminforth, options) {
+        this.getAdminforth = getAdminforth;
+        this.options = options;
+    }
+    touchSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getAdminforth().resource(this.options.sessionResource.resourceId).update(sessionId, {
+                [this.options.sessionResource.createdAtField]: new Date().toISOString(),
+            });
+        });
+    }
+    saveTurnResponse(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const turnUpdates = {
+                [this.options.turnResource.responseField]: input.responseText,
+            };
+            if (this.options.turnResource.debugField) {
+                turnUpdates[this.options.turnResource.debugField] = input.debugHistory;
+            }
+            yield this.getAdminforth()
+                .resource(this.options.turnResource.resourceId)
+                .update(input.turnId, turnUpdates);
+        });
+    }
+}