dsh-caduceus 0.1.1 → 0.5.1

package/README.md

@@ -78,6 +78,18 @@ onlyBuiltDependencies:
 | `personaAutoSync` | `true` | Sync SOUL into `$DSH_HOME/AGENTS.md` at startup |
 | `agentPreset` | `standard` | dsh agent preset mounted for new sessions |
 | `logLevel` | `info` | File log level: `info` / `debug` |
+| `approvalCard` | `true` | Send interactive approval cards (`allow once` / `reject`) |
+| `questionCard` | `true` | Send interactive question cards; single-select ≤4 options get buttons |
+| `interactiveTimeoutMs` | `300000` | How long an approval/question card waits before it expires |
+| `approvalPolicy` | `ask` | Session approval policy: `ask` (card confirmation, default) or `never` |
+| `reactions` | `true` | Emoji reactions on messages: `OnIt` while running, `DONE`/`CROSS_MARK` at turn end |
+| `reactionOnStart` | `OnIt` | Reaction added when a user message is accepted |
+| `reactionOnDone` | `DONE` | Reaction added when a turn completes |
+| `reactionOnFail` | `CROSS_MARK` | Reaction added when a turn errors/interrupts (falls back to `THINKING`) |
+| `gateRequireBotIdentity` | `true` | Group @ gate fails closed when the bot open id is unknown |
+| `images` | `true` | Accept image messages and attach them to the agent prompt |
+| `files` | `true` | Accept file messages (durable attachment or saved to cwd) |
+| `maxAttachmentBytes` | `20971520` | Per-attachment download limit (20 MiB) |
 
 ## Commands
 

package/README.zh.md

@@ -77,6 +77,18 @@ onlyBuiltDependencies:
 | `personaAutoSync` | `true` | 启动时把 SOUL 同步到 `$DSH_HOME/AGENTS.md` |
 | `agentPreset` | `standard` | 新会话挂载的 dsh agent preset |
 | `logLevel` | `info` | 文件日志级别：`info` / `debug` |
+| `approvalCard` | `true` | 发交互审批卡（允许一次 / 拒绝） |
+| `questionCard` | `true` | 发交互选项卡；单选且 ≤4 个选项时显示按钮 |
+| `interactiveTimeoutMs` | `300000` | 审批/选项卡等待多久后过期 |
+| `approvalPolicy` | `ask` | 会话审批策略：`ask`（弹卡确认，默认）或 `never` |
+| `reactions` | `true` | 消息表情反馈：处理中 `OnIt`，结束 `DONE`/`CROSS_MARK` |
+| `reactionOnStart` | `OnIt` | 收到用户消息时添加的表情 |
+| `reactionOnDone` | `DONE` | 回合完成时添加的表情 |
+| `reactionOnFail` | `CROSS_MARK` | 回合出错/中断时添加的表情（失败退回 `THINKING`） |
+| `gateRequireBotIdentity` | `true` | bot open id 未知时群 @ 门禁 fail-closed（false 恢复旧放行） |
+| `images` | `true` | 接收图片消息并作为附件交给 agent |
+| `files` | `true` | 接收文件消息（附件服务或落到 cwd） |
+| `maxAttachmentBytes` | `20971520` | 单个附件下载上限（20 MiB） |
 
 ## 命令
 

package/dist/bridge/bridge.d.ts

@@ -19,6 +19,15 @@ export declare class Bridge {
     handleSessionEvent(session: {
         readonly id: string;
     }, event: StatusEventLike): Promise<void>;
+    /**
+     * Send an interactive card the same way process cards go out: reply into the
+     * originating topic/thread when the session still has a live scope. Falls
+     * back to a chat send only when the scope state is gone.
+     */
+    sendInteractiveCard(sessionId: string, card: FeishuCard): Promise<{
+        readonly messageId: string;
+        readonly threadId?: string;
+    }>;
 }
 /** Build the process card for one snapshot (exported for render tests). */
 export declare function progressCardForSnapshot(snapshot: StatusSnapshot, sessionTitle: string | undefined, recentEvent: string, tail: string, now: number, presetMissing?: boolean): FeishuCard;

