@adminforth/agent 2.0.10 → 2.2.0

package/sessionStore.ts

@@ -1,105 +0,0 @@
-import type { AdminUser, IAdminForth } from "adminforth";
-import { Filters, Sorts } from "adminforth";
-import { randomUUID } from "crypto";
-import type { ChatSurfaceIncomingMessage } from "adminforth";
-import type { PreviousUserMessage } from "./agent/languageDetect.js";
-import type { PluginOptions } from "./types.js";
-
-export const AGENT_SYSTEM_TURN_PROMPT = "__adminforth_system_message__";
-
-export class AgentSessionStore {
-  constructor(
-    private getAdminforth: () => IAdminForth,
-    private options: PluginOptions,
-  ) {}
-
-  async createNewTurn(sessionId: string, prompt: string, response?: string) {
-    const turnId = randomUUID();
-    const turnRecord = {
-      [this.options.turnResource.idField]: turnId,
-      [this.options.turnResource.sessionIdField]: sessionId,
-      [this.options.turnResource.promptField]: prompt,
-      [this.options.turnResource.responseField]: response ?? "not_finished",
-    };
-    const newTurn = await this.getAdminforth().resource(this.options.turnResource.resourceId).create(turnRecord);
-    return newTurn.createdRecord[this.options.turnResource.idField];
-  }
-
-  async createSystemTurn(sessionId: string, systemMessage: string) {
-    const turnId = randomUUID();
-    const turnRecord = {
-      [this.options.turnResource.idField]: turnId,
-      [this.options.turnResource.sessionIdField]: sessionId,
-      [this.options.turnResource.promptField]: AGENT_SYSTEM_TURN_PROMPT,
-      [this.options.turnResource.responseField]: systemMessage,
-    };
-    const newTurn = await this.getAdminforth().resource(this.options.turnResource.resourceId).create(turnRecord);
-    return newTurn.createdRecord[this.options.turnResource.idField];
-  }
-
-  async getSessionTurns(sessionId: string) {
-    const turns = await this.getAdminforth().resource(this.options.turnResource.resourceId).list(
-      [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)],
-      undefined,
-      undefined,
-      [Sorts.ASC(this.options.turnResource.createdAtField)]
-    );
-    return turns.map(turn => ({
-      prompt: turn[this.options.turnResource.promptField],
-      response: turn[this.options.turnResource.responseField],
-    }));
-  }
-
-  async getPreviousUserMessages(sessionId: string) {
-    const turns = await this.getAdminforth().resource(this.options.turnResource.resourceId).list(
-      [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)],
-      2,
-      undefined,
-      [Sorts.DESC(this.options.turnResource.createdAtField)]
-    );
-    return turns
-      .reverse()
-      .filter((turn) => turn[this.options.turnResource.promptField] !== AGENT_SYSTEM_TURN_PROMPT)
-      .map((turn): PreviousUserMessage => ({
-        text: turn[this.options.turnResource.promptField],
-      }));
-  }
-
-  async getLatestTurn(sessionId: string) {
-    const turns = await this.getAdminforth().resource(this.options.turnResource.resourceId).list(
-      [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)],
-      1,
-      undefined,
-      [Sorts.DESC(this.options.turnResource.createdAtField)]
-    );
-
-    return turns[0];
-  }
-
-  getChatSurfaceSessionId(incoming: ChatSurfaceIncomingMessage) {
-    return `${incoming.surface}:${incoming.externalConversationId}`;
-  }
-
-  async getOrCreateChatSurfaceSession(
-    incoming: ChatSurfaceIncomingMessage,
-    adminUser: AdminUser,
-  ) {
-    const sessionId = this.getChatSurfaceSessionId(incoming);
-    const sessionResource = this.getAdminforth().resource(this.options.sessionResource.resourceId);
-    const session = await sessionResource.get(
-      [Filters.EQ(this.options.sessionResource.idField, sessionId)]
-    );
-
-    if (session) {
-      return sessionId;
-    }
-
-    await sessionResource.create({
-      [this.options.sessionResource.idField]: sessionId,
-      [this.options.sessionResource.titleField]: incoming.prompt.slice(0, 40) || "New Session",
-      [this.options.sessionResource.askerIdField]: adminUser.pk,
-    });
-
-    return sessionId;
-  }
-}

package/surfaces/web-sse/createSseEventEmitter.ts

