@adminforth/agent 1.45.1 → 1.47.0

package/build.log

@@ -7,7 +7,6 @@ custom/
 custom/ChatFooter.vue
 custom/ChatHeader.vue
 custom/ChatSurface.vue
-custom/ChatSurfaceSettings.vue
 custom/CustomAutoScrollContainer.vue
 custom/SessionsHistory.vue
 custom/chat.ts
@@ -63,5 +62,5 @@ custom/speech_recognition_frontend/voiceActivityDetection.ts
 custom/speech_recognition_frontend/types/
 custom/speech_recognition_frontend/types/voice-activity-detection.d.ts
 
-sent 1,671,664 bytes  received 936 bytes  3,345,200.00 bytes/sec
-total size is 1,667,436  speedup is 1.00
+sent 1,667,665 bytes  received 921 bytes  3,337,172.00 bytes/sec
+total size is 1,663,512  speedup is 1.00

package/chatSurfaceService.ts

@@ -5,78 +5,46 @@ import type {
   ChatSurfaceIncomingMessage,
   IAdminForth,
 } from "adminforth";
-import { Filters } from "adminforth";
-import { randomUUID } from "crypto";
+import { Filters, logger } from "adminforth";
 import type { AgentEventEmitter } from "./agentEvents.js";
-import type { HandleTurnInput } from "./agentTurnService.js";
-import type { PluginOptions } from "./types.js";
+import type {
+  HandleTurnInput,
+  RunAndPersistAgentResponseInput,
+  RunAndPersistAgentResponseResult,
+} from "./agentTurnService.js";
+import { getErrorMessage, isAbortError } from "./errors.js";
 import type { AgentSessionStore } from "./sessionStore.js";
+import { sanitizeSpeechText } from "./sanitizeSpeechText.js";
+import type { PluginOptions } from "./types.js";
 