package/dist/bridge/bridge.js

@@ -17,6 +17,8 @@
  * @module dsh-caduceus/bridge/bridge
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { planSlashLine } from '../commands/dispatch.js';
 import { helpText } from '../commands/parse.js';
 import { evaluateGate, logGate } from '../gate.js';
@@ -27,7 +29,7 @@ import { writeOwnership } from '../ownership.js';
 import { finalCard, finalCardPlainText, progressCard, } from '../render/cards.js';
 import { CardStream, systemClock } from '../render/stream.js';
 import { mintSessionId, scopeKey, SCOPE_KEY_SEPARATOR } from '../session-key.js';
-import { StatusTracker, shouldNotifyTerminal, recentEventText, statusLabel, statusTemplate, statusText, terminalNotice, } from '../status.js';
+import { StatusTracker, shouldNotifyTerminal, stateForTurnEnd, recentEventText, statusLabel, statusTemplate, statusText, terminalNotice, } from '../status.js';
 import { ScopeQueue } from './scope-queue.js';
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -81,6 +83,8 @@ export class Bridge {
     #selfCheck;
     #agentCtxBySession = new Map();
     #toolsCheckedSessions = new Set();
+    #approvalMissingWarned = false;
+    #botIdentityErrorLogged = false;
     /** Last fail-id set already notified into the conversation. */
     #selfCheckNotifiedSignature;
     /** Session ids whose preset mount failed (shown as `（preset 未挂载）`). */
@@ -88,6 +92,7 @@ export class Bridge {
     #sessionTitleProvider;
     #queue = new ScopeQueue();
     #states = new Map();
+    #chatIdBySession = new Map();
     #scopeBySession = new Map();
     constructor(options) {
         this.#options = options;
@@ -117,6 +122,12 @@ export class Bridge {
             if (sessionId !== undefined)
                 this.#scopeBySession.set(sessionId, key);
         }
+        if (options.interactive !== undefined && options.rootCtx !== undefined) {
+            options.interactive.registerRoot(options.rootCtx, {
+                ownsSession: (sessionId) => this.ownsSession(sessionId),
+                contextFor: (sessionId) => this.#interactiveContext(sessionId),
+            });
+        }
     }
     /** True when a session id belongs to a scope this bridge renders. */
     ownsSession(sessionId) {
@@ -124,16 +135,35 @@ export class Bridge {
     }
     /** Process one inbound message (serialized per scope). */
     async handleInbound(message) {
+        if (message.unsupportedType !== undefined) {
+            const state = this.#stateFor(message);
+            this.#logger.info(`unsupported message type: ${message.unsupportedType}`);
+            await this.#replyText(state, '这类消息暂不支持。');
+            await this.#safeAddReaction(message.messageId, 'CROSS_MARK');
+            return;
+        }
+        // Bot identity may have failed at startup; retry on the next group message
+        // before deciding, so a late bot/v3/info success restores normal gating.
+        if (message.chatType === 'group' && (this.#transport.getBotOpenId?.() ?? '').length === 0) {
+            try {
+                await this.#transport.refreshBotOpenId?.();
+            }
+            catch (error) {
+                this.#logger.warn(`bot identity refresh failed: ${errorMessage(error)}`);
+            }
+        }
+        const botOpenId = this.#transport.getBotOpenId?.();
         const decision = evaluateGate({
             chatType: message.chatType,
             chatId: message.chatId,
             ...(message.threadId === undefined ? {} : { threadId: message.threadId }),
             senderOpenId: message.senderOpenId,
-            text: message.text,
+            text: message.text.trim().length === 0 && (message.attachments?.length ?? 0) > 0
+                ? '[attachment]'
+                : message.text,
             ...(message.mentions === undefined ? {} : { mentions: message.mentions }),
-            ...(this.#transport.getBotOpenId?.() === undefined
-                ? {}
-                : { botOpenId: this.#transport.getBotOpenId?.() }),
+            ...(botOpenId === undefined ? {} : { botOpenId }),
+            requireBotIdentity: this.#config.gateRequireBotIdentity !== false,
             allowedChats: this.#config.allowedChats,
             allowedUsers: this.#config.allowedUsers,
         });
@@ -142,6 +172,12 @@ export class Bridge {
             ...(message.threadId === undefined ? {} : { threadId: message.threadId }),
             senderOpenId: message.senderOpenId,
         });
+        if (!decision.accept && decision.reason === 'bot-identity-unknown') {
+            if (!this.#botIdentityErrorLogged) {
+                this.#botIdentityErrorLogged = true;
+                this.#logger.error('gate: bot identity unknown; group @ messages are rejected until resolved');
+            }
+        }
         if (!decision.accept)
             return;
         await this.#queue.run(scopeKey(message.chatType, message.chatId, message.threadId, message.senderOpenId, this.#config.groupSessionsPerUser), () => this.#processInbound(message));
@@ -218,6 +254,7 @@ export class Bridge {
     async #processInbound(message) {
         const state = this.#stateFor(message);
         state.lastInboundMessageId = message.messageId;
+        state.ownerOpenId = message.senderOpenId;
         // Startup-stage failures have no session to notify yet; the first message
         // with a session catches up here (once per fail combination).
         await this.#maybeNotifySelfCheck(state);
@@ -226,7 +263,12 @@ export class Bridge {
             await this.#handleSlash(state, message.text);
             return;
         }
-        await this.#deliverTurn(state, message.text);
+        state.reactionQueue.push(message.messageId);
+        this.#startReaction(state, message.messageId);
+        await this.#deliverTurn(state, {
+            text: message.text,
+            ...(message.attachments === undefined ? {} : { attachments: message.attachments }),
+        });
     }
     async #handleSlash(state, raw) {
         const plan = planSlashLine(raw);
@@ -382,14 +424,136 @@ export class Bridge {
             }
         }
     }
-    async #deliverTurn(state, text) {
+    async #prepareAttachments(state, input) {
+        const attachments = input.attachments ?? [];
+        if (attachments.length === 0) {
+            return { content: [{ type: 'text', text: input.text }] };
+        }
+        const maxBytes = this.#config.maxAttachmentBytes ?? 20 * 1024 * 1024;
+        const imagesEnabled = this.#config.images !== false;
+        const filesEnabled = this.#config.files !== false;
+        const kept = [];
+        let imageCount = 0;
+        let truncatedImages = 0;
+        let ignored = 0;
+        for (const attachment of attachments) {
+            if (attachment.kind === 'image') {
+                if (!imagesEnabled) {
+                    ignored += 1;
+                    continue;
+                }
+                if (imageCount >= 9) {
+                    truncatedImages += 1;
+                    continue;
+                }
+                imageCount += 1;
+                kept.push(attachment);
+            }
+            else if (!filesEnabled) {
+                ignored += 1;
+            }
+            else {
+                kept.push(attachment);
+            }
+        }
+        if (ignored > 0) {
+            await this.#replyText(state, '当前未启用图片/文件消息，已忽略部分附件。');
+        }
+        let annotated = input.text;
+        if (truncatedImages > 0) {
+            annotated += `（图片超过 9 张，已截断 ${truncatedImages} 张）`;
+        }
+        const store = this.#options.attachmentProvider?.();
+        const parts = [];
+        for (const attachment of kept) {
+            let downloaded;
+            try {
+                downloaded = await this.#transport.downloadResource(state.lastInboundMessageId ?? '', attachment.fileKey, attachment.kind, maxBytes);
+            }
+            catch (error) {
+                const tooLarge = errorMessage(error).includes('too large');
+                await this.#replyText(state, tooLarge ? '文件太大，已跳过。' : '附件下载失败，已跳过。');
+                await this.#safeAddReaction(state.lastInboundMessageId ?? '', 'CROSS_MARK');
+                return undefined;
+            }
+            if (downloaded.bytes.length > maxBytes) {
+                await this.#replyText(state, '文件太大，已跳过。');
+                await this.#safeAddReaction(state.lastInboundMessageId ?? '', 'CROSS_MARK');
+                return undefined;
+            }
+            const base64 = Buffer.from(downloaded.bytes).toString('base64');
+            if (attachment.kind === 'image') {
+                if (store === undefined) {
+                    await this.#replyText(state, '当前无法处理图片（attachments 服务不可用）。');
+                    await this.#safeAddReaction(state.lastInboundMessageId ?? '', 'CROSS_MARK');
+                    return undefined;
+                }
+                parts.push({
+                    type: 'image',
+                    mediaType: imageMediaType(downloaded.contentType),
+                    data: base64,
+                    ...(attachment.fileName === undefined ? {} : { name: attachment.fileName }),
+                });
+                continue;
+            }
+            const fileName = attachment.fileName ?? attachment.fileKey;
+            let admitted = false;
+            if (store !== undefined) {
+                try {
+                    const ref = await store.admitEncodedFile({ data: base64, name: fileName });
+                    parts.push({ type: 'file', attachment: ref });
+                    admitted = true;
+                }
+                catch {
+                    admitted = false;
+                }
+            }
+            if (!admitted) {
+                try {
+                    const dir = this.#config.defaultCwd;
+                    mkdirSync(dir, { recursive: true });
+                    const target = join(dir, `${Date.now()}-${fileName.replace(/[^\w.-]+/g, '_')}`);
+                    writeFileSync(target, downloaded.bytes);
+                    annotated += `（文件已保存：${target}）`;
+                }
+                catch (error) {
+                    this.#logger.warn(`attachment file save failed: ${errorMessage(error)}`);
+                    await this.#replyText(state, '附件保存失败，已跳过。');
+                    await this.#safeAddReaction(state.lastInboundMessageId ?? '', 'CROSS_MARK');
+                    return undefined;
+                }
+            }
+        }
+        if (parts.length === 0)
+            return { content: [{ type: 'text', text: annotated }] };
+        if (store !== undefined) {
+            try {
+                const admitted = await store.admitPromptContent([
+                    { type: 'text', text: annotated },
+                    ...parts,
+                ]);
+                return { content: admitted };
+            }
+            catch (error) {
+                this.#logger.warn(`attachment admission failed: ${errorMessage(error)}`);
+                await this.#replyText(state, '附件处理失败，已跳过。');
+                await this.#safeAddReaction(state.lastInboundMessageId ?? '', 'CROSS_MARK');
+                return undefined;
+            }
+        }
+        return { content: [{ type: 'text', text: annotated }, ...parts] };
+    }
+    async #deliverTurn(state, input) {
+        const prepared = await this.#prepareAttachments(state, input);
+        if (prepared === undefined)
+            return;
         const resolved = await this.#tryResolve(state);
         if (resolved === undefined) {
             await this.#replyText(state, '无法创建会话（agents 服务不可用）。');
             return;
         }
         const message = createUserMessage({
-            content: [{ type: 'text', text }],
+            content: prepared.content,
             source: { kind: 'user' },
         });
         const agent = resolved.agent;
@@ -412,11 +576,17 @@ export class Bridge {
     }
     async #settleTurn(state, event) {
         state.running = false;
+        const kind = turnEndReasonKind(event.data);
+        const finalState = stateForTurnEnd(kind);
+        const finalStateLabel = statusLabel(finalState);
+        // The tracker is usually already terminal (apply ran before this method),
+        // but re-apply to guarantee /status never disagrees with the final card.
+        state.status.apply(event);
         const snapshot = state.status.get();
         const body = state.lastOutput.trim().length > 0
             ? state.lastOutput
-            : `本轮已结束（${statusLabel(snapshot.state)}）。`;
-        const finalInput = this.#finalCardInput(state, snapshot, body);
+            : `本轮已结束（${finalStateLabel}）。`;
+        const finalInput = this.#finalCardInput(state, snapshot, body, finalState, finalStateLabel);
         const stream = state.progress;
         const messageId = stream?.messageId;
         if (stream !== undefined) {
@@ -441,19 +611,20 @@ export class Bridge {
                 await this.#finalFallback(state, finalInput, error);
             }
         }
-        const kind = turnEndReasonKind(event.data);
         if (shouldNotifyTerminal(kind)) {
             const notice = terminalNotice(kind, snapshot.errorMessage);
             if (notice !== undefined)
                 await this.#replyText(state, notice);
         }
+        await this.#finishReactions(state, kind);
         state.lastOutput = '';
     }
