@adminforth/agent 1.44.2 → 1.45.1

package/chatSurfaceService.ts

@@ -0,0 +1,189 @@
+import type {
+  AdminUser,
+  ChatSurfaceAdapter,
+  ChatSurfaceEventSink,
+  ChatSurfaceIncomingMessage,
+  IAdminForth,
+} from "adminforth";
+import { Filters } from "adminforth";
+import { randomUUID } from "crypto";
+import type { AgentEventEmitter } from "./agentEvents.js";
+import type { HandleTurnInput } 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>;
+};
+
+type ChatSurfaceLinkTokenPayload = {
+  surface: string;
+  adminUserId: AdminUser["pk"];
+  expiresAt: number;
+};
+
+const DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD = "externalUserId";
+const CHAT_SURFACE_LINK_TOKEN_TTL_MS = 60 * 1000;
+
+export class ChatSurfaceService {
+  private linkTokens = new Map<string, ChatSurfaceLinkTokenPayload>();
+
+  constructor(
+    private getAdminforth: () => IAdminForth,
+    private options: PluginOptions,
+    private sessionStore: AgentSessionStore,
+    private handleTurn: (input: HandleTurnInput) => Promise<unknown>,
+  ) {}
+
+  getConnectActionAdapters() {
+    return (this.options.chatSurfaceAdapters ?? [])
+      .map((adapter) => adapter as ChatSurfaceAdapterWithConnectAction)
+      .filter((adapter) => adapter.createConnectAction);
+  }
+
+  createLinkToken(surface: string, adminUser: AdminUser) {
+    for (const [token, payload] of this.linkTokens) {
+      if (payload.expiresAt <= Date.now()) {
+        this.linkTokens.delete(token);
+      }
+    }
+
+    const token = randomUUID();
+    this.linkTokens.set(token, {
+      surface,
+      adminUserId: adminUser.pk,
+      expiresAt: Date.now() + CHAT_SURFACE_LINK_TOKEN_TTL_MS,
+    });
+
+    return token;
+  }
+
+  private consumeLinkToken(surface: string, token: string) {
+    const payload = this.linkTokens.get(token);
+    this.linkTokens.delete(token);
+
+    if (!payload || payload.surface !== surface || payload.expiresAt <= Date.now()) {
+      return null;
+    }
+
+    return payload;
+  }
+
+  private createEventEmitter(sink: ChatSurfaceEventSink): AgentEventEmitter {
+    return async (event) => {
+      if (event.type === "text-delta") {
+        await sink.emit({
+          type: "text_delta",
+          delta: event.delta,
+        });
+        return;
+      }
+
+      if (event.type === "response") {
+        await sink.emit({
+          type: "done",
+          text: event.text,
+        });
+        return;
+      }
+
+      if (event.type === "error") {
+        await sink.emit({
+          type: "error",
+          message: event.error,
+        });
+      }
+    };
+  }
+
+  private async handleLink(
+    incoming: ChatSurfaceIncomingMessage,
+    sink: ChatSurfaceEventSink,
+  ) {
+    if (typeof incoming.metadata?.startPayload !== "string") {
+      return false;
+    }
+
+    const payload = this.consumeLinkToken(incoming.surface, incoming.metadata.startPayload);
+    if (!payload) {
+      await sink.emit({
+        type: "error",
+        message: "This chat surface link is expired or invalid. Please start linking again from AdminForth.",
+      });
+      return true;
+    }
+    const externalUserIdField = this.options.chatExternalIdsField ?? DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
+    const adminforth = this.getAdminforth();
+    const authResourceId = adminforth.config.auth!.usersResourceId!;
+    const authResource = adminforth.config.resources.find((resource) => resource.resourceId === authResourceId)!;
+    const primaryKeyField = authResource.columns.find((column) => column.primaryKey)!.name!;
+    const adminUserRecord = await adminforth.resource(authResourceId).get([
+      Filters.EQ(primaryKeyField, payload.adminUserId),
+    ]);
+
+    await adminforth.resource(authResourceId).update(payload.adminUserId, {
+      [externalUserIdField]: {
+        ...(adminUserRecord[externalUserIdField] ?? {}),
+        [incoming.surface]: incoming.externalUserId,
+      },
+    });
+    await sink.emit({
+      type: "done",
+      text: `${incoming.surface} account connected to AdminForth.`,
+    });
+
+    return true;
+  }
+
+  async handleMessage(
+    adapter: ChatSurfaceAdapter,
+    incoming: ChatSurfaceIncomingMessage,
+    sink: ChatSurfaceEventSink,
+  ) {
+    if (await this.handleLink(incoming, sink)) {
+      return;
+    }
+
+    const adminforth = this.getAdminforth();
+    const authResourceId = adminforth.config.auth!.usersResourceId!;
+    const authResource = adminforth.config.resources.find((resource) => resource.resourceId === authResourceId)!;
+    const primaryKeyField = authResource.columns.find((column) => column.primaryKey)!.name!;
+    const externalUserIdField = this.options.chatExternalIdsField ?? DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
+    const adminUserRecord = (
+      await adminforth.resource(authResourceId).list(Filters.IS_NOT_EMPTY(externalUserIdField))
+    ).find((user) => user[externalUserIdField]?.[adapter.name] === incoming.externalUserId);
+
+    if (!adminUserRecord) {
+      await sink.emit({
+        type: "error",
+        message: "This chat account is not authorized to use AdminForth Agent.",
+      });
+      return;
+    }
+
+    const adminUser = {
+      pk: adminUserRecord[primaryKeyField],
+      username: adminUserRecord[adminforth.config.auth!.usernameField],
+      dbUser: adminUserRecord,
+    };
+
+    await this.handleTurn({
+      prompt: incoming.prompt,
+      sessionId: await this.sessionStore.getOrCreateChatSurfaceSession(incoming, adminUser),
+      modeName: incoming.modeName,
+      userTimeZone: incoming.userTimeZone ?? "UTC",
+      adminUser,
+      emit: this.createEventEmitter(sink),
+      failureLogMessage: `Agent ${incoming.surface} surface response failed`,
+      abortLogMessage: `Agent ${incoming.surface} surface response aborted`,
+    });
+  }
+}

