@adminforth/agent 2.0.10 → 2.2.0

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

@@ -1,11 +0,0 @@
-import type { AgentEventEmitter } from "../../agentEvents.js";
-export declare class TurnStreamConsumer {
-    consume(input: {
-        stream: AsyncIterable<["messages", [any, any]] | ["updates", Record<string, any>]>;
-        abortSignal?: AbortSignal;
-        emit?: AgentEventEmitter;
-        onInterrupt?: (interrupt: unknown) => void | Promise<void>;
-    }): Promise<{
-        text: string;
-    }>;
-}

package/dist/agent/turn/TurnStreamConsumer.js

@@ -1,84 +0,0 @@
-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, _f;
-            let fullResponse = "";
-            const textBuffer = new VegaLiteStreamBuffer();
-            try {
-                for (var _g = true, _h = __asyncValues(input.stream), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
-                    _c = _j.value;
-                    _g = false;
-                    const [mode, chunk] = _c;
-                    if ((_d = input.abortSignal) === null || _d === void 0 ? void 0 : _d.aborted) {
-                        throw new DOMException("This operation was aborted", "AbortError");
-                    }
-                    if (mode === "updates") {
-                        if ("__interrupt__" in chunk) {
-                            yield ((_e = input.onInterrupt) === null || _e === void 0 ? void 0 : _e.call(input, chunk.__interrupt__));
-                        }
-                        continue;
-                    }
-                    const [token, metadata] = chunk;
-                    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 ((_f = input.emit) === null || _f === void 0 ? void 0 : _f.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 (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            yield textBuffer.flush(input.emit);
-            return {
-                text: fullResponse,
-            };
-        });
-    }
-}

package/dist/agentTurnService.d.ts

@@ -1,24 +0,0 @@
-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 readonly lifecycle;
-    private readonly contextBuilder;
-    private readonly modeResolver;
-    private readonly modelFactory;
-    private readonly promptBuilder;
-    private readonly runtime;
-    private readonly streamConsumer;
-    private readonly pendingInterrupts;
-    constructor(lifecycle: TurnLifecycleService, contextBuilder: TurnContextBuilder, modeResolver: AgentModeResolver, modelFactory: AgentModelFactory, promptBuilder: TurnPromptBuilder, runtime: AgentRuntime, streamConsumer: TurnStreamConsumer);
-    private prepareTurn;
-    private runAgentTurn;
-    runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
-    handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
-}

package/dist/agentTurnService.js