-    #finalCardInput(state, snapshot, body) {
+    #finalCardInput(state, snapshot, body, finalState, finalStateLabel) {
         const sessionTitle = this.#titleOf(state)?.trim() ?? state.title;
         return {
             title: '飞书会话 · 过程',
-            stateLabel: statusLabel(snapshot.state),
+            // Event-derived, never the (possibly stale) tracker snapshot.
+            stateLabel: finalStateLabel,
             steps: snapshot.steps,
             tools: snapshot.tools,
             ...(sessionTitle === undefined ? {} : { sessionTitle }),
@@ -461,7 +632,7 @@ export class Bridge {
             ...(snapshot.startedAt === undefined ? {} : { startedAt: snapshot.startedAt }),
             ...(snapshot.endedAt === undefined ? {} : { endedAt: snapshot.endedAt }),
             body,
-            template: statusTemplate(snapshot.state),
+            template: statusTemplate(finalState),
         };
     }
     /** The ONLY fallback path: card edit failed, so send the same content as text once. */
@@ -698,11 +869,20 @@ export class Bridge {
     async #switchSession(state, target, verb = '已恢复会话') {
         const current = state.sessionId ?? this.#sessionMap.get(state.key);
         try {
-            const { agent } = await this.#agents.resume({ resumeSessionId: target });
+            const persistedPreset = this.#sessionPresetLookup?.(target);
+            const { agent } = await this.#agents.resume({
+                resumeSessionId: target,
+                setup: async (agentCtx) => {
+                    this.#agentCtxBySession.set(target, agentCtx);
+                    if (persistedPreset === undefined)
+                        await this.#mountPreset(target, agentCtx);
+                },
+            });
             if (current !== undefined && current !== target) {
                 state.previousSessionId = current;
                 state.previousSessionAt = this.#lastActivityAt(state) ?? this.#now();
             }
