@openacp/cli 2026.413.1 → 2026.414.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as Attachment, O as OutgoingMessage, I as IChannelAdapter, T as TurnMeta, a as AgentEvent, S as StopReason, P as PermissionRequest, N as NotificationMessage, b as SessionStatus, U as UsageRecord, c as AgentCapabilities, d as AgentDefinition, M as McpServerConfig, e as SetConfigOptionValue, f as InstalledAgent, R as RegistryAgent, g as AgentListItem, h as AvailabilityResult, i as InstallProgress, j as InstallResult, k as TurnContext, C as ConfigOption, l as AgentSwitchEntry, m as AgentCommand, n as TurnRouting, o as SessionRecord, p as UsageRecordEvent, q as IncomingMessage, D as DisplayVerbosity, r as ChannelConfig, s as AdapterCapabilities, t as ToolCallMeta, V as ViewerLinks, u as OutputMode, v as PlanEntry } from './channel-Dg1nGCYa.js';
-export { w as AgentDistribution, x as AuthMethod, y as AuthenticateRequest, z as ChannelAdapter, B as ConfigSelectChoice, E as ConfigSelectGroup, F as ContentBlock, K as KIND_ICONS, G as ModelInfo, H as NewSessionResponse, J as PermissionOption, L as PromptResponse, Q as RegistryBinaryTarget, W as RegistryDistribution, X as STATUS_ICONS, Y as SessionListItem, Z as SessionListResponse, _ as SessionMode, $ as SessionModeState, a0 as SessionModelState, a1 as TelegramPlatformData, a2 as ToolUpdateMeta, a3 as createTurnContext, a4 as getEffectiveTarget, a5 as isSystemEvent } from './channel-Dg1nGCYa.js';
+import { A as Attachment, O as OutgoingMessage, I as IChannelAdapter, T as TurnMeta, a as AgentEvent, S as StopReason, P as PermissionRequest, N as NotificationMessage, b as SessionStatus, U as UsageRecord, c as AgentCapabilities, d as AgentDefinition, M as McpServerConfig, e as SetConfigOptionValue, f as InstalledAgent, R as RegistryAgent, g as AgentListItem, h as AvailabilityResult, i as InstallProgress, j as InstallResult, k as TurnContext, C as ConfigOption, l as AgentSwitchEntry, m as AgentCommand, n as TurnRouting, o as SessionRecord, p as UsageRecordEvent, q as TurnSender, r as IncomingMessage, D as DisplayVerbosity, s as ChannelConfig, t as AdapterCapabilities, u as ToolCallMeta, V as ViewerLinks, v as OutputMode, w as PlanEntry } from './channel-bWC2vDOv.js';
+export { x as AgentDistribution, y as AuthMethod, z as AuthenticateRequest, B as ChannelAdapter, E as ConfigSelectChoice, F as ConfigSelectGroup, G as ContentBlock, K as KIND_ICONS, H as ModelInfo, J as NewSessionResponse, L as PermissionOption, Q as PromptResponse, W as RegistryBinaryTarget, X as RegistryDistribution, Y as STATUS_ICONS, Z as SessionListItem, _ as SessionListResponse, $ as SessionMode, a0 as SessionModeState, a1 as SessionModelState, a2 as TelegramPlatformData, a3 as ToolUpdateMeta, a4 as createTurnContext, a5 as getEffectiveTarget, a6 as isSystemEvent } from './channel-bWC2vDOv.js';
 import pino from 'pino';
 import * as zod from 'zod';
 import { ZodSchema, z } from 'zod';