@@ -1,269 +0,0 @@
-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 { randomUUID } from "crypto";
-import { Command } from "@langchain/langgraph";
-import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
-import { getErrorMessage, isAbortError } from "./errors.js";
-function getApprovalDecision(input) {
-    return "approvalDecision" in input
-        && (input.approvalDecision === "approve" || input.approvalDecision === "reject")
-        ? input.approvalDecision
-        : undefined;
-}
-function getInterruptItems(interrupt) {
-    return Array.isArray(interrupt) ? interrupt : [interrupt];
-}
-function getHitlInterrupts(interrupt) {
-    return getInterruptItems(interrupt).flatMap((item) => {
-        const value = item && typeof item === "object" && "value" in item
-            ? item.value
-            : item;
-        const actionRequests = value && typeof value === "object"
-            ? value.actionRequests
-            : undefined;
-        const interruptId = item && typeof item === "object"
-            ? item.id
-            : undefined;
-        return typeof interruptId === "string" && Array.isArray(actionRequests)
-            ? [{ id: interruptId, count: actionRequests.length }]
-            : [];
-    });
-}
-function buildHitlDecision(decision, prompt) {
-    if (decision === "approve") {
-        return { type: "approve" };
-    }
-    return {
-        type: "reject",
-        message: prompt
-            ? `User rejected the pending tool execution and sent a new instruction instead: ${prompt}`
-            : "User rejected executing this tool",
-    };
-}
-function buildHitlResumeValue(input) {
-    return {
-        decisions: Array.from({ length: input.count }, () => (buildHitlDecision(input.decision, input.prompt))),
-    };
-}
-function buildLangGraphResume(input) {
-    var _a;
-    const interrupts = (_a = input.interrupts) !== null && _a !== void 0 ? _a : [];
-    if (interrupts.length === 0) {
-        throw new Error("No pending approval interrupt found for resume.");
-    }
-    if (interrupts.length === 1) {
-        return buildHitlResumeValue({
-            decision: input.decision,
-            count: interrupts[0].count,
-            prompt: input.prompt,
-        });
-    }
-    return Object.fromEntries(interrupts.map((interrupt) => [
-        interrupt.id,
-        buildHitlResumeValue({
-            decision: input.decision,
-            count: interrupt.count,
-            prompt: input.prompt,
-        }),
-    ]));
-}
-export class AgentTurnService {
-    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;
-        this.pendingInterrupts = new Map();
-    }
-    prepareTurn(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sequenceDebugCollector = createSequenceDebugCollector();
-            const approvalDecision = getApprovalDecision(input);
-            const shouldResume = Boolean(approvalDecision);
-            const pendingInterrupts = this.pendingInterrupts.get(input.sessionId);
-            if (shouldResume && (!pendingInterrupts || pendingInterrupts.length === 0)) {
-                throw new Error(`No pending approval interrupt found for session "${input.sessionId}".`);
-            }
-            const lifecycleTurn = shouldResume
-                ? yield this.lifecycle.resume(input)
-                : yield this.lifecycle.start(input);
-            const context = yield this.contextBuilder.build({
-                base: input,
-                turnId: lifecycleTurn.turnId,
-            });
-            return {
-                prompt: input.prompt,
-                sessionId: input.sessionId,
-                turnId: lifecycleTurn.turnId,
-                previousUserMessages: lifecycleTurn.previousUserMessages,
-                modeName: input.modeName,
-                context,
-                observability: {
-                    emit: undefined,
-                    sequenceDebugSink: sequenceDebugCollector,
-                },
-                resume: shouldResume
-                    ? {
-                        decision: approvalDecision,
-                        interrupts: pendingInterrupts,
-                    }
-                    : undefined,
-                initialResponse: shouldResume && "initialResponse" in lifecycleTurn
-                    ? lifecycleTurn.initialResponse
-                    : undefined,
-            };
-        });
-    }
-    runAgentTurn(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 stream = yield this.runtime.stream({
-                models,
-                input: input.resume
-                    ? new Command({
-                        resume: buildLangGraphResume({
-                            decision: input.resume.decision,
-                            interrupts: input.resume.interrupts,
-                            prompt: input.prompt,
-                        }),
-                    })
-                    : { messages },
-                context: input.context,
-                observability: input.observability,
-            });
-            let interrupted = false;
-            try {
-                return yield this.streamConsumer.consume({
-                    stream: stream,
-                    abortSignal: input.context.abortSignal,
-                    emit: input.observability.emit,
-                    onInterrupt: (interrupt) => __awaiter(this, void 0, void 0, function* () {
-                        var _a, _b, _c;
-                        interrupted = true;
-                        const interrupts = getHitlInterrupts(interrupt);
-                        const pendingInterrupts = (_a = this.pendingInterrupts.get(input.sessionId)) !== null && _a !== void 0 ? _a : [];
-                        const mergedInterrupts = new Map(pendingInterrupts.map((pendingInterrupt) => [
-                            pendingInterrupt.id,
-                            pendingInterrupt.count,
-                        ]));
-                        for (const pendingInterrupt of interrupts) {
-                            mergedInterrupts.set(pendingInterrupt.id, pendingInterrupt.count);
-                        }
-                        this.pendingInterrupts.set(input.sessionId, [...mergedInterrupts.entries()].map(([id, count]) => ({ id, count })));
-                        yield ((_c = (_b = input.observability).emit) === null || _c === void 0 ? void 0 : _c.call(_b, {
-                            type: "interrupt",
-                            sessionId: input.sessionId,
-                            interrupt,
-                        }));
-                    }),
-                });
-            }
-            finally {
-                if (!interrupted) {
-                    this.pendingInterrupts.delete(input.sessionId);
-                }
-            }
-        });
-    }
-    runAndPersistAgentResponse(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const preparedTurn = yield this.prepareTurn(input);
-            preparedTurn.observability.emit = input.emit;
-            let fullResponse = (_a = preparedTurn.initialResponse) !== null && _a !== void 0 ? _a : "";
-            let aborted = false;
-            let failed = false;
-            try {
-                const agentResponse = yield this.runAgentTurn(preparedTurn);
-                fullResponse += agentResponse.text;
-            }
-            catch (error) {
-                if (((_b = input.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) || isAbortError(error)) {
-                    aborted = true;
-                    logger.info(input.abortLogMessage);
-                }
-                else {
-                    failed = true;
-                    fullResponse = getErrorMessage(error);
-                    logger.error(`${input.failureLogMessage}:\n${fullResponse}`);
-                }
-            }
-            preparedTurn.observability.sequenceDebugSink.flush();
-            yield this.lifecycle.finish({
-                turnId: preparedTurn.turnId,
-                responseText: fullResponse,
-                debugHistory: preparedTurn.observability.sequenceDebugSink.getHistory(),
-            });
-            return {
-                text: fullResponse,
-                turnId: preparedTurn.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,
-                chatSurface: input.chatSurface,
-                adminPublicOrigin: input.adminPublicOrigin,
-                approvalDecision: input.approvalDecision,
-                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;
-        });
-    }
-}

package/dist/surfaces/web-sse/createSseEventEmitter.d.ts

