@adminforth/agent 1.50.1 → 1.51.1

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

@@ -0,0 +1,19 @@
+import type { AdminUser, IAdminForth } from "adminforth";
+import { HumanMessage, SystemMessage } from "langchain";
+import { type PreviousUserMessage } from "../languageDetect.js";
+import type { AgentModeCompletionAdapter } from "../simpleAgent.js";
+export declare class TurnPromptBuilder {
+    private readonly options;
+    constructor(options: {
+        getAgentSystemPrompt: () => Promise<string>;
+        getAdminforth: () => IAdminForth;
+    });
+    build(input: {
+        prompt: string;
+        previousUserMessages: PreviousUserMessage[];
+        adminUser: AdminUser;
+        completionAdapter: AgentModeCompletionAdapter;
+        chatSurface?: string;
+        abortSignal?: AbortSignal;
+    }): Promise<(SystemMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>> | HumanMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>)[]>;
+}

package/dist/agent/turn/TurnPromptBuilder.js

@@ -0,0 +1,43 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { logger } from "adminforth";
+import { HumanMessage, SystemMessage } from "langchain";
+import { detectUserLanguage } from "../languageDetect.js";
+import { buildAgentTurnSystemPrompt } from "../systemPrompt.js";
+import { getErrorMessage, isAbortError } from "../../errors.js";
+export class TurnPromptBuilder {
+    constructor(options) {
+        this.options = options;
+    }
+    build(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adminforth = this.options.getAdminforth();
+            const userLanguage = yield detectUserLanguage(input.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 systemPrompt = buildAgentTurnSystemPrompt({
+                agentSystemPrompt: yield this.options.getAgentSystemPrompt(),
+                adminUser: input.adminUser,
+                usernameField: adminforth.config.auth.usernameField,
+                userLanguage,
+                chatSurface: input.chatSurface,
+            });
+            return [
+                new SystemMessage(systemPrompt),
+                new HumanMessage(input.prompt),
+            ];
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { AgentEventEmitter } from "../../agentEvents.js";
+export declare class TurnStreamConsumer {
+    consume(input: {
+        stream: AsyncIterable<[any, any]>;
+        abortSignal?: AbortSignal;
+        emit?: AgentEventEmitter;
+    }): Promise<{
+        text: string;
+    }>;
+}

package/dist/agent/turn/TurnStreamConsumer.js

@@ -0,0 +1,78 @@
+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 { VegaLiteStreamBuffer } from "./VegaLiteStreamBuffer.js";
+export class TurnStreamConsumer {
+    consume(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            let fullResponse = "";
+            const textBuffer = new VegaLiteStreamBuffer();
+            try {
+                for (var _f = true, _g = __asyncValues(input.stream), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const rawChunk = _c;
+                    if ((_d = input.abortSignal) === null || _d === void 0 ? void 0 : _d.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((block) => (block === null || block === void 0 ? void 0 : block.type) === "reasoning")
+                        .map((block) => { var _a; return String((_a = block.reasoning) !== null && _a !== void 0 ? _a : ""); })
+                        .join("");
+                    const textDelta = blocks
+                        .filter((block) => (block === null || block === void 0 ? void 0 : block.type) === "text")
+                        .map((block) => { var _a; return String((_a = block.text) !== null && _a !== void 0 ? _a : ""); })
+                        .join("");
+                    if (reasoningDelta) {
+                        yield ((_e = input.emit) === null || _e === void 0 ? void 0 : _e.call(input, {
+                            type: "reasoning-delta",
+                            delta: reasoningDelta,
+                        }));
+                    }
+                    if (textDelta) {
+                        fullResponse += textDelta;
+                        yield textBuffer.push(textDelta, input.emit);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            yield textBuffer.flush(input.emit);
+            return {
+                text: fullResponse,
+            };
+        });
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { AgentEventEmitter } from "../../agentEvents.js";
+export declare class VegaLiteStreamBuffer {
+    private bufferedTextDelta;
+    private isRenderingVegaLite;
+    push(textDelta: string, emit?: AgentEventEmitter): Promise<void>;
+    flush(emit?: AgentEventEmitter): Promise<void>;
+}

package/dist/agent/turn/VegaLiteStreamBuffer.js

@@ -0,0 +1,87 @@
+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());
+    });
+};
+const VEGA_LITE_FENCE_START = "```vega-lite";
+const FENCE_END = "```";
+export class VegaLiteStreamBuffer {
+    constructor() {
+        this.bufferedTextDelta = "";
+        this.isRenderingVegaLite = false;
+    }
+    push(textDelta, emit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.bufferedTextDelta += textDelta;
+            if (hasUnclosedLatestVegaLiteBlock(this.bufferedTextDelta)) {
+                if (!this.isRenderingVegaLite) {
+                    this.isRenderingVegaLite = true;
+                    yield (emit === null || emit === void 0 ? void 0 : emit({
+                        type: "rendering",
+                        phase: "start",
+                        label: "Rendering...",
+                    }));
+                }
+                return;
+            }
+            if (this.isRenderingVegaLite) {
+                this.isRenderingVegaLite = false;
+                yield (emit === null || emit === void 0 ? void 0 : emit({
+                    type: "rendering",
+                    phase: "end",
+                    label: "Rendering...",
+                }));
+            }
+            const streamableLength = this.bufferedTextDelta.includes(VEGA_LITE_FENCE_START)
+                ? this.bufferedTextDelta.length
+                : this.bufferedTextDelta.length - getPartialVegaLiteFenceStartLength(this.bufferedTextDelta);
+            if (!streamableLength) {
+                return;
+            }
+            yield (emit === null || emit === void 0 ? void 0 : emit({
+                type: "text-delta",
+                delta: this.bufferedTextDelta.slice(0, streamableLength),
+            }));
+            this.bufferedTextDelta = this.bufferedTextDelta.slice(streamableLength);
+        });
+    }
+    flush(emit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRenderingVegaLite) {
+                yield (emit === null || emit === void 0 ? void 0 : emit({
+                    type: "rendering",
+                    phase: "end",
+                    label: "Rendering...",
+                }));
+                this.isRenderingVegaLite = false;
+            }
+            if (this.bufferedTextDelta) {
+                yield (emit === null || emit === void 0 ? void 0 : emit({
+                    type: "text-delta",
+                    delta: this.bufferedTextDelta,
+                }));
+                this.bufferedTextDelta = "";
+            }
+        });
+    }
+}
+function hasUnclosedLatestVegaLiteBlock(text) {
+    const latestBlockStart = text.lastIndexOf(VEGA_LITE_FENCE_START);
+    if (latestBlockStart === -1) {
+        return false;
+    }
+    const blockContentStart = latestBlockStart + VEGA_LITE_FENCE_START.length;
+    return text.indexOf(FENCE_END, blockContentStart) === -1;
+}
+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/agent/turn/turnTypes.d.ts

