@adminforth/agent 1.50.1 → 1.51.0

package/dist/agentTurnService.js

@@ -7,231 +7,79 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import { logger } from "adminforth";
 import { randomUUID } from "crypto";
-import { HumanMessage, SystemMessage } from "langchain";
-import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
 import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
-import { detectUserLanguage } from "./agent/languageDetect.js";
-import { prepareApiBasedTools as buildApiBasedTools } from "./apiBasedTools.js";
-import { buildAgentTurnSystemPrompt } from "./agent/systemPrompt.js";
-import { isAbortError, getErrorMessage } from "./errors.js";
-import { sanitizeSpeechText } from "./sanitizeSpeechText.js";
-const VEGA_LITE_FENCE_START = "```vega-lite";
-const COMPLETE_VEGA_LITE_BLOCK_RE = /```vega-lite[\s\S]*?```/;
+import { getErrorMessage, isAbortError } from "./errors.js";
 export class AgentTurnService {
-    constructor(serviceOptions) {
-        this.serviceOptions = serviceOptions;
+    constructor(lifecycle, contextBuilder, modeResolver, modelFactory, promptBuilder, runtime, streamConsumer) {
+        this.lifecycle = lifecycle;
+        this.contextBuilder = contextBuilder;
+        this.modeResolver = modeResolver;
+        this.modelFactory = modelFactory;
+        this.promptBuilder = promptBuilder;
+        this.runtime = runtime;
+        this.streamConsumer = streamConsumer;
+    }
+    prepareTurn(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sequenceDebugCollector = createSequenceDebugCollector();
+            const { turnId, previousUserMessages } = yield this.lifecycle.start(input);
+            const context = yield this.contextBuilder.build({
+                base: input,
+                turnId,
+            });
+            return {
+                prompt: input.prompt,
+                sessionId: input.sessionId,
+                turnId,
+                previousUserMessages,
+                modeName: input.modeName,
+                context,
+                observability: {
+                    emit: undefined,
+                    sequenceDebugSink: sequenceDebugCollector,
+                },
+            };
+        });
     }
     runAgentTurn(input) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            const adminforth = this.serviceOptions.getAdminforth();
