@adminforth/agent 2.0.9 → 2.1.0

package/dist/application/runTurnUseCase.js

@@ -0,0 +1,358 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { logger } from "adminforth";
+import { randomUUID } from "crypto";
+import { VegaLiteStreamBuffer } from "../domain/vegaLiteStreamBuffer.js";
+import { buildAgentTurnSystemPrompt } from "../domain/systemPrompt.js";
+import { getErrorMessage, isAbortError } from "../shared/errors.js";
+function getApprovalDecision(input) {
+    return "approvalDecision" in input
+        && (input.approvalDecision === "approve" || input.approvalDecision === "reject")
+        ? input.approvalDecision
+        : undefined;
+}
+function buildHitlDecision(decision, prompt) {
+    if (decision === "approve") {
+        return { type: "approve" };
+    }
+    return {
+        type: "reject",
+        message: prompt
+            ? `User rejected the pending tool execution and sent a new instruction instead: ${prompt}`
+            : "User rejected executing this tool",
+    };
+}
+function buildHitlResumeValue(input) {
+    return {
+        decisions: Array.from({ length: input.count }, () => (buildHitlDecision(input.decision, input.prompt))),
+    };
+}
+/**
+ * Build the provider-agnostic resume payload for a human-in-the-loop turn.
+ * Exported for unit testing; the LLM port wraps it into a LangGraph Command.
+ */
+export function buildResumeValue(input) {
+    var _a;
+    const interrupts = (_a = input.interrupts) !== null && _a !== void 0 ? _a : [];
+    if (interrupts.length === 0) {
+        throw new Error("No pending approval interrupt found for resume.");
+    }
+    if (interrupts.length === 1) {
+        return buildHitlResumeValue({
+            decision: input.decision,
+            count: interrupts[0].count,
+            prompt: input.prompt,
+        });
+    }
+    return Object.fromEntries(interrupts.map((interrupt) => [
+        interrupt.id,
+        buildHitlResumeValue({
+            decision: input.decision,
+            count: interrupt.count,
+            prompt: input.prompt,
+        }),
+    ]));
+}
+/**
+ * Single entry point for running an agent turn: prepare (start/resume) → build
+ * the prompt → stream from the LLM port → consume the typed stream into SSE
+ * events → persist the result. Replaces the former AgentTurnService plus the
+ * TurnLifecycle/Context/Prompt/Persistence/StreamConsumer + ModeResolver stack.
+ */
+export class RunTurnUseCase {
+    constructor(deps) {
+        this.deps = deps;
+        this.pendingInterrupts = new Map();
+    }
+    resolveMode(modeName) {
+        var _a;
+        return (_a = this.deps.modes.find((mode) => mode.name === modeName)) !== null && _a !== void 0 ? _a : this.deps.modes[0];
+    }
+    buildContext(input, turnId) {
+        var _a, _b;
+        return {
+            adminUser: input.adminUser,
+            sessionId: input.sessionId,
+            turnId,
+            abortSignal: input.abortSignal,
+            currentPage: input.currentPage,
+            chatSurface: input.chatSurface,
+            userTimeZone: (_a = input.userTimeZone) !== null && _a !== void 0 ? _a : "UTC",
+            adminPublicOrigin: (_b = input.adminPublicOrigin) !== null && _b !== void 0 ? _b : this.deps.getAdminforth().config.baseUrlSlashed,
+        };
+    }
+    /**
+     * Resolve the pending HITL interrupts for a resume. With a persistent checkpointer the
+     * checkpoint is authoritative (correct across instances and restarts); with the in-memory
+     * MemorySaver the in-process cache is authoritative (single process, cannot be stale).
+     */
+    resolvePendingInterrupts(sessionId, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.deps.hasPersistentCheckpointer) {
+                // The in-process cache can be stale after a cross-instance resume, so it is intentionally
+                // NOT consulted here. A failure to read the checkpoint is surfaced as a real error — never
+                // masked as "no pending approval".
+                try {
+                    return yield this.deps.llm.getPendingInterrupts({
+                        completionAdapter: mode.completionAdapter,
+                        sessionId,
+                    });
+                }
+                catch (error) {
+                    logger.error(`Failed to read pending approval state from checkpoint for session "${sessionId}": ${getErrorMessage(error)}`);
+                    throw error;
+                }
+            }
+            return (_a = this.pendingInterrupts.get(sessionId)) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    prepareTurn(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sequenceDebugSink = this.deps.createDebugSink();
+            const mode = this.resolveMode(input.modeName);
+            const approvalDecision = getApprovalDecision(input);
+            const shouldResume = Boolean(approvalDecision);
+            let turnId;
+            let previousUserMessages = [];
+            let initialResponse;
+            let resumeInterrupts;
+            if (shouldResume) {
+                resumeInterrupts = yield this.resolvePendingInterrupts(input.sessionId, mode);
+                if (resumeInterrupts.length === 0) {
+                    throw new Error(`No pending approval interrupt found for session "${input.sessionId}".`);
+                }
+                const resumeState = yield this.deps.sessions.getResumeState(input.sessionId);
+                turnId = resumeState.turnId;
+                initialResponse = resumeState.initialResponse;
+            }
+            else {
+                previousUserMessages = yield this.deps.sessions.getPreviousUserMessages(input.sessionId);
+                turnId = yield this.deps.sessions.createNewTurn(input.sessionId, input.prompt);
+                yield this.deps.sessions.touchSession(input.sessionId);
+            }
+            return {
+                prompt: input.prompt,
+                sessionId: input.sessionId,
+                turnId,
+                previousUserMessages,
+                mode,
+                context: this.buildContext(input, turnId),
+                observability: {
+                    emit: input.emit,
+                    sequenceDebugSink,
+                },
+                resume: shouldResume
+                    ? { decision: approvalDecision, interrupts: resumeInterrupts }
+                    : undefined,
+                initialResponse,
+            };
+        });
+    }
+    buildMessages(prepared) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userLanguage = yield this.deps.llm
+                .detectLanguage({
+                completionAdapter: prepared.mode.completionAdapter,
+                prompt: prepared.prompt,
+                previousUserMessages: prepared.previousUserMessages,
+            })
+                .catch((error) => {
+                var _a;
+                if (((_a = prepared.context.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 adminforth = this.deps.getAdminforth();
+            const systemPrompt = buildAgentTurnSystemPrompt({
+                agentSystemPrompt: yield this.deps.getAgentSystemPrompt(),
+                adminUser: prepared.context.adminUser,
+                usernameField: adminforth.config.auth.usernameField,
+                userLanguage,
+                chatSurface: prepared.context.chatSurface,
+            });
+            return [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: prepared.prompt },
+            ];
+        });
+    }
+    handleInterrupt(prepared, interrupt, descriptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!this.deps.hasPersistentCheckpointer) {
+                const existing = (_a = this.pendingInterrupts.get(prepared.sessionId)) !== null && _a !== void 0 ? _a : [];
+                const merged = new Map(existing.map((item) => [item.id, item.count]));
+                for (const item of descriptors) {
+                    merged.set(item.id, item.count);
+                }
+                this.pendingInterrupts.set(prepared.sessionId, [...merged.entries()].map(([id, count]) => ({ id, count })));
+            }
+            yield ((_c = (_b = prepared.observability).emit) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                type: "interrupt",
+                sessionId: prepared.sessionId,
+                interrupt,
+            }));
+        });
+    }
+    runAgentTurn(prepared) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const streamInput = prepared.resume
+                ? {
+                    resume: buildResumeValue({
+                        decision: prepared.resume.decision,
+                        interrupts: prepared.resume.interrupts,
+                        prompt: prepared.prompt,
+                    }),
+                }
+                : { messages: yield this.buildMessages(prepared) };
+            const stream = yield this.deps.llm.streamTurn({
+                completionAdapter: prepared.mode.completionAdapter,
+                input: streamInput,
+                context: prepared.context,
+                observability: prepared.observability,
+            });
+            const { emit } = prepared.observability;
+            const abortSignal = prepared.context.abortSignal;
+            const textBuffer = new VegaLiteStreamBuffer();
+            let fullResponse = "";
+            let interrupted = false;
+            try {
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        const chunk = _c;
+                        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                            throw new DOMException("This operation was aborted", "AbortError");
+                        }
+                        if (chunk.kind === "interrupt") {
+                            interrupted = true;
+                            yield this.handleInterrupt(prepared, chunk.interrupt, chunk.descriptors);
+                            continue;
+                        }
+                        if (chunk.kind === "reasoning") {
+                            if (chunk.delta) {
+                                yield (emit === null || emit === void 0 ? void 0 : emit({ type: "reasoning-delta", delta: chunk.delta }));
+                            }
+                            continue;
+                        }
+                        if (chunk.delta) {
+                            fullResponse += chunk.delta;
+                            yield textBuffer.push(chunk.delta, emit);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                yield textBuffer.flush(emit);
+                return { text: fullResponse };
+            }
+            finally {
+                if (!this.deps.hasPersistentCheckpointer && !interrupted) {
+                    this.pendingInterrupts.delete(prepared.sessionId);
+                }
+            }
+        });
+    }
+    runAndPersistAgentResponse(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const prepared = yield this.prepareTurn(input);
+            let fullResponse = (_a = prepared.initialResponse) !== null && _a !== void 0 ? _a : "";
+            let aborted = false;
+            let failed = false;
+            try {
+                const agentResponse = yield this.runAgentTurn(prepared);
+                fullResponse += agentResponse.text;
+            }
+            catch (error) {
+                if (((_b = input.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) || isAbortError(error)) {
+                    aborted = true;
+                    logger.info(input.abortLogMessage);
+                }
+                else {
+                    failed = true;
+                    fullResponse = getErrorMessage(error);
+                    logger.error(`${input.failureLogMessage}:\n${fullResponse}`);
+                }
+            }
+            prepared.observability.sequenceDebugSink.flush();
+            yield this.deps.sessions.saveTurnResponse({
+                turnId: prepared.turnId,
+                responseText: fullResponse,
+                debugHistory: prepared.observability.sequenceDebugSink.getHistory(),
+            });
+            return {
+                text: fullResponse,
+                turnId: prepared.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,
+                chatSurface: input.chatSurface,
+                adminPublicOrigin: input.adminPublicOrigin,
+                approvalDecision: input.approvalDecision,
+                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;
+        });
+    }
+}

