@adminforth/agent 1.45.0 → 1.46.0

package/dist/agentTurnService.js

@@ -0,0 +1,453 @@
+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 { 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]*?```/;
+export class AgentTurnService {
+    constructor(serviceOptions) {
+        this.serviceOptions = serviceOptions;
+    }
+    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 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 systemPrompt = buildAgentTurnSystemPrompt({
+                agentSystemPrompt: yield this.serviceOptions.getAgentSystemPrompt(),
+                adminUser: input.adminUser,
+                usernameField: adminforth.config.auth.usernameField,
+                userLanguage,
+            });
+            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",
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+                currentPage: input.currentPage,
+                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,
+                    }));
+                },
+                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();
+            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,
+                    abortSignal: input.abortSignal,
+                    adminUser: input.adminUser,
+                    sequenceDebugCollector,
+                    emit: input.emit,
+                });
+                fullResponse = agentResponse.text;
+            }
+            catch (error) {
+                if (((_a = input.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || isAbortError(error)) {
+                    aborted = true;
+                    logger.info(input.abortLogMessage);
+                }
+                else {
+                    failed = true;
+                    fullResponse = getErrorMessage(error);
+                    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);
+            return {
+                text: fullResponse,
+                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,
+                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;
+        });
+    }
+    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,
+                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/chatSurfaceService.d.ts

@@ -0,0 +1,32 @@
+import type { AdminUser, ChatSurfaceAdapter, ChatSurfaceEventSink, ChatSurfaceIncomingMessage, IAdminForth } from "adminforth";
+import type { HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "./agentTurnService.js";
+import type { PluginOptions } from "./types.js";
+import type { AgentSessionStore } from "./sessionStore.js";
+type ChatSurfaceConnectAction = {
+    type: "url";
+    label: string;
+    url: string;
+};
+export type ChatSurfaceAdapterWithConnectAction = ChatSurfaceAdapter & {
+    createConnectAction?(input: {
+        token: string;
+    }): ChatSurfaceConnectAction | Promise<ChatSurfaceConnectAction>;
+};
+export declare class ChatSurfaceService {
+    private getAdminforth;
+    private options;
+    private sessionStore;
+    private handleTurn;
+    private runAndPersistAgentResponse;
+    private linkTokens;
+    constructor(getAdminforth: () => IAdminForth, options: PluginOptions, sessionStore: AgentSessionStore, handleTurn: (input: HandleTurnInput) => Promise<unknown>, runAndPersistAgentResponse: (input: RunAndPersistAgentResponseInput) => Promise<RunAndPersistAgentResponseResult>);
+    getConnectActionAdapters(): ChatSurfaceAdapterWithConnectAction[];
+    createLinkToken(surface: string, adminUser: AdminUser): `${string}-${string}-${string}-${string}-${string}`;
+    private consumeLinkToken;
+    private createEventEmitter;
+    private handleLink;
+    private handleAudioMessage;
+    private handleAgentSurfaceResponse;
+    handleMessage(adapter: ChatSurfaceAdapter, incoming: ChatSurfaceIncomingMessage, sink: ChatSurfaceEventSink): Promise<void>;
+}
+export {};