+            this.#applyApprovalPolicy(agent);
             this.#sessionMap.set(state.key, target);
             state.sessionId = target;
             state.pendingCreate = false;
@@ -775,6 +955,45 @@ export class Bridge {
             this.#agentPresetsCache = service;
         return service;
     }
+    /**
+     * Apply the configured session approval policy to a freshly created/resumed
+     * agent. Missing service warns once; setPolicy errors never block the turn.
+     */
+    #applyApprovalPolicy(agent) {
+        const policy = this.#options.approvalPolicy ?? 'ask';
+        this.#logger.info(`agent approval policy=${policy}`);
+        const provider = this.#options.approvalProvider;
+        if (provider === undefined)
+            return;
+        const service = provider();
+        if (service === undefined) {
+            if (!this.#approvalMissingWarned) {
+                this.#approvalMissingWarned = true;
+                this.#logger.warn('approval service unavailable; session approval policy not applied');
+            }
+            return;
+        }
+        try {
+            service.setPolicy(agent, policy);
+        }
+        catch (error) {
+            this.#logger.warn(`agent approval policy=${policy} failed: ${errorMessage(error)}`);
+        }
+    }
+    #interactiveContext(sessionId) {
+        const key = this.#scopeBySession.get(sessionId);
+        if (key === undefined)
+            return undefined;
+        const state = this.#states.get(key);
+        if (state === undefined || state.ownerOpenId === undefined)
+            return undefined;
+        return {
+            scopeKey: state.key,
+            chatId: state.chatId,
+            ownerOpenId: state.ownerOpenId,
+            sessionId,
+        };
+    }
     /**
      * Mount the configured agent preset in the unpublished agent scope.
      * Idempotent for resumes: a context that already reports a composed preset is
@@ -827,6 +1046,7 @@ export class Bridge {
         catch (error) {
             this.#logger.warn(`ownership write failed for ${sessionId}: ${errorMessage(error)}`);
         }
+        this.#applyApprovalPolicy(agent);
         await this.#runSelfCheckStageB(state, sessionId);
         return { agent };
     }
@@ -1020,6 +1240,7 @@ export class Bridge {
                 },
             });
             this.#bindSession(state, String(agent.session.id));
+            this.#applyApprovalPolicy(agent);
             await this.#runSelfCheckStageB(state, sessionId);
             return { agent, sessionId, cwd };
         }
@@ -1045,8 +1266,77 @@ export class Bridge {
                 this.#scopeBySession.delete(id);
         }
         this.#scopeBySession.set(sessionId, state.key);
+        this.#chatIdBySession.set(sessionId, state.chatId);
         state.sessionId = sessionId;
     }
+    /**
+     * Send an interactive card the same way process cards go out: reply into the
+     * originating topic/thread when the session still has a live scope. Falls
+     * back to a chat send only when the scope state is gone.
+     */
+    async sendInteractiveCard(sessionId, card) {
+        const key = this.#scopeBySession.get(sessionId);
+        const state = key === undefined ? undefined : this.#states.get(key);
+        if (state === undefined) {
+            const chatId = this.#chatIdBySession.get(sessionId) ?? '';
+            this.#logger.warn(`interactive: no scope state for ${sessionId}; falling back to chat send`);
+            return this.#transport.sendCard(chatId, card);
+        }
+        const sent = await this.#sendNewCard(state, card);
+        return {
+            ...sent,
+            ...(state.threadId === undefined ? {} : { threadId: state.threadId }),
+        };
+    }
+    #startReaction(state, messageId) {
+        if (this.#config.reactions === false)
+            return;
+        const promise = this.#safeAddReaction(messageId, this.#config.reactionOnStart ?? 'OnIt');
+        state.reactionStarts.set(messageId, promise);
+        void promise;
+    }
+    /** Remove the start reaction, then add the terminal reaction (best effort). */
+    async #finishReactions(state, turnKind) {
+        if (this.#config.reactions === false)
+            return;
+        const messageId = state.reactionQueue.shift();
+        if (messageId === undefined)
+            return;
+        const start = state.reactionStarts.get(messageId);
+        state.reactionStarts.delete(messageId);
+        const reactionId = start === undefined ? undefined : await start;
+        if (reactionId !== undefined)
+            await this.#safeRemoveReaction(messageId, reactionId);
+        const completed = turnKind === 'completed';
+        const emoji = completed
+            ? (this.#config.reactionOnDone ?? 'DONE')
+            : (this.#config.reactionOnFail ?? 'CROSS_MARK');
+        const added = await this.#safeAddReaction(messageId, emoji);
+        if (!completed && added === undefined && emoji !== 'THINKING') {
+            await this.#safeAddReaction(messageId, 'THINKING');
+        }
+    }
+    async #safeAddReaction(messageId, emojiType) {
+        try {
+            return await this.#transport.addReaction(messageId, emojiType);
+        }
+        catch (error) {
+            this.#logReactionSkipped(error);
+            return undefined;
+        }
+    }
+    async #safeRemoveReaction(messageId, reactionId) {
+        try {
+            await this.#transport.removeReaction(messageId, reactionId);
+        }
+        catch (error) {
+            this.#logReactionSkipped(error);
+        }
+    }
+    #logReactionSkipped(error) {
+        const code = error.code;
+        this.#logger.debug(`reaction skipped: ${typeof code === 'number' ? code : 'unknown'} ${errorMessage(error)}`);
+    }
     #stateFor(message) {
         const key = scopeKey(message.chatType, message.chatId, message.threadId, message.senderOpenId, this.#config.groupSessionsPerUser);
         const existing = this.#states.get(key);
@@ -1061,6 +1351,8 @@ export class Bridge {
             running: false,
             status: new StatusTracker(),
             lastOutput: '',
+            reactionQueue: [],
+            reactionStarts: new Map(),
         };
         this.#states.set(key, created);
         return created;
@@ -1080,7 +1372,7 @@ export class Bridge {
     }
     async #sendNewCard(state, card) {
         if (state.lastInboundMessageId !== undefined) {
-            return this.#transport.reply(state.chatId, state.lastInboundMessageId, { kind: 'card', card }, { threadId: state.threadId });
+            return this.#transport.reply(state.chatId, state.lastInboundMessageId, { kind: 'card', card }, state.threadId === undefined ? {} : { threadId: state.threadId });
         }
         return this.#transport.sendCard(state.chatId, card);
     }