@@ -0,0 +1,81 @@
+import type { AdminUser, AudioAdapter } from "adminforth";
+import type { Messages } 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";
+export type BaseAgentTurnInput = {
+    prompt: string;
+    sessionId: string;
+    modeName?: string | null;
+    userTimeZone?: string;
+    currentPage?: CurrentPageContext;
+    chatSurface?: string;
+    adminPublicOrigin?: string;
+    abortSignal?: AbortSignal;
+    adminUser: AdminUser;
+};
+export type TextAgentTurnInput = BaseAgentTurnInput & {
+    emit: AgentEventEmitter;
+    failureLogMessage?: string;
+    abortLogMessage?: string;
+};
+export type SpeechAgentTurnInput = Omit<BaseAgentTurnInput, "prompt"> & {
+    emit: AgentEventEmitter;
+    audioAdapter: AudioAdapter;
+    audio: {
+        buffer: Buffer;
+        filename: string;
+        mimeType: string;
+    };
+    failureLogMessage?: string;
+    abortLogMessage?: string;
+};
+export type AgentTurnContext = {
+    adminUser: AdminUser;
+    userTimeZone: string;
+    sessionId: string;
+    turnId: string;
+    abortSignal?: AbortSignal;
+    currentPage?: CurrentPageContext;
+    chatSurface?: string;
+    adminPublicOrigin?: string;
+};
+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;
+};
+export type AgentTurnModels = {
+    model: AgentChatModel;
+    summaryModel: AgentChatModel;
+    modelMiddleware?: AgentMiddleware[];
+};
+export type AgentRuntimeRunInput = {
+    models: AgentTurnModels;
+    messages: Messages;
+    context: AgentTurnContext;
+    observability: AgentTurnObservability;
+};
+export type RunAndPersistAgentResponseInput = BaseAgentTurnInput & {
+    emit?: AgentEventEmitter;
+    failureLogMessage: string;
+    abortLogMessage: string;
+};
+export type RunAndPersistAgentResponseResult = {
+    text: string;
+    turnId: string;
+    aborted: boolean;
+    failed: boolean;
+};
+export type HandleTurnInput = TextAgentTurnInput;
+export type HandleSpeechTurnInput = SpeechAgentTurnInput;

