@addozhang/dsh-discord 0.3.0 → 0.5.0-alpha.1

package/lib/features/adapter-status.js

@@ -95,9 +95,105 @@ export function createAdapterManagementHandler(deps) {
         return Promise.resolve({ ok: false, error: { code: 'bad-request', message: `Unknown ${DISCORD_RPC_CHANNEL} endpoint.` } });
     };
 }
-/** Register the management channel; returns the connection service's disposer. */
-export function installAdapterStatusRpc(connection, tracker, deps = { tracker }) {
-    return connection.rpc.handle(DISCORD_RPC_CHANNEL, createAdapterManagementHandler(deps), {
-        authority: 'loopback',
+function readBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on('data', chunk => { chunks.push(chunk); });
+        request.on('end', () => { resolve(Buffer.concat(chunks).toString('utf8')); });
+        request.on('error', reject);
     });
 }
+/** The endpoint segment path under the channel, validated like the host's. */
+function endpointOf(channel, url) {
+    const pathname = url === undefined ? '' : url.split('?')[0] ?? '';
+    if (!pathname.startsWith(`${channel}/`))
+        return undefined;
+    const endpoint = pathname.slice(channel.length + 1);
+    const valid = endpoint.split('/').every(segment => segment !== '' && segment !== '.' && segment !== '..' && /^[A-Za-z0-9_$.-]+$/.test(segment));
+    return valid ? endpoint : undefined;
+}
+function respondEnvelope(response, rpcId, result) {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+}
+function badRequest(response, rpcId, message) {
+    respondEnvelope(response, rpcId, { ok: false, error: { code: 'gateway/bad-request', message, details: { issues: [] } } });
+}
+/**
+ * Serve one channel request: the connection service's fence first (the
+ * browser-auth + trusted-host verdict), then the host's channel wire
+ * protocol — POST + JSON `client-request` envelope whose method must match
+ * the endpoint, answered with a `server-response` envelope.
+ */
+async function serveChannel(connection, handler, request, response) {
+    const rejection = connection.requestRejection(request);
+    if (rejection !== undefined) {
+        response.writeHead(rejection);
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointOf(DISCORD_RPC_CHANNEL, request.url);
+    if (request.method !== 'POST' || endpoint === undefined) {
+        response.writeHead(404);
+        response.end('not found');
+        return;
+    }
+    const contentType = request.headers['content-type'];
+    const contentTypeText = (Array.isArray(contentType) ? contentType[0] : contentType)?.split(';', 1)[0]?.trim().toLowerCase();
+    if (contentTypeText !== 'application/json') {
+        response.writeHead(415);
+        response.end('content type must be application/json');
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(await readBody(request));
+    }
+    catch {
+        response.writeHead(400);
+        response.end('body is not JSON');
+        return;
+    }
+    const message = body;
+    const rpcId = typeof message.rpcId === 'string' ? message.rpcId : '';
+    if (message.type !== 'client-request' || rpcId === '' || typeof message.method !== 'string'
+        || typeof message.payload !== 'object' || message.payload === null || Array.isArray(message.payload)) {
+        badRequest(response, rpcId, 'invalid client-request message');
+        return;
+    }
+    if (message.method !== endpoint) {
+        badRequest(response, rpcId, `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`);
+        return;
+    }
+    try {
+        const result = await handler(endpoint, message.payload, undefined);
+        respondEnvelope(response, rpcId, result);
+    }
+    catch (cause) {
+        response.writeHead(500);
+        response.end(`handler failure: ${String(cause)}`);
+    }
+}
+/**
+ * Register the management channel on the webServer through the plugin's own
+ * context effect. The 0.1.6 host's `connection.rpc.handle` mounts through
+ * the connection service's OWN inject scope — an external plugin's call is
+ * rejected ("cannot get property webServer without inject") and a runtime
+ * ctx.inject wrapper never fires on an already-started plugin, so the
+ * sanctioned shape is: our prefix route, the connection service's fence
+ * method, and the channel envelope replicated verbatim.
+ */
+export function installAdapterStatusRpc(ctx, tracker, deps = { tracker }) {
+    const connection = ctx.get('connection');
+    const webServer = ctx.get('webServer');
+    const handler = createAdapterManagementHandler(deps);
+    const disposer = ctx.effect(() => webServer.register({
+        kind: 'prefix',
+        path: DISCORD_RPC_CHANNEL,
+        handler: (request, response) => serveChannel(connection, handler, request, response),
+    }), 'dsh-discord management channel');
+    return () => {
+        if (typeof disposer === 'function')
+            disposer();
+    };
+}

package/lib/features/approval-store.d.ts

@@ -68,7 +68,7 @@ export interface ApprovalClick {
 }
 export type ApprovalDecision = {
     allowed: true;
-    /** Respond data built solely from the record, for apiProxy.respond. */
+    /** Respond data built solely from the record, for the settle port. */
     respond: {
         rpcId: string;
         sessionId: string;

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/interaction-router.d.ts

@@ -11,7 +11,7 @@ import type { SharedRestClient } from '../discord/rest.js';
 import { type PolicyTable } from '../policy/authorization.js';
 import { type ProjectListPort } from './project-list.js';
 import type { WorkspaceResolver } from './project-bind.js';
-import type { CancelOutcome, PromptOutcome, QueueRemoveOutcome, WorkspaceDetailOutcome } from '../dsh/api-proxy-face.js';
+import type { CancelOutcome, PromptOutcome, QueueRemoveOutcome, WorkspaceDetailOutcome } from '../dsh/host-face.js';
 import type { TurnTracker } from './turn-ownership.js';
 import { type DshApprovalRespondPort } from './approval-routing.js';
 import { type DshModelPort } from './model-control.js';
@@ -20,7 +20,7 @@ import type { ApprovalStore } from './approval-store.js';
 import type { ChannelBinding } from '../state/records.js';
 import type { NormalizedInteraction } from '../gateway/inbound.js';
 import type { CopyTable } from '../i18n.js';
-/** The DSH faces the control commands submit through (apiProxy-backed). */
+/** The DSH faces the control commands submit through (host-face-backed). */
 export interface InteractionDshFace {
     cancel(sessionId: string): Promise<CancelOutcome>;
     steer(sessionId: string, prompt: string): Promise<PromptOutcome>;

package/lib/features/model-control.d.ts

@@ -11,7 +11,7 @@
  * any mutation.
  */
 import type { AccessDecision } from '../policy/authorization.js';
-import type { ModelSelectionShape, SessionModelsShape } from '../dsh/api-proxy-face.js';
+import type { ModelSelectionShape, SessionModelsShape } from '../dsh/host-face.js';
 export interface DshModelPort {
     models(sessionId: string): Promise<{
         outcome: 'completed';

package/lib/features/project-list.d.ts

@@ -1,6 +1,6 @@
 /**
  * `/project list` discovery (design.md §3, §13). The feature talks to DSH
- * through one narrow port (satisfied by the apiProxy adapter in production,
+ * through one narrow port (satisfied by the host-face adapter in production,
  * by fakes in tests): every registered Workspace is selectable, labels come
  * from the least-disclosure policy (safe titles, opaque `ws:` references,
  * duplicate disambiguation); per amended design §3 the bind autocomplete

package/lib/features/project-list.js

@@ -1,6 +1,6 @@
 /**
  * `/project list` discovery (design.md §3, §13). The feature talks to DSH
- * through one narrow port (satisfied by the apiProxy adapter in production,
+ * through one narrow port (satisfied by the host-face adapter in production,
  * by fakes in tests): every registered Workspace is selectable, labels come
  * from the least-disclosure policy (safe titles, opaque `ws:` references,
  * duplicate disambiguation); per amended design §3 the bind autocomplete

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/features/session-resume.d.ts

@@ -6,7 +6,7 @@
  * title/id substring, and sort newest-first — Discord autocomplete caps at
  * 25 choices, the caller slices.
  */
-import type { SessionResumeRow } from '../dsh/api-proxy-face.js';
+import type { SessionResumeRow } from '../dsh/host-face.js';
 export type { SessionResumeRow };
 import type { CopyTable } from '../i18n.js';
 import { type SelectorOption } from '../discord/selector.js';

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.',