dsh-any-deepseek 0.0.7 → 0.0.9

package/lib/adapter.d.ts

@@ -27,12 +27,51 @@ import { LlmAdapter } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, PreparedAdapterCall, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { type Api, type AssistantMessage, type AssistantMessageEvent, type Context as PiContext, type Model } from '@earendil-works/pi-ai';
+import { type ChannelModality } from './presets.js';
 import type { ResolvedChannel } from './channels.js';
 import type { LedgerEntry } from './usage-ledger.js';
 /** The single provider route this plugin owns. */
 export declare const PROVIDER_ID = "any-deepseek";
 /** Display name for the route in provider selectors. */
 export declare const PROVIDER_NAME = "Any DeepSeek";
+/**
+ * Input modalities this provider's one model accepts.
+ *
+ * 🔴 **Declared at registration, because the harness asks the model — not the channel.**
+ *
+ * `LlmModelInfo.inputModalities` is documented as "absent means unknown" (`dsh-llm/lib/types/
+ * types.d.ts:330-331`), and the host reads it at dispatch to decide whether an image survives
+ * projection at all: `if (modelInfo.inputModalities !== undefined &&
+ * !modelInfo.inputModalities.includes('image') && …) projectImagesForTextModel(…)`
+ * (`dsh-llm/lib/index.js:2337`). Omitting it therefore did not mean "we never send images"; it
+ * meant a user's screenshot was replaced by a placeholder *before* this plugin ever saw it, which
+ * is why the model answered as though the message had been text.
+ *
+ * The value is the MODEL's capability, so it does not depend on which channel is selected, on
+ * whether a key exists, or on whether `current` is set — the same rule as the catalog itself.
+ * A relay that genuinely cannot carry images declares `input: ['text']` on its own channel, and
+ * the transport (`pi-ai`) downgrades the image per channel; the harness-level answer stays the
+ * model's.
+ */
+export declare const MODEL_INPUT_MODALITIES: readonly ChannelModality[];
+/**
+ * The reasoning levels in force for one channel.
+ *
+ * 🔴 **A channel that says nothing inherits the model's table, and that is the whole fix for the
+ * missing thinking control.**
+ *
+ * The old code read `channel.reasoningEfforts` alone. That value only existed once a channel
+ * declared it — so during first-run setup (no channel, or a channel written before the panel
+ * offered levels) the answer was "no reasoning at all", and the composer's strength selector was
+ * absent. But the model always had levels; the CHANNEL was merely silent about them.
+ *
+ * An empty map counts as silence, not as "explicitly unsupported": `z.dict()` produces `{}` when
+ * the panel writes the field, and treating that as a negative capability is how the picker broke
+ * with `INVALID_MODEL_REASONING` in the first place.
+ * @param channel - the selected channel, when there is one.
+ * @returns the levels to advertise and to send, keyed by level name.
+ */
+export declare function effectiveReasoningEfforts(channel: ResolvedChannel | undefined): Record<string, string | null>;
 /** What the adapter needs from the plugin, so it can be tested without a harness context. */
 export interface AdapterDeps {
     /** Enabled, resolved channels in configuration order. */
@@ -48,17 +87,73 @@ export interface AdapterDeps {
     resolveKey: (ref: string) => Promise<string | undefined>;
     /** Record one finished request. Must never throw. */
     record: (entry: LedgerEntry) => Promise<void>;
+    /**
+     * Read one image's request bytes from the durable attachment store.
+     *
+     * 🔴 Optional, and its absence is a real state (a composition without the attachment service).
+     * An `ImageBlock` in the harness carries only an `attachmentId` — never bytes — so without this
+     * seam an image cannot be sent at all. When it is missing, image content is replaced by a text
+     * placeholder rather than silently dropped: the model should know an image existed even when it
+     * cannot see it.
+     * @param ref - the block's attachment reference, passed through WHOLE.
+     * @returns base64 bytes and the media type to put on the wire.
+     */
+    readImage?: (ref: HarnessImageRef) => Promise<{
+        data: string;
+        mediaType: string;
+    } | undefined>;
     /** Clock, injectable so tests are deterministic. */
     now: () => Date;
     /** Monotonic-ish millisecond clock for durations. */
     elapsed: () => number;
 }
+/** A durable image reference as a harness message block carries it. */
+export interface HarnessImageRef {
+    attachmentId: string;
+    mediaType: string;
+    bytes?: number;
+    width?: number;
+    height?: number;
+    name?: string;
+}
 /** One finished call, as the adapter observed it. */
 interface CallOutcome {
     ok: boolean;
     code?: string;
     usage: TokenUsage | null;
 }
+/**
+ * Derive the value for the OpenCode session header.
+ *
+ * 🔴 This is THIS PLUGIN's job, not the harness's. `/zen/go` is one relay's private requirement;
+ * the host cannot know about it and must not be expected to stamp anything for it. Whatever the
+ * harness happens to put on a request is only an input to a decision made here.
+ *
+ * The id is a stable hash of the harness session id, so:
+ *  · the same conversation keeps one affinity key (what the endpoint wants), and
+ *  · the value is opaque rather than echoing an internal id to a third party.
+ *
+ * Two hard requirements, both learned from a 400:
+ *  · **never absent** — the header is always sent, so a request can never go out without it;
+ *  · **stable when there is no session** — falling back to a random value would give every
+ *    request a different affinity key, which is worse than a constant.
+ * @param sessionId - the harness session id, when it supplied one.
+ * @returns a stable, non-empty session id.
+ */
+export declare function opencodeSessionId(sessionId: unknown): string;
+/**
+ * Build the per-request headers one channel needs.
+ *
+ * 🔴 **Shared by BOTH paths that talk to a relay** — the runtime `stream()` and the panel's
+ * `/probe`. They used to differ: `stream()` injected the OpenCode session header and `/probe`
+ * did not, so "测试" reported 400 `MissingSessionID` for a channel that worked in real use. A
+ * probe that checks something other than what a real request does is not a probe; it is a second
+ * implementation of the truth, and the two will disagree.
+ * @param channel - the resolved channel.
+ * @param sessionId - the harness session id, when the caller has one.
+ * @returns headers to send, on top of whatever the channel already declares.
+ */
+export declare function requestHeadersFor(channel: ResolvedChannel, sessionId: unknown): Record<string, string>;
 /**
  * Build the pi-ai model entry for one channel.
  *
@@ -68,15 +163,35 @@ interface CallOutcome {
  * @returns a pi-ai chat model describing that relay's view of the model.
  */
 export declare function buildPiModel(channel: ResolvedChannel): Model<Api>;
+/** One resolved image, keyed by attachment id. */
+export type ImageBytes = Map<string, {
+    data: string;
+    mediaType: string;
+}>;
+/**
+ * Collect the bytes for every image in a request.
+ *
+ * 🔴 A separate pass, because the conversion itself is synchronous and the store is not. This is
+ * also how the host's own pi-ai adapter does it, for the same reason.
+ *
+ * A block that cannot be read is left OUT of the map, and the converter then substitutes a text
+ * placeholder. That is deliberate: dropping the block would tell the model nothing, while a
+ * placeholder at least says an image was attached and names why it could not be shown. Skipping
+ * it silently is the failure mode this whole change exists to remove — the user sent an image and
+ * the model answered as though the message had been text only.
+ * @param options - the harness request.
+ * @param readImage - the attachment seam, when the composition has one.
+ * @returns resolved images keyed by attachment id.
+ */
+export declare function collectImages(options: GenerateOptions, readImage: AdapterDeps['readImage']): Promise<ImageBytes>;
 /**
  * Translate one harness request into a pi-ai context.
  *
- * The harness already projects images and files before an adapter sees them, so this is a
- * straightforward content mapping; anything the harness did not project is passed through.
  * @param options - the harness request.
+ * @param images - image bytes collected by {@link collectImages}; omitted for a text-only request.
  * @returns a pi-ai context plus the one-shot system prompt, when the caller set one.
  */
-export declare function toPiContext(options: GenerateOptions): PiContext;
+export declare function toPiContext(options: GenerateOptions, images?: ImageBytes): PiContext;
 /** Map pi-ai usage onto the harness's disjoint counters. */
 export declare function toTokenUsage(usage: AssistantMessage['usage']): TokenUsage;
 /**
@@ -123,6 +238,9 @@ export declare class AnyDeepSeekAdapter extends LlmAdapter {
      * ⇒ The catalog answers "what does this provider serve", which is a property of the plugin.
      * Key presence is answered per request (`MISSING_CREDENTIAL`) and per row in the panel
      * (`keyConfigured`), where the user can actually act on it.
+     *
+     * The same reasoning extends to `inputModalities`: it describes the model this route serves,
+     * so it is reported here unconditionally rather than derived from a channel.
      */
     listModels(_provider: string): Promise<LlmModelInfo[]>;
     resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;

package/lib/http.d.ts

@@ -64,12 +64,19 @@ export interface WebServerLike {
  *
  * This spends tokens, which is why it is an explicit route rather than something the panel does
  * on render. The request asks for one output token, so the cost is a prompt plus a token.
+ *
+ * 🔴 **The headers come from `requestHeadersFor`, the same function the runtime uses.** They used
+ * to be built here separately, which meant this probe sent no OpenCode session header while real
+ * requests did — so "测试" reported 400 `MissingSessionID` on a channel that worked in use. A
+ * probe that does not send what a real request sends is not testing the channel.
  * @param channel - the channel to probe.
  * @param key - its resolved credential.
+ * @param sessionId - session identity for per-request headers (the probe has no conversation of
+ *   its own, so callers pass the selected channel's own stable value).
  * @param signal - cancellation.
  * @returns a verdict and, on success, what the relay reported.
  */
-export declare function probeChannel(channel: ResolvedChannel, key: string, signal?: AbortSignal): Promise<{
+export declare function probeChannel(channel: ResolvedChannel, key: string, sessionId?: string, signal?: AbortSignal): Promise<{
     ok: boolean;
     ms: number;
     code?: string;

package/lib/index.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { LlmAdapter, ReasoningEffortId, ToolCallId } from "@deepseek-ai/dsh-llm";
 import "@deepseek-ai/dsh-credentials";
+import { createHash } from "node:crypto";
 import { createModels, createProvider } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { appendFile, mkdir, readFile, readdir } from "node:fs/promises";
@@ -162,17 +163,25 @@ const DEFAULT_MAX_TOKENS = 32768;
 * Kept as one constant because these are properties of the *model*, not of a relay; a relay
 * that disagrees corrects them in its own preset.
 *
-* ⚠️ `input` is `['text']` **on purpose, for now**. The model is multimodal, but declaring image
-* support is a promise this adapter cannot keep yet: a harness `ImageBlock` carries only an
-* `attachmentId`, and turning that into bytes requires the durable attachment service
-* (`ctx.attachments.readImageRequest`), which the adapter does not consult. Declaring images
-* without that path would be worse than declaring text — the harness would stop substituting its
-* placeholder text and the image would be silently dropped. See SESSION decision 38.
+* ## Why `input` lists image
+*
+* The model is multimodal, and the harness only projects an image into a request when the model
+* entry declares the capability. Declaring text-only therefore did not mean "we never send
+* images" — it meant the user's image never reached the model at all, silently. The relay side is
+* now real: `adapter.ts` collects image bytes through the durable attachment store and maps them
+* to pi-ai `image` content, and falls back to a visible text placeholder when it cannot.
+*
+* ## Why this is exported
+*
+* The adapter must report the SAME capabilities through `listModels()` / `resolveModel()`, which
+* describe the advertised model rather than any one channel. Reaching for this constant (instead
+* of re-listing the numbers there) keeps the catalog and the exact-model answer from drifting —
+* and they are read by different host paths, so a drift is silent.
 */
 const V41_FLASH_CAPS = {
 	contextWindow: 1e6,
 	maxTokens: 384e3,
-	input: ["text"],
+	input: ["text", "image"],
 	/**
 	* Selectable thinking levels, in pi-ai's vocabulary.
 	*
@@ -201,21 +210,12 @@ const DEEPSEEK_THINKING_COMPAT = {
 	thinkingFormat: "deepseek"
 };
 /**
-* Headers the OpenCode Go endpoint requires, MINUS the session id.
-*
-* `/zen/go` answers 400 `Request is missing x-opencode-session` without it, and the official
-* documentation adds two requirements this preset has to respect:
-*
-*  1. the session id must be **stable per conversation** — a constant shared by every
-*     conversation violates the thing the header exists for (routing and cache affinity);
-*  2. the client must **identify itself with its own user agent** rather than a generic SDK name.
+* Static headers the OpenCode Go endpoint wants on every request.
 *
-* So the session id is deliberately NOT here: `adapter.ts` injects it per request from the
-* harness's own session identity. What stays here is the static identity of this client.
-*
-* ⚠️ The upstream documentation lists **DeepSeek Harness as a known-problematic client** for this
-* endpoint ("session information arrives on some model paths, but is missing on others"). Even
-* with everything here correct, expect this relay to be stricter than the others.
+* The session id is NOT here on purpose — it is injected per request, because the endpoint wants
+* it stable *per conversation* rather than per install. What lives here is the client identity,
+* which does not vary. See {@link OPENCODE_SESSION_FALLBACK} for what happens when the harness
+* gives us no session at all.
 */
 const OPENCODE_HEADERS = {
 	"x-opencode-client": "dsh",
@@ -224,12 +224,28 @@ const OPENCODE_HEADERS = {
 /**
 * The user agent a request to OpenCode Go identifies itself with.
 *
-* Requirement 2 above: a generic SDK name is exactly what they ask clients not to send.
+* The upstream asks clients to identify themselves rather than send a generic SDK name.
 */
 const CLIENT_USER_AGENT = "dsh-any-deepseek/1.0";
 /** Header carrying the per-conversation routing id on OpenCode Go. */
 const OPENCODE_SESSION_HEADER = "x-opencode-session";
 /**
+* Session id used when the harness gives us none.
+*
+* 🔴 **This fallback is load-bearing, not decoration**, and dropping it is a measured failure.
+*
+* The endpoint wants a per-conversation id, so the honest implementation is "use the harness's
+* `sessionId`". The problem is that the harness does not stamp one on every request — and when it
+* does not, an implementation that ONLY reads `options.sessionId` sends **no session header at
+* all**, which the endpoint rejects with 400 `MissingSessionID`: precisely the failure the header
+* exists to prevent. So the value is "harness session when present, this constant otherwise".
+*
+* A constant is a worse affinity key than a real per-session id and a far better one than none:
+* it still gives the upstream one consistent key per install. That is the same trade the sibling
+* `dsh-serenity-hooks` plugin made for the same endpoint, proved on a real host.
+*/
+const OPENCODE_SESSION_FALLBACK = "dsh-any-deepseek";
+/**
 * Presets keyed by a stable id.
 *
 * The id is what a channel entry stores (`preset: opencode-go`), so it is part of the user's
@@ -493,12 +509,42 @@ function resolveChannel(id, raw) {
 			input,
 			...(entry.reasoningEfforts ?? preset?.reasoningEfforts) === void 0 ? {} : { reasoningEfforts: entry.reasoningEfforts ?? preset?.reasoningEfforts },
 			...(entry.compat ?? preset?.compat) === void 0 ? {} : { compat: entry.compat ?? preset?.compat },
-			...(entry.headers ?? preset?.headers) === void 0 ? {} : { headers: entry.headers ?? preset?.headers },
+			/**
+			* 🔴 Headers MERGE per key; they do not replace.
+			*
+			* `entry.headers ?? preset?.headers` treated the two as alternatives, so a user who added
+			* one header of their own silently lost the preset's — and for OpenCode Go those are the
+			* headers the endpoint refuses requests without. Merging keeps the preset's required set
+			* and lets the entry win only on the keys it actually names.
+			*/
+			...mergeHeaders(preset?.headers, entry.headers) === void 0 ? {} : { headers: mergeHeaders(preset?.headers, entry.headers) },
 			warnings
 		}
 	};
 }
 /**
+* Merge preset headers with entry headers, the entry winning per key.
+*
+* HTTP field names are case-insensitive, so a user writing `X-Session-ID` must override a
+* preset's `x-session-id` rather than appearing alongside it as a second header — sending both
+* would leave the upstream to pick one, which is exactly the ambiguity the header exists to
+* resolve.
+* @param preset - headers the preset declares.
+* @param entry - headers the entry declares.
+* @returns the merged set, or undefined when neither side declares any.
+*/
+function mergeHeaders(preset, entry) {
+	if (entry === void 0) return preset === void 0 ? void 0 : { ...preset };
+	if (preset === void 0) return { ...entry };
+	const merged = {};
+	for (const [name, value] of Object.entries(preset)) merged[name] = value;
+	for (const [name, value] of Object.entries(entry)) {
+		for (const existing of Object.keys(merged)) if (existing !== name && existing.toLowerCase() === name.toLowerCase()) delete merged[existing];
+		merged[name] = value;
+	}
+	return merged;
+}
+/**
 * Resolve every channel in one configuration document.
 *
 * Problems are collected, never thrown: one broken channel must not make the rest of the
@@ -615,6 +661,93 @@ const PROVIDER_ID = "any-deepseek";
 /** Display name for the route in provider selectors. */
 const PROVIDER_NAME = "Any DeepSeek";
 /**
+* Input modalities this provider's one model accepts.
+*
+* 🔴 **Declared at registration, because the harness asks the model — not the channel.**
+*
+* `LlmModelInfo.inputModalities` is documented as "absent means unknown" (`dsh-llm/lib/types/
+* types.d.ts:330-331`), and the host reads it at dispatch to decide whether an image survives
+* projection at all: `if (modelInfo.inputModalities !== undefined &&
+* !modelInfo.inputModalities.includes('image') && …) projectImagesForTextModel(…)`
+* (`dsh-llm/lib/index.js:2337`). Omitting it therefore did not mean "we never send images"; it
+* meant a user's screenshot was replaced by a placeholder *before* this plugin ever saw it, which
+* is why the model answered as though the message had been text.
+*
+* The value is the MODEL's capability, so it does not depend on which channel is selected, on
+* whether a key exists, or on whether `current` is set — the same rule as the catalog itself.
+* A relay that genuinely cannot carry images declares `input: ['text']` on its own channel, and
+* the transport (`pi-ai`) downgrades the image per channel; the harness-level answer stays the
+* model's.
+*/
+const MODEL_INPUT_MODALITIES = V41_FLASH_CAPS.input;
+/**
+* The reasoning levels in force for one channel.
+*
+* 🔴 **A channel that says nothing inherits the model's table, and that is the whole fix for the
+* missing thinking control.**
+*
+* The old code read `channel.reasoningEfforts` alone. That value only existed once a channel
+* declared it — so during first-run setup (no channel, or a channel written before the panel
+* offered levels) the answer was "no reasoning at all", and the composer's strength selector was
+* absent. But the model always had levels; the CHANNEL was merely silent about them.
+*
+* An empty map counts as silence, not as "explicitly unsupported": `z.dict()` produces `{}` when
+* the panel writes the field, and treating that as a negative capability is how the picker broke
+* with `INVALID_MODEL_REASONING` in the first place.
+* @param channel - the selected channel, when there is one.
+* @returns the levels to advertise and to send, keyed by level name.
+*/
+function effectiveReasoningEfforts(channel) {
+	const declared = channel?.reasoningEfforts;
+	if (declared !== void 0 && Object.keys(declared).length > 0) return declared;
+	return V41_FLASH_CAPS.reasoningEfforts;
+}
+/**
+* Derive the value for the OpenCode session header.
+*
+* 🔴 This is THIS PLUGIN's job, not the harness's. `/zen/go` is one relay's private requirement;
+* the host cannot know about it and must not be expected to stamp anything for it. Whatever the
+* harness happens to put on a request is only an input to a decision made here.
+*
+* The id is a stable hash of the harness session id, so:
+*  · the same conversation keeps one affinity key (what the endpoint wants), and
+*  · the value is opaque rather than echoing an internal id to a third party.
+*
+* Two hard requirements, both learned from a 400:
+*  · **never absent** — the header is always sent, so a request can never go out without it;
+*  · **stable when there is no session** — falling back to a random value would give every
+*    request a different affinity key, which is worse than a constant.
+* @param sessionId - the harness session id, when it supplied one.
+* @returns a stable, non-empty session id.
+*/
+function opencodeSessionId(sessionId) {
+	const raw = sessionId === void 0 || sessionId === null ? "" : String(sessionId).trim();
+	if (raw === "") return OPENCODE_SESSION_FALLBACK;
+	return createHash("sha256").update(raw).digest("hex").slice(0, 32);
+}
+/**
+* Build the per-request headers one channel needs.
+*
+* 🔴 **Shared by BOTH paths that talk to a relay** — the runtime `stream()` and the panel's
+* `/probe`. They used to differ: `stream()` injected the OpenCode session header and `/probe`
+* did not, so "测试" reported 400 `MissingSessionID` for a channel that worked in real use. A
+* probe that checks something other than what a real request does is not a probe; it is a second
+* implementation of the truth, and the two will disagree.
+* @param channel - the resolved channel.
+* @param sessionId - the harness session id, when the caller has one.
+* @returns headers to send, on top of whatever the channel already declares.
+*/
+function requestHeadersFor(channel, sessionId) {
+	const headers = {};
+	if (channel.headers !== void 0 && Object.hasOwn(channel.headers, "x-opencode-client")) {
+		const session = opencodeSessionId(sessionId);
+		headers[OPENCODE_SESSION_HEADER] = session;
+		headers["X-Session-ID"] = session;
+		headers["User-Agent"] = CLIENT_USER_AGENT;
+	}
+	return headers;
+}
+/**
 * Build the pi-ai model entry for one channel.
 *
 * The advertised id (`deepseek-v4.1-flash`) never reaches the wire here: each channel's own
@@ -623,8 +756,12 @@ const PROVIDER_NAME = "Any DeepSeek";
 * @returns a pi-ai chat model describing that relay's view of the model.
 */
 function buildPiModel(channel) {
-	const thinkingLevelMap = channel.reasoningEfforts === void 0 ? void 0 : Object.fromEntries(Object.entries(channel.reasoningEfforts).filter(([, value]) => value !== null));
-	const hasThinking = thinkingLevelMap !== void 0 && Object.keys(thinkingLevelMap).length > 0;
+	const thinkingLevelMap = (() => {
+		const declared = {};
+		for (const [level, wire] of Object.entries(effectiveReasoningEfforts(channel))) if (typeof wire === "string") declared[level] = wire;
+		return Object.keys(declared).length === 0 ? void 0 : declared;
+	})();
+	const hasThinking = thinkingLevelMap !== void 0;
 	return {
 		id: channel.model,
 		name: channel.label,
@@ -647,14 +784,54 @@ function buildPiModel(channel) {
 	};
 }
 /**
+* Collect the bytes for every image in a request.
+*
+* 🔴 A separate pass, because the conversion itself is synchronous and the store is not. This is
+* also how the host's own pi-ai adapter does it, for the same reason.
+*
+* A block that cannot be read is left OUT of the map, and the converter then substitutes a text
+* placeholder. That is deliberate: dropping the block would tell the model nothing, while a
+* placeholder at least says an image was attached and names why it could not be shown. Skipping
+* it silently is the failure mode this whole change exists to remove — the user sent an image and
+* the model answered as though the message had been text only.
+* @param options - the harness request.
+* @param readImage - the attachment seam, when the composition has one.
+* @returns resolved images keyed by attachment id.
+*/
+async function collectImages(options, readImage) {
+	const images = /* @__PURE__ */ new Map();
+	if (readImage === void 0) return images;
+	const pending = [];
+	for (const message of options.messages) {
+		if (!Array.isArray(message.content)) continue;
+		for (const block of message.content) {
+			const candidate = block;
+			if (candidate.type !== "image") continue;
+			const ref = candidate.attachment;
+			if (ref === void 0 || typeof ref.attachmentId !== "string") continue;
+			if (images.has(ref.attachmentId)) continue;
+			if (pending.some((item) => item.attachmentId === ref.attachmentId)) continue;
+			pending.push(ref);
+		}
+	}
+	const resolved = await Promise.all(pending.map(async (ref) => {
+		try {
+			return [ref.attachmentId, await readImage(ref)];
+		} catch {
+			return [ref.attachmentId, void 0];
+		}
+	}));
+	for (const [id, value] of resolved) if (value !== void 0) images.set(id, value);
+	return images;
+}
+/**
 * Translate one harness request into a pi-ai context.
 *
-* The harness already projects images and files before an adapter sees them, so this is a
-* straightforward content mapping; anything the harness did not project is passed through.
 * @param options - the harness request.
+* @param images - image bytes collected by {@link collectImages}; omitted for a text-only request.
 * @returns a pi-ai context plus the one-shot system prompt, when the caller set one.
 */
-function toPiContext(options) {
+function toPiContext(options, images) {
 	const messages = options.messages.map((message) => {
 		if (message.role === "assistant") return {
 			role: "assistant",
@@ -691,7 +868,7 @@ function toPiContext(options) {
 		};
 		return {
 			role: "user",
-			content: textAndImages(message.content),
+			content: userContent(message.content, images),
 			timestamp: 0
 		};
 	});
@@ -731,14 +908,45 @@ function safeJson(raw) {
 		return {};
 	}
 }
-/** Map harness content blocks to pi-ai text/image blocks. */
-function textAndImages(content) {
+/**
+* Map one user message's blocks to pi-ai content.
+*
+* 🔴 An image block carries an `attachmentId`, never bytes — so it can only become an image when
+* {@link collectImages} resolved it. When it did not, the block becomes a TEXT PLACEHOLDER rather
+* than disappearing: the model should be told an image was attached and that it could not be
+* read. The previous version dropped such blocks entirely, which is how a user's screenshot
+* reached the plugin and the model answered as though the message had been text only.
+* @param content - harness content blocks.
+* @param images - resolved image bytes, when any were collected.
+* @returns pi-ai content blocks.
+*/
+function userContent(content, images) {
 	const out = [];
 	for (const block of content) {
 		const typed = block;
-		if (typed.type === "text" && typeof typed.text === "string") out.push({
+		if (typed.type === "text" && typeof typed.text === "string") {
+			out.push({
+				type: "text",
+				text: typed.text
+			});
+			continue;
+		}
+		if (typed.type !== "image") continue;
+		const id = typed.attachment?.attachmentId;
+		const resolved = typeof id === "string" ? images?.get(id) : void 0;
+		if (resolved !== void 0) {
+			out.push({
+				type: "image",
+				data: resolved.data,
+				mimeType: resolved.mediaType
+			});
+			continue;
+		}
+		if (typed.offloaded === true || typed.attachment?.offloaded === true) continue;
+		const name = typed.attachment?.name === void 0 ? "" : ` (${typed.attachment.name})`;
+		out.push({
 			type: "text",
-			text: typed.text
+			text: `[an image was attached${name}, but this route could not read its bytes]`
 		});
 	}
 	return out;
@@ -1009,6 +1217,9 @@ var AnyDeepSeekAdapter = class extends LlmAdapter {
 	* ⇒ The catalog answers "what does this provider serve", which is a property of the plugin.
 	* Key presence is answered per request (`MISSING_CREDENTIAL`) and per row in the panel
 	* (`keyConfigured`), where the user can actually act on it.
+	*
+	* The same reasoning extends to `inputModalities`: it describes the model this route serves,
+	* so it is reported here unconditionally rather than derived from a channel.
 	*/
 	async listModels(_provider) {
 		const selected = this.selected();
@@ -1018,12 +1229,13 @@ var AnyDeepSeekAdapter = class extends LlmAdapter {
 			provider: PROVIDER_ID,
 			id: ADVERTISED_MODEL_ID,
 			name: ADVERTISED_MODEL_NAME,
-			description: label === void 0 ? "no channel configured yet" : `via ${label}`
+			description: label === void 0 ? "no channel configured yet" : `via ${label}`,
+			inputModalities: [...MODEL_INPUT_MODALITIES]
 		}];
 	}
 	async resolveModel(provider, model, _signal) {
 		const channel = this.selected();
-		const efforts = Object.entries(channel?.reasoningEfforts ?? {}).filter(([, wire]) => wire !== null).map(([id]) => id);
+		const efforts = Object.entries(effectiveReasoningEfforts(channel)).filter(([, wire]) => wire !== null).map(([id]) => id);
 		const reasoning = efforts.length === 0 ? {} : { reasoning: { efforts: efforts.map((id) => ({
 			id: ReasoningEffortId(id),
 			name: id
@@ -1035,6 +1247,7 @@ var AnyDeepSeekAdapter = class extends LlmAdapter {
 			description: channel === void 0 ? void 0 : `via ${channel.label}`,
 			context: { contextWindow: channel?.contextWindow ?? 1e6 },
 			defaultMaxTokens: channel?.maxTokens,
+			inputModalities: [...MODEL_INPUT_MODALITIES],
 			...reasoning
 		};
 	}
@@ -1125,22 +1338,18 @@ var AnyDeepSeekAdapter = class extends LlmAdapter {
 		*
 		* Two things OpenCode Go requires cannot live in a preset, because neither is a constant:
 		*
-		*  · `x-opencode-session` must be STABLE PER CONVERSATION. A single shared literal satisfied
-		*    the letter of "send the header" while defeating its purpose (routing and prompt-cache
-		*    affinity), which is why the previous preset's fixed value produced 400s. The harness
-		*    already stamps every request with `sessionId`; that is the correct source.
+		*  · `x-opencode-session` must be STABLE PER CONVERSATION, and it must ALWAYS be present.
+		*    Both halves matter, and getting only the first produced a 400: an earlier version read
+		*    `options.sessionId` and sent nothing when it was absent — and the harness does not stamp
+		*    one on every request. So the value is a stable hash of the harness session id when we
+		*    have one, and a constant when we do not. A hash keeps the id opaque while staying stable
+		*    for the same conversation, which is all the endpoint's affinity key needs.
 		*  · `User-Agent` must identify THIS client rather than the generic SDK. pi-ai sets its own,
 		*    so the preset's static headers alone can never satisfy that rule.
+		*
+		* The construction lives in `requestHeadersFor` so the panel's probe sends the same thing.
 		*/
-		const requestHeaders = {};
-		if (channel.headers !== void 0 && Object.hasOwn(channel.headers, "x-opencode-client")) {
-			const session = options.sessionId === void 0 ? void 0 : String(options.sessionId);
-			if (session !== void 0 && session !== "") {
-				requestHeaders[OPENCODE_SESSION_HEADER] = session;
-				requestHeaders["X-Session-ID"] = session;
-			}
-			requestHeaders["User-Agent"] = CLIENT_USER_AGENT;
-		}
+		const requestHeaders = requestHeadersFor(channel, options.sessionId);
 		const streamOptions = {
 			apiKey: key,
 			signal: options.signal,
@@ -1150,7 +1359,8 @@ var AnyDeepSeekAdapter = class extends LlmAdapter {
 			...Object.keys(requestHeaders).length === 0 ? {} : { headers: requestHeaders }
 		};
 		try {
-			const events = models.streamSimple(model, toPiContext(options), streamOptions);
+			const images = await collectImages(options, this.deps.readImage);
+			const events = models.streamSimple(model, toPiContext(options, images), streamOptions);
 			for await (const chunk of toStreamChunks(events, (observed) => {
 				outcome = observed;
 			})) yield chunk;
@@ -1472,12 +1682,19 @@ function queryDate(value) {
 *
 * This spends tokens, which is why it is an explicit route rather than something the panel does
 * on render. The request asks for one output token, so the cost is a prompt plus a token.
+*
+* 🔴 **The headers come from `requestHeadersFor`, the same function the runtime uses.** They used
+* to be built here separately, which meant this probe sent no OpenCode session header while real
+* requests did — so "测试" reported 400 `MissingSessionID` on a channel that worked in use. A
+* probe that does not send what a real request sends is not testing the channel.
 * @param channel - the channel to probe.
 * @param key - its resolved credential.
+* @param sessionId - session identity for per-request headers (the probe has no conversation of
+*   its own, so callers pass the selected channel's own stable value).
 * @param signal - cancellation.
 * @returns a verdict and, on success, what the relay reported.
 */
-async function probeChannel(channel, key, signal) {
+async function probeChannel(channel, key, sessionId, signal) {
 	const started = Date.now();
 	const url = `${channel.baseURL.replace(/\/+$/, "")}/chat/completions`;
 	try {
@@ -1486,7 +1703,8 @@ async function probeChannel(channel, key, signal) {
 			headers: {
 				"content-type": "application/json",
 				authorization: `Bearer ${key}`,
-				...channel.headers
+				...channel.headers,
+				...requestHeadersFor(channel, sessionId)
 			},
 			body: JSON.stringify({
 				model: channel.model,
@@ -1647,7 +1865,7 @@ function registerStatsRoutes(ctx, webServer, deps) {
 					});
 					return;
 				}
-				const verdict = await probeChannel(channel, key);
+				const verdict = await probeChannel(channel, key, `probe:${channel.id}`);
 				json(res, verdict.ok ? 200 : 502, verdict);
 			}
 		}
@@ -1757,10 +1975,48 @@ function apply(ctx, config) {
 		const value = unwrap((ctx.fiber?.config ?? config).current);
 		return typeof value === "string" ? value : void 0;
 	};
+	/**
+	* Read one image's request bytes from the harness attachment store.
+	*
+	* 🔴 This is the host seam, not something this plugin invents: a harness `ImageBlock` carries
+	* only an `attachmentId`, and `readImageRequest` is the documented way to turn that into bytes.
+	* Without this path the model cannot receive an image no matter what `input` declares — which
+	* was exactly this plugin's state until now, and why a screenshot the user sent never arrived.
+	*
+	* The target bounds are the store's own normalization request, not a guess about the relay:
+	* 2048px keeps the harness's normal form, and the byte ceiling is the one the host's pi-ai
+	* adapter uses for the same purpose.
+	*/
+	const readImage = async (ref) => {
+		const attachments = service(ctx, "attachments");
+		if (attachments?.readImageRequest === void 0) {
+			console.warn("[any-deepseek] 图片无法读取：本组合没有装配 attachments 服务（readImageRequest 不可用）");
+			return;
+		}
+		try {
+			const stored = await attachments.readImageRequest(ref, {
+				width: 2048,
+				height: 2048,
+				maxBytes: 4194304
+			});
+			if (stored?.data === void 0) {
+				console.warn(`[any-deepseek] 图片 ${ref.attachmentId} 读取结果为空`);
+				return;
+			}
+			return {
+				data: Buffer.from(stored.data).toString("base64"),
+				mediaType: stored.mediaType ?? ref.mediaType
+			};
+		} catch (error) {
+			console.warn(`[any-deepseek] 读不到图片 ${ref.attachmentId}: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+	};
 	const adapter = new AnyDeepSeekAdapter({
 		channels,
 		current,
 		resolveKey,
+		readImage,
 		record: makeRecorder(ctx, config),
 		now: () => /* @__PURE__ */ new Date(),
 		elapsed: () => Number(process.hrtime.bigint() / 1000000n)

package/lib/presets.d.ts

@@ -81,14 +81,65 @@ export declare const ADVERTISED_MODEL_NAME = "DeepSeek V4.1 Flash";
  */
 export declare const DEFAULT_CONTEXT_WINDOW = 262144;
 export declare const DEFAULT_MAX_TOKENS = 32768;
+/**
+ * Capability numbers shared by every DeepSeek V4.1 Flash deployment we know of.
+ *
+ * Kept as one constant because these are properties of the *model*, not of a relay; a relay
+ * that disagrees corrects them in its own preset.
+ *
+ * ## Why `input` lists image
+ *
+ * The model is multimodal, and the harness only projects an image into a request when the model
+ * entry declares the capability. Declaring text-only therefore did not mean "we never send
+ * images" — it meant the user's image never reached the model at all, silently. The relay side is
+ * now real: `adapter.ts` collects image bytes through the durable attachment store and maps them
+ * to pi-ai `image` content, and falls back to a visible text placeholder when it cannot.
+ *
+ * ## Why this is exported
+ *
+ * The adapter must report the SAME capabilities through `listModels()` / `resolveModel()`, which
+ * describe the advertised model rather than any one channel. Reaching for this constant (instead
+ * of re-listing the numbers there) keeps the catalog and the exact-model answer from drifting —
+ * and they are read by different host paths, so a drift is silent.
+ */
+export declare const V41_FLASH_CAPS: {
+    contextWindow: number;
+    maxTokens: number;
+    input: ChannelModality[];
+    /**
+     * Selectable thinking levels, in pi-ai's vocabulary.
+     *
+     * The VALUES are the wire spellings this model family accepts (`reasoning_effort`); `null`
+     * would mark a level as unsupported. pi-ai consumes this map directly as `thinkingLevelMap`,
+     * which is why this plugin does not implement a translation layer of its own — a second
+     * mapping would inevitably drift from the one the transport actually applies.
+     */
+    reasoningEfforts: Record<string, string | null>;
+};
 /**
  * The user agent a request to OpenCode Go identifies itself with.
  *
- * Requirement 2 above: a generic SDK name is exactly what they ask clients not to send.
+ * The upstream asks clients to identify themselves rather than send a generic SDK name.
  */
 export declare const CLIENT_USER_AGENT = "dsh-any-deepseek/1.0";
 /** Header carrying the per-conversation routing id on OpenCode Go. */
 export declare const OPENCODE_SESSION_HEADER = "x-opencode-session";
+/**
+ * Session id used when the harness gives us none.
+ *
+ * 🔴 **This fallback is load-bearing, not decoration**, and dropping it is a measured failure.
+ *
+ * The endpoint wants a per-conversation id, so the honest implementation is "use the harness's
+ * `sessionId`". The problem is that the harness does not stamp one on every request — and when it
+ * does not, an implementation that ONLY reads `options.sessionId` sends **no session header at
+ * all**, which the endpoint rejects with 400 `MissingSessionID`: precisely the failure the header
+ * exists to prevent. So the value is "harness session when present, this constant otherwise".
+ *
+ * A constant is a worse affinity key than a real per-session id and a far better one than none:
+ * it still gives the upstream one consistent key per install. That is the same trade the sibling
+ * `dsh-serenity-hooks` plugin made for the same endpoint, proved on a real host.
+ */
+export declare const OPENCODE_SESSION_FALLBACK = "dsh-any-deepseek";
 /**
  * Presets keyed by a stable id.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-any-deepseek",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "One DeepSeek V4.1 Flash provider for DeepSeek Harness: paste a key per channel, switch channels manually, token usage booked per real upstream.",
   "license": "MIT",
   "repository": {