@adminforth/agent 2.0.10 → 2.1.0

package/agent/turn/TurnLifecycleService.ts

@@ -1,47 +0,0 @@
-import type { AgentSessionStore } from "../../sessionStore.js";
-import type { PluginOptions } from "../../types.js";
-import type { BaseAgentTurnInput } from "./turnTypes.js";
-import { TurnPersistenceService } from "./TurnPersistenceService.js";
-
-export class TurnLifecycleService {
-  constructor(
-    private readonly sessionStore: AgentSessionStore,
-    private readonly persistence: TurnPersistenceService,
-    private readonly options: PluginOptions,
-  ) {}
-
-  async start(input: BaseAgentTurnInput) {
-    const previousUserMessages = await this.sessionStore.getPreviousUserMessages(input.sessionId);
-    const turnId = await this.sessionStore.createNewTurn(input.sessionId, input.prompt);
-    await this.persistence.touchSession(input.sessionId);
-
-    return {
-      turnId,
-      previousUserMessages,
-    };
-  }
-
-  async resume(input: BaseAgentTurnInput) {
-    const latestTurn = await this.sessionStore.getLatestTurn(input.sessionId);
-
-    if (!latestTurn) {
-      throw new Error(`No agent turn found for session "${input.sessionId}".`);
-    }
-
-    return {
-      turnId: latestTurn[this.options.turnResource.idField],
-      previousUserMessages: await this.sessionStore.getPreviousUserMessages(input.sessionId),
-      initialResponse: latestTurn[this.options.turnResource.responseField] === "not_finished"
-        ? ""
-        : String(latestTurn[this.options.turnResource.responseField]),
-    };
-  }
-
-  async finish(input: {
-    turnId: string;
-    responseText: string;
-    debugHistory?: unknown;
-  }) {
-    await this.persistence.saveTurnResponse(input);
-  }
-}

package/agent/turn/TurnPersistenceService.ts

@@ -1,33 +0,0 @@
-import type { IAdminForth } from "adminforth";
-import type { PluginOptions } from "../../types.js";
-
-export class TurnPersistenceService {
-  constructor(
-    private readonly getAdminforth: () => IAdminForth,
-    private readonly options: PluginOptions,
-  ) {}
-
-  async touchSession(sessionId: string) {
-    await this.getAdminforth().resource(this.options.sessionResource.resourceId).update(sessionId, {
-      [this.options.sessionResource.createdAtField]: new Date().toISOString(),
-    });
-  }
-
-  async saveTurnResponse(input: {
-    turnId: string;
-    responseText: string;
-    debugHistory?: unknown;
-  }) {
-    const turnUpdates: Record<string, unknown> = {
-      [this.options.turnResource.responseField]: input.responseText,
-    };
-
-    if (this.options.turnResource.debugField) {
-      turnUpdates[this.options.turnResource.debugField] = input.debugHistory;
-    }
-
-    await this.getAdminforth()
-      .resource(this.options.turnResource.resourceId)
-      .update(input.turnId, turnUpdates);
-  }
-}

package/agent/turn/TurnPromptBuilder.ts

@@ -1,51 +0,0 @@
-import type { AdminUser, IAdminForth } from "adminforth";
-import { logger } from "adminforth";
-import { HumanMessage, SystemMessage } from "langchain";
-import { detectUserLanguage, type PreviousUserMessage } from "../languageDetect.js";
-import { buildAgentTurnSystemPrompt } from "../systemPrompt.js";
-import { getErrorMessage, isAbortError } from "../../errors.js";
-import type { AgentModeCompletionAdapter } from "../simpleAgent.js";
-
-export class TurnPromptBuilder {
-  constructor(
-    private readonly options: {
-      getAgentSystemPrompt: () => Promise<string>;
-      getAdminforth: () => IAdminForth;
-    },
-  ) {}
-
-  async build(input: {
-    prompt: string;
-    previousUserMessages: PreviousUserMessage[];
-    adminUser: AdminUser;
-    completionAdapter: AgentModeCompletionAdapter;
-    chatSurface?: string;
-    abortSignal?: AbortSignal;
-  }) {
-    const adminforth = this.options.getAdminforth();
-    const userLanguage = await detectUserLanguage(
-      input.completionAdapter,
-      input.prompt,
-      input.previousUserMessages,
-    ).catch((error) => {
-      if (input.abortSignal?.aborted || isAbortError(error)) {
-        throw error;
-      }
-
-      logger.warn(`Failed to detect user language: ${getErrorMessage(error)}`);
-      return null;
-    });
-    const systemPrompt = buildAgentTurnSystemPrompt({
-      agentSystemPrompt: await this.options.getAgentSystemPrompt(),
-      adminUser: input.adminUser,
-      usernameField: adminforth.config.auth!.usernameField,
-      userLanguage,
-      chatSurface: input.chatSurface,
-    });
-
-    return [
-      new SystemMessage(systemPrompt),
-      new HumanMessage(input.prompt),
-    ];
-  }
-}