package/dist/{agentEvents.d.ts → domain/agentEvents.d.ts}

@@ -1,4 +1,4 @@
-import type { ToolCallEvent } from "./agent/toolCallEvents.js";
+import type { ToolCallEvent } from "./toolCallEvents.js";
 export type AgentEvent = {
     type: "turn-started";
     messageId: string;

package/dist/{agent → domain}/systemPrompt.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { listProjectSkillManifests, } from "./skills/registry.js";
+import { listProjectSkillManifests, } from "../tools/skills/registry.js";
 export const DEFAULT_AGENT_SYSTEM_PROMPT = [
     "You are helpful AI Assistant for Admin Panel.",
     // about admin

package/dist/{agent/turn → domain}/turnTypes.d.ts

@@ -1,11 +1,21 @@
 import type { AdminUser, AudioAdapter } from "adminforth";
-import type { Messages } from "@langchain/langgraph";
-import type { Command } from "@langchain/langgraph";
-import type { AgentChatModel, AgentMiddleware } from "../simpleAgent.js";
-import type { SequenceDebugCollector } from "../middleware/sequenceDebug.js";
-import type { PreviousUserMessage } from "../languageDetect.js";
 import type { CurrentPageContext } from "../tools/getUserLocation.js";
-import type { AgentEventEmitter } from "../../agentEvents.js";
+import type { AgentEventEmitter } from "./agentEvents.js";
+/**
+ * Minimal sink the application layer uses to persist per-turn debug traces. The
+ * concrete implementation (the sequence-debug collector) lives in the llm layer;
+ * the domain/application layers depend only on this narrow interface, so the
+ * dependency direction stays llm -> application/domain.
+ */
+export type DebugSink = {
+    flush(): void;
+    getHistory(): unknown[];
+};
+/** A pending human-in-the-loop approval, normalized (provider-agnostic). */
+export type PendingInterrupt = {
+    id: string;
+    count: number;
+};
 export type BaseAgentTurnInput = {
     prompt: string;
     sessionId: string;
@@ -46,37 +56,7 @@ export type AgentTurnContext = {
 };
 export type AgentTurnObservability = {
     emit?: AgentEventEmitter;
-    sequenceDebugSink: SequenceDebugCollector;
-};
-export type PreparedAgentTurn = {
-    prompt: string;
-    sessionId: string;
-    turnId: string;
-    previousUserMessages: PreviousUserMessage[];
-    modeName?: string | null;
-    context: AgentTurnContext;
-    observability: AgentTurnObservability;
-    resume?: {
-        decision: "approve" | "reject";
-        interrupts?: {
-            id: string;
-            count: number;
-        }[];
-    };
-    initialResponse?: string;
-};
-export type AgentTurnModels = {
-    model: AgentChatModel;
-    summaryModel: AgentChatModel;
-    modelMiddleware?: AgentMiddleware[];
-};
-export type AgentRuntimeRunInput = {
-    models: AgentTurnModels;
-    input: {
-        messages: Messages;
-    } | Command;
-    context: AgentTurnContext;
-    observability: AgentTurnObservability;
+    sequenceDebugSink: DebugSink;
 };
 export type RunAndPersistAgentResponseInput = BaseAgentTurnInput & {
     emit?: AgentEventEmitter;
@@ -92,3 +72,27 @@ export type RunAndPersistAgentResponseResult = {
 };
 export type HandleTurnInput = TextAgentTurnInput;
 export type HandleSpeechTurnInput = SpeechAgentTurnInput;
+/**
+ * Provider-agnostic message passed from the application layer to the LLM port.
+ * The infrastructure adapter maps it onto concrete LangChain messages.
+ */
+export type AgentMessage = {
+    role: "system" | "user";
+    content: string;
+};
+/**
+ * Normalized unit of a streamed agent turn. The LLM port converts the raw
+ * LangGraph stream into these typed chunks so the application layer never
+ * touches LangGraph's tuple/`any` stream shape.
+ */
+export type AgentStreamChunk = {
+    kind: "text";
+    delta: string;
+} | {
+    kind: "reasoning";
+    delta: string;
+} | {
+    kind: "interrupt";
+    interrupt: unknown;
+    descriptors: PendingInterrupt[];
+};

package/dist/{agent/turn/VegaLiteStreamBuffer.d.ts → domain/vegaLiteStreamBuffer.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentEventEmitter } from "../../agentEvents.js";
+import type { AgentEventEmitter } from "./agentEvents.js";
 export declare class VegaLiteStreamBuffer {
     private bufferedTextDelta;
     private isRenderingVegaLite;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import type { AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
 import { AdminForthPlugin } from "adminforth";
 import type { PluginOptions } from './types.js';
-export type { AgentEvent, AgentEventEmitter } from "./agentEvents.js";
+export type { AgentEvent, AgentEventEmitter } from "./domain/agentEvents.js";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     options: PluginOptions;
     agentSystemPromptPromise: Promise<string>;
@@ -9,11 +9,12 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     private agentSystemPrompt;
     private checkpointer;
     private sessionStore;
-    private agentTurnService;
+    private runTurnUseCase;
     private speechTurnService;
     private chatSurfaceService;
     private getCheckpointer;
     private getInternalAgentResourceIds;
+    private getAgentSystemPrompt;
     constructor(options: PluginOptions);
     modifyGlobalConfig(adminforth: IAdminForth): Promise<void>;
     validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource): void;

package/dist/index.js

@@ -7,26 +7,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthPlugin } from "adminforth";
+import { AdminForthPlugin, logger } from "adminforth";
 import { MemorySaver } from "@langchain/langgraph";
-import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
-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";
-import { AgentModelFactory } from "./agent/models/AgentModelFactory.js";
-import { AgentModeResolver } from "./agent/models/AgentModeResolver.js";
-import { AgentRuntime } from "./agent/runtime/AgentRuntime.js";
-import { SpeechTurnService } from "./agent/speech/SpeechTurnService.js";
-import { AgentToolProvider } from "./agent/tools/AgentToolProvider.js";
-import { TurnContextBuilder } from "./agent/turn/TurnContextBuilder.js";
-import { TurnLifecycleService } from "./agent/turn/TurnLifecycleService.js";
-import { TurnPersistenceService } from "./agent/turn/TurnPersistenceService.js";
-import { TurnPromptBuilder } from "./agent/turn/TurnPromptBuilder.js";
-import { TurnStreamConsumer } from "./agent/turn/TurnStreamConsumer.js";
+import { AdminForthCheckpointSaver } from "./persistence/checkpointStore.js";
+import { appendCustomSystemPrompt, buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT } from "./domain/systemPrompt.js";
+import { setupCoreEndpoints } from "./transport/http/coreEndpoints.js";
+import { setupSessionEndpoints } from "./transport/http/sessionEndpoints.js";
+import { setupChatSurfaceEndpoints } from "./transport/http/chatSurfaceEndpoints.js";
+import { AgentSessionStore } from "./persistence/sessionStore.js";
+import { ChatSurfaceService } from "./transport/surfaces/chatSurfaceService.js";
+import { RunTurnUseCase } from "./application/runTurnUseCase.js";
+import { createSequenceDebugCollector } from "./llm/middleware/sequenceDebug.js";
+import { LangGraphLlm } from "./llm/langGraphLlm.js";
+import { AgentModelFactory } from "./llm/modelFactory.js";
+import { AgentRuntime } from "./llm/agentRuntime.js";
+import { SpeechTurnService } from "./transport/surfaces/speechTurnService.js";
+import { AgentToolProvider } from "./tools/agentToolProvider.js";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     getCheckpointer() {
         if (this.checkpointer)
@@ -44,6 +40,18 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             (_a = this.options.checkpointResource) === null || _a === void 0 ? void 0 : _a.resourceId,
         ].filter((resourceId) => Boolean(resourceId));
     }
+    getAgentSystemPrompt() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.agentSystemPrompt) {
+                const systemPrompt = yield buildAgentSystemPrompt(this.adminforth, this.getInternalAgentResourceIds()).catch((err) => {
+                    logger.error(`Failed to build agent system prompt, falling back to default: ${err instanceof Error ? err.message : String(err)}`);
+                    return DEFAULT_AGENT_SYSTEM_PROMPT;
+                });
+                this.agentSystemPrompt = appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt);
+            }
+            return this.agentSystemPrompt;
+        });
+    }
     constructor(options) {
         var _a;
         super(options, import.meta.url);
@@ -59,21 +67,18 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             getCheckpointer: this.getCheckpointer.bind(this),
             toolProvider,
         });
