@adminforth/agent 1.43.29 → 1.44.0

package/dist/surfaces/web-sse/createSseEventEmitter.js

@@ -0,0 +1,196 @@
+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 { randomUUID } from "crypto";
+function createAgentEventStream(res, options = {}) {
+    let isStreamClosed = false;
+    let activeBlock = null;
+    res.writeHead(200, Object.assign({ "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }, (options.vercelAiUiMessageStream
+        ? { "x-vercel-ai-ui-message-stream": "v1" }
+        : {})));
+    const stream = {
+        send(obj) {
+            if (isStreamClosed || res.writableEnded || res.destroyed) {
+                return;
+            }
+            res.write(`data: ${JSON.stringify(obj)}\n\n`);
+        },
+        endActiveBlock() {
+            if (!activeBlock) {
+                return;
+            }
+            stream.send({
+                type: `${activeBlock.type}-end`,
+                id: activeBlock.id,
+            });
+            activeBlock = null;
+        },
+        startBlock(type) {
+            if ((activeBlock === null || activeBlock === void 0 ? void 0 : activeBlock.type) === type) {
+                return activeBlock.id;
+            }
+            stream.endActiveBlock();
+            const id = randomUUID();
+            activeBlock = { type, id };
+            stream.send({
+                type: `${type}-start`,
+                id,
+            });
+            return id;
+        },
+        start(messageId) {
+            stream.send({
+                type: "start",
+                messageId,
+            });
+        },
+        textDelta(delta) {
+            const textId = stream.startBlock("text");
+            stream.send({
+                type: "text-delta",
+                id: textId,
+                delta,
+            });
+        },
+        reasoningDelta(delta) {
+            const reasoningId = stream.startBlock("reasoning");
+            stream.send({
+                type: "reasoning-delta",
+                id: reasoningId,
+                delta,
+            });
+        },
+        toolCall(event) {
+            if (options.closeActiveBlockOnToolStart && event.phase === "start") {
+                stream.endActiveBlock();
+            }
+            stream.send({
+                type: "data-tool-call",
+                data: event,
+            });
+        },
+        transcript(text, language) {
+            stream.send({
+                type: "transcript",
+                data: {
+                    text,
+                    language,
+                },
+            });
+        },
+        response(text, sessionId, turnId) {
+            stream.send({
+                type: "response",
+                data: {
+                    text,
+                    sessionId,
+                    turnId,
+                },
+            });
+        },
+        speechResponse(transcript, response, sessionId, turnId) {
+            stream.send({
+                type: "speech-response",
+                data: {
+                    transcript,
+                    response,
+                    sessionId,
+                    turnId,
+                },
+            });
+        },
+        audioStart(mimeType, format, sampleRate, channelCount, bitsPerSample) {
+            stream.send({
+                type: "audio-start",
+                data: {
+                    mimeType,
+                    format,
+                    sampleRate,
+                    channelCount,
+                    bitsPerSample,
+                },
+            });
+        },
+        audioDelta(value) {
+            stream.send({
+                type: "audio-delta",
+                data: {
+                    base64: Buffer.from(value).toString("base64"),
+                },
+            });
+        },
+        audioDone() {
+            stream.send({
+                type: "audio-done",
+            });
+        },
+        error(error) {
+            stream.send({
+                type: "error",
+                error,
+            });
+        },
+        end() {
+            if (isStreamClosed || res.writableEnded || res.destroyed) {
+                return;
+            }
+            stream.endActiveBlock();
+            stream.send({
+                type: "finish",
+            });
+            res.write("data: [DONE]\n\n");
+            isStreamClosed = true;
+            res.end();
+        },
+    };
+    return stream;
+}
+export function createSseEventEmitter(res, options = {}) {
+    const stream = createAgentEventStream(res, options);
+    return (event) => __awaiter(this, void 0, void 0, function* () {
+        switch (event.type) {
+            case "turn-started":
+                stream.start(event.messageId);
+                break;
+            case "text-delta":
+                stream.textDelta(event.delta);
+                break;
+            case "reasoning-delta":
+                stream.reasoningDelta(event.delta);
+                break;
+            case "tool-call":
+                stream.toolCall(event.data);
+                break;
+            case "transcript":
+                stream.transcript(event.text, event.language);
+                break;
+            case "response":
+                stream.response(event.text, event.sessionId, event.turnId);
+                break;
+            case "speech-response":
+                stream.speechResponse(event.transcript, event.response, event.sessionId, event.turnId);
+                break;
+            case "audio-start":
+                stream.audioStart(event.mimeType, event.format, event.sampleRate, event.channelCount, event.bitsPerSample);
+                break;
+            case "audio-delta":
+                stream.audioDelta(event.value);
+                break;
+            case "audio-done":
+                stream.audioDone();
+                break;
+            case "error":
+                stream.error(event.error);
+                break;
+            case "finish":
+                stream.end();
+                break;
+        }
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+import { type PluginsCommonOptions, type AdminUser, type HttpExtra, type AudioAdapter, type ChatSurfaceAdapter } from "adminforth";
+import type { AgentModeCompletionAdapter } from "./agent/simpleAgent.js";
+interface ISessionResource {
+    resourceId: string;
+    idField: string;
+    titleField: string;
+    turnsField: string;
+    askerIdField: string;
+    createdAtField: string;
+}
+interface ITurnResource {
+    resourceId: string;
+    idField: string;
+    sessionIdField: string;
+    createdAtField: string;
+    promptField: string;
+    responseField: string;
+    debugField?: string;
+}
+interface ICheckpointResource {
+    resourceId: string;
+    idField: string;
+    threadIdField: string;
+    checkpointNamespaceField: string;
+    checkpointIdField: string;
+    parentCheckpointIdField: string;
+    rowKindField: string;
+    taskIdField: string;
+    sequenceField: string;
+    createdAtField: string;
+    checkpointPayloadField: string;
+    metadataPayloadField: string;
+    writesPayloadField: string;
+    schemaVersionField: string;
+}
+export interface PluginOptions extends PluginsCommonOptions {
+    /**
+     * Optional placeholder examples to preload for the chat textarea.
+     * They are resolved once when the chat frontend loads.
+     */
+    placeholderMessages?: ((input: {
+        adminUser: AdminUser;
+        headers: HttpExtra["headers"];
+    }) => string[] | Promise<string[]>);
+    /**
+     * Modes for the plugin.
+     * Each mode can have its own configuration.
+     * Each mode uses its own completion adapter instance.
+     */
+    modes: {
+        name: string;
+        completionAdapter: AgentModeCompletionAdapter;
+    }[];
+    /**
+     * Optional audio adapter for speech-to-text and text-to-speech flows.
+     */
+    audioAdapter?: AudioAdapter;
+    /**
+     * Optional external chat surfaces, such as Telegram webhooks.
+     */
+    chatSurfaceAdapters?: ChatSurfaceAdapter[];
+    /**
+     * Max tokens for the generation.
+     * Default is 1000
+     */
+    maxTokens?: number;
+    /**
+     * Optional custom system prompt appended to the built-in agent system prompt.
+     */
+    systemPrompt?: string;
+    /**
+     * Response generation level.
+     * Default is low
+     */
+    reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    /**
+     * Resource configuration for sessions.
+     */
+    sessionResource: ISessionResource;
+    /**
+     * Resource configuration for turns.
+     */
+    turnResource: ITurnResource;
+    /**
+     * Makes chat sticky by default. By default this prop is false
+     */
+    stickByDefault?: boolean;
+    /**
+     * Optional resource configuration for a persistent LangGraph checkpointer.
+     * Falls back to an in-memory MemorySaver when omitted.
+     */
+    checkpointResource?: ICheckpointResource;
+}
+export {};