@adminforth/agent 1.50.0 → 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/custom/skills/fetch_data/SKILL.md

@@ -24,6 +24,8 @@ If several rows look similar, do not guess which one is "the same" record. Show
 
 For long texts show only several first words and add "..." at the end (only if user did not request this field specifically).
 
+Never show information about more than 10 records in one message. If a tool returns more than 10 relevant records, summarize the total count if known, show only the 10 most relevant records, and offer to narrow filters, sort differently, or continue with the next 10.
+
 Also when you communicate with user about record, add related link to this record. Build it as `{ADMIN_BASE_PATH}resource/{resourceId}/show/{primary key}`. Use _label from `get_resource_data` as anchor text for link (use markdown link). Links should always be relative paths and must start with `ADMIN_BASE_PATH`. Do not add an extra slash after `ADMIN_BASE_PATH`.
 
 Before sending the link, verify that the `resourceId`, `{primary key}`, `_label`, and shown fields come from the same exact returned row.

package/dist/custom/skills/mutate_data/SKILL.md

@@ -27,6 +27,8 @@ Also please add related link to record with will be changed. Build it as `{ADMIN
 
 Before sending the confirmation, verify that the `resourceId`, `{primary key}`, `_label`, and all shown fields come from the same exact fetched row.
 
+Never show information about more than 10 records in one message. If a mutation plan affects more than 10 records, show only the 10 most important examples plus the total count if known, and ask the user to confirm the clearly described full batch.
+
 And in the same message ask user for final confirmation.
 
 When creating new record, show user all data which you gona create and in same message ask for confirmation.
@@ -123,6 +125,8 @@ For decimal fields please use string values with dot as decimal separator.
 
 After creation of new record also show user a link to this record. If several records record were created, show links to all of them in list.
 
+If more than 10 records were created, show links or details for only 10 of them and summarize the remaining count.
+
 Omit any pictures or file paths, you are not capable of doing it. If they are not required all is good, if they are required, explain to user that you are not able to create record because of this reason.
 
 ### Working with dates 

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.0",
+  "version": "1.51.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",