-        const persistence = new TurnPersistenceService(() => this.adminforth, this.options);
-        this.agentTurnService = new AgentTurnService(new TurnLifecycleService(this.sessionStore, persistence, this.options), new TurnContextBuilder(() => this.adminforth), new AgentModeResolver(this.options), new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000), new TurnPromptBuilder({
+        const llm = new LangGraphLlm(runtime, new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000));
+        this.runTurnUseCase = new RunTurnUseCase({
+            llm,
+            sessions: this.sessionStore,
+            modes: this.options.modes,
             getAdminforth: () => this.adminforth,
-            getAgentSystemPrompt: () => __awaiter(this, void 0, void 0, function* () {
-                if (!this.agentSystemPrompt) {
-                    const systemPrompt = yield buildAgentSystemPrompt(this.adminforth, this.getInternalAgentResourceIds()).catch((err) => {
-                        return DEFAULT_AGENT_SYSTEM_PROMPT;
-                    });
-                    this.agentSystemPrompt = appendCustomSystemPrompt(systemPrompt, this.options.systemPrompt);
-                }
-                return this.agentSystemPrompt;
-            }),
-        }), runtime, new TurnStreamConsumer());
-        this.speechTurnService = new SpeechTurnService(this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService));
-        this.chatSurfaceService = new ChatSurfaceService(() => this.adminforth, this.options, this.sessionStore, this.agentTurnService.handleTurn.bind(this.agentTurnService), this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService));
+            getAgentSystemPrompt: this.getAgentSystemPrompt.bind(this),
+            hasPersistentCheckpointer: Boolean(this.options.checkpointResource),
+            createDebugSink: createSequenceDebugCollector,
+        });
+        this.speechTurnService = new SpeechTurnService(this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase));
+        this.chatSurfaceService = new ChatSurfaceService(() => this.adminforth, this.options, this.sessionStore, this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase), this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase));
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
     }