package/custom/ChatSurfaceSettings.vue

@@ -0,0 +1,125 @@
+<template>
+  <div class="flex flex-col justify-center mr-6 md:mr-12">
+    <h2 class="flex items-start justify-start leading-none text-gray-800 dark:text-gray-50 text-3xl font-semibold">
+      {{ $t('Chat Surfaces') }}
+    </h2>
+    <p class="text-sm mt-3">
+      {{ $t('Connect external chat accounts to your AdminForth user') }}
+    </p>
+
+    <div class="mt-6 flex flex-wrap gap-4">
+      <div
+        v-for="surface in surfaces"
+        :key="surface.name"
+        class="flex flex-col w-full lg:w-72 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-xl p-4 shadow-sm"
+      >
+        <div class="flex items-center justify-between gap-3 mb-4">
+          <div class="min-w-0">
+            <p class="font-semibold text-gray-900 dark:text-white truncate">
+              {{ formatSurfaceName(surface.name) }}
+            </p>
+            <p class="text-xs text-gray-500 dark:text-gray-400">
+              {{ surface.externalUserId || $t('Not connected') }}
+            </p>
+          </div>
+          <span
+            class="shrink-0 inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium"
+            :class="surface.externalUserId
+              ? 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200'
+              : 'bg-gray-100 text-gray-700 dark:bg-gray-700 dark:text-gray-300'"
+          >
+            {{ surface.externalUserId ? $t('Active') : $t('Inactive') }}
+          </span>
+        </div>
+
+        <div class="grid gap-2 mt-auto" :class="surface.externalUserId ? 'grid-cols-2' : 'grid-cols-1'">
+          <Button
+            class="w-full"
+            :disabled="isSurfaceBusy(surface.name)"
+            :loader="connectingSurfaceName === surface.name"
+            @click="connectSurface(surface.name)"
+          >
+            {{ surface.externalUserId ? $t('Reconnect') : $t('Connect') }}
+          </Button>
+          <Button
+            v-if="surface.externalUserId"
+            class="w-full"
+            :disabled="isSurfaceBusy(surface.name)"
+            :loader="disconnectingSurfaceName === surface.name"
+            @click="disconnectSurface(surface.name)"
+          >
+            {{ $t('Disconnect') }}
+          </Button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { Button } from '@/afcl';
+import { callAdminForthApi } from '@/utils';
+
+type ChatSurface = {
+  name: string;
+  externalUserId: string | null;
+};
+
+const surfaces = ref<ChatSurface[]>([]);
+const connectingSurfaceName = ref<string | null>(null);
+const disconnectingSurfaceName = ref<string | null>(null);
+
+onMounted(loadSurfaces);
+
+async function loadSurfaces() {
+  const response = await callAdminForthApi({
+    method: 'POST',
+    path: '/agent/surfaces/connectable',
+    body: {},
+  });
+
+  surfaces.value = response.surfaces;
+}
+
+async function connectSurface(surfaceName: string) {
+  connectingSurfaceName.value = surfaceName;
+
+  try {
+    const response = await callAdminForthApi({
+      method: 'POST',
+      path: `/agent/surface/${surfaceName}/connect-action`,
+      body: {},
+    });
+
+    if (response.action.type === 'url') {
+      window.open(response.action.url, '_blank', 'noopener,noreferrer');
+    }
+  } finally {
+    connectingSurfaceName.value = null;
+  }
+}
+
+async function disconnectSurface(surfaceName: string) {
+  disconnectingSurfaceName.value = surfaceName;
+
+  try {
+    await callAdminForthApi({
+      method: 'POST',
+      path: `/agent/surface/${surfaceName}/disconnect`,
+      body: {},
+    });
+    await loadSurfaces();
+  } finally {
+    disconnectingSurfaceName.value = null;
+  }
+}
+
+function isSurfaceBusy(surfaceName: string) {
+  return connectingSurfaceName.value === surfaceName || disconnectingSurfaceName.value === surfaceName;
+}
+
+function formatSurfaceName(surfaceName: string) {
+  return surfaceName.charAt(0).toUpperCase() + surfaceName.slice(1);
+}
+</script>