-            const options = this.serviceOptions.options;
-            let fullResponse = "";
-            let bufferedTextDelta = "";
-            let isRenderingVegaLite = false;
-            const maxTokens = (_d = options.maxTokens) !== null && _d !== void 0 ? _d : 1000;
-            const selectedMode = (_e = options.modes.find((mode) => mode.name === input.modeName)) !== null && _e !== void 0 ? _e : options.modes[0];
-            const [primaryModelSpec, summaryModelSpec] = yield Promise.all([
-                createAgentChatModel({
-                    adapter: selectedMode.completionAdapter,
-                    maxTokens,
-                    purpose: "primary",
-                }),
-                createAgentChatModel({
-                    adapter: selectedMode.completionAdapter,
-                    maxTokens,
-                    purpose: "summary",
+            const selectedMode = this.modeResolver.resolve(input.modeName);
+            const [models, messages] = yield Promise.all([
+                this.modelFactory.create(selectedMode.completionAdapter),
+                this.promptBuilder.build({
+                    prompt: input.prompt,
+                    previousUserMessages: input.previousUserMessages,
+                    adminUser: input.context.adminUser,
+                    completionAdapter: selectedMode.completionAdapter,
+                    chatSurface: input.context.chatSurface,
+                    abortSignal: input.context.abortSignal,
                 }),
             ]);
-            const model = primaryModelSpec.model;
-            const summaryModel = summaryModelSpec.model;
-            const modelMiddleware = primaryModelSpec.middleware;
-            const userLanguage = yield detectUserLanguage(selectedMode.completionAdapter, input.prompt, input.previousUserMessages)
-                .catch((error) => {
-                var _a;
-                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
-                    throw error;
-                }
-                logger.warn(`Failed to detect user language: ${getErrorMessage(error)}`);
-                return null;
+            const stream = yield this.runtime.stream({
+                models,
+                messages,
+                context: input.context,
+                observability: input.observability,
             });
-            const systemPrompt = buildAgentTurnSystemPrompt({
-                agentSystemPrompt: yield this.serviceOptions.getAgentSystemPrompt(),
-                adminUser: input.adminUser,
-                usernameField: adminforth.config.auth.usernameField,
-                userLanguage,
-                chatSurface: input.chatSurface,
+            return this.streamConsumer.consume({
+                stream: stream,
+                abortSignal: input.context.abortSignal,
+                emit: input.observability.emit,
             });
-            const apiBasedTools = buildApiBasedTools(adminforth, this.serviceOptions.getInternalAgentResourceIds());
-            const stream = yield callAgent({
-                name: `adminforth-agent-${this.serviceOptions.getPluginInstanceId()}`,
-                model,
-                summaryModel,
-                modelMiddleware,
-                checkpointer: this.serviceOptions.getCheckpointer(),
-                messages: [
-                    new SystemMessage(systemPrompt),
-                    new HumanMessage(input.prompt),
-                ],
-                adminUser: input.adminUser,
-                adminforth,
-                apiBasedTools,
-                customComponentsDir: (_f = adminforth.config.customization.customComponentsDir) !== null && _f !== void 0 ? _f : "custom",
-                pluginCustomFolderPaths: adminforth.activatedPlugins.map((plugin) => plugin.customFolderPath),
-                sessionId: input.sessionId,
-                turnId: input.turnId,
-                currentPage: input.currentPage,
-                chatSurface: input.chatSurface,
-                adminPublicOrigin: input.adminPublicOrigin,
-                userTimeZone: input.userTimeZone,
-                abortSignal: input.abortSignal,
-                emitToolCallEvent: (event) => {
-                    var _a;
-                    input.sequenceDebugCollector.handleToolCallEvent(event);
-                    void ((_a = input.emit) === null || _a === void 0 ? void 0 : _a.call(input, {
-                        type: "tool-call",
-                        data: event,
-                    }));
-                },
-                emitAgentEvent: input.emit,
-                sequenceDebugSink: input.sequenceDebugCollector,
-            });
-            try {
-                for (var _p = true, _q = __asyncValues(stream), _r; _r = yield _q.next(), _a = _r.done, !_a; _p = true) {
-                    _c = _r.value;
-                    _p = false;
-                    const rawChunk = _c;
-                    if ((_g = input.abortSignal) === null || _g === void 0 ? void 0 : _g.aborted) {
-                        throw new DOMException("This operation was aborted", "AbortError");
-                    }
-                    const [token, metadata] = rawChunk;
-                    const nodeName = typeof (metadata === null || metadata === void 0 ? void 0 : metadata.langgraph_node) === "string"
-                        ? metadata.langgraph_node
-                        : "";
-                    if (nodeName && !["model", "model_request"].includes(nodeName)) {
-                        continue;
-                    }
-                    const blocks = Array.isArray(token === null || token === void 0 ? void 0 : token.contentBlocks)
-                        ? token.contentBlocks
-                        : Array.isArray(token === null || token === void 0 ? void 0 : token.content)
-                            ? token.content
-                            : [];
-                    const reasoningDelta = blocks
-                        .filter((b) => (b === null || b === void 0 ? void 0 : b.type) === "reasoning")
-                        .map((b) => { var _a; return String((_a = b.reasoning) !== null && _a !== void 0 ? _a : ""); })
-                        .join("");
-                    const textDelta = blocks
-                        .filter((b) => (b === null || b === void 0 ? void 0 : b.type) === "text")
-                        .map((b) => { var _a; return String((_a = b.text) !== null && _a !== void 0 ? _a : ""); })
-                        .join("");
-                    if (reasoningDelta) {
-                        yield ((_h = input.emit) === null || _h === void 0 ? void 0 : _h.call(input, {
-                            type: "reasoning-delta",
-                            delta: reasoningDelta,
-                        }));
-                    }
-                    if (textDelta) {
-                        fullResponse += textDelta;
-                        bufferedTextDelta += textDelta;
-                        if (bufferedTextDelta.includes(VEGA_LITE_FENCE_START) &&
-                            !COMPLETE_VEGA_LITE_BLOCK_RE.test(bufferedTextDelta)) {
-                            if (!isRenderingVegaLite) {
-                                isRenderingVegaLite = true;
-                                yield ((_j = input.emit) === null || _j === void 0 ? void 0 : _j.call(input, {
-                                    type: "rendering",
-                                    phase: "start",
-                                    label: "Rendering...",
-                                }));
-                            }
-                            continue;
-                        }
-                        if (isRenderingVegaLite) {
-                            isRenderingVegaLite = false;
-                            yield ((_k = input.emit) === null || _k === void 0 ? void 0 : _k.call(input, {
-                                type: "rendering",
-                                phase: "end",
-                                label: "Rendering...",
-                            }));
-                        }
-                        const streamableLength = bufferedTextDelta.includes(VEGA_LITE_FENCE_START)
-                            ? bufferedTextDelta.length
-                            : bufferedTextDelta.length - getPartialVegaLiteFenceStartLength(bufferedTextDelta);
-                        if (!streamableLength) {
-                            continue;
-                        }
-                        yield ((_l = input.emit) === null || _l === void 0 ? void 0 : _l.call(input, {
-                            type: "text-delta",
-                            delta: bufferedTextDelta.slice(0, streamableLength),
-                        }));
-                        bufferedTextDelta = bufferedTextDelta.slice(streamableLength);
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_p && !_a && (_b = _q.return)) yield _b.call(_q);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            if (isRenderingVegaLite) {
-                yield ((_m = input.emit) === null || _m === void 0 ? void 0 : _m.call(input, {
-                    type: "rendering",
-                    phase: "end",
-                    label: "Rendering...",
-                }));
-            }
-            if (bufferedTextDelta) {
-                yield ((_o = input.emit) === null || _o === void 0 ? void 0 : _o.call(input, {
-                    type: "text-delta",
-                    delta: bufferedTextDelta,
-                }));
-            }
-            return {
-                text: fullResponse,
-            };
         });
     }
     runAndPersistAgentResponse(input) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const adminforth = this.serviceOptions.getAdminforth();
-            const options = this.serviceOptions.options;
-            const previousUserMessages = yield this.serviceOptions.sessionStore.getPreviousUserMessages(input.sessionId);
-            const turnId = yield this.serviceOptions.sessionStore.createNewTurn(input.sessionId, input.prompt);
-            yield adminforth.resource(options.sessionResource.resourceId).update(input.sessionId, {
-                [options.sessionResource.createdAtField]: new Date().toISOString(),
-            });
-            const sequenceDebugCollector = createSequenceDebugCollector();
+            const preparedTurn = yield this.prepareTurn(input);
+            preparedTurn.observability.emit = input.emit;
             let fullResponse = "";
             let aborted = false;
             let failed = false;
             try {
-                const agentResponse = yield this.runAgentTurn({
-                    prompt: input.prompt,
-                    sessionId: input.sessionId,
-                    turnId,
-                    previousUserMessages,
-                    modeName: input.modeName,
-                    userTimeZone: input.userTimeZone,
-                    currentPage: input.currentPage,
-                    chatSurface: input.chatSurface,
-                    adminPublicOrigin: input.adminPublicOrigin,
-                    abortSignal: input.abortSignal,
-                    adminUser: input.adminUser,
-                    sequenceDebugCollector,
-                    emit: input.emit,
-                });
+                const agentResponse = yield this.runAgentTurn(preparedTurn);
                 fullResponse = agentResponse.text;
             }
             catch (error) {
@@ -245,17 +93,15 @@ export class AgentTurnService {
                     logger.error(`${input.failureLogMessage}:\n${fullResponse}`);
                 }
             }
-            sequenceDebugCollector.flush();
-            const turnUpdates = {
-                [options.turnResource.responseField]: fullResponse,
-            };
-            if (options.turnResource.debugField) {
-                turnUpdates[options.turnResource.debugField] = sequenceDebugCollector.getHistory();
-            }
-            yield adminforth.resource(options.turnResource.resourceId).update(turnId, turnUpdates);
+            preparedTurn.observability.sequenceDebugSink.flush();
+            yield this.lifecycle.finish({
+                turnId: preparedTurn.turnId,
+                responseText: fullResponse,
+                debugHistory: preparedTurn.observability.sequenceDebugSink.getHistory(),
+            });
             return {
                 text: fullResponse,
-                turnId,
+                turnId: preparedTurn.turnId,
                 aborted,
                 failed,
             };
@@ -302,163 +148,4 @@ export class AgentTurnService {
             return agentResponse;
         });
     }
-    handleSpeechTurn(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;
-            }
-        });
-    }
-}
-function getPartialVegaLiteFenceStartLength(text) {
-    for (let length = Math.min(text.length, VEGA_LITE_FENCE_START.length - 1); length > 0; length -= 1) {
-        if (VEGA_LITE_FENCE_START.startsWith(text.slice(-length))) {
-            return length;
-        }
-    }
-    return 0;
 }

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     private checkpointer;
     private sessionStore;
     private agentTurnService;