-type ChatSurfaceConnectAction = {
-  type: "url";
-  label: string;
-  url: string;
-};
-
-export type ChatSurfaceAdapterWithConnectAction = ChatSurfaceAdapter & {
-  createConnectAction?(input: {
-    token: string;
-  }): ChatSurfaceConnectAction | Promise<ChatSurfaceConnectAction>;
+type ChatSurfaceIncomingMessageWithAudio = ChatSurfaceIncomingMessage & {
+  audio?: {
+    buffer: Buffer;
+    filename: string;
+    mimeType: string;
+  };
 };
 
-type ChatSurfaceLinkTokenPayload = {
-  surface: string;
-  adminUserId: AdminUser["pk"];
-  expiresAt: number;
+type ChatSurfaceEventSinkWithAudio = ChatSurfaceEventSink & {
+  emit(event: Parameters<ChatSurfaceEventSink["emit"]>[0] | {
+    type: "audio";
+    audio: Buffer;
+    filename: string;
+    mimeType: string;
+  }): void | Promise<void>;
 };
 
-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>,
+    private runAndPersistAgentResponse: (
+      input: RunAndPersistAgentResponseInput,
+    ) => Promise<RunAndPersistAgentResponseResult>,
   ) {}
 
-  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") {
@@ -108,39 +76,200 @@ export class ChatSurfaceService {
     incoming: ChatSurfaceIncomingMessage,
     sink: ChatSurfaceEventSink,
   ) {
-    if (typeof incoming.metadata?.startPayload !== "string") {
+    if (incoming.metadata?.isStartCommand !== true) {
       return false;
     }
 
-    const payload = this.consumeLinkToken(incoming.surface, incoming.metadata.startPayload);
-    if (!payload) {
+    await sink.emit({
+      type: "done",
+      text: `Open AdminForth and connect your ${incoming.surface} account from Connected Accounts settings.`,
+    });
+    return true;
+  }
+
+  private async handleAudioMessage(
+    incoming: ChatSurfaceIncomingMessageWithAudio,
+    sink: ChatSurfaceEventSinkWithAudio,
+    adminUser: AdminUser,
+  ) {
+    const audioAdapter = this.options.audioAdapter;
+    if (!audioAdapter) {
       await sink.emit({
         type: "error",
-        message: "This chat surface link is expired or invalid. Please start linking again from AdminForth.",
+        message: "Audio adapter is not configured for AdminForth Agent.",
       });
-      return true;
+      return;
+    }
+
+    let transcription;
+
+    try {
+      transcription = await audioAdapter.transcribe({
+        buffer: incoming.audio!.buffer,
+        filename: incoming.audio!.filename,
+        mimeType: incoming.audio!.mimeType,
+        language: "auto",
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        logger.info(`Agent ${incoming.surface} surface speech transcription aborted`);
+        return;
+      }
+
+      logger.error(`Agent ${incoming.surface} surface speech transcription failed:\n${getErrorMessage(error)}`);
+      await sink.emit({
+        type: "error",
+        message: "Speech transcription failed. Check server logs for details.",
+      });
+      return;
+    }
+
+    if (!transcription.text) {
+      await sink.emit({
+        type: "error",
+        message: "Speech transcription is empty",
+      });
+      return;
+    }
+
+    const agentResponse = await this.handleAgentSurfaceResponse(
+      incoming,
+      sink,
+      adminUser,
+      transcription.text,
+      { emitDone: false },
+    );
+
+    if (!agentResponse || agentResponse.aborted || agentResponse.failed) {
+      return;
     }
-    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.`,
+      text: agentResponse.text,
     });
 
-    return true;
+    try {
+      const speech = await audioAdapter.synthesize({
+        text: sanitizeSpeechText(agentResponse.text),
+        stream: false,
+        format: "opus",
+      });
+
+      await sink.emit({
+        type: "audio",
+        audio: speech.audio,
+        filename: "agent-response.ogg",
+        mimeType: speech.mimeType,
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        logger.info(`Agent ${incoming.surface} surface speech synthesis aborted`);
+        return;
+      }
+
+      logger.error(`Agent ${incoming.surface} surface speech synthesis failed:\n${getErrorMessage(error)}`);
+      await sink.emit({
+        type: "error",
+        message: getErrorMessage(error),
+      });
+    }
+  }
+
+  private async handleAgentSurfaceResponse(
+    incoming: ChatSurfaceIncomingMessage,
+    sink: ChatSurfaceEventSink,
+    adminUser: AdminUser,
+    prompt: string,
+    options?: { emitDone?: boolean },
+  ) {
+    const emitDone = options?.emitDone ?? true;
+    const sessionId = await this.sessionStore.getOrCreateChatSurfaceSession(
+      { ...incoming, prompt },
+      adminUser,
+    );
+
+    if (emitDone) {
+      await this.handleTurn({
+        prompt,
+        sessionId,
+        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`,
+      });
+      return null;
+    }
+
+    const agentResponse = await this.runAndPersistAgentResponse({
+      prompt,
+      sessionId,
+      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`,
+    });
+
+    if (agentResponse.failed) {
+      await sink.emit({
+        type: "error",
+        message: agentResponse.text,
+      });
+    }
+
+    return agentResponse;
+  }
+
+  private async getAdminUserRecordForChatSurface(
+    adapter: ChatSurfaceAdapter,
+    incoming: ChatSurfaceIncomingMessage,
+  ) {
+    const adminforth = this.getAdminforth();
+    const authResourceId = adminforth.config.auth!.usersResourceId!;
+    const externalIdentityResource = this.options.chatExternalIdentityResource;
+    if (!externalIdentityResource) {
+      return null;
+    }
+
+    const surfaceIdentityConfig = externalIdentityResource.surfaces[adapter.name];
+    if (!surfaceIdentityConfig) {
+      return null;
+    }
+
+    const providerField = externalIdentityResource.providerField ?? 'provider';
+    const subjectField = externalIdentityResource.subjectField ?? 'subject';
+    const adminUserIdField = externalIdentityResource.adminUserIdField ?? 'adminUserId';
+    const externalUserIdField = externalIdentityResource.externalUserIdField ?? 'externalUserId';
+    const identityFilters = [
+      Filters.EQ(providerField, surfaceIdentityConfig.provider),
+      Filters.EQ(externalUserIdField, incoming.externalUserId),
+    ];
+    const identities = await adminforth.resource(externalIdentityResource.resourceId).list(identityFilters);
+    const identity = identities.find((identity) => {
+      if (String(identity[externalUserIdField]) === incoming.externalUserId) {
+        return true;
+      }
+
+      if (String(identity[subjectField]) === incoming.externalUserId) {
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!identity) {
+      return null;
+    }
+
+    const authResource = adminforth.config.resources.find((resource) => resource.resourceId === authResourceId)!;
+    const primaryKeyField = authResource.columns.find((column) => column.primaryKey)!.name!;
+    return adminforth.resource(authResourceId).get([
+      Filters.EQ(primaryKeyField, identity[adminUserIdField]),
+    ]);
   }
 
   async handleMessage(
@@ -156,10 +285,7 @@ export class ChatSurfaceService {
     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);
+    const adminUserRecord = await this.getAdminUserRecordForChatSurface(adapter, incoming);
 
     if (!adminUserRecord) {
       await sink.emit({
@@ -175,15 +301,12 @@ export class ChatSurfaceService {
       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`,
-    });
+    const incomingWithAudio = incoming as ChatSurfaceIncomingMessageWithAudio;
+    if (incomingWithAudio.audio) {
+      await this.handleAudioMessage(incomingWithAudio, sink as ChatSurfaceEventSinkWithAudio, adminUser);
+      return;
+    }
+
+    await this.handleAgentSurfaceResponse(incoming, sink, adminUser, incoming.prompt);
   }
 }