package/custom/incremark_code_renderers/incremarkRenderer.ts

@@ -625,11 +625,11 @@ function sanitizeClassToken(value: string): string {
 
 function escapeHtml(value: string): string {
 	return value
-		.replaceAll('&', '&')
-		.replaceAll('<', '&lt;')
-		.replaceAll('>', '&gt;')
-		.replaceAll('"', '&quot;')
-		.replaceAll("'", '&#39;');
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&#39;');
 }
 
 function escapeAttribute(value: string): string {

package/dist/agentTurnService.d.ts

@@ -0,0 +1,70 @@
+import type { AdminUser, AudioAdapter, IAdminForth } from "adminforth";
+import type { BaseCheckpointSaver } from "@langchain/langgraph";
+import type { AgentEventEmitter } from "./agentEvents.js";
+import type { CurrentPageContext } from "./agent/tools/getUserLocation.js";
+import type { AgentSessionStore } from "./sessionStore.js";
+import type { PluginOptions } from "./types.js";
+export type RunAndPersistAgentResponseInput = {
+    prompt: string;
+    sessionId: string;
+    modeName?: string | null;
+    userTimeZone: string;
+    currentPage?: CurrentPageContext;
+    abortSignal?: AbortSignal;
+    adminUser: AdminUser;
+    emit?: AgentEventEmitter;
+    failureLogMessage: string;
+    abortLogMessage: string;
+};
+export type RunAndPersistAgentResponseResult = {
+    text: string;
+    turnId: string;
+    aborted: boolean;
+    failed: boolean;
+};
+export type HandleTurnInput = Omit<RunAndPersistAgentResponseInput, "failureLogMessage" | "abortLogMessage"> & {
+    emit: AgentEventEmitter;
+    failureLogMessage?: string;
+    abortLogMessage?: string;
+};
+export type HandleSpeechTurnInput = Omit<HandleTurnInput, "prompt"> & {
+    audioAdapter: AudioAdapter;
+    audio: {
+        buffer: Buffer;
+        filename: string;
+        mimeType: string;
+    };
+};
+type AgentTurnServiceOptions = {
+    getAdminforth: () => IAdminForth;
+    getPluginInstanceId: () => string;
+    options: PluginOptions;
+    sessionStore: AgentSessionStore;
+    getCheckpointer: () => BaseCheckpointSaver;
+    getInternalAgentResourceIds: () => string[];
+    getAgentSystemPrompt: () => Promise<string>;
+};
+export declare class AgentTurnService {
+    private serviceOptions;
+    constructor(serviceOptions: AgentTurnServiceOptions);
+    private runAgentTurn;
+    runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput): Promise<{
+        text: string;
+        turnId: any;
+        aborted: boolean;
+        failed: boolean;
+    }>;
+    handleTurn(input: HandleTurnInput): Promise<{
+        text: string;
+        turnId: any;
+        aborted: boolean;
+        failed: boolean;
+    }>;
+    handleSpeechTurn(input: HandleSpeechTurnInput): Promise<{
+        text: string;
+        turnId: any;
+        aborted: boolean;
+        failed: boolean;
+    } | null>;
+}
+export {};