@xmanrui/dsh-im 4.35.0 → 4.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.35.0",
+  "version": "4.36.0",
   "icon": "./assets/logo-plugin-message-link-gradient.webp",
   "description": "把微信、飞书、企微、钉钉、QQ、Telegram、WhatsApp、Slack、Discord、Matrix接入DSH。 Connect Telegram, WhatsApp, Slack, Discord, Matrix, WeChat, Feishu, WeCom, DingTalk, and QQ to DSH.",
   "keywords": [
@@ -87,9 +87,9 @@
       "platform": "web"
     },
     "compatibility": {
-      "dsh": "0.1.7-alpha.1",
+      "dsh": "0.2.0-rc.2",
       "dshReleases": {
-        "0.1.7-alpha.1": "compatible"
+        "0.2.0-rc.2": "compatible"
       },
       "profiles": [
         "web"

package/plugin-src/host/channels/dingtalk/production.mjs

@@ -45,7 +45,7 @@ function pluginPaths(config) {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-dingtalk requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ConfigStore = internals.ConfigStore ?? DingtalkConfigStore;
   const DeviceAuth = internals.DeviceAuth ?? DingtalkDeviceAuth;

package/plugin-src/host/channels/feishu/production.mjs

@@ -101,7 +101,7 @@ function pluginPaths(config) {
  */
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-feishu requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const lark = internals.lark ?? Lark;
   const Controller = internals.Controller ?? MultiBotDshFeishuController;
@@ -226,7 +226,7 @@ export async function createProductionController(ctx, config = {}, internals = {
     verifyApp,
     credentials: ctx.credentials,
     configStore: observedConfigStore,
-    createRuntime: async ({ botId, config: botConfig, appSecret, repair }) => {
+    createRuntime: async ({ botId, config: botConfig, appSecret, repair, acceptExternal }) => {
       const state = await stateFor(botConfig);
       const id = botId ?? botConfig.id ?? botConfig.appId;
       await workspaces.ensure(id, {
@@ -248,6 +248,8 @@ export async function createProductionController(ctx, config = {}, internals = {
       }
       return new Runtime({
         lark,
+        consumerMode: botConfig.consumerMode,
+        acceptExternal,
         botId: id,
         repair,
         appId: botConfig.appId,

package/plugin-src/host/channels/matrix/production.mjs

@@ -34,7 +34,7 @@ import {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-im matrix requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ResolvedConfigStore = internals.ConfigStore ?? MatrixConfigStore;
   const ResolvedStateStore = internals.StateStore ?? ConversationStateStore;

package/plugin-src/host/channels/qq/production.mjs

@@ -45,7 +45,7 @@ function pluginPaths(config) {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-im QQ requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ConfigStore = internals.ConfigStore ?? QqConfigStore;
   const StateStore = internals.StateStore ?? QqStateStore;

package/plugin-src/host/channels/shared/production.mjs

@@ -44,7 +44,7 @@ export async function createTokenProductionController(ctx, config, internals, de
     channel, ConfigStore, StateStore, HarnessClient, Controller, Runtime, runtimeOptions,
   } = definitions;
   if (!ctx?.credentials) throw new TypeError(`dsh-im ${channel} requires ctx.credentials`);
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: ['telegram', 'discord'].includes(channel) });
 
   const ResolvedConfigStore = internals.ConfigStore ?? ConfigStore;
   const ResolvedStateStore = internals.StateStore ?? StateStore;

package/plugin-src/host/channels/slack/production.mjs

@@ -33,7 +33,7 @@ import {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-im slack requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ResolvedConfigStore = internals.ConfigStore ?? SlackConfigStore;
   const ResolvedStateStore = internals.StateStore ?? SlackStateStore;

package/plugin-src/host/channels/wecom/production.mjs

@@ -44,7 +44,7 @@ function pluginPaths(config) {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-im Enterprise WeChat requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ConfigStore = internals.ConfigStore ?? WecomConfigStore;
   const StateStore = internals.StateStore ?? WecomStateStore;

package/plugin-src/host/channels/wecom-app/production.mjs

@@ -49,7 +49,7 @@ function normalizeOrigin(value) {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-im Enterprise WeChat app requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ConfigStore = internals.ConfigStore ?? WecomAppConfigStore;
   const StateStore = internals.StateStore ?? WecomAppStateStore;

package/plugin-src/host/channels/weixin/production.mjs

@@ -77,7 +77,7 @@ function diagnosticWorkspaces(store) {
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-weixin requires ctx.credentials');
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
 
   const ConfigStore = internals.ConfigStore ?? WeixinConfigStore;
   const StateStore = internals.StateStore ?? WeixinStateStore;

package/plugin-src/host/channels/whatsapp/production.mjs

@@ -54,7 +54,7 @@ function pluginPaths(config) {
 }
 
 export async function createProductionController(ctx, config = {}, internals = {}) {
-  const connection = harnessConnection(ctx, config);
+  const connection = harnessConnection(ctx, config, { competitiveApprovals: true });
   const logger = typeof ctx.logger === 'function'
     ? ctx.logger('dsh-im:whatsapp') : (ctx.logger ?? console);
   const agentPresetCatalog = () => listAgentPresetCatalog(ctx);

package/plugin-src/host/delivery-adapter.mjs

@@ -231,8 +231,35 @@ export function createDeliveryAdapter({ channel, workspaces, coreController, sta
   if (typeof stateFor !== 'function') {
     throw new TypeError('delivery adapter requires a bot state getter');
   }
+  const syncTarget = async (botId, targetId, sessionId) => {
+    const configured = sessionSyncConfigs(workspaces, botId).find((entry) => entry.targetId === targetId);
+    const target = workspaces.deliveryTargetFor(botId, targetId);
+    if (!configured || !target || !privateConversationKeyMatchesTarget(channel, configured.conversationKey, target)) {
+      throw sessionSyncUnavailable('Session sync target is no longer enabled');
+    }
+    const sessions = stateSessions(await stateFor(botId));
+    if (sessions?.[configured.conversationKey] !== sessionId) {
+      throw sessionSyncUnavailable('Session sync target is no longer bound to this Session');
+    }
+    return { target, conversationKey: configured.conversationKey };
+  };
   return Object.freeze({
     channel,
+    consumeInbound: (botId, options) => {
+      if (typeof coreController.consumeInbound !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      return coreController.consumeInbound(botId, options);
+    },
+    historyChecked: (botId, route, query, options) => {
+      if (typeof coreController.historyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      return coreController.historyChecked(botId, route, query, options);
+    },
+    replyChecked: (botId, route, text, options) => {
+      if (typeof coreController.replyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      return coreController.replyChecked(botId, route, text, options);
+    },
     describeAccount: (botId) => {
       if (typeof coreController.describeDeliveryAccount !== 'function') {
         const error = new Error('Verified account capability unavailable');
@@ -339,20 +366,41 @@ export function createDeliveryAdapter({ channel, workspaces, coreController, sta
       }
       return matches;
     },
+    async describeSessionSyncApprovalTarget(botId, targetId, sessionId) {
+      const { conversationKey } = await syncTarget(botId, targetId, sessionId);
+      return { conversationKey };
+    },
+    async presentSessionSyncApproval(botId, targetId, sessionId, interaction, options = {}) {
+      const original = await syncTarget(botId, targetId, sessionId);
+      if (typeof coreController.presentSessionSyncApproval !== 'function') {
+        throw sessionSyncUnavailable('This channel cannot present synced approvals');
+      }
+      const validate = async () => {
+        const current = await syncTarget(botId, targetId, sessionId);
+        if (current.conversationKey !== original.conversationKey || options.signal?.aborted) {
+          throw sessionSyncUnavailable('The approval target changed or the approval ended');
+        }
+      };
+      const guarded = {
+        ...interaction,
+        respond: async (result, responseOptions) => {
+          try { await validate(); }
+          catch (error) {
+            await interaction.withdraw?.();
+            throw Object.assign(new Error('Approval route is no longer available', { cause: error }), {
+              code: 'interaction-not-pending',
+            });
+          }
+          return interaction.respond(result, responseOptions);
+        },
+      };
+      return coreController.presentSessionSyncApproval(botId, original.target, guarded, {
+        ...options, key: original.conversationKey, validate,
+      });
+    },
     async sendSessionSyncText(botId, targetId, sessionId, text, options = {}) {
       if (typeof text !== 'string' || !text.trim()) throw new TypeError('text is required');
-      const configured = sessionSyncConfigs(workspaces, botId)
-        .find((target) => target.targetId === targetId);
-      const target = workspaces.deliveryTargetFor(botId, targetId);
-      if (!configured || !target || !privateConversationKeyMatchesTarget(
-        channel,
-        configured.conversationKey,
-        target,
-      )) throw sessionSyncUnavailable('Session sync target is no longer enabled');
-      const sessions = stateSessions(await stateFor(botId));
-      if (sessions?.[configured.conversationKey] !== sessionId) {
-        throw sessionSyncUnavailable('Session sync target is no longer bound to this Session');
-      }
+      const { target } = await syncTarget(botId, targetId, sessionId);
       if (typeof coreController.sendProactiveText !== 'function') {
         throw new TypeError('delivery controller cannot send proactive text');
       }

package/plugin-src/host/delivery-service.mjs

@@ -1,5 +1,7 @@
 import { createHash } from 'node:crypto';
 import { normalizeDeliveryTarget } from './delivery-adapter.mjs';
+import { COMPETITIVE_APPROVAL_CHANNELS } from '../../src/channels/shared/harness-approval.mjs';
+import { t } from '../../src/channels/shared/i18n.mjs';
 
 const BOT_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 const TARGET_ID_PATTERN = /^[A-Za-z0-9._:@-]{1,128}$/;
@@ -33,6 +35,17 @@ const DELIVERY_ERROR_CODES = new Set([
   'send-result-unknown',
   'session-sync-unavailable',
   'cancelled',
+  'provider-unavailable',
+  'consumer-unavailable',
+  'consumer-conflict',
+  'ingress-not-accepted',
+  'invalid-inbound',
+  'stale-route',
+  'reply-result-unknown',
+  'history-permission-denied',
+  'history-unavailable',
+  'thread-unavailable',
+  'untrusted-source',
 ]);
 
 const SESSION_SYNC_METHODS = Object.freeze([
@@ -132,11 +145,13 @@ export class DeliveryService {
 
   registerAdapter(value) {
     const adapter = validateAdapter(value);
-    const registration = Object.freeze({ adapter });
+    this.#adapters.get(adapter.channel)?.controller.abort(deliveryError('provider-unavailable'));
+    const registration = Object.freeze({ adapter, controller: new AbortController() });
     this.#adapters.set(adapter.channel, registration);
     return () => {
       if (this.#adapters.get(adapter.channel) !== registration) return false;
       this.#adapters.delete(adapter.channel);
+      registration.controller.abort(deliveryError('provider-unavailable'));
       return true;
     };
   }
@@ -273,6 +288,59 @@ export class DeliveryService {
     return targets;
   }
 
+  /** Offer one existing bound private chat the same approval the Host is awaiting. */
+  async presentSessionSyncApproval(sessionId, interaction, { signal, completion } = {}) {
+    const targets = (await this.listSessionSyncTargets(sessionId))
+      .filter((target) => COMPETITIVE_APPROVAL_CHANNELS.includes(target.channel));
+    if (signal?.aborted || targets.length === 0) return false;
+    let outcome = null;
+    let notified = false;
+    const notify = async (finished = false) => {
+      if (!finished && (signal?.aborted || outcome !== null)) return;
+      const text = finished
+        ? t('未找到可处理端，本次操作未获批准。')
+        : t('有操作在等待审批：{tool}，请到 Web 处理。', { tool: interaction.payload.toolName });
+      const results = await Promise.allSettled(targets.map((target) => this.sendSessionSyncText(
+        target.botId, target.targetId, sessionId, text, finished ? {} : { signal },
+      )));
+      notified ||= results.some((result) => result.status === 'fulfilled');
+    };
+    Promise.resolve(completion).then(async (value) => {
+      outcome = value;
+      if (value === 'unavailable' && notified) await notify(true);
+    }).catch((error) => console.warn('[dsh-im] approval status notification failed:', error?.code ?? error?.name));
+    const candidates = new Map();
+    let unresolvedTarget = false;
+    for (const target of targets) {
+      try {
+        const adapter = await this.#adapterFor(target.botId);
+        if (typeof adapter.describeSessionSyncApprovalTarget !== 'function') {
+          unresolvedTarget = true;
+          continue;
+        }
+        const info = await adapter.describeSessionSyncApprovalTarget(target.botId, target.targetId, sessionId);
+        candidates.set(JSON.stringify([target.channel, target.botId, info.conversationKey]), { adapter, target });
+      } catch (error) {
+        unresolvedTarget = true;
+        console.warn('[dsh-im] approval target unavailable:', error?.code ?? error?.name);
+      }
+    }
+    if (signal?.aborted) return false;
+    if (!unresolvedTarget && candidates.size === 1) {
+      const { adapter, target } = candidates.values().next().value;
+      try {
+        if (await adapter.presentSessionSyncApproval(target.botId, target.targetId, sessionId, interaction, {
+          signal, completion,
+        })) return true;
+      } catch (error) {
+        if (!signal?.aborted) console.warn('[dsh-im] synced approval unavailable:', error?.code ?? error?.name);
+      }
+    }
+    if (outcome === 'unavailable') await notify(true);
+    else await notify();
+    return false;
+  }
+
   async sendSessionSyncText(botId, targetId, sessionId, text, { signal } = {}) {
     const id = botIdOf(botId);
     const targetKey = targetIdOf(targetId);
@@ -315,6 +383,64 @@ export class DeliveryService {
     } catch (error) { throw publicOperationError(error); }
   }
 
+  async consumeInbound(botId, options = {}) {
+    const id = botIdOf(botId);
+    cancellation(options.signal);
+    if (!/^[a-f0-9]{64}$/.test(options.expectedFingerprint ?? '') || typeof options.onEvent !== 'function')
+      throw deliveryError('bad-request');
+    const registration = await this.#checkedRegistrationFor(id);
+    if (typeof registration.adapter.consumeInbound !== 'function' || typeof options.onEvent !== 'function')
+      throw deliveryError('capability-unavailable');
+    this.#assertRegistered(registration);
+    const dispose = await registration.adapter.consumeInbound(id, {
+      ...options,
+      signal: options.signal ? AbortSignal.any([options.signal, registration.controller.signal]) : registration.controller.signal,
+      onEvent: async (evidence, context) => {
+        this.#assertRegistered(registration);
+        const result = await options.onEvent(evidence, context);
+        this.#assertRegistered(registration);
+        return result;
+      },
+    });
+    try { this.#assertRegistered(registration); } catch (error) { dispose(); throw error; }
+    return dispose;
+  }
+
+  async historyChecked(botId, route, query, options = {}) {
+    const id = botIdOf(botId);
+    cancellation(options.signal);
+    if (!/^[a-f0-9]{64}$/.test(options.expectedFingerprint ?? '')) throw deliveryError('bad-request');
+    const registration = await this.#checkedRegistrationFor(id);
+    if (typeof registration.adapter.historyChecked !== 'function') throw deliveryError('capability-unavailable');
+    this.#assertRegistered(registration);
+    const signal = options.signal ? AbortSignal.any([options.signal, registration.controller.signal]) : registration.controller.signal;
+    try {
+      const result = await registration.adapter.historyChecked(id, structuredClone(route), structuredClone(query), { ...options, signal });
+      this.#assertRegistered(registration);
+      cancellation(options.signal);
+      return result;
+    } catch (error) {
+      this.#assertRegistered(registration);
+      if (signal.aborted || error?.name === 'AbortError') throw deliveryError('cancelled');
+      throw publicOperationError(error, 'history-unavailable');
+    }
+  }
+
+  async replyChecked(botId, route, text, options = {}) {
+    const id = botIdOf(botId);
+    cancellation(options.signal);
+    if (!/^[a-f0-9]{64}$/.test(options.expectedFingerprint ?? '')
+      || typeof text !== 'string' || !text.trim() || text.length > 4000)
+      throw deliveryError('bad-request');
+    const registration = await this.#checkedRegistrationFor(id);
+    if (typeof registration.adapter.replyChecked !== 'function') throw deliveryError('capability-unavailable');
+    this.#assertRegistered(registration);
+    try { return await registration.adapter.replyChecked(id, structuredClone(route), text, {
+      ...options, signal: options.signal ? AbortSignal.any([options.signal, registration.controller.signal]) : registration.controller.signal,
+    }); }
+    catch (error) { throw publicOperationError(error); }
+  }
+
   async sendChecked(botId, targetId, text, { expectedFingerprint, expectedTargetDigest, signal, format = 'plain', receipt = false } = {}) {
     const id = botIdOf(botId);
     const key = targetIdOf(targetId);

package/plugin-src/host/delivery-suggestions.mjs

@@ -124,7 +124,7 @@ export function deliverySuggestionFromConversationKey(channel, key) {
     case 'whatsapp':
       return whatsappSuggestion(key);
     case 'matrix':
-      return matrixSuggestion(key);
+      return matrixSuggestion(key.replace(/^(direct|group):/, ''));
     default:
       return null;
   }
@@ -132,6 +132,7 @@ export function deliverySuggestionFromConversationKey(channel, key) {
 
 /** Convert only a persisted private-chat key into its stable delivery route. */
 export function privateDeliverySuggestionFromConversationKey(channel, key) {
+  if (channel === 'matrix' && typeof key === 'string') key = key.replace(/^direct:dm:/, 'dm:');
   const separator = typeof key === 'string' ? key.indexOf(':') : -1;
   const prefix = separator > 0 ? key.slice(0, separator) : '';
   const privatePrefix = {

package/plugin-src/host/harness-connection.mjs

@@ -1,18 +1,14 @@
 import { modernHarnessApi } from './modern-harness-api.mjs';
 
-function optionalService(ctx, name) {
-  if (ctx && Object.hasOwn(ctx, name)) return ctx[name];
-  return typeof ctx?.get === 'function' ? ctx.get(name) : undefined;
-}
-
 /** Connect to this Host directly unless an external Harness URL was configured. */
-export function harnessConnection(ctx, config = {}) {
+export function harnessConnection(ctx, config = {}, { competitiveApprovals = false } = {}) {
   if (config.harnessBaseUrl !== undefined) {
     return { baseUrl: new URL(config.harnessBaseUrl) };
   }
-  const apiProxy = optionalService(ctx, 'apiProxy') ?? modernHarnessApi(ctx);
+  const apiProxy = modernHarnessApi(ctx, { deliveryService: config.deliveryService });
   return {
     apiProxy,
+    competitiveApprovals,
     // Cordis child contexts share one root; different Hosts must not share
     // ownership of pending questions and approvals.
     interactionScope: ctx.root ?? ctx,

package/plugin-src/host/index.mjs

@@ -93,6 +93,10 @@ export function createImHostPlugin(internals = {}) {
         ctx.provide('dshIm', Object.freeze({
           contractVersion: 1,
           receiptVersion: 1,
+          inboundVersion: 1,
+          consumeInbound: (botId, options) => deliveryService.consumeInbound(botId, options),
+          historyChecked: (botId, route, query, options) => deliveryService.historyChecked(botId, route, query, options),
+          replyChecked: (botId, route, text, options) => deliveryService.replyChecked(botId, route, text, options),
           describeBot: (botId) => deliveryService.describeBot(botId),
           sendChecked: (botId, targetId, text, options) => deliveryService.sendChecked(botId, targetId, text, options),
           send: (botId, targetId, text, options) => (
@@ -106,9 +110,8 @@ export function createImHostPlugin(internals = {}) {
         await activateChannels(readyCtx, config, deliveryService);
       };
       if (typeof ctx?.inject === 'function') {
-        const modern = typeof ctx?.typertGateway?.stream === 'function';
         await ctx.inject(
-          modern ? ['sessionController', 'workspaceController'] : ['apiProxy'],
+          ['sessionController', 'workspaceController'],
           activate,
         );
         ctx.inject(['webServer'], (httpCtx) => {

package/plugin-src/host/modern-harness-api.mjs

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 
-import { hasActiveHarnessInteractionOwner } from '../../src/channels/shared/harness-client.mjs';
+import { activeHarnessInteractionOwner, hasActiveHarnessInteractionOwner, harnessToolCallFromEvent, HarnessInteractionError } from '../../src/channels/shared/harness-client.mjs';
 import { extractConnectionEvidence } from '../../src/channels/shared/connection-error.mjs';
 
 const modernApis = new WeakMap();
@@ -196,6 +196,7 @@ class MuxSubscription {
 
 class ModernHarnessApi {
   #gateway;
+  #deliveryService;
   #scope;
   #mux = new Set();
   #pendingQuestions = new Map();
@@ -286,6 +287,10 @@ class ModernHarnessApi {
     }
   }
 
+  setDeliveryService(service) {
+    if (service) this.#deliveryService = service;
+  }
+
   async #invoke(namespace, method, args, signal) {
     return this.#gateway.invoke(remoteRequest(namespace, method, args, signal));
   }
@@ -467,7 +472,9 @@ class ModernHarnessApi {
     subscription = new MuxSubscription(signal, () => this.#mux.delete(subscription));
     this.#mux.add(subscription);
     for (const pending of this.#pendingQuestions.values()) subscription.push(this.#questionFrame(pending));
-    for (const pending of this.#pendingApprovals.values()) subscription.push(this.#approvalFrame(pending));
+    for (const pending of this.#pendingApprovals.values()) {
+      if (pending.broadcast !== false && pending.imAvailable !== false) subscription.push(this.#approvalFrame(pending));
+    }
     return subscription;
   }
 
@@ -630,6 +637,7 @@ class ModernHarnessApi {
         type: 'approval/requested',
         sessionId: pending.sessionId,
         approvalId: pending.approvalId,
+        ...(pending.competitive ? { competitive: true } : {}),
         toolName: pending.toolName,
         ...(pending.callId === undefined ? {} : { callId: pending.callId }),
         ...(pending.reason === undefined ? {} : { reason: pending.reason }),
@@ -638,6 +646,123 @@ class ModernHarnessApi {
   }
 
   #requestApproval(request, next) {
+    const session = request?.agent?.session;
+    const sessionId = session?.id ?? request?.agent?.id;
+    const events = sessionEvents(session);
+    if (typeof sessionId !== 'string' || !events) return next();
+    const owner = activeHarnessInteractionOwner(this.#scope, sessionId, events);
+    if (owner && !owner.competitiveApprovals) return this.#requestExclusiveApproval(request, next);
+    if (!owner && typeof this.#deliveryService?.presentSessionSyncApproval !== 'function') return next();
+    const turnSignal = request.signal;
+    if (turnSignal?.aborted) return Promise.resolve('cancelled');
+    const claimed = new Set([...this.#pendingApprovals.values()].map((entry) => entry.approvalId));
+    const decided = new Set();
+    let approvalId;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event.type === 'approval/decided') decided.add(event.data?.id);
+      if (event.type !== 'approval/asked') continue;
+      const id = event.data?.id;
+      if (!id || decided.has(id) || claimed.has(id)
+        || (request.callId ?? null) !== (event.data?.callId ?? null)) continue;
+      approvalId = id;
+      break;
+    }
+    if (!approvalId) return next();
+    let toolCall = owner?.toolCalls.get(request.callId);
+    if (!toolCall) {
+      for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'turn/start') break;
+        const call = harnessToolCallFromEvent(event);
+        if (call?.callId === request.callId && call.name === request.toolName) {
+          toolCall = call;
+          break;
+        }
+      }
+    }
+    // This controller retires only this approval; the caller keeps its turn signal.
+    const lifetime = new AbortController();
+    request.signal = lifetime.signal;
+    let nativeAvailable = true;
+    let resolveResult;
+    const result = new Promise((resolve) => { resolveResult = resolve; });
+    const pending = {
+      rpcId: randomUUID(), sessionId, approvalId,
+      toolName: request.toolName, callId: request.callId, reason: request.reason,
+      competitive: true, broadcast: Boolean(owner), imAvailable: true,
+      settle: (outcome) => {
+        if (!this.#pendingApprovals.delete(pending.rpcId)) return false;
+        turnSignal?.removeEventListener('abort', onAbort);
+        if (pending.broadcast) this.#broadcast({
+          type: 'approval/resolved', sessionId, approvalId, outcome,
+        });
+        // Reserve the result before aborting the losing native presentation.
+        resolveResult(outcome);
+        lifetime.abort(new Error('approval settled'));
+        if (request.signal === lifetime.signal) request.signal = turnSignal;
+        return true;
+      },
+      withdraw: () => {
+        if (!this.#pendingApprovals.has(pending.rpcId) || !pending.imAvailable) return false;
+        pending.imAvailable = false;
+        if (pending.broadcast) this.#broadcast({
+          type: 'approval/resolved', sessionId, approvalId, outcome: 'unavailable',
+        });
+        if (!nativeAvailable) pending.settle('unavailable');
+        return true;
+      },
+    };
+    const onAbort = () => pending.settle('cancelled');
+    this.#pendingApprovals.set(pending.rpcId, pending);
+    turnSignal?.addEventListener('abort', onAbort, { once: true });
+    if (turnSignal?.aborted) onAbort();
+    // Start both providers without waiting for target lookup or platform delivery.
+    Promise.resolve().then(() => {
+      if (lifetime.signal.aborted) return 'cancelled';
+      return next();
+    }).then((outcome) => {
+      if (outcome === 'allowed-once' || outcome === 'rejected') pending.settle(outcome);
+      else {
+        nativeAvailable = false;
+        if (!pending.imAvailable) pending.settle('unavailable');
+      }
+    }, (error) => {
+      nativeAvailable = false;
+      if (!lifetime.signal.aborted) console.warn('[dsh-im] native approval provider unavailable:', error?.code ?? error?.name);
+      if (!pending.imAvailable) pending.settle('unavailable');
+    });
+    if (!lifetime.signal.aborted && owner) {
+      this.#broadcast(this.#approvalFrame(pending).payload, pending.rpcId);
+    } else if (!lifetime.signal.aborted) {
+      const respond = async (response) => {
+        const receipt = this.#respond({ rpcId: pending.rpcId, result: response });
+        if (!receipt.accepted) throw new HarnessInteractionError(
+          `interaction-${receipt.reason}`, 'This approval is no longer answerable',
+        );
+        return receipt;
+      };
+      const interaction = {
+        kind: 'approval', interactionId: approvalId, rpcId: pending.rpcId, sessionId,
+        payload: this.#approvalFrame(pending).payload, toolCall, respond,
+        withdraw: async () => pending.withdraw(),
+      };
+      Promise.resolve().then(() => {
+        if (lifetime.signal.aborted) return false;
+        return this.#deliveryService.presentSessionSyncApproval(sessionId, interaction, {
+          signal: lifetime.signal, completion: result,
+        });
+      }).then((available) => {
+        if (!available) pending.withdraw();
+      }, (error) => {
+        if (!lifetime.signal.aborted) console.warn('[dsh-im] synced approval delivery unavailable:', error?.code ?? error?.name);
+        pending.withdraw();
+      });
+    }
+    return result;
+  }
+
+  #requestExclusiveApproval(request, next) {
     const owner = this.#claimableAgent(request?.agent);
     if (!owner) return next();
     if (request.signal?.aborted) return Promise.resolve('cancelled');
@@ -687,6 +812,12 @@ class ModernHarnessApi {
   #respond(message) {
     const approval = this.#pendingApprovals.get(message?.rpcId);
     if (approval) {
+      if (approval.imAvailable === false) return { accepted: false, reason: 'not-pending' };
+      if (approval.competitive && message?.result?.ok === false
+        && message?.result?.error?.code === 'unavailable') {
+        return approval.withdraw()
+          ? { accepted: true } : { accepted: false, reason: 'not-pending' };
+      }
       const value = message?.result?.value;
       if (message?.result?.ok !== true
         || !value || typeof value !== 'object'
@@ -738,18 +869,22 @@ class ModernHarnessApi {
 }
 
 /** Create one modern compatibility API per Cordis Host root. */
-export function modernHarnessApi(ctx) {
+export function modernHarnessApi(ctx, { deliveryService } = {}) {
   const scope = ctx?.root ?? ctx;
   if (!scope || !['object', 'function'].includes(typeof scope)) {
     throw new TypeError('dsh-im requires a Cordis Host context');
   }
   const cached = modernApis.get(scope);
-  if (cached) return cached;
+  if (cached) {
+    cached.setDeliveryService(deliveryService);
+    return cached;
+  }
   const gateway = ctx?.typertGateway;
   if (!gateway || typeof gateway.invoke !== 'function' || typeof gateway.stream !== 'function') {
     throw new TypeError('dsh-im requires the modern Host Typert gateway');
   }
   const api = new ModernHarnessApi(ctx, gateway, scope);
+  api.setDeliveryService(deliveryService);
   modernApis.set(scope, api);
   if (typeof ctx.effect === 'function') {
     ctx.effect(() => () => {