package/dist/chatSurfaceService.d.ts

@@ -1,29 +1,18 @@
-import type { AdminUser, ChatSurfaceAdapter, ChatSurfaceEventSink, ChatSurfaceIncomingMessage, IAdminForth } from "adminforth";
-import type { HandleTurnInput } from "./agentTurnService.js";
-import type { PluginOptions } from "./types.js";
+import type { ChatSurfaceAdapter, ChatSurfaceEventSink, ChatSurfaceIncomingMessage, IAdminForth } from "adminforth";
+import type { HandleTurnInput, RunAndPersistAgentResponseInput, RunAndPersistAgentResponseResult } from "./agentTurnService.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>;
-};
+import type { PluginOptions } from "./types.js";
 export declare class ChatSurfaceService {
     private getAdminforth;
     private options;
     private sessionStore;
     private handleTurn;
-    private linkTokens;
-    constructor(getAdminforth: () => IAdminForth, options: PluginOptions, sessionStore: AgentSessionStore, handleTurn: (input: HandleTurnInput) => Promise<unknown>);
-    getConnectActionAdapters(): ChatSurfaceAdapterWithConnectAction[];
-    createLinkToken(surface: string, adminUser: AdminUser): `${string}-${string}-${string}-${string}-${string}`;
-    private consumeLinkToken;
+    private runAndPersistAgentResponse;
+    constructor(getAdminforth: () => IAdminForth, options: PluginOptions, sessionStore: AgentSessionStore, handleTurn: (input: HandleTurnInput) => Promise<unknown>, runAndPersistAgentResponse: (input: RunAndPersistAgentResponseInput) => Promise<RunAndPersistAgentResponseResult>);
     private createEventEmitter;
     private handleLink;
+    private handleAudioMessage;
+    private handleAgentSurfaceResponse;
+    private getAdminUserRecordForChatSurface;
     handleMessage(adapter: ChatSurfaceAdapter, incoming: ChatSurfaceIncomingMessage, sink: ChatSurfaceEventSink): Promise<void>;
 }
-export {};

package/dist/chatSurfaceService.js