package/agent/turn/TurnStreamConsumer.ts

@@ -1,69 +0,0 @@
-import type { AgentEventEmitter } from "../../agentEvents.js";
-import { VegaLiteStreamBuffer } from "./VegaLiteStreamBuffer.js";
-
-export class TurnStreamConsumer {
-  async consume(input: {
-    stream: AsyncIterable<["messages", [any, any]] | ["updates", Record<string, any>]>;
-    abortSignal?: AbortSignal;
-    emit?: AgentEventEmitter;
-    onInterrupt?: (interrupt: unknown) => void | Promise<void>;
-  }) {
-    let fullResponse = "";
-    const textBuffer = new VegaLiteStreamBuffer();
-
-    for await (const [mode, chunk] of input.stream) {
-      if (input.abortSignal?.aborted) {
-        throw new DOMException("This operation was aborted", "AbortError");
-      }
-
-      if (mode === "updates") {
-        if ("__interrupt__" in chunk) {
-          await input.onInterrupt?.(chunk.__interrupt__);
-        }
-        continue;
-      }
-
-      const [token, metadata] = chunk;
-      const nodeName =
-        typeof metadata?.langgraph_node === "string"
-          ? metadata.langgraph_node
-          : "";
-
-      if (nodeName && !["model", "model_request"].includes(nodeName)) {
-        continue;
-      }
-
-      const blocks = Array.isArray(token?.contentBlocks)
-        ? token.contentBlocks
-        : Array.isArray(token?.content)
-          ? token.content
-          : [];
-      const reasoningDelta = blocks
-        .filter((block: any) => block?.type === "reasoning")
-        .map((block: any) => String(block.reasoning ?? ""))
-        .join("");
-      const textDelta = blocks
-        .filter((block: any) => block?.type === "text")
-        .map((block: any) => String(block.text ?? ""))
-        .join("");
-
-      if (reasoningDelta) {
-        await input.emit?.({
-          type: "reasoning-delta",
-          delta: reasoningDelta,
-        });
-      }
-
-      if (textDelta) {
-        fullResponse += textDelta;
-        await textBuffer.push(textDelta, input.emit);
-      }
-    }
-
-    await textBuffer.flush(input.emit);
-
-    return {
-      text: fullResponse,
-    };
-  }
-}

package/agent/turn/VegaLiteStreamBuffer.ts

