@addozhang/dsh-discord 0.3.0 → 0.4.0

package/README.md

@@ -6,6 +6,7 @@
 [![CI](https://img.shields.io/github/actions/workflow/status/addozhang/dsh-discord/ci.yml?branch=main&label=CI)](https://github.com/addozhang/dsh-discord/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/@addozhang/dsh-discord)](./LICENSE)
 [![node](https://img.shields.io/node/v/@addozhang/dsh-discord)](./package.json)
+[![dshfind](https://dshfind.com/api/badge/addozhang/dsh-discord)](https://dshfind.com/en/plugins/addozhang/dsh-discord?ref=badge)
 
 A Discord-first adapter for [DeepSeek Harness](https://github.com/deepseek-ai): run DSH sessions from a Discord guild — mention the bot to open a task thread, steer and stop turns, answer approvals and questions inline, and watch the answer stream in.
 
@@ -17,7 +18,7 @@ This is a function/namespace plugin (`inject: ['apiProxy', 'credentials', 'setti
 
 ## Features
 
-- **Mention-driven sessions** — an authorized `@bot <task>` in a bound channel anchors a thread (the author's message becomes the first post), creates the DSH session, and submits the prompt at most once. Follow-ups inside the thread queue without a mention.
+- **Mention-driven sessions** — an authorized `@bot <task>` in a bound channel anchors a thread (the author's message becomes the first post), creates the DSH session, and submits the prompt at most once. Follow-ups inside the thread queue without a mention. Attached images ride along: they are downloaded from the Discord CDN within strict size/host bounds and submitted as image parts for multimodal models.
 - **Stream rendering** — typing indicators, a single edited head message, per-tool activity rows, fenced long-answer splitting, one-time finalize; the activity message is deleted when the turn ends.
 - **Approvals & questions** — DSH ask frames become Discord buttons, select menus, and a free-text modal; ownership is enforced (the asker — or the thread owner on later turns — clicks), expiry sweeps fail closed, and settled controls grey out in place.
 
@@ -132,7 +133,7 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 
 ```sh
 pnpm install --ignore-scripts
-pnpm test          # 650 tests incl. gateway/REST twin E2E
+pnpm test          # 683 tests incl. gateway/REST twin E2E
 pnpm typecheck
 pnpm lint
 pnpm build         # lib + client bundle

package/README.zh.md

@@ -6,6 +6,7 @@
 [![CI](https://img.shields.io/github/actions/workflow/status/addozhang/dsh-discord/ci.yml?branch=main&label=CI)](https://github.com/addozhang/dsh-discord/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/@addozhang/dsh-discord)](./LICENSE)
 [![node](https://img.shields.io/node/v/@addozhang/dsh-discord)](./package.json)
+[![dshfind](https://dshfind.com/api/badge/addozhang/dsh-discord)](https://dshfind.com/en/plugins/addozhang/dsh-discord?ref=badge)
 
 [DeepSeek Harness](https://github.com/deepseek-ai) 的 Discord 优先适配器：在 Discord 服务器中运行 DSH 会话——@机器人即可开启任务线程、插话与停止运行、在线审批与回答问题，并实时观看回答流式输出。
 
@@ -17,7 +18,7 @@
 
 ## 功能
 
-- **@提及驱动会话** — 在已绑定的频道中，被授权的 `@机器人 <任务>` 会锚定一个线程（你的消息成为首帖）、创建 DSH 会话，并且至多提交一次。线程内的后续消息无需 @ 即可排队。
+- **@提及驱动会话** — 在已绑定的频道中，被授权的 `@机器人 <任务>` 会锚定一个线程（你的消息成为首帖）、创建 DSH 会话，并且至多提交一次。线程内的后续消息无需 @ 即可排队。消息附带的图片会一并送达：在严格的大小与主机白名单约束下从 Discord CDN 下载，并作为 image parts 提交给多模态模型。
 - **流式渲染** — typing 指示、单条头消息编辑、逐工具活动行、代码围栏感知的长文分段、一次性收尾；Turn 结束时活动消息会被删除。
 - **审批与提问** — DSH ask 帧渲染为 Discord 按钮、下拉菜单与自由文本弹窗；所有权强制校验（提问者——或后续 Turn 的线程属主——才能点击），超时清扫 fail-closed，结算后的控件原地置灰。
 
@@ -133,7 +134,7 @@ dsh-discord:
 
 ```sh
 pnpm install --ignore-scripts
-pnpm test          # 650 tests incl. gateway/REST twin E2E
+pnpm test          # 683 tests incl. gateway/REST twin E2E
 pnpm typecheck
 pnpm lint
 pnpm build         # lib + client bundle

package/lib/compose.d.ts

@@ -31,6 +31,13 @@ export interface SessionMainlinePort {
         authorId: string;
         workspaceId: string;
         prompt: string;
+        /** Declared image attachments carried by the message (16.50). */
+        images: ReadonlyArray<{
+            url: string;
+            filename: string;
+            declaredSize: number;
+            contentType: string;
+        }>;
     }): Promise<{
         outcome: 'admitted';
         threadId: string;
@@ -47,6 +54,9 @@ export interface SessionMainlinePort {
         outcome: 'prompt-rejected';
     } | {
         outcome: 'prompt-unknown';
+    } | {
+        outcome: 'image-failed';
+        reason: string;
     }>;
     continueInThread(request: {
         applicationId: string;
@@ -55,6 +65,13 @@ export interface SessionMainlinePort {
         sessionId: string;
         messageId: string;
         prompt: string;
+        /** Declared image attachments carried by the message (16.50). */
+        images: ReadonlyArray<{
+            url: string;
+            filename: string;
+            declaredSize: number;
+            contentType: string;
+        }>;
     }): Promise<{
         outcome: 'queued';
     } | {
@@ -65,6 +82,9 @@ export interface SessionMainlinePort {
         outcome: 'rejected';
     } | {
         outcome: 'unknown';
+    } | {
+        outcome: 'image-failed';
+        reason: string;
     }>;
 }
 export interface BindingsProbe {

package/lib/compose.js

@@ -18,10 +18,13 @@ export const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json';
 export function routeEvent(deps, event, decision) {
     if (event.kind === 'message') {
         const prompt = event.content.trim();
+        const images = event.images;
+        // Text and images are independent task carriers: either alone admits.
+        const hasTask = prompt !== '' || images.length > 0;
         // Adapter-owned thread: ordinary continuation, no mention required.
         const sessionId = deps.bindings.sessionForThread(event.guildId, event.channelId);
         if (sessionId !== undefined) {
-            if (prompt === '')
+            if (!hasTask)
                 return;
             const request = {
                 applicationId: deps.applicationId(),
@@ -30,10 +33,11 @@ export function routeEvent(deps, event, decision) {
                 sessionId,
                 messageId: event.messageId,
                 prompt,
+                images,
             };
             void deps.mainline.continueInThread(request)
                 .then((result) => {
-                if (result.outcome === 'rejected' || result.outcome === 'unknown') {
+                if (result.outcome === 'rejected' || result.outcome === 'unknown' || result.outcome === 'image-failed') {
                     deps.logger?.warn('discord_continuation_not_queued', { ...result, messageId: event.messageId });
                 }
             })
@@ -63,7 +67,7 @@ export function routeEvent(deps, event, decision) {
             }
             return;
         }
-        if (prompt === '')
+        if (!hasTask)
             return;
         void deps.mainline.admitMention({
             applicationId: deps.applicationId(),
@@ -73,6 +77,7 @@ export function routeEvent(deps, event, decision) {
             authorId: event.authorId,
             workspaceId,
             prompt,
+            images,
         })
             .then((result) => {
             if (result.outcome !== 'admitted') {

package/lib/dsh/api-proxy-face.d.ts

@@ -34,6 +34,10 @@ export interface DshApiProxyFace {
             content: Array<{
                 type: 'text';
                 text: string;
+            } | {
+                type: 'image';
+                mediaType: string;
+                data: string;
             }>;
         }>): Promise<RpcResponseShape<{
             accepted: true;
@@ -215,10 +219,16 @@ export type PromptOutcome = {
  * the turn may or may not have been admitted, so callers must not resubmit.
  * `options.rpcId` pins the adapter-owned stable request id, which the Host
  * records on the durable `user/message` (`source.rpcId`) for reconciliation.
+ * Images (16.50) encode as ordered `image` parts after the text part — the
+ * rc.2 `session.prompt` content is parts-shaped at this seam.
  */
 export declare function promptSession(dsh: DshApiProxyFace, request: {
     sessionId: string;
     prompt: string;
+    images?: ReadonlyArray<{
+        mediaType: string;
+        base64: string;
+    }>;
 }, options?: ApiProxyFaceOptions & {
     rpcId?: string;
 }): Promise<PromptOutcome>;

package/lib/dsh/api-proxy-face.js

@@ -174,6 +174,8 @@ export async function readWorkspaceDetail(dsh, reference, options = {}) {
  * the turn may or may not have been admitted, so callers must not resubmit.
  * `options.rpcId` pins the adapter-owned stable request id, which the Host
  * records on the durable `user/message` (`source.rpcId`) for reconciliation.
+ * Images (16.50) encode as ordered `image` parts after the text part — the
+ * rc.2 `session.prompt` content is parts-shaped at this seam.
  */
 export async function promptSession(dsh, request, options = {}) {
     return submitPromptTurn(dsh, { ...request, mode: 'queue' }, options);
@@ -193,7 +195,10 @@ async function submitPromptTurn(dsh, request, options) {
         response = await withRpcTimeout(dsh.sessions.prompt(mintRequest({
             sessionId: request.sessionId,
             mode: request.mode,
-            content: [{ type: 'text', text: request.prompt }],
+            content: [
+                { type: 'text', text: request.prompt },
+                ...(request.images ?? []).map(image => ({ type: 'image', mediaType: image.mediaType, data: image.base64 })),
+            ],
         }, options.rpcId)), timeoutMs);
     }
     catch (cause) {

package/lib/features/image-collection.d.ts

@@ -37,10 +37,21 @@ export interface ImageAttachment {
     declaredSize: number;
     contentType: string;
 }
+/**
+ * The production download port (16.50): every fetch rides the safe boundary
+ * — allowlisted Discord CDN hosts over HTTPS, one revalidated redirect hop,
+ * supported media types only.
+ */
+export declare function createSafeImageDownloadPort(): ImageDownloadPort;
 export type ImageCollectionResult = {
     outcome: 'collected';
     images: number;
     totalBytes: number;
+    /** The downloaded images in attachment order (16.50): callers encode them for submission. */
+    downloaded: ReadonlyArray<{
+        mediaType: string;
+        body: Uint8Array;
+    }>;
 } | {
     outcome: 'too-large';
     reason: 'declared' | 'actual' | 'aggregate';

package/lib/features/image-collection.js

@@ -8,10 +8,22 @@
  * bounded in practice by Discord CDN attachment limits and the aggregate
  * cap, not by streaming. Refusals are plain values.
  */
+import { createHttpFetchPort, fetchSafeImage } from './image-download.js';
 /** Per-image cap (design: bounded by DSH-advertised limits; adapter-capped). */
 export const MAX_IMAGE_BYTES = 8 * 1_024 * 1_024;
 /** Aggregate cap across all images of one message. */
 export const MAX_AGGREGATE_IMAGE_BYTES = 24 * 1_024 * 1_024;
+/**
+ * The production download port (16.50): every fetch rides the safe boundary
+ * — allowlisted Discord CDN hosts over HTTPS, one revalidated redirect hop,
+ * supported media types only.
+ */
+export function createSafeImageDownloadPort() {
+    const http = createHttpFetchPort();
+    return {
+        download: request => fetchSafeImage(http, { url: request.url }),
+    };
+}
 /**
  * Wrap the safe download boundary with byte-count enforcement: the body size
  * is checked against the remaining aggregate budget before it is accepted,
@@ -35,6 +47,7 @@ export function collectImages(port, request) {
     let remainingAggregate = MAX_AGGREGATE_IMAGE_BYTES;
     let images = 0;
     let totalBytes = 0;
+    const downloaded = [];
     const inner = port;
     async function run() {
         for (const attachment of request.attachments) {
@@ -50,30 +63,31 @@ export function collectImages(port, request) {
             const timeout = new Promise((resolve) => {
                 timer = setTimeout(() => { resolve('timeout'); }, request.timeoutMs);
             });
-            const downloaded = await Promise.race([
+            const downloadedImage = await Promise.race([
                 bounded.download({ url: attachment.url }).then((result) => result),
                 timeout,
             ]).finally(() => {
                 if (timer !== undefined)
                     clearTimeout(timer);
             });
-            if (downloaded === 'timeout')
+            if (downloadedImage === 'timeout')
                 return { outcome: 'timeout' };
-            if (downloaded.outcome === 'downloaded') {
-                if (downloaded.body.byteLength > MAX_IMAGE_BYTES) {
+            if (downloadedImage.outcome === 'downloaded') {
+                if (downloadedImage.body.byteLength > MAX_IMAGE_BYTES) {
                     return { outcome: 'too-large', reason: 'actual' };
                 }
                 images += 1;
-                totalBytes += downloaded.body.byteLength;
-                remainingAggregate -= downloaded.body.byteLength;
+                totalBytes += downloadedImage.body.byteLength;
+                remainingAggregate -= downloadedImage.body.byteLength;
+                downloaded.push({ mediaType: downloadedImage.mediaType, body: downloadedImage.body });
                 continue;
             }
-            if (downloaded.outcome === 'http-error' && downloaded.status === 413) {
+            if (downloadedImage.outcome === 'http-error' && downloadedImage.status === 413) {
                 return { outcome: 'too-large', reason: 'actual' };
             }
             return { outcome: 'download-failed' };
         }
-        return { outcome: 'collected', images, totalBytes };
+        return { outcome: 'collected', images, totalBytes, downloaded };
     }
     return run();
 }

package/lib/features/image-download.d.ts

@@ -46,3 +46,9 @@ export type SafeImageResult = {
 export declare function fetchSafeImage(port: HttpFetchPort, request: {
     url: string;
 }): Promise<SafeImageResult>;
+/**
+ * The production fetch boundary over the platform `fetch` (16.50). Redirects
+ * are NOT followed here — `fetchSafeImage` revalidates every hop itself —
+ * and the body is only read for a terminal 200 response.
+ */
+export declare function createHttpFetchPort(): HttpFetchPort;

package/lib/features/image-download.js

@@ -75,3 +75,24 @@ function isParseable(rawUrl) {
 export function fetchSafeImage(port, request) {
     return fetchOnce(port, MAX_REDIRECTS, request);
 }
+/**
+ * The production fetch boundary over the platform `fetch` (16.50). Redirects
+ * are NOT followed here — `fetchSafeImage` revalidates every hop itself —
+ * and the body is only read for a terminal 200 response.
+ */
+export function createHttpFetchPort() {
+    return {
+        async fetch(url) {
+            const response = await fetch(url, { redirect: 'manual' });
+            const location = response.headers.get('location');
+            const contentType = response.headers.get('content-type');
+            const body = response.status === 200 ? new Uint8Array(await response.arrayBuffer()) : undefined;
+            return {
+                status: response.status,
+                contentType: contentType ?? undefined,
+                location: location ?? undefined,
+                body,
+            };
+        },
+    };
+}

package/lib/features/prompt-submission.d.ts

@@ -15,6 +15,8 @@ export interface DshPromptPort {
         sessionId: string;
         prompt: string;
         mode: 'queue';
+        /** Collected images (16.50); omitted for text-only prompts so legacy shapes are untouched. */
+        images?: ReadonlyArray<PromptRequestImage>;
     }): Promise<{
         outcome: 'accepted';
     } | {
@@ -24,6 +26,11 @@ export interface DshPromptPort {
         outcome: 'unknown';
     }>;
 }
+/** One collected image, ready for the prompt parts encoding. */
+export interface PromptRequestImage {
+    mediaType: string;
+    base64: string;
+}
 export interface PromptSubmissionDeps {
     prompts: DshPromptPort;
     intents: IntentStore;
@@ -44,6 +51,8 @@ export interface PromptRequest {
     requestId: string;
     sessionId: string;
     prompt: string;
+    /** Collected images (16.50); omitted for text-only prompts. */
+    images?: ReadonlyArray<PromptRequestImage>;
 }
 export declare function createPromptSubmissionFlow(deps: PromptSubmissionDeps): {
     submitOnce(request: PromptRequest): Promise<PromptSubmissionResult>;

package/lib/features/prompt-submission.js

@@ -10,7 +10,12 @@
 import { hashPayload } from '../state/intents.js';
 export function createPromptSubmissionFlow(deps) {
     async function submit(requestId, request) {
-        const contentHash = await hashPayload({ sessionId: request.sessionId, prompt: request.prompt });
+        const images = request.images ?? [];
+        const contentHash = await hashPayload({
+            sessionId: request.sessionId,
+            prompt: request.prompt,
+            ...(images.length > 0 ? { images } : {}),
+        });
         const claim = await deps.intents.claim({
             messageId: requestId,
             contentHash,
@@ -26,6 +31,7 @@ export function createPromptSubmissionFlow(deps) {
             sessionId: request.sessionId,
             prompt: request.prompt,
             mode: 'queue',
+            ...(images.length > 0 ? { images } : {}),
         });
         if (submitted.outcome === 'accepted') {
             await deps.intents.resolve(requestId, 'succeeded', deps.nowMs());

package/lib/features/session-mainline.d.ts

@@ -9,13 +9,44 @@
  */
 import type { createThreadCreationFlow } from './thread-creation.js';
 import type { createSessionCreationFlow } from './session-creation.js';
-import type { createPromptSubmissionFlow } from './prompt-submission.js';
+import type { createPromptSubmissionFlow, PromptRequestImage } from './prompt-submission.js';
 import type { TurnTracker } from './turn-ownership.js';
+/** Declared image metadata as carried on the normalized wire message. */
+export interface MainlineWireImage {
+    url: string;
+    filename: string;
+    declaredSize: number;
+    contentType: string;
+}
+/** One collected image, ready for submission. */
+export type MainlineImage = PromptRequestImage;
+/**
+ * The bounded collection boundary (design.md §12, 16.50): declared wire
+ * metadata goes in, base64-encoded images come out. The composition root
+ * implements it over the safe-download boundary — this layer never touches
+ * the network itself.
+ */
+export interface MainlineImageCollector {
+    collect(request: {
+        attachments: ReadonlyArray<{
+            url: string;
+            declaredSize: number;
+            contentType: string;
+        }>;
+    }): Promise<{
+        outcome: 'collected';
+        images: ReadonlyArray<MainlineImage>;
+    } | {
+        outcome: 'failed';
+        reason: string;
+    }>;
+}
 export interface SessionMainlineDeps {
     threads: ReturnType<typeof createThreadCreationFlow>;
     sessions: ReturnType<typeof createSessionCreationFlow>;
     prompts: ReturnType<typeof createPromptSubmissionFlow>;
     turns: TurnTracker;
+    images: MainlineImageCollector;
 }
 export type MentionMainlineResult = {
     outcome: 'admitted';
@@ -33,6 +64,9 @@ export type MentionMainlineResult = {
     outcome: 'prompt-rejected';
 } | {
     outcome: 'prompt-unknown';
+} | {
+    outcome: 'image-failed';
+    reason: string;
 };
 export interface MentionMainlineRequest {
     applicationId: string;
@@ -43,6 +77,8 @@ export interface MentionMainlineRequest {
     authorId: string;
     workspaceId: string;
     prompt: string;
+    /** Declared image attachments (16.50); omitted for text-only mentions. */
+    images?: ReadonlyArray<MainlineWireImage>;
 }
 export type ContinuationMainlineResult = {
     outcome: 'queued';
@@ -54,6 +90,9 @@ export type ContinuationMainlineResult = {
     outcome: 'rejected';
 } | {
     outcome: 'unknown';
+} | {
+    outcome: 'image-failed';
+    reason: string;
 };
 export interface ContinuationMainlineRequest {
     applicationId: string;
@@ -62,6 +101,8 @@ export interface ContinuationMainlineRequest {
     sessionId: string;
     messageId: string;
     prompt: string;
+    /** Declared image attachments (16.50); omitted for text-only messages. */
+    images?: ReadonlyArray<MainlineWireImage>;
 }
 /**
  * The stable, adapter-owned request id for a submitted prompt: derived from

package/lib/features/session-mainline.js

@@ -30,17 +30,38 @@ function mapSubmission(result) {
         return { outcome: 'conflict' };
     return result.outcome === 'rejected' ? { outcome: 'rejected' } : { outcome: 'unknown' };
 }
+/**
+ * Collect the request's declared images through the bounded boundary. A
+ * text-only request never touches the collector; a failed collection is a
+ * first-class outcome so no degraded text-only submission is sent silently.
+ */
+async function collectRequestImages(deps, images) {
+    if (images.length === 0)
+        return { outcome: 'collected', images: [] };
+    const collected = await deps.images.collect({
+        attachments: images.map(({ url, declaredSize, contentType }) => ({ url, declaredSize, contentType })),
+    });
+    if (collected.outcome !== 'collected')
+        return { outcome: 'image-failed', reason: collected.reason };
+    return collected;
+}
 export function createSessionMainline(deps) {
     return {
         async admitMention(request) {
+            const declaredImages = request.images ?? [];
+            const images = await collectRequestImages(deps, declaredImages);
+            if (images.outcome !== 'collected')
+                return images;
             // The source message id is the durable intent: one thread per message,
-            // deterministic recovery on redelivery (design.md §4, §10).
+            // deterministic recovery on redelivery (design.md §4, §10). An
+            // image-only mention names the thread after its first image's filename.
+            const title = request.prompt !== '' ? request.prompt : (declaredImages[0]?.filename ?? '');
             const thread = await deps.threads.ensureThread({
                 sourceMessageId: request.messageId,
-                contentHash: await hashPayload({ prompt: request.prompt }),
+                contentHash: await hashPayload({ prompt: request.prompt, images: declaredImages }),
                 guildId: request.guildId,
                 parentChannelId: request.channelId,
-                threadName: safeTitle(request.prompt),
+                threadName: safeTitle(title),
                 creatorUserId: request.authorId,
             });
             if (thread.outcome === 'conflict')
@@ -66,6 +87,7 @@ export function createSessionMainline(deps) {
                 requestId,
                 sessionId,
                 prompt: request.prompt,
+                ...(images.images.length > 0 ? { images: images.images } : {}),
             });
             if (submitted.outcome === 'accepted') {
                 ownTurn(deps, { sessionId, requestId, threadId });
@@ -81,11 +103,15 @@ export function createSessionMainline(deps) {
             return submitted.outcome === 'rejected' ? { outcome: 'prompt-rejected' } : { outcome: 'prompt-unknown' };
         },
         async continueInThread(request) {
+            const images = await collectRequestImages(deps, request.images ?? []);
+            if (images.outcome !== 'collected')
+                return images;
             const requestId = requestIdFor(request.messageId);
             const submitted = await deps.prompts.submitOnce({
                 requestId,
                 sessionId: request.sessionId,
                 prompt: request.prompt,
+                ...(images.images.length > 0 ? { images: images.images } : {}),
             });
             if (submitted.outcome === 'accepted') {
                 ownTurn(deps, { sessionId: request.sessionId, requestId, threadId: request.threadId });

package/lib/gateway/inbound.d.ts

@@ -40,6 +40,20 @@ export interface NormalizedMessage {
     mentionedBot: boolean;
     /** The snowflake of the message this one replies to, when present and valid. */
     repliedToId: DiscordSnowflake | undefined;
+    /**
+     * DECLARED image-attachment metadata (16.50): supported types only,
+     * malformed entries skipped, capped at Discord's per-message limit. No
+     * bytes cross this boundary — download happens later, behind the
+     * allowlisted fetch boundary.
+     */
+    images: DiscordImageAttachment[];
+}
+/** One supported image attachment, as declared by the wire. */
+export interface DiscordImageAttachment {
+    url: string;
+    filename: string;
+    declaredSize: number;
+    contentType: string;
 }
 /** A validated guild interaction with its actor identity. */
 export interface NormalizedInteraction {

package/lib/gateway/inbound.js

@@ -40,6 +40,46 @@ function extractRoleIds(payload) {
 function asSnowflake(value) {
     return isDiscordSnowflake(value) ? value : undefined;
 }
+/** Image content types the adapter carries (design.md §12). */
+const SUPPORTED_IMAGE_TYPES = new Set([
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/gif',
+]);
+/** Discord's per-message attachment cap; a defensive bound on untrusted input. */
+const MAX_MESSAGE_IMAGES = 10;
+/**
+ * Narrow untrusted `attachments` onto declared image metadata. Entries that
+ * are not records, lack any required field, or declare an unsupported media
+ * type are skipped — a malformed attachment never rejects the message.
+ */
+function extractImages(payload) {
+    const raw = payload['attachments'];
+    if (!Array.isArray(raw))
+        return [];
+    const images = [];
+    for (const entry of raw) {
+        if (images.length >= MAX_MESSAGE_IMAGES)
+            break;
+        if (!isRecord(entry))
+            continue;
+        const url = entry['url'];
+        const filename = entry['filename'];
+        const size = entry['size'];
+        const contentType = entry['content_type'];
+        if (typeof url !== 'string' || url === '')
+            continue;
+        if (typeof filename !== 'string' || filename === '')
+            continue;
+        if (typeof size !== 'number' || !Number.isFinite(size) || size < 0)
+            continue;
+        if (typeof contentType !== 'string' || !SUPPORTED_IMAGE_TYPES.has(contentType))
+            continue;
+        images.push({ url, filename, declaredSize: size, contentType });
+    }
+    return images;
+}
 function parseMessage(payload, selfUserId) {
     // Webhook-authored messages are app-driven surfaces, not member input:
     // their author object need not carry `bot: true`, and anyone with
@@ -93,6 +133,7 @@ function parseMessage(payload, selfUserId) {
             content: stripped.text,
             mentionedBot: stripped.mentioned,
             repliedToId,
+            images: extractImages(payload),
         },
     };
 }

package/lib/i18n.d.ts

@@ -78,6 +78,7 @@ declare const zh: {
     mainlineSessionRejected: string;
     mainlineSessionUnknown: string;
     mainlinePromptRejected: string;
+    mainlineImageFailed: string;
     mainlinePromptUnknown: string;
     continuationRejected: string;
     continuationUnknown: string;

package/lib/i18n.js

@@ -84,6 +84,7 @@ const zh = {
     mainlineSessionRejected: '⚠️ DSH 拒绝了会话创建（工作区可能已失效）；请稍后重试或重新 /project bind。',
     mainlineSessionUnknown: '⚠️ 会话创建结果未知；请到 DSH Web 确认后再重试，不会自动重复创建。',
     mainlinePromptRejected: '⚠️ DSH 拒绝了任务提交。',
+    mainlineImageFailed: '⚠️ 附件图片获取失败，任务未提交；请重试或改用文字描述。',
     mainlinePromptUnknown: '⚠️ 任务提交结果未知；为避免重复执行不会自动重发，请确认后重试。',
     continuationRejected: '⚠️ 消息提交被 DSH 拒绝。',
     continuationUnknown: '⚠️ 消息提交结果未知；不会自动重发，请确认后重试。',
@@ -207,6 +208,7 @@ const en = {
     mainlineSessionRejected: '⚠️ DSH rejected the session creation (the workspace may be stale); try again later or re-run /project bind.',
     mainlineSessionUnknown: '⚠️ Session creation outcome unknown; confirm on the DSH web console before retrying. It will not be resubmitted automatically.',
     mainlinePromptRejected: '⚠️ DSH rejected the task submission.',
+    mainlineImageFailed: '⚠️ Could not fetch the attached image(s); the task was not submitted. Retry or describe it in text.',
     mainlinePromptUnknown: '⚠️ Task submission outcome unknown; it will not be resent automatically to avoid double execution. Confirm and retry.',
     continuationRejected: '⚠️ The message submission was rejected by DSH.',
     continuationUnknown: '⚠️ Message submission outcome unknown; it will not be resent automatically. Confirm and retry.',

package/lib/index.js

@@ -31,6 +31,7 @@ import { createSessionCreationFlow } from './features/session-creation.js';
 import { createResumeCandidatesPort } from './features/session-resume.js';
 import { createPromptSubmissionFlow } from './features/prompt-submission.js';
 import { createSessionMainline, requestIdFor } from './features/session-mainline.js';
+import { collectImages, createSafeImageDownloadPort } from './features/image-collection.js';
 import { startLiveRender } from './stream/live.js';
 import { planWorkspaceChannel, workspaceChannelName } from './features/workspace-channel.js';
 /** Stable Cordis plugin name for diagnostics. */
@@ -286,7 +287,37 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             createSession: request => createSessionViaProxy(apiProxy, request, { log: rpcLog }),
         };
         const dshPromptPort = {
-            submit: request => promptSession(apiProxy, { sessionId: request.sessionId, prompt: request.prompt }, { log: rpcLog, rpcId: request.requestId }),
+            submit: request => promptSession(apiProxy, {
+                sessionId: request.sessionId,
+                prompt: request.prompt,
+                ...(request.images === undefined ? {} : { images: request.images }),
+            }, { log: rpcLog, rpcId: request.requestId }),
+        };
+        /**
+         * The bounded image collection boundary (16.50): downloads ride the
+         * safe-download port (allowlisted CDN hosts, capped sizes, timeout) and
+         * come back base64-encoded for the prompt parts.
+         */
+        const IMAGE_DOWNLOAD_TIMEOUT_MS = 15_000;
+        const imageCollector = {
+            collect: async ({ attachments }) => {
+                const result = await collectImages(createSafeImageDownloadPort(), {
+                    nowMs: Date.now(),
+                    timeoutMs: IMAGE_DOWNLOAD_TIMEOUT_MS,
+                    attachments,
+                });
+                if (result.outcome !== 'collected') {
+                    const reason = result.outcome === 'too-large' ? `too-large:${result.reason}` : result.outcome;
+                    return { outcome: 'failed', reason };
+                }
+                return {
+                    outcome: 'collected',
+                    images: result.downloaded.map(image => ({
+                        mediaType: image.mediaType,
+                        base64: Buffer.from(image.body).toString('base64'),
+                    })),
+                };
+            },
         };
         const composedMainline = createSessionMainline({
             threads: createThreadCreationFlow({
@@ -305,6 +336,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 nowMs: () => Date.now(),
             }),
             turns: turnTracker,
+            images: imageCollector,
         });
         /** Mainline outcome → copy key; the string resolves live per language. */
         const MAINLINE_FAILURE_KEYS = {
@@ -314,6 +346,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             'session-unknown': 'mainlineSessionUnknown',
             'prompt-rejected': 'mainlinePromptRejected',
             'prompt-unknown': 'mainlinePromptUnknown',
+            'image-failed': 'mainlineImageFailed',
         };
         const mainline = {
             admitMention: async (request) => {
@@ -334,9 +367,13 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             },
             continueInThread: async (request) => {
                 const result = await composedMainline.continueInThread(request);
-                if (result.outcome === 'rejected' || result.outcome === 'unknown') {
+                if (result.outcome === 'rejected' || result.outcome === 'unknown' || result.outcome === 'image-failed') {
                     rpcLog('discord_continuation_not_queued', { messageId: request.messageId, outcome: result.outcome });
-                    const notice = result.outcome === 'rejected' ? copy.continuationRejected : copy.continuationUnknown;
+                    const notice = result.outcome === 'rejected'
+                        ? copy.continuationRejected
+                        : result.outcome === 'image-failed'
+                            ? copy.mainlineImageFailed
+                            : copy.continuationUnknown;
                     void withRest(rest => rest.request('POST', `/channels/${request.threadId}/messages`, { content: notice, flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, allowed_mentions: ALLOWED_MENTIONS_NONE }))
                         .catch((cause) => { rpcLog('discord_mainline_notice_failed', String(cause)); });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addozhang/dsh-discord",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Discord-first adapter for DeepSeek Harness",
   "license": "MIT",
   "type": "module",

package/lib/features/image-submission.d.ts

@@ -1,67 +0,0 @@
-/**
- * Image submission through `session.prompt` (design.md §12, task 12.3).
- * Mixed text/images encode into ordered prompt parts; the model's modality
- * is checked BEFORE any DSH call; and the request id claims an intent so a
- * duplicate Discord delivery never resubmits. Host outcomes map to values
- * with the intent state kept honest (failed on rejection, unknown preserved
- * for reconciliation).
- */
-import { type IntentStore } from '../state/intents.js';
-export type PromptPart = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'image';
-    mediaType: string;
-    data: string;
-};
-export interface DshImagePromptPort {
-    submit(request: {
-        requestId: string;
-        sessionId: string;
-        parts: readonly PromptPart[];
-    }): Promise<{
-        outcome: 'accepted';
-    } | {
-        outcome: 'rejected';
-    } | {
-        outcome: 'unknown';
-    }>;
-}
-export interface ImageSubmissionDeps {
-    prompts: DshImagePromptPort;
-    intents: IntentStore;
-    /** Whether the session's current model accepts image parts. */
-    modality: () => boolean;
-    nowMs: () => number;
-}
-export type ImageSubmissionResult = {
-    outcome: 'accepted';
-} | {
-    outcome: 'rejected';
-} | {
-    outcome: 'unknown';
-} | {
-    outcome: 'already-submitted';
-} | {
-    outcome: 'conflict';
-} | {
-    outcome: 'refused';
-    reason: 'unsupported-modality';
-};
-/** Encode text plus images into ordered prompt parts. */
-export declare function encodePromptParts(text: string, images: ReadonlyArray<{
-    mediaType: string;
-    base64: string;
-}>): PromptPart[];
-export declare function createImageSubmissionFlow(deps: ImageSubmissionDeps): {
-    submit(request: {
-        requestId: string;
-        sessionId: string;
-        text: string;
-        images: ReadonlyArray<{
-            mediaType: string;
-            base64: string;
-        }>;
-    }): Promise<ImageSubmissionResult>;
-};

package/lib/features/image-submission.js

@@ -1,57 +0,0 @@
-/**
- * Image submission through `session.prompt` (design.md §12, task 12.3).
- * Mixed text/images encode into ordered prompt parts; the model's modality
- * is checked BEFORE any DSH call; and the request id claims an intent so a
- * duplicate Discord delivery never resubmits. Host outcomes map to values
- * with the intent state kept honest (failed on rejection, unknown preserved
- * for reconciliation).
- */
-import { hashPayload } from '../state/intents.js';
-/** Encode text plus images into ordered prompt parts. */
-export function encodePromptParts(text, images) {
-    const parts = [];
-    const trimmed = text.trim();
-    if (trimmed !== '')
-        parts.push({ type: 'text', text: trimmed });
-    for (const image of images) {
-        parts.push({ type: 'image', mediaType: image.mediaType, data: image.base64 });
-    }
-    return parts;
-}
-export function createImageSubmissionFlow(deps) {
-    return {
-        async submit(request) {
-            const parts = encodePromptParts(request.text, request.images);
-            // Modality gate: refuse BEFORE the intent claim so an explicit user
-            // retry with a text-only message is a clean new attempt.
-            if (request.images.length > 0 && !deps.modality()) {
-                return { outcome: 'refused', reason: 'unsupported-modality' };
-            }
-            const contentHash = await hashPayload({ sessionId: request.sessionId, parts });
-            const claim = await deps.intents.claim({
-                messageId: request.requestId,
-                contentHash,
-                claimedAtMs: deps.nowMs(),
-            });
-            if (claim.outcome === 'conflict')
-                return { outcome: 'conflict' };
-            if (claim.outcome === 'duplicate')
-                return { outcome: 'already-submitted' };
-            const submitted = await deps.prompts.submit({
-                requestId: request.requestId,
-                sessionId: request.sessionId,
-                parts,
-            });
-            if (submitted.outcome === 'accepted') {
-                await deps.intents.resolve(request.requestId, 'succeeded', deps.nowMs());
-                return { outcome: 'accepted' };
-            }
-            if (submitted.outcome === 'rejected') {
-                await deps.intents.resolve(request.requestId, 'failed', deps.nowMs());
-                return { outcome: 'rejected' };
-            }
-            await deps.intents.resolve(request.requestId, 'unknown', deps.nowMs());
-            return { outcome: 'unknown' };
-        },
-    };
-}