@@ -1125,3 +1417,14 @@ export function progressCardForSnapshot(snapshot, sessionTitle, recentEvent, tai
         now,
     });
 }
+/** Normalize a resource content-type to one of dsh's accepted image types. */
+function imageMediaType(contentType) {
+    const normalized = (contentType ?? '').split(';')[0]?.trim().toLowerCase();
+    if (normalized === 'image/png' ||
+        normalized === 'image/jpeg' ||
+        normalized === 'image/webp' ||
+        normalized === 'image/gif') {
+        return normalized;
+    }
+    return 'image/jpeg';
+}

package/dist/bridge/types.d.ts

@@ -13,10 +13,25 @@ import type { HarnessCommandResult } from '../commands/harness.js';
 import type { LoggerLike } from '../logger.js';
 import type { Clock } from '../render/stream.js';
 import type { DoctorInputs, DoctorSessionInfo } from '../doctor.js';
+import type { InteractiveRuntime } from '../interactive/runtime.js';
 import type { SessionStore } from '../session-key.js';
 import type { Transport } from '../transport/types.js';
 /** Busy-turn delivery policy (design doc §6 L3). */
 export type BusyMode = 'queue' | 'steer' | 'interrupt';
+/** Session approval policy understood by dsh's approval service. */
+export type ApprovalPolicy = 'ask' | 'never';
+/** The slice of dsh's attachment service the bridge needs. */
+export interface AttachmentStoreLike {
+    admitPromptContent(content: readonly unknown[]): Promise<readonly unknown[]>;
+    admitEncodedFile(input: {
+        readonly data: string;
+        readonly name?: string;
+    }): Promise<unknown>;
+}
+/** The slice of dsh's approval service the bridge needs. */
+export interface ApprovalServiceLike {
+    setPolicy(agent: AgentLike, policy: ApprovalPolicy): void;
+}
 /** Structural subset of a dsh session. */
 export interface SessionLike {
     readonly id: string;
@@ -86,6 +101,19 @@ export interface BridgeConfig {
     readonly groupSessionsPerUser: boolean;
     /** Agent preset mounted for caduceus sessions (default `standard`). */
     readonly agentPreset?: string;
+    /** Emoji reactions enabled (default true). */
+    readonly reactions?: boolean;
+    readonly reactionOnStart?: string;
+    readonly reactionOnDone?: string;
+    readonly reactionOnFail?: string;
+    /** Default true: group @ gate fails closed when bot open id is unknown. */
+    readonly gateRequireBotIdentity?: boolean;
+    /** Process image attachments (default true). */
+    readonly images?: boolean;
+    /** Process file attachments (default true). */
+    readonly files?: boolean;
+    /** Per-attachment byte cap (default 20 MiB). */
+    readonly maxAttachmentBytes?: number;
 }
 /** Everything the bridge needs; unit tests provide fakes for every seam. */
 export interface BridgeOptions {
@@ -111,6 +139,16 @@ export interface BridgeOptions {
     readonly persona?: (action: 'show' | 'sync') => Promise<PersonaCommandResult>;
     /** Time source for elapsed rendering; defaults to the clock. */
     readonly now?: () => number;
+    /** Interactive approval/question cards (wired by the gateway). */
+    readonly interactive?: InteractiveRuntime;
+    /** Plugin root Cordis context; answerers register here once, not per agent. */
+    readonly rootCtx?: unknown;
+    /** Lazily resolve dsh's attachment service (image admission / file refs). */
+    readonly attachmentProvider?: () => AttachmentStoreLike | undefined;
+    /** Lazily resolve dsh's approval service (agent-scoped setPolicy). */
+    readonly approvalProvider?: () => ApprovalServiceLike | undefined;
+    /** Desired session approval policy (default `ask`). */
+    readonly approvalPolicy?: ApprovalPolicy;
     /** `/doctor` data collector (wired by the gateway; not available in tests by default). */
     readonly doctorInputs?: (session: DoctorSessionInfo) => DoctorInputs | Promise<DoctorInputs>;
     /** Optional self-check controller (`/status`, `/selfcheck`, stage B). */

package/dist/commands/parse.d.ts

@@ -1,14 +1,3 @@
-/**
- * Slash-command parsing for the Feishu surface. Pure: no I/O, no side effects.
- *
- * Eleven commands are owned by dsh-caduceus: `/new`, `/sessions`, `/rename`,
- * `/resume`, `/adopt`, `/stop`, `/status`, `/persona`, `/help`. Everything else — unknown slash
- * commands such as `/compact` and all ordinary user text — comes back as
- * `{ kind: 'passthrough', raw }` so the caller can forward it unchanged to the
- * dsh command registry or the agent (design doc §6 L3).
- *
- * @module dsh-caduceus/commands/parse
- */
 /** Commands dsh-caduceus owns. Keep in sync with README's command table. */
 export declare const COMMAND_NAMES: readonly ["new", "sessions", "rename", "resume", "adopt", "selfcheck", "doctor", "stop", "status", "persona", "help"];
 export type CommandName = (typeof COMMAND_NAMES)[number];

package/dist/commands/parse.js

@@ -9,6 +9,7 @@
  *
  * @module dsh-caduceus/commands/parse
  */
+import { stripLeadingMentions } from '../mentions.js';
 /** Commands dsh-caduceus owns. Keep in sync with README's command table. */
 export const COMMAND_NAMES = ['new', 'sessions', 'rename', 'resume', 'adopt', 'selfcheck', 'doctor', 'stop', 'status', 'persona', 'help'];
 /** Command metadata; `helpText()` and the README command table both derive from it. */
@@ -37,7 +38,10 @@ function usageResult(command, reason) {
  * never rewrites a user's text.
  */
 export function parseCommand(raw) {
-    const trimmed = raw.trim();
+    // A topic/group message may arrive as "@_user_1 /stop" (Feishu's mention
+    // placeholder). Strip only the leading mentions before command detection;
+    // passthrough still forwards the ORIGINAL bytes.
+    const trimmed = stripLeadingMentions(raw).trim();
     if (!trimmed.startsWith('/'))
         return { kind: 'passthrough', raw };
     const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(trimmed);