@@ -1,90 +0,0 @@
-import type { AgentEventEmitter } from "../../agentEvents.js";
-
-const VEGA_LITE_FENCE_START = "```vega-lite";
-const FENCE_END = "```";
-
-export class VegaLiteStreamBuffer {
-  private bufferedTextDelta = "";
-  private isRenderingVegaLite = false;
-
-  async push(textDelta: string, emit?: AgentEventEmitter) {
-    this.bufferedTextDelta += textDelta;
-
-    if (
-      hasUnclosedLatestVegaLiteBlock(this.bufferedTextDelta)
-    ) {
-      if (!this.isRenderingVegaLite) {
-        this.isRenderingVegaLite = true;
-        await emit?.({
-          type: "rendering",
-          phase: "start",
-          label: "Rendering...",
-        });
-      }
-      return;
-    }
-
-    if (this.isRenderingVegaLite) {
-      this.isRenderingVegaLite = false;
-      await 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;
-    }
-
-    await emit?.({
-      type: "text-delta",
-      delta: this.bufferedTextDelta.slice(0, streamableLength),
-    });
-    this.bufferedTextDelta = this.bufferedTextDelta.slice(streamableLength);
-  }
-
-  async flush(emit?: AgentEventEmitter) {
-    if (this.isRenderingVegaLite) {
-      await emit?.({
-        type: "rendering",
-        phase: "end",
-        label: "Rendering...",
-      });
-      this.isRenderingVegaLite = false;
-    }
-
-    if (this.bufferedTextDelta) {
-      await emit?.({
-        type: "text-delta",
-        delta: this.bufferedTextDelta,
-      });
-      this.bufferedTextDelta = "";
-    }
-  }
-}
-
-function hasUnclosedLatestVegaLiteBlock(text: string): boolean {
-  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: string): number {
-  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/agent/turn/turnTypes.ts

@@ -1,100 +0,0 @@
-import type { AdminUser, AudioAdapter } from "adminforth";
-import type { Messages } from "@langchain/langgraph";
-import type { Command } 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;
-  approvalDecision?: "approve" | "reject";
-  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;
-  resume?: {
-    decision: "approve" | "reject";
-    interrupts?: { id: string; count: number }[];
-  };
-  initialResponse?: string;
-};
-
-export type AgentTurnModels = {
-  model: AgentChatModel;
-  summaryModel: AgentChatModel;
-  modelMiddleware?: AgentMiddleware[];
-};
-
-export type AgentRuntimeRunInput = {
-  models: AgentTurnModels;
-  input: { messages: Messages } | Command;
-  context: AgentTurnContext;
-  observability: AgentTurnObservability;
-};
-
-export type RunAndPersistAgentResponseInput = BaseAgentTurnInput & {
-  emit?: AgentEventEmitter;
-  approvalDecision?: "approve" | "reject";
-  failureLogMessage: string;
-  abortLogMessage: string;
-};
-
-export type RunAndPersistAgentResponseResult = {
-  text: string;
-  turnId: string;
-  aborted: boolean;
-  failed: boolean;
-};
-
-export type HandleTurnInput = TextAgentTurnInput;
-export type HandleSpeechTurnInput = SpeechAgentTurnInput;

package/agentEvents.ts

@@ -1,75 +0,0 @@
-import type { ToolCallEvent } from "./agent/toolCallEvents.js";
-
-export type AgentEvent =
-  | {
-      type: "turn-started";
-      messageId: string;
-    }
-  | {
-      type: "text-delta";
-      delta: string;
-    }
-  | {
-      type: "reasoning-delta";
-      delta: string;
-    }
-  | {
-      type: "tool-call";
-      data: ToolCallEvent;
-    }
-  | {
-      type: "rendering";
-      phase: "start" | "end";
-      label: string;
-    }
-  | {
-      type: "interrupt";
-      sessionId: string;
-      interrupt: unknown;
-    }
-  | {
-      type: "open-page";
-      targetPath: string;
-    }
-  | {
-      type: "transcript";
-      text: string;
-      language?: string;
-    }
-  | {
-      type: "response";
-      text: string;
-      sessionId: string;
-      turnId: string;
-    }
-  | {
-      type: "speech-response";
-      transcript: { text: string; language?: string };
-      response: { text: string };
-      sessionId: string;
-      turnId: string;
-    }
-  | {
-      type: "audio-start";
-      mimeType: string;
-      format: string;
-      sampleRate: number;
-      channelCount: number;
-      bitsPerSample: number;
-    }
-  | {
-      type: "audio-delta";
-      value: Uint8Array;
-    }
-  | {
-      type: "audio-done";
-    }
-  | {
-      type: "error";
-      error: string;
-    }
-  | {
-      type: "finish";
-    };
-
-export type AgentEventEmitter = (event: AgentEvent) => void | Promise<void>;