@@ -139,9 +144,9 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         const endpointContext = {
             adminforth: this.adminforth,
             options: this.options,
-            handleTurn: this.agentTurnService.handleTurn.bind(this.agentTurnService),
+            handleTurn: this.runTurnUseCase.handleTurn.bind(this.runTurnUseCase),
             handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
-            runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
+            runAndPersistAgentResponse: this.runTurnUseCase.runAndPersistAgentResponse.bind(this.runTurnUseCase),
             getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
             createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),
             createSystemTurn: this.sessionStore.createSystemTurn.bind(this.sessionStore),

package/dist/{agent/runtime/AgentContext.d.ts → llm/agentContext.d.ts}

@@ -1,9 +1,9 @@
 import type { AdminUser } from "adminforth";
 import { z } from "zod";
-import type { AgentEventEmitter } from "../../agentEvents.js";
-import type { SequenceDebugCollector } from "../middleware/sequenceDebug.js";
+import type { AgentEventEmitter } from "../domain/agentEvents.js";
+import type { SequenceDebugCollector } from "./middleware/sequenceDebug.js";
 import type { CurrentPageContext } from "../tools/getUserLocation.js";
-import type { AgentTurnContext } from "../turn/turnTypes.js";
+import type { AgentTurnContext } from "../domain/turnTypes.js";
 export declare const contextSchema: z.ZodObject<{
     adminUser: z.ZodCustom<AdminUser, AdminUser>;
     userTimeZone: z.ZodString;