@@ -1,14 +0,0 @@
-import type { AgentEventEmitter } from "../../agentEvents.js";
-type AgentEventStreamResponse = {
-    writeHead: (statusCode: number, headers: Record<string, string>) => void;
-    write: (chunk: string) => unknown;
-    end: () => unknown;
-    writableEnded: boolean;
-    destroyed: boolean;
-};
-type AgentEventStreamOptions = {
-    vercelAiUiMessageStream?: boolean;
-    closeActiveBlockOnToolStart?: boolean;
-};
-export declare function createSseEventEmitter(res: AgentEventStreamResponse, options?: AgentEventStreamOptions): AgentEventEmitter;
-export {};

package/endpoints/chatSurfaces.ts

@@ -1,66 +0,0 @@
-import type {
-  IAdminForthEndpointHandlerInput,
-  IHttpServer,
-} from "adminforth";
-import type { ChatSurfaceEndpointsContext } from "./context.js";
-
-function getHeaderValue(headers: Record<string, unknown>, name: string) {
-  const value = headers[name] ?? headers[name.toLowerCase()];
-
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-
-  return typeof value === "string" ? value : undefined;
-}
-
-function getRequestOrigin(input: IAdminForthEndpointHandlerInput) {
-  const forwardedProto = getHeaderValue(input.headers, "x-forwarded-proto")?.split(",")[0]?.trim();
-  const forwardedHost = getHeaderValue(input.headers, "x-forwarded-host")?.split(",")[0]?.trim();
-  const host = forwardedHost ?? getHeaderValue(input.headers, "host");
-
-  if (!host) {
-    return undefined;
-  }
-
-  const proto = forwardedProto
-    ?? (host.startsWith("localhost") || host.startsWith("127.0.0.1") ? "http" : "https");
-
-  return `${proto}://${host}`;
-}
-
-export function setupChatSurfaceEndpoints(ctx: ChatSurfaceEndpointsContext, server: IHttpServer) {
-  for (const adapter of ctx.options.chatSurfaceAdapters ?? []) {
-    server.endpoint({
-      method: "POST",
-      noAuth: true,
-      path: `/agent/surface/${adapter.name}/webhook`,
-      handler: async (endpointInput: IAdminForthEndpointHandlerInput) => {
-        const surfaceContext = {
-          body: endpointInput.body,
-          headers: endpointInput.headers,
-          abortSignal: endpointInput.abortSignal,
-          rawRequest: endpointInput._raw_express_req,
-          rawResponse: endpointInput._raw_express_res,
-        };
-
-        const incoming = await adapter.parseIncomingMessage(surfaceContext);
-        if (!incoming) return { ok: true };
-        incoming.metadata = {
-          ...incoming.metadata,
-          adminPublicOrigin: getRequestOrigin(endpointInput),
-        };
-
-        const sink = await adapter.createEventSink(surfaceContext, incoming);
-
-        try {
-          await ctx.handleChatSurfaceMessage(adapter, incoming, sink);
-        } finally {
-          await sink.close?.();
-        }
-
-        return { ok: true };
-      },
-    });
-  }
-}

package/endpoints/context.ts

@@ -1,52 +0,0 @@
-import type {
-  ChatSurfaceAdapter,
-  ChatSurfaceEventSink,
-  ChatSurfaceIncomingMessage,
-  IAdminForth,
-} from "adminforth";
-import type {
-  HandleSpeechTurnInput,
-  HandleTurnInput,
-  RunAndPersistAgentResponseInput,
-  RunAndPersistAgentResponseResult,
-} from "../agentTurnService.js";
-import type { PluginOptions } from "../types.js";
-
-export type SessionTurn = {
-  prompt: string;
-  response: string;
-};
-
-export type AgentEndpointsContext = {
-  adminforth: IAdminForth;
-  options: PluginOptions;
-  handleTurn(input: HandleTurnInput): Promise<RunAndPersistAgentResponseResult>;
-  handleSpeechTurn(input: HandleSpeechTurnInput): Promise<RunAndPersistAgentResponseResult | null>;
-  runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<RunAndPersistAgentResponseResult>;
-  getSessionTurns(sessionId: string): Promise<SessionTurn[]>;
-  createNewTurn(sessionId: string, prompt: string, response?: string): Promise<string>;
-  createSystemTurn(sessionId: string, systemMessage: string): Promise<string>;
-  handleChatSurfaceMessage(
-    adapter: ChatSurfaceAdapter,
-    incoming: ChatSurfaceIncomingMessage,
-    sink: ChatSurfaceEventSink,
-  ): Promise<void>;
-};
-
-export type CoreEndpointsContext = Pick<
-  AgentEndpointsContext,
-  "options" | "handleTurn" | "handleSpeechTurn"
->;
-
-export type SessionEndpointsContext = Pick<
-  AgentEndpointsContext,
-  "adminforth" | "options" | "getSessionTurns" | "createNewTurn"
-  | "createSystemTurn"
->;
-
-export type ChatSurfaceEndpointsContext = Pick<
-  AgentEndpointsContext,
-  | "adminforth"
-  | "options"
-  | "handleChatSurfaceMessage"
->;