package/dist/agent/turn/turnTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/agentTurnService.d.ts

@@ -1,72 +1,23 @@
-import type { AdminUser, AudioAdapter, IAdminForth } from "adminforth";
-import type { BaseCheckpointSaver } from "@langchain/langgraph";
-import type { AgentEventEmitter } from "./agentEvents.js";
-import type { CurrentPageContext } from "./agent/tools/getUserLocation.js";
-import type { AgentSessionStore } from "./sessionStore.js";
-import type { PluginOptions } from "./types.js";
-export type RunAndPersistAgentResponseInput = {
-    prompt: string;
-    sessionId: string;
-    modeName?: string | null;
-    userTimeZone: string;
-    currentPage?: CurrentPageContext;
-    chatSurface?: string;
-    adminPublicOrigin?: string;
-    abortSignal?: AbortSignal;
-    adminUser: AdminUser;
-    emit?: AgentEventEmitter;
-    failureLogMessage: string;
-    abortLogMessage: string;
-};
-export type RunAndPersistAgentResponseResult = {
-    text: string;
-    turnId: string;
-    aborted: boolean;
-    failed: boolean;
-};
-export type HandleTurnInput = Omit<RunAndPersistAgentResponseInput, "failureLogMessage" | "abortLogMessage"> & {
-    emit: AgentEventEmitter;
-    failureLogMessage?: string;
-    abortLogMessage?: string;
-};
-export type HandleSpeechTurnInput = Omit<HandleTurnInput, "prompt"> & {
-    audioAdapter: AudioAdapter;
-    audio: {
-        buffer: Buffer;
-        filename: string;
-        mimeType: string;
-    };
-};
-type AgentTurnServiceOptions = {
-    getAdminforth: () => IAdminForth;
-    getPluginInstanceId: () => string;
-    options: PluginOptions;
-    sessionStore: AgentSessionStore;
-    getCheckpointer: () => BaseCheckpointSaver;
-    getInternalAgentResourceIds: () => string[];
-    getAgentSystemPrompt: () => Promise<string>;
-};
+import { AgentModelFactory } from "./agent/models/AgentModelFactory.js";
+import { AgentModeResolver } from "./agent/models/AgentModeResolver.js";
+import { AgentRuntime } from "./agent/runtime/AgentRuntime.js";
+import { TurnContextBuilder } from "./agent/turn/TurnContextBuilder.js";
+import { TurnLifecycleService } from "./agent/turn/TurnLifecycleService.js";
+import { TurnPromptBuilder } from "./agent/turn/TurnPromptBuilder.js";
+import { TurnStreamConsumer } from "./agent/turn/TurnStreamConsumer.js";
+import type { HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "./agent/turn/turnTypes.js";
+export type { BaseAgentTurnInput, HandleSpeechTurnInput, HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult, } from "./agent/turn/turnTypes.js";
 export declare class AgentTurnService {
-    private serviceOptions;
-    constructor(serviceOptions: AgentTurnServiceOptions);
+    private readonly lifecycle;
+    private readonly contextBuilder;
+    private readonly modeResolver;
+    private readonly modelFactory;
+    private readonly promptBuilder;
+    private readonly runtime;
+    private readonly streamConsumer;
+    constructor(lifecycle: TurnLifecycleService, contextBuilder: TurnContextBuilder, modeResolver: AgentModeResolver, modelFactory: AgentModelFactory, promptBuilder: TurnPromptBuilder, runtime: AgentRuntime, streamConsumer: TurnStreamConsumer);
+    private prepareTurn;
     private runAgentTurn;
-    runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<{
-        text: string;
-        turnId: any;
-        aborted: boolean;
-        failed: boolean;
-    }>;
-    handleTurn(input: HandleTurnInput): Promise<{
-        text: string;
-        turnId: any;
-        aborted: boolean;
-        failed: boolean;
-    }>;
-    handleSpeechTurn(input: HandleSpeechTurnInput): Promise<{
-        text: string;
-        turnId: any;
-        aborted: boolean;
-        failed: boolean;
-    } | null>;
+    runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
+    handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
 }
-export {};