+    private speechTurnService;
     private chatSurfaceService;
     private parseBody;
     private getCheckpointer;

package/dist/index.js

@@ -17,6 +17,16 @@ 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";
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
     parseBody(schema, body, response) {
         const parsed = schema.safeParse(body !== null && body !== void 0 ? body : {});
@@ -43,19 +53,24 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         ].filter((resourceId) => Boolean(resourceId));
     }
     constructor(options) {
+        var _a;
         super(options, import.meta.url);
         this.checkpointer = null;
         this.options = options;
         this.sessionStore = new AgentSessionStore(() => this.adminforth, this.options);
-        this.agentTurnService = new AgentTurnService({
+        const toolProvider = new AgentToolProvider(() => this.adminforth, this.getInternalAgentResourceIds.bind(this));
+        const runtime = new AgentRuntime({
+            name: `adminforth-agent-${this.pluginInstanceId}`,
             getAdminforth: () => this.adminforth,
-            getPluginInstanceId: () => this.pluginInstanceId,
-            options: this.options,
-            sessionStore: this.sessionStore,
             getCheckpointer: this.getCheckpointer.bind(this),
-            getInternalAgentResourceIds: this.getInternalAgentResourceIds.bind(this),
-            getAgentSystemPrompt: () => this.agentSystemPromptPromise,
+            toolProvider,
         });
+        const persistence = new TurnPersistenceService(() => this.adminforth, this.options);
+        this.agentTurnService = new AgentTurnService(new TurnLifecycleService(this.sessionStore, persistence), new TurnContextBuilder(() => this.adminforth), new AgentModeResolver(this.options), new AgentModelFactory((_a = this.options.maxTokens) !== null && _a !== void 0 ? _a : 1000), new TurnPromptBuilder({
+            getAdminforth: () => this.adminforth,
+            getAgentSystemPrompt: () => this.agentSystemPromptPromise,
+        }), 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));
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
@@ -120,7 +135,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             options: this.options,
             parseBody: this.parseBody.bind(this),
             handleTurn: this.agentTurnService.handleTurn.bind(this.agentTurnService),
-            handleSpeechTurn: this.agentTurnService.handleSpeechTurn.bind(this.agentTurnService),
+            handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
             runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
             getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
             createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),

package/index.ts

@@ -18,6 +18,16 @@ import type { AgentEndpointsContext } from "./endpoints/context.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";
 
 export type { AgentEvent, AgentEventEmitter } from "./agentEvents.js";
 
@@ -27,6 +37,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
   private checkpointer: BaseCheckpointSaver | null = null;
   private sessionStore: AgentSessionStore;
   private agentTurnService: AgentTurnService;
+  private speechTurnService: SpeechTurnService;
   private chatSurfaceService: ChatSurfaceService;
   private parseBody<T>(
     schema: z.ZodType<T>,
@@ -62,15 +73,32 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     super(options, import.meta.url);
     this.options = options;
     this.sessionStore = new AgentSessionStore(() => this.adminforth, this.options);
-    this.agentTurnService = new AgentTurnService({
+    const toolProvider = new AgentToolProvider(
+      () => this.adminforth,
+      this.getInternalAgentResourceIds.bind(this),
+    );
+    const runtime = new AgentRuntime({
+      name: `adminforth-agent-${this.pluginInstanceId}`,
       getAdminforth: () => this.adminforth,
-      getPluginInstanceId: () => this.pluginInstanceId,
-      options: this.options,
-      sessionStore: this.sessionStore,
       getCheckpointer: this.getCheckpointer.bind(this),
-      getInternalAgentResourceIds: this.getInternalAgentResourceIds.bind(this),
-      getAgentSystemPrompt: () => this.agentSystemPromptPromise,
+      toolProvider,
     });
+    const persistence = new TurnPersistenceService(() => this.adminforth, this.options);
+    this.agentTurnService = new AgentTurnService(
+      new TurnLifecycleService(this.sessionStore, persistence),
+      new TurnContextBuilder(() => this.adminforth),
+      new AgentModeResolver(this.options),
+      new AgentModelFactory(this.options.maxTokens ?? 1000),
+      new TurnPromptBuilder({
+        getAdminforth: () => this.adminforth,
+        getAgentSystemPrompt: () => this.agentSystemPromptPromise,
+      }),
+      runtime,
+      new TurnStreamConsumer(),
+    );
+    this.speechTurnService = new SpeechTurnService(
+      this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
+    );
     this.chatSurfaceService = new ChatSurfaceService(
       () => this.adminforth,
       this.options,
@@ -146,7 +174,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
       options: this.options,
       parseBody: this.parseBody.bind(this),
       handleTurn: this.agentTurnService.handleTurn.bind(this.agentTurnService),
-      handleSpeechTurn: this.agentTurnService.handleSpeechTurn.bind(this.agentTurnService),
+      handleSpeechTurn: this.speechTurnService.handle.bind(this.speechTurnService),
       runAndPersistAgentResponse: this.agentTurnService.runAndPersistAgentResponse.bind(this.agentTurnService),
       getSessionTurns: this.sessionStore.getSessionTurns.bind(this.sessionStore),
       createNewTurn: this.sessionStore.createNewTurn.bind(this.sessionStore),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "1.50.1",
+  "version": "1.51.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",