@@ -1,311 +0,0 @@
-import { randomUUID } from "crypto";
-
-import type { AgentEvent, AgentEventEmitter } from "../../agentEvents.js";
-import type { ToolCallEvent } from "../../agent/toolCallEvents.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;
-};
-
-function createAgentEventStream(
-  res: AgentEventStreamResponse,
-  options: AgentEventStreamOptions = {},
-) {
-  let isStreamClosed = false;
-  let activeBlock: { type: "text" | "reasoning"; id: string } | null = null;
-  const isAiUiMessageStream = options.vercelAiUiMessageStream === true;
-
-  res.writeHead(200, {
-    "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: unknown) {
-      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: "text" | "reasoning") {
-      if (activeBlock?.type === type) {
-        return activeBlock.id;
-      }
-
-      stream.endActiveBlock();
-
-      const id = randomUUID();
-      activeBlock = { type, id };
-
-      stream.send({
-        type: `${type}-start`,
-        id,
-      });
-
-      return id;
-    },
-
-    start(messageId: string) {
-      stream.send({
-        type: "start",
-        messageId,
-      });
-    },
-
-    textDelta(delta: string) {
-      const textId = stream.startBlock("text");
-      stream.send({
-        type: "text-delta",
-        id: textId,
-        delta,
-      });
-    },
-
-    reasoningDelta(delta: string) {
-      const reasoningId = stream.startBlock("reasoning");
-      stream.send({
-        type: "reasoning-delta",
-        id: reasoningId,
-        delta,
-      });
-    },
-
-    toolCall(event: ToolCallEvent) {
-      if (options.closeActiveBlockOnToolStart && event.phase === "start") {
-        stream.endActiveBlock();
-      }
-
-      stream.send({
-        type: "data-tool-call",
-        data: event,
-      });
-    },
-
-    rendering(phase: "start" | "end", label: string) {
-      if (phase === "start") {
-        stream.endActiveBlock();
-      }
-
-      stream.send({
-        type: "data-rendering",
-        data: {
-          phase,
-          label,
-        },
-      });
-    },
-
-    interrupt(sessionId: string, interrupt: unknown) {
-      stream.endActiveBlock();
-      stream.send({
-        type: isAiUiMessageStream ? "data-interrupt" : "interrupt",
-        data: {
-          sessionId,
-          interrupt,
-        },
-      });
-    },
-
-    openPage(targetPath: string) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-open-page" : "open-page",
-        data: {
-          targetPath,
-        },
-      });
-    },
-
-    transcript(text: string, language?: string) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-transcript" : "transcript",
-        data: {
-          text,
-          language,
-        },
-      });
-    },
-
-    response(text: string, sessionId: string, turnId: string) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-response" : "response",
-        data: {
-          text,
-          sessionId,
-          turnId,
-        },
-      });
-    },
-
-    speechResponse(
-      transcript: { text: string; language?: string },
-      response: { text: string },
-      sessionId: string,
-      turnId: string,
-    ) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-speech-response" : "speech-response",
-        data: {
-          transcript,
-          response,
-          sessionId,
-          turnId,
-        },
-      });
-    },
-
-    audioStart(
-      mimeType: string,
-      format: string,
-      sampleRate: number,
-      channelCount: number,
-      bitsPerSample: number,
-    ) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-audio-start" : "audio-start",
-        data: {
-          mimeType,
-          format,
-          sampleRate,
-          channelCount,
-          bitsPerSample,
-        },
-      });
-    },
-
-    audioDelta(value: Uint8Array) {
-      stream.send({
-        type: isAiUiMessageStream ? "data-audio-delta" : "audio-delta",
-        data: {
-          base64: Buffer.from(value).toString("base64"),
-        },
-      });
-    },
-
-    audioDone() {
-      stream.send({
-        type: isAiUiMessageStream ? "data-audio-done" : "audio-done",
-        ...(isAiUiMessageStream ? { data: {} } : {}),
-      });
-    },
-
-    error(error: string) {
-      stream.send(isAiUiMessageStream
-        ? {
-            type: "error",
-            errorText: error,
-          }
-        : {
-            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: AgentEventStreamResponse,
-  options: AgentEventStreamOptions = {},
-): AgentEventEmitter {
-  const stream = createAgentEventStream(res, options);
-
-  return async (event: AgentEvent) => {
-    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 "rendering":
-        stream.rendering(event.phase, event.label);
-        break;
-      case "interrupt":
-        stream.interrupt(event.sessionId, event.interrupt);
-        break;
-      case "open-page":
-        stream.openPage(event.targetPath);
-        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/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-      "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include*/ 
-      "module": "node16",                                /* Specify what module code is generated. */
-      "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
-      "declaration": true,
-      "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules.  */
-      "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-      "strict": true,                                     /* Enable all strict type-checking options. */
-      "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
-    },
-    "exclude": ["node_modules", "dist", "custom"],           /* Exclude files from compilation. */
-  }
-  

package/types.ts

@@ -1,127 +0,0 @@
-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;
-
-  /**
-   * Optional resource configuration for resolving chat users through OAuth external identities.
-   */
-  chatExternalIdentityResource?: {
-    resourceId: string;
-    adminUserIdField?: string;
-    providerField?: string;
-    subjectField?: string;
-    externalUserIdField?: string;
-    surfaces: Record<string, {
-      provider: string;
-    }>;
-  };
-}