@@ -7,45 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Filters } from "adminforth";
-import { randomUUID } from "crypto";
-const DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD = "externalUserId";
-const CHAT_SURFACE_LINK_TOKEN_TTL_MS = 60 * 1000;
+import { Filters, logger } from "adminforth";
+import { getErrorMessage, isAbortError } from "./errors.js";
+import { sanitizeSpeechText } from "./sanitizeSpeechText.js";
 export class ChatSurfaceService {
-    constructor(getAdminforth, options, sessionStore, handleTurn) {
+    constructor(getAdminforth, options, sessionStore, handleTurn, runAndPersistAgentResponse) {
         this.getAdminforth = getAdminforth;
         this.options = options;
         this.sessionStore = sessionStore;
         this.handleTurn = handleTurn;
-        this.linkTokens = new Map();
-    }
-    getConnectActionAdapters() {
-        var _a;
-        return ((_a = this.options.chatSurfaceAdapters) !== null && _a !== void 0 ? _a : [])
-            .map((adapter) => adapter)
-            .filter((adapter) => adapter.createConnectAction);
-    }
-    createLinkToken(surface, 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;
-    }
-    consumeLinkToken(surface, token) {
-        const payload = this.linkTokens.get(token);
-        this.linkTokens.delete(token);
-        if (!payload || payload.surface !== surface || payload.expiresAt <= Date.now()) {
-            return null;
-        }
-        return payload;
+        this.runAndPersistAgentResponse = runAndPersistAgentResponse;
     }
     createEventEmitter(sink) {
         return (event) => __awaiter(this, void 0, void 0, function* () {
@@ -73,39 +44,169 @@ export class ChatSurfaceService {
     }
     handleLink(incoming, sink) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            if (typeof ((_a = incoming.metadata) === null || _a === void 0 ? void 0 : _a.startPayload) !== "string") {
+            var _a;
+            if (((_a = incoming.metadata) === null || _a === void 0 ? void 0 : _a.isStartCommand) !== true) {
                 return false;
             }
-            const payload = this.consumeLinkToken(incoming.surface, incoming.metadata.startPayload);
-            if (!payload) {
+            yield sink.emit({
+                type: "done",
+                text: `Open AdminForth and connect your ${incoming.surface} account from Connected Accounts settings.`,
+            });
+            return true;
+        });
+    }
+    handleAudioMessage(incoming, sink, adminUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const audioAdapter = this.options.audioAdapter;
+            if (!audioAdapter) {
+                yield sink.emit({
+                    type: "error",
+                    message: "Audio adapter is not configured for AdminForth Agent.",
+                });
+                return;
+            }
+            let transcription;
+            try {
+                transcription = yield audioAdapter.transcribe({
+                    buffer: incoming.audio.buffer,
+                    filename: incoming.audio.filename,
+                    mimeType: incoming.audio.mimeType,
+                    language: "auto",
+                });
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    logger.info(`Agent ${incoming.surface} surface speech transcription aborted`);
+                    return;
+                }
+                logger.error(`Agent ${incoming.surface} surface speech transcription failed:\n${getErrorMessage(error)}`);
+                yield sink.emit({
+                    type: "error",
+                    message: "Speech transcription failed. Check server logs for details.",
+                });
+                return;
+            }
+            if (!transcription.text) {
+                yield sink.emit({
+                    type: "error",
+                    message: "Speech transcription is empty",
+                });
+                return;
+            }
+            const agentResponse = yield this.handleAgentSurfaceResponse(incoming, sink, adminUser, transcription.text, { emitDone: false });
+            if (!agentResponse || agentResponse.aborted || agentResponse.failed) {
+                return;
+            }
+            yield sink.emit({
+                type: "done",
+                text: agentResponse.text,
+            });
+            try {
+                const speech = yield audioAdapter.synthesize({
+                    text: sanitizeSpeechText(agentResponse.text),
+                    stream: false,
+                    format: "opus",
+                });
+                yield sink.emit({
+                    type: "audio",
+                    audio: speech.audio,
+                    filename: "agent-response.ogg",
+                    mimeType: speech.mimeType,
+                });
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    logger.info(`Agent ${incoming.surface} surface speech synthesis aborted`);
+                    return;
+                }
+                logger.error(`Agent ${incoming.surface} surface speech synthesis failed:\n${getErrorMessage(error)}`);
                 yield sink.emit({
                     type: "error",
-                    message: "This chat surface link is expired or invalid. Please start linking again from AdminForth.",
+                    message: getErrorMessage(error),
                 });
-                return true;
             }
-            const externalUserIdField = (_b = this.options.chatExternalIdsField) !== null && _b !== void 0 ? _b : DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
+        });
+    }
+    handleAgentSurfaceResponse(incoming, sink, adminUser, prompt, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const emitDone = (_a = options === null || options === void 0 ? void 0 : options.emitDone) !== null && _a !== void 0 ? _a : true;
+            const sessionId = yield this.sessionStore.getOrCreateChatSurfaceSession(Object.assign(Object.assign({}, incoming), { prompt }), adminUser);
+            if (emitDone) {
+                yield this.handleTurn({
+                    prompt,
+                    sessionId,
+                    modeName: incoming.modeName,
+                    userTimeZone: (_b = incoming.userTimeZone) !== null && _b !== void 0 ? _b : "UTC",
+                    adminUser,
+                    emit: this.createEventEmitter(sink),
+                    failureLogMessage: `Agent ${incoming.surface} surface response failed`,
+                    abortLogMessage: `Agent ${incoming.surface} surface response aborted`,
+                });
+                return null;
+            }
+            const agentResponse = yield this.runAndPersistAgentResponse({
+                prompt,
+                sessionId,
+                modeName: incoming.modeName,
+                userTimeZone: (_c = incoming.userTimeZone) !== null && _c !== void 0 ? _c : "UTC",
+                adminUser,
+                emit: this.createEventEmitter(sink),
+                failureLogMessage: `Agent ${incoming.surface} surface response failed`,
+                abortLogMessage: `Agent ${incoming.surface} surface response aborted`,
+            });
+            if (agentResponse.failed) {
+                yield sink.emit({
+                    type: "error",
+                    message: agentResponse.text,
+                });
+            }
+            return agentResponse;
+        });
+    }
+    getAdminUserRecordForChatSurface(adapter, incoming) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
             const adminforth = this.getAdminforth();
             const authResourceId = adminforth.config.auth.usersResourceId;