@@ -559,6 +559,9 @@ interface MiddlewarePayloadMap {
         promptNumber: number;
         turnId: string;
         meta?: TurnMeta;
+        userPrompt?: string;
+        sourceAdapterId?: string;
+        responseAdapterId?: string | null;
     };
     'turn:end': {
         sessionId: string;
@@ -1868,6 +1871,11 @@ declare class Session extends TypedEmitter<SessionEvents> {
     get queueDepth(): number;
     /** Whether a prompt is currently being processed by the agent */
     get promptRunning(): boolean;
+    /** Snapshot of queued (not yet processing) items — for inspection by API consumers. */
+    get queueItems(): {
+        userPrompt: string;
+        turnId?: string;
+    }[];
     /** Store context markdown to be prepended to the next prompt (used for session resume with history). */
     setContext(markdown: string): void;
     /** Set TTS mode: "off" = disabled, "next" = one-shot (auto-resets after prompt), "on" = persistent. */
@@ -1938,13 +1946,13 @@ declare class PromptQueue {
     private abortController;
     /** Set when abort is triggered; drainNext waits for the current processor to settle before starting the next item. */
     private processorSettled;
-    constructor(processor: (text: string, attachments?: Attachment[], routing?: TurnRouting, turnId?: string, meta?: TurnMeta) => Promise<void>, onError?: ((err: unknown) => void) | undefined);
+    constructor(processor: (text: string, userPrompt: string, attachments?: Attachment[], routing?: TurnRouting, turnId?: string, meta?: TurnMeta) => Promise<void>, onError?: ((err: unknown) => void) | undefined);
     /**
      * Add a prompt to the queue. If no prompt is currently processing, it runs
      * immediately. Otherwise, it's buffered and the returned promise resolves
      * only after the prompt finishes processing.
      */
-    enqueue(text: string, attachments?: Attachment[], routing?: TurnRouting, turnId?: string, meta?: TurnMeta): Promise<void>;
+    enqueue(text: string, userPrompt: string, attachments?: Attachment[], routing?: TurnRouting, turnId?: string, meta?: TurnMeta): Promise<void>;
     /** Run a single prompt through the processor, then drain the next queued item. */
     private process;
     /** Dequeue and process the next pending prompt, if any. Called after each prompt completes. */
@@ -1956,6 +1964,11 @@ declare class PromptQueue {
     clear(): void;
     get pending(): number;
     get isProcessing(): boolean;
+    /** Snapshot of queued (not yet processing) items — used for queue inspection by callers. */
+    get pendingItems(): Array<{
+        userPrompt: string;
+        turnId?: string;
+    }>;
 }
 
 /**
@@ -2036,6 +2049,7 @@ interface EventBusEvents {
     }) => void;
     "agent:event": (data: {
         sessionId: string;
+        turnId: string;
         event: AgentEvent;
     }) => void;
     "permission:request": (data: {
@@ -2056,6 +2070,8 @@ interface EventBusEvents {
         commands: Array<{
             name: string;
             description: string;
+            category?: string;
+            usage?: string;
         }>;
     }) => void;
     "plugin:loaded": (data: {
@@ -2103,13 +2119,24 @@ interface EventBusEvents {
         attachments?: unknown[];
         timestamp: string;
         queueDepth: number;
+        sender?: TurnSender | null;
     }) => void;
     "message:processing": (data: {
         sessionId: string;
         turnId: string;
         sourceAdapterId: string;
+        userPrompt: string;
+        finalPrompt: string;
+        attachments?: unknown[];
+        sender?: TurnSender | null;
         timestamp: string;
     }) => void;
+    /** Fired when a queued message is rejected before processing (e.g. blocked by middleware). */
+    "message:failed": (data: {
+        sessionId: string;
+        turnId: string;
+        reason: string;
+    }) => void;
     "session:agentSwitch": (data: {
         sessionId: string;
         fromAgent: string;
@@ -3325,24 +3352,37 @@ declare class OpenACPCore {
      * If no session is found, the user is told to start one with /new.
      */
     handleMessage(message: IncomingMessage, initialMeta?: Record<string, unknown>): Promise<void>;
+    /**
+     * Shared dispatch path for sending a prompt to a session.
+     * Called by both handleMessage (Telegram) and handleMessageInSession (SSE/API)
+     * after their respective middleware/enrichment steps.
+     */
+    private _dispatchToSession;
     /**
      * Send a message to a known session, running the full message:incoming → agent:beforePrompt
      * middleware chain (same as handleMessage) but without the threadId-based session lookup.
      *
-     * Used by channels that already hold a direct session reference (e.g. SSE adapter), where
-     * looking up by channelId+threadId is unreliable (API sessions may have no threadId).
+     * Used by channels that already hold a direct session reference (e.g. SSE adapter, api-server),
+     * where looking up by channelId+threadId is unreliable (API sessions may have no threadId).
      *
      * @param session  The target session — caller is responsible for validating its status.
      * @param message  Sender context and message content.
      * @param initialMeta  Optional adapter-specific context to seed the TurnMeta bag
      *                     (e.g. channelUser with display name/username).
+     * @param options  Optional turnId override and response routing.
      */
     handleMessageInSession(session: Session, message: {
         channelId: string;
         userId: string;
         text: string;
         attachments?: Attachment[];
-    }, initialMeta?: Record<string, unknown>): Promise<void>;
+    }, initialMeta?: Record<string, unknown>, options?: {
+        externalTurnId?: string;
+        responseAdapterId?: string | null;
+    }): Promise<{
+        turnId: string;
+        queueDepth: number;
+    }>;
     /**
      * Create (or resume) a session with full wiring: agent, adapter thread, bridge, persistence.
      *
@@ -3780,6 +3820,13 @@ interface StoredToken {
     revoked: boolean;
     /** User ID from identity system. Null until user completes /identity/setup. */
     userId?: string;
+    /**
+     * Per-token secret for identity re-linking on reconnect.
+     * Never embedded in the JWT — only returned at token creation/exchange time.
+     * The App stores this in its workspace store and uses it to silently re-link
+     * a new token to the same user after the old token's refresh deadline expires.
+     */
+    identitySecret: string;
 }
 interface CreateTokenOpts {
     role: string;
@@ -3860,6 +3907,14 @@ declare class TokenStore {
     setUserId(tokenId: string, userId: string): void;
     /** Get the user ID associated with a token. */
     getUserId(tokenId: string): string | undefined;
+    /**
+     * Looks up a non-revoked token by its identity secret.
+     *
+     * Used by the identity re-link flow: the App sends the old token's identitySecret
+     * to prove continuity of identity when reconnecting with a new JWT.
+     * Returns undefined if no match, or if the matching token is revoked.
+     */
+    getByIdentitySecret(secret: string): StoredToken | undefined;
     /**
      * Generates a one-time authorization code that can be exchanged for a JWT.
      *
@@ -4931,10 +4986,11 @@ declare class TelegramAdapter extends MessagingAdapter {
      */
     private retryWithBackoff;
     /**
-     * Register Telegram commands in the background with retries.
-     * Non-critical — bot works fine without autocomplete commands.
+     * Sync Telegram autocomplete commands after all plugins are ready.
+     * Merges STATIC_COMMANDS (hardcoded system commands) with plugin commands
+     * from the registry, deduplicating by command name. Non-critical.
      */
-    private registerCommandsWithRetry;
+    private syncCommandsWithRetry;
     private initTopicDependentFeatures;
     private startPrerequisiteWatcher;
     /**

package/dist/index.js

@@ -852,6 +852,8 @@ var init_events = __esm({
       MESSAGE_QUEUED: "message:queued",
       /** Fired when a queued message starts processing. */
       MESSAGE_PROCESSING: "message:processing",
+      /** Fired when a queued message is rejected (e.g. blocked by middleware). */
+      MESSAGE_FAILED: "message:failed",
       // --- System lifecycle ---
       /** Fired after kernel (core + plugin infrastructure) has booted. */
       KERNEL_BOOTED: "kernel:booted",
@@ -3538,7 +3540,8 @@ var init_sse_manager = __esm({
           BusEvent.PERMISSION_REQUEST,
           BusEvent.PERMISSION_RESOLVED,
           BusEvent.MESSAGE_QUEUED,
-          BusEvent.MESSAGE_PROCESSING
+          BusEvent.MESSAGE_PROCESSING,
+          BusEvent.MESSAGE_FAILED
         ];
         for (const eventName of events) {
           const handler = (data) => {
@@ -3620,7 +3623,8 @@ data: ${JSON.stringify(data)}
           BusEvent.PERMISSION_RESOLVED,
           BusEvent.SESSION_UPDATED,
           BusEvent.MESSAGE_QUEUED,
-          BusEvent.MESSAGE_PROCESSING
+          BusEvent.MESSAGE_PROCESSING,
+          BusEvent.MESSAGE_FAILED
         ];
         for (const res of this.sseConnections) {
           const filter = res.sessionFilter;
@@ -10110,7 +10114,11 @@ var init_adapter = __esm({
           }
           return prev(method, payload, signal);
         });
-        this.registerCommandsWithRetry();
+        const onCommandsReady = ({ commands }) => {
+          this.core.eventBus.off(BusEvent.SYSTEM_COMMANDS_READY, onCommandsReady);
+          this.syncCommandsWithRetry(commands);
+        };
+        this.core.eventBus.on(BusEvent.SYSTEM_COMMANDS_READY, onCommandsReady);
         this.bot.use((ctx, next) => {
           const chatId = ctx.chat?.id ?? ctx.callbackQuery?.message?.chat?.id;
           if (chatId !== this.telegramConfig.chatId) return;
@@ -10336,12 +10344,16 @@ ${p}` : p;
         throw new Error("unreachable");
       }
       /**
-       * Register Telegram commands in the background with retries.
-       * Non-critical — bot works fine without autocomplete commands.
+       * Sync Telegram autocomplete commands after all plugins are ready.
+       * Merges STATIC_COMMANDS (hardcoded system commands) with plugin commands
+       * from the registry, deduplicating by command name. Non-critical.
        */
-      registerCommandsWithRetry() {
+      syncCommandsWithRetry(registryCommands) {
+        const staticNames = new Set(STATIC_COMMANDS.map((c2) => c2.command));
+        const pluginCommands = registryCommands.filter((c2) => c2.category === "plugin" && !staticNames.has(c2.name) && /^[a-z0-9_]+$/.test(c2.name)).map((c2) => ({ command: c2.name, description: c2.description.slice(0, 256) }));
+        const allCommands = [...STATIC_COMMANDS, ...pluginCommands].slice(0, 100);
         this.retryWithBackoff(
-          () => this.bot.api.setMyCommands(STATIC_COMMANDS, {
+          () => this.bot.api.setMyCommands(allCommands, {
             scope: { type: "chat", chat_id: this.telegramConfig.chatId }
           }),
           "setMyCommands"
@@ -12833,16 +12845,16 @@ var PromptQueue = class {
    * immediately. Otherwise, it's buffered and the returned promise resolves
    * only after the prompt finishes processing.
    */
-  async enqueue(text3, attachments, routing, turnId, meta) {
+  async enqueue(text3, userPrompt, attachments, routing, turnId, meta) {
     if (this.processing) {
       return new Promise((resolve7) => {
-        this.queue.push({ text: text3, attachments, routing, turnId, meta, resolve: resolve7 });
+        this.queue.push({ text: text3, userPrompt, attachments, routing, turnId, meta, resolve: resolve7 });
       });
     }
-    await this.process(text3, attachments, routing, turnId, meta);
+    await this.process(text3, userPrompt, attachments, routing, turnId, meta);
   }
   /** Run a single prompt through the processor, then drain the next queued item. */
-  async process(text3, attachments, routing, turnId, meta) {
+  async process(text3, userPrompt, attachments, routing, turnId, meta) {
     this.processing = true;
     this.abortController = new AbortController();
     const { signal } = this.abortController;
@@ -12852,7 +12864,7 @@ var PromptQueue = class {
     });
     try {
       await Promise.race([
-        this.processor(text3, attachments, routing, turnId, meta),
+        this.processor(text3, userPrompt, attachments, routing, turnId, meta),
         new Promise((_, reject) => {
           signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
         })
@@ -12873,7 +12885,7 @@ var PromptQueue = class {
   drainNext() {
     const next = this.queue.shift();
     if (next) {
-      this.process(next.text, next.attachments, next.routing, next.turnId, next.meta).then(next.resolve);
+      this.process(next.text, next.userPrompt, next.attachments, next.routing, next.turnId, next.meta).then(next.resolve);
     }
   }
   /**
@@ -12895,6 +12907,13 @@ var PromptQueue = class {
   get isProcessing() {
     return this.processing;
   }
+  /** Snapshot of queued (not yet processing) items — used for queue inspection by callers. */
+  get pendingItems() {
+    return this.queue.map((item) => ({
+      userPrompt: item.userPrompt,
+      turnId: item.turnId
+    }));
+  }
 };
 
 // src/core/sessions/permission-gate.ts
@@ -12976,17 +12995,31 @@ import * as fs8 from "fs";
 
 // src/core/sessions/turn-context.ts
 import { nanoid } from "nanoid";
-function createTurnContext(sourceAdapterId, responseAdapterId, turnId) {
+function extractSender(meta) {
+  const identity = meta?.identity;
+  if (!identity || !identity.userId || !identity.identityId) return null;
   return {
-    turnId: turnId ?? nanoid(8),
-    sourceAdapterId,
-    responseAdapterId
+    userId: identity.userId,
+    identityId: identity.identityId,
+    displayName: identity.displayName,
+    username: identity.username
   };
 }
 function getEffectiveTarget(ctx) {
   if (ctx.responseAdapterId === null) return null;
   return ctx.responseAdapterId ?? ctx.sourceAdapterId;
 }
+function createTurnContext(sourceAdapterId, responseAdapterId, turnId, userPrompt, finalPrompt, attachments, meta) {
+  return {
+    turnId: turnId ?? nanoid(8),
+    sourceAdapterId,
+    responseAdapterId,
+    userPrompt,
+    finalPrompt,
+    attachments,
+    meta
+  };
+}
 var SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
   "session_end",
   "system_message",
@@ -13081,7 +13114,7 @@ var Session = class extends TypedEmitter {
     this.log = createSessionLogger(this.id, moduleLog);
     this.log.info({ agentName: this.agentName }, "Session created");
     this.queue = new PromptQueue(
-      (text3, attachments, routing, turnId, meta) => this.processPrompt(text3, attachments, routing, turnId, meta),
+      (text3, userPrompt, attachments, routing, turnId, meta) => this.processPrompt(text3, userPrompt, attachments, routing, turnId, meta),
       (err) => {
         this.log.error({ err }, "Prompt execution failed");
         const message = err instanceof Error ? err.message : String(err);
@@ -13161,6 +13194,10 @@ var Session = class extends TypedEmitter {
   get promptRunning() {
     return this.queue.isProcessing;
   }
+  /** Snapshot of queued (not yet processing) items — for inspection by API consumers. */
+  get queueItems() {
+    return this.queue.pendingItems;
+  }
   // --- Context Injection ---
   /** Store context markdown to be prepended to the next prompt (used for session resume with history). */
   setContext(markdown) {
@@ -13183,22 +13220,28 @@ var Session = class extends TypedEmitter {
   async enqueuePrompt(text3, attachments, routing, externalTurnId, meta) {
     const turnId = externalTurnId ?? nanoid2(8);
     const turnMeta = meta ?? { turnId };
+    const userPrompt = text3;
     if (this.middlewareChain) {
       const payload = { text: text3, attachments, sessionId: this.id, sourceAdapterId: routing?.sourceAdapterId, meta: turnMeta };
       const result = await this.middlewareChain.execute(Hook.AGENT_BEFORE_PROMPT, payload, async (p) => p);
-      if (!result) return turnId;
+      if (!result) throw new Error("PROMPT_BLOCKED");
       text3 = result.text;
       attachments = result.attachments;
     }
-    await this.queue.enqueue(text3, attachments, routing, turnId, turnMeta);
+    await this.queue.enqueue(text3, userPrompt, attachments, routing, turnId, turnMeta);
     return turnId;
   }
-  async processPrompt(text3, attachments, routing, turnId, meta) {
+  async processPrompt(text3, userPrompt, attachments, routing, turnId, meta) {
     if (this._status === "finished") return;
     this.activeTurnContext = createTurnContext(
       routing?.sourceAdapterId ?? this.channelId,
       routing?.responseAdapterId,
-      turnId
+      turnId,
+      userPrompt,
+      text3,
+      // finalPrompt (after middleware transformations)
+      attachments,
+      meta
     );
     this.emit(SessionEv.TURN_STARTED, this.activeTurnContext);
     this.promptCount++;
@@ -13249,7 +13292,16 @@ ${text3}`;
       this.agentInstance.on(SessionEv.AGENT_EVENT, afterEventListener);
     }
     if (this.middlewareChain) {
-      this.middlewareChain.execute(Hook.TURN_START, { sessionId: this.id, promptText: processed.text, promptNumber: this.promptCount, turnId: this.activeTurnContext?.turnId ?? turnId ?? "", meta }, async (p) => p).catch(() => {
+      this.middlewareChain.execute(Hook.TURN_START, {
+        sessionId: this.id,
+        promptText: processed.text,
+        promptNumber: this.promptCount,
+        turnId: this.activeTurnContext?.turnId ?? turnId ?? "",
+        meta,
+        userPrompt: this.activeTurnContext?.userPrompt,
+        sourceAdapterId: this.activeTurnContext?.sourceAdapterId,
+        responseAdapterId: this.activeTurnContext?.responseAdapterId
+      }, async (p) => p).catch(() => {
       });
     }
     let stopReason = "end_turn";
@@ -14418,7 +14470,7 @@ var SessionBridge = class {
       if (this.shouldForward(event)) {
         this.dispatchAgentEvent(event);
       } else {
-        this.deps.eventBus?.emit(BusEvent.AGENT_EVENT, { sessionId: this.session.id, event });
+        this.deps.eventBus?.emit(BusEvent.AGENT_EVENT, { sessionId: this.session.id, turnId: "", event });
       }
     });
     if (!this.session.agentInstance.onPermissionRequest || this.session.agentInstance.onPermissionRequest.__bridgeId === void 0) {
@@ -14471,14 +14523,16 @@ var SessionBridge = class {
       this.deps.sessionManager.patchRecord(this.session.id, { currentPromptCount: count });
     });
     this.listen(this.session, SessionEv.TURN_STARTED, (ctx) => {
-      if (ctx.sourceAdapterId !== "sse") {
-        this.deps.eventBus?.emit(BusEvent.MESSAGE_PROCESSING, {
-          sessionId: this.session.id,
-          turnId: ctx.turnId,
-          sourceAdapterId: ctx.sourceAdapterId,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
+      this.deps.eventBus?.emit(BusEvent.MESSAGE_PROCESSING, {
+        sessionId: this.session.id,
+        turnId: ctx.turnId,
+        sourceAdapterId: ctx.sourceAdapterId,
+        userPrompt: ctx.userPrompt,
+        finalPrompt: ctx.finalPrompt,
+        attachments: ctx.attachments,
+        sender: extractSender(ctx.meta),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
     });
     if (this.session.latestCommands !== null) {
       this.session.emit(SessionEv.AGENT_EVENT, { type: "commands_update", commands: this.session.latestCommands });
@@ -14644,6 +14698,7 @@ var SessionBridge = class {
     }
     this.deps.eventBus?.emit(BusEvent.AGENT_EVENT, {
       sessionId: this.session.id,
+      turnId: this.session.activeTurnContext?.turnId ?? "",
       event
     });
     return outgoing;
@@ -14844,6 +14899,7 @@ var SessionFactory = class {
       const failedSessionId = createParams.existingSessionId ?? `failed-${Date.now()}`;
       this.eventBus.emit(BusEvent.AGENT_EVENT, {
         sessionId: failedSessionId,
+        turnId: "",
         event: guidance
       });
       throw err;
@@ -15393,7 +15449,7 @@ var AgentSwitchHandler = class {
       message: `Switching from ${fromAgent} to ${toAgent}...`
     };
     session.emit(SessionEv.AGENT_EVENT, startEvent);
-    eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: startEvent });
+    eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, turnId: "", event: startEvent });
     eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
       sessionId,
       fromAgent,
@@ -15456,7 +15512,7 @@ var AgentSwitchHandler = class {
         message: resumed ? `Switched to ${toAgent} (resumed previous session).` : `Switched to ${toAgent} (new session).`
       };
       session.emit(SessionEv.AGENT_EVENT, successEvent);
-      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: successEvent });
+      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, turnId: "", event: successEvent });
       eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
         sessionId,
         fromAgent,
@@ -15471,7 +15527,7 @@ var AgentSwitchHandler = class {
         message: `Failed to switch to ${toAgent}: ${errorMessage}`
       };
       session.emit(SessionEv.AGENT_EVENT, failedEvent);
-      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: failedEvent });
+      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, turnId: "", event: failedEvent });
       eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
         sessionId,
         fromAgent,
@@ -17567,9 +17623,6 @@ var OpenACPCore = class {
       }
       return;
     }
-    this.sessionManager.patchRecord(session.id, {
-      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
     let text3 = message.text;
     if (this.assistantManager?.isAssistant(session.id)) {
       const pending = this.assistantManager.consumePendingSystemPrompt(message.channelId);
@@ -17582,38 +17635,56 @@ User message:
 ${text3}`;
       }
     }
-    const sourceAdapterId = message.routing?.sourceAdapterId ?? message.channelId;
-    const routing = sourceAdapterId !== message.routing?.sourceAdapterId ? { ...message.routing, sourceAdapterId } : message.routing;
     const enrichedMeta = message.meta ?? meta;
-    if (sourceAdapterId && sourceAdapterId !== "sse" && sourceAdapterId !== "api") {
-      this.eventBus.emit(BusEvent.MESSAGE_QUEUED, {
+    await this._dispatchToSession(session, text3, message.attachments, {
+      sourceAdapterId: message.routing?.sourceAdapterId ?? message.channelId,
+      responseAdapterId: message.routing?.responseAdapterId
+    }, turnId, enrichedMeta);
+  }
+  /**
+   * Shared dispatch path for sending a prompt to a session.
+   * Called by both handleMessage (Telegram) and handleMessageInSession (SSE/API)
+   * after their respective middleware/enrichment steps.
+   */
+  async _dispatchToSession(session, text3, attachments, routing, turnId, meta) {
+    this.sessionManager.patchRecord(session.id, {
+      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.eventBus.emit(BusEvent.MESSAGE_QUEUED, {
+      sessionId: session.id,
+      turnId,
+      text: text3,
+      sourceAdapterId: routing.sourceAdapterId,
+      attachments,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      queueDepth: session.queueDepth + 1,
+      sender: extractSender(meta)
+    });
+    session.enqueuePrompt(text3, attachments, routing, turnId, meta).catch((err) => {
+      const reason = err instanceof Error ? err.message : String(err);
+      log16.warn({ err, sessionId: session.id, turnId, reason }, "enqueuePrompt failed \u2014 emitting message:failed");
+      this.eventBus.emit(BusEvent.MESSAGE_FAILED, {
         sessionId: session.id,
         turnId,
-        text: text3,
-        sourceAdapterId,
-        attachments: message.attachments,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        queueDepth: session.queueDepth
+        reason
       });
-      await session.enqueuePrompt(text3, message.attachments, routing, turnId, enrichedMeta);
-    } else {
-      await session.enqueuePrompt(text3, message.attachments, routing, turnId, enrichedMeta);
-    }
+    });
   }
   /**
    * Send a message to a known session, running the full message:incoming → agent:beforePrompt
    * middleware chain (same as handleMessage) but without the threadId-based session lookup.
    *
-   * Used by channels that already hold a direct session reference (e.g. SSE adapter), where
-   * looking up by channelId+threadId is unreliable (API sessions may have no threadId).
+   * Used by channels that already hold a direct session reference (e.g. SSE adapter, api-server),
+   * where looking up by channelId+threadId is unreliable (API sessions may have no threadId).
    *
    * @param session  The target session — caller is responsible for validating its status.
    * @param message  Sender context and message content.
    * @param initialMeta  Optional adapter-specific context to seed the TurnMeta bag
    *                     (e.g. channelUser with display name/username).
+   * @param options  Optional turnId override and response routing.
    */
-  async handleMessageInSession(session, message, initialMeta) {
-    const turnId = nanoid3(8);
+  async handleMessageInSession(session, message, initialMeta, options) {
+    const turnId = options?.externalTurnId ?? nanoid3(8);
     const meta = { turnId, ...initialMeta };
     let text3 = message.text;
     let { attachments } = message;
@@ -17632,13 +17703,17 @@ ${text3}`;
         payload,
         async (p) => p
       );
-      if (!result) return;
+      if (!result) return { turnId, queueDepth: session.queueDepth };
       text3 = result.text;
       attachments = result.attachments;
       enrichedMeta = result.meta ?? meta;
     }
-    const routing = { sourceAdapterId: message.channelId };
-    await session.enqueuePrompt(text3, attachments, routing, turnId, enrichedMeta);
+    const routing = {
+      sourceAdapterId: message.channelId,
+      responseAdapterId: options?.responseAdapterId
+    };
+    await this._dispatchToSession(session, text3, attachments, routing, turnId, enrichedMeta);
+    return { turnId, queueDepth: session.queueDepth };
   }
   // --- Unified Session Creation Pipeline ---
   /**
@@ -17750,7 +17825,7 @@ ${text3}`;
         } else if (processedEvent.type === "error") {
           session.fail(processedEvent.message);
         }
-        this.eventBus.emit(BusEvent.AGENT_EVENT, { sessionId: session.id, event: processedEvent });
+        this.eventBus.emit(BusEvent.AGENT_EVENT, { sessionId: session.id, turnId: session.activeTurnContext?.turnId ?? "", event: processedEvent });
       });
       session.on(SessionEv.STATUS_CHANGE, (_from, to) => {
         this.sessionManager.patchRecord(session.id, {
@@ -17762,6 +17837,18 @@ ${text3}`;
       session.on(SessionEv.PROMPT_COUNT_CHANGED, (count) => {
         this.sessionManager.patchRecord(session.id, { currentPromptCount: count });
       });
+      session.on(SessionEv.TURN_STARTED, (ctx) => {
+        this.eventBus.emit(BusEvent.MESSAGE_PROCESSING, {
+          sessionId: session.id,
+          turnId: ctx.turnId,
+          sourceAdapterId: ctx.sourceAdapterId,
+          userPrompt: ctx.userPrompt,
+          finalPrompt: ctx.finalPrompt,
+          attachments: ctx.attachments,
+          sender: extractSender(ctx.meta),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      });
     }
     this.sessionFactory.wireSideEffects(session, {
       eventBus: this.eventBus,