+            const externalIdentityResource = this.options.chatExternalIdentityResource;
+            if (!externalIdentityResource) {
+                return null;
+            }
+            const surfaceIdentityConfig = externalIdentityResource.surfaces[adapter.name];
+            if (!surfaceIdentityConfig) {
+                return null;
+            }
+            const providerField = (_a = externalIdentityResource.providerField) !== null && _a !== void 0 ? _a : 'provider';
+            const subjectField = (_b = externalIdentityResource.subjectField) !== null && _b !== void 0 ? _b : 'subject';
+            const adminUserIdField = (_c = externalIdentityResource.adminUserIdField) !== null && _c !== void 0 ? _c : 'adminUserId';
+            const externalUserIdField = (_d = externalIdentityResource.externalUserIdField) !== null && _d !== void 0 ? _d : 'externalUserId';
+            const identityFilters = [
+                Filters.EQ(providerField, surfaceIdentityConfig.provider),
+                Filters.EQ(externalUserIdField, incoming.externalUserId),
+            ];
+            const identities = yield adminforth.resource(externalIdentityResource.resourceId).list(identityFilters);
+            const identity = identities.find((identity) => {
+                if (String(identity[externalUserIdField]) === incoming.externalUserId) {
+                    return true;
+                }
+                if (String(identity[subjectField]) === incoming.externalUserId) {
+                    return true;
+                }
+                return false;
+            });
+            if (!identity) {
+                return null;
+            }
             const authResource = adminforth.config.resources.find((resource) => resource.resourceId === authResourceId);
             const primaryKeyField = authResource.columns.find((column) => column.primaryKey).name;
-            const adminUserRecord = yield adminforth.resource(authResourceId).get([
-                Filters.EQ(primaryKeyField, payload.adminUserId),
+            return adminforth.resource(authResourceId).get([
+                Filters.EQ(primaryKeyField, identity[adminUserIdField]),
             ]);
-            yield adminforth.resource(authResourceId).update(payload.adminUserId, {
-                [externalUserIdField]: Object.assign(Object.assign({}, ((_c = adminUserRecord[externalUserIdField]) !== null && _c !== void 0 ? _c : {})), { [incoming.surface]: incoming.externalUserId }),
-            });
-            yield sink.emit({
-                type: "done",
-                text: `${incoming.surface} account connected to AdminForth.`,
-            });
-            return true;
         });
     }
     handleMessage(adapter, incoming, sink) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
             if (yield this.handleLink(incoming, sink)) {
                 return;
             }
@@ -113,8 +214,7 @@ export class ChatSurfaceService {
             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 = (_a = this.options.chatExternalIdsField) !== null && _a !== void 0 ? _a : DEFAULT_ADMIN_USER_EXTERNAL_USER_ID_FIELD;
-            const adminUserRecord = (yield adminforth.resource(authResourceId).list(Filters.IS_NOT_EMPTY(externalUserIdField))).find((user) => { var _a; return ((_a = user[externalUserIdField]) === null || _a === void 0 ? void 0 : _a[adapter.name]) === incoming.externalUserId; });
+            const adminUserRecord = yield this.getAdminUserRecordForChatSurface(adapter, incoming);
             if (!adminUserRecord) {
                 yield sink.emit({
                     type: "error",
@@ -127,16 +227,12 @@ export class ChatSurfaceService {
                 username: adminUserRecord[adminforth.config.auth.usernameField],
                 dbUser: adminUserRecord,
             };
-            yield this.handleTurn({
-                prompt: incoming.prompt,
-                sessionId: yield this.sessionStore.getOrCreateChatSurfaceSession(incoming, adminUser),
-                modeName: incoming.modeName,
-                userTimeZone: (_b = incoming.userTimeZone) !== null && _b !== void 0 ? _b : "UTC",
-                adminUser,
-                emit: this.createEventEmitter(sink),
-                failureLogMessage: `Agent ${incoming.surface} surface response failed`,
-                abortLogMessage: `Agent ${incoming.surface} surface response aborted`,
-            });
+            const incomingWithAudio = incoming;
+            if (incomingWithAudio.audio) {
+                yield this.handleAudioMessage(incomingWithAudio, sink, adminUser);
+                return;
+            }
+            yield this.handleAgentSurfaceResponse(incoming, sink, adminUser, incoming.prompt);
         });
     }
 }