dsh-mcp 1.5.0 → 1.6.0

package/CHANGELOG.en.md

@@ -7,6 +7,12 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.0] - 2026-08-17
+
+### Added
+
+- **MCP tool image results**: image content blocks returned by MCP tools are projected through the attachment service into model image context, with strict type/size/count preflight and degraded text fallbacks; non-image content (audio/resource etc.) gets bounded text fallbacks (PR #4, thanks @coding-chong)
+
 ## [1.5.0] - 2026-08-17
 
 ### Added

package/CHANGELOG.md

@@ -7,6 +7,12 @@
 格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，
 版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [1.6.0] - 2026-08-17
+
+### 新增
+
+- **MCP 工具图片结果**：工具返回的图片内容（image blocks）经附件服务投影为图片引用进入模型上下文，带严格的类型/大小/数量预检与降级文案；非图片内容（audio/resource 等）给出有界文本回退（PR #4，感谢 @coding-chong）
+
 ## [1.5.0] - 2026-08-17
 
 ### 新增

package/README.en.md

@@ -18,6 +18,7 @@
 - **Process-level environment variables**: a global key-value list (expanded by default, batch-add supported); header values can reference a variable by bare name or `${NAME}` and are substituted at connect time (e.g. `Authorization: Bearer ${TOKEN}`)
 - **Whole-list JSON config**: the "JSON config editor" panel views/edits every server as one JSON array; applying saves immediately (create/update/delete)
 - **Fine-grained tool control**: expand each server to see its tools, all checked by default; uncheck to load only what you need
+- **Image result passthrough**: images returned by MCP tools (screenshots/charts) are projected through the attachment service into model image context, with strict preflight and bounded fallbacks (PR #4)
 - **Two injection modes**: `search` (on-demand, token-saving) and `full` (inject everything)
 - **Zero npm dependencies**: plugs into DeepSeek Harness internals, install and go
 - **OAuth authentication**: for `streamable-http` servers using MCP OAuth (authorization-code + PKCE), the browser opens automatically for authorization on connect; tokens and OAuth client info are persisted and refreshed automatically by the SDK (auto-renewed while active within 24h), with automatic re-authorization after expiry
@@ -152,7 +153,7 @@ Check in order:
    the `web` profile (`dsh plugin --profile web add dsh-mcp` +
    `$DSH_HOME/profiles/web/cordis.patch.yml`); other profiles have their own settings pages.
 5. **Is it the latest version?** npm metadata caching can pin an old version; force the version
-   with `dsh plugin --profile web add dsh-mcp@latest` (or `@1.4.0`).
+   with `dsh plugin --profile web add dsh-mcp@latest` (or `@1.6.0`).
 
 **Q2: "MCP" is visible but the server list is empty or errors?**
 

package/README.md

@@ -20,6 +20,7 @@
 - **进程级环境变量**：全局 KV 配置（默认展开、支持批量添加），服务器请求头 value 写 `变量名` 或 `${变量名}` 即可在连接时自动替换为配置值（如 `Authorization: Bearer ${TOKEN}`）
 - **JSON 全量配置**：「JSON 维护配置」面板以一段 JSON 数组查看/编辑全部服务器配置，应用即保存（新增/更新/删除）
 - **工具级精细控制**：每个服务器展开工具列表，默认全选，可取消勾选只加载需要的部分
+- **图片结果透传**：MCP 工具返回的图片（截图/图表等）经附件服务投影为图片引用进入模型上下文，带严格预检与有界降级文案（PR #4）
 - **双注入模式**：`search`（按需检索，省 token）与 `full`（全量注入）
 - **零 npm 依赖**：直接对接 DeepSeek Harness 内部能力，安装即用
 - **OAuth 认证支持**：`streamable-http` 服务器若走 MCP OAuth（授权码 + PKCE），连接时自动打开浏览器授权；token 与 client 信息持久化、由 SDK 自动刷新（24 小时内活跃自动续期），失效后自动重新授权
@@ -135,7 +136,7 @@ dsh plugin --profile web add link:<本仓库绝对路径>
    （`dsh plugin --profile web add dsh-mcp` + `$DSH_HOME/profiles/web/cordis.patch.yml`）；
    装到其他 profile 则在其他 profile 的设置页查看。
 5. **是否为最新版本**：npm 元数据缓存可能导致装到旧版，可强制指定版本
-   `dsh plugin --profile web add dsh-mcp@latest`（或 `@1.4.0`）。
+   `dsh plugin --profile web add dsh-mcp@latest`（或 `@1.6.0`）。
 
 **Q2：设置页能看到「MCP」，但服务器列表为空/报错？**
 

package/lib/mcp-client.js

@@ -6,7 +6,9 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { z as z$1 } from "zod";
+import { isImageAdmissionError } from "@deepseek-ai/dsh-attachment";
 import { assertSupportedJsonSchema } from "@deepseek-ai/dsh-tools";
 //#region lib/types/transport.js
 /**
@@ -74,6 +76,15 @@ const INVALID_NAME_CHARS = /[^A-Za-z0-9_-]/g;
 const HASH_LENGTH = 12;
 /** Raw result record: the bridge owns JSON-value validation after transport. */
 const RawCallToolResultSchema = z$1.record(z$1.string(), z$1.unknown());
+/** Raster formats supported by the durable attachment vocabulary. */
+const IMAGE_MEDIA_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+];
+/** Canonical RFC 4648 base64, excluding whitespace and URL-safe aliases. */
+const CANONICAL_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 /** List without mutating the SDK's per-page output-validator cache. */
 function listToolsUncached(client, cursor) {
 	return client.request({
@@ -147,13 +158,7 @@ async function syncTools(client, ctx, opts, previous) {
 		for (const tool of response.tools) {
 			const publicName = publicToolName(opts.serverName, tool.name);
 			if (definitions.has(publicName)) throw new Error(`mcp-client(${opts.serverName}): server listed tool "${tool.name}" more than once — invalid tool list`);
-			definitions.set(publicName, {
-				name: publicName,
-				description: tool.description ?? "",
-				parameters: tool.inputSchema,
-				output: createOutput(tool.name, supportedOutputSchema(tool.outputSchema)),
-				execute: createExecutor(client, tool.name, tool.execution?.taskSupport === "required", opts)
-			});
+			definitions.set(publicName, createDefinition(client, ctx, publicName, tool.name, tool.description ?? "", tool.inputSchema, supportedOutputSchema(tool.outputSchema), tool.execution?.taskSupport === "required", opts));
 		}
 		cursor = response.nextCursor;
 	} while (cursor);
@@ -213,6 +218,26 @@ function supportedOutputSchema(candidate) {
 		return;
 	}
 }
+/** Build one tool definition with execution-local rich image projections. */
+function createDefinition(client, ctx, publicName, rawName, description, parameters, structuredSchema, taskRequired, opts) {
+	const projections = /* @__PURE__ */ new WeakMap();
+	return {
+		name: publicName,
+		description,
+		parameters,
+		output: createOutput(rawName, structuredSchema),
+		execute: createExecutor(client, ctx, rawName, taskRequired, opts, projections),
+		finalizeContent(exec, result) {
+			const projection = projections.get(exec);
+			if (projection === void 0) return void 0;
+			projections.delete(exec);
+			if (result.isError) return void 0;
+			if (!isDeepStrictEqual(result.value, projection.value)) return void 0;
+			if (!isDeepStrictEqual(result.content, projection.fallback)) return void 0;
+			return projection.content;
+		}
+	};
+}
 /** Build the canonical result schema and existing Native text projection. */
 function createOutput(rawName, structuredSchema) {
 	return {
@@ -246,7 +271,7 @@ function createOutput(rawName, structuredSchema) {
 * When the MCP server returns `isError: true`, the executor throws so that
 * the ToolRuntime's catch path produces an `isError` result for the model.
 */
-function createExecutor(client, rawName, taskRequired, opts) {
+function createExecutor(client, ctx, rawName, taskRequired, opts, projections) {
 	return async (args, exec) => {
 		if (taskRequired) throw new Error(`Tool "${rawName}" requires task-based execution, which this bridge does not support`);
 		const result = await callToolUncached(client, rawName, typeof args === "object" && args !== null ? args : {}, exec, opts);
@@ -265,10 +290,23 @@ function createExecutor(client, rawName, taskRequired, opts) {
 		const content = result.content;
 		const text = extractText(content, rawName);
 		if (result.isError === true) throw new Error(text);
-		return {
+		const value = {
 			content,
 			...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
 		};
+		if (containsImage(content)) {
+			const fallback = [{
+				type: "text",
+				text: extractText(content, rawName)
+			}];
+			const projected = await prepareImageProjection(ctx, exec, content, rawName);
+			projections.set(exec, {
+				value,
+				fallback,
+				content: projected
+			});
+		}
+		return value;
 	};
 }
 /**
@@ -279,32 +317,125 @@ function createExecutor(client, rawName, taskRequired, opts) {
 * Defensive: fields that the MCP spec declares required (mimeType, text) are
 * guarded with fallbacks because this is a network trust boundary.
 */
+function containsImage(content) {
+	return content.some((value) => isRecord(value) && value.type === "image");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isImageMediaType(value) {
+	return IMAGE_MEDIA_TYPES.includes(value);
+}
+function decodedByteLength(base64) {
+	const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	return base64.length / 4 * 3 - padding;
+}
+function imageDiagnostic(reason) {
+	return `[image unavailable: ${reason}; image bytes were not added to text context]`;
+}
+function preflightImages(content, limits) {
+	const images = [];
+	let totalBytes = 0;
+	for (const [index, value] of content.entries()) {
+		if (!isRecord(value) || value.type !== "image") continue;
+		if (value.mimeType === void 0 || !isImageMediaType(value.mimeType) || !limits.mediaTypes.includes(value.mimeType)) return { reason: "image type is not accepted" };
+		if (value.data === void 0 || !CANONICAL_BASE64.test(value.data)) return { reason: "invalid image data" };
+		const bytes = decodedByteLength(value.data);
+		if (bytes > limits.maxImageBytes) return { reason: "image exceeds the active size limit" };
+		totalBytes += bytes;
+		if (totalBytes > limits.maxMessageImageBytes) return { reason: "image batch exceeds the active size limit" };
+		images.push({ index, block: value });
+	}
+	if (images.length > limits.maxImagesPerMessage) return { reason: "image batch exceeds the active count limit" };
+	return { images };
+}
+function decodeImage(block) {
+	const data = Buffer.from(block.data, "base64");
+	if (data.toString("base64") !== block.data) throw new Error("invalid image data");
+	return { data, mediaType: block.mimeType };
+}
+async function resolveImageAdmission(ctx, exec) {
+	const attachments = ctx.get("attachments");
+	if (attachments === void 0 || attachments.imageLimits === void 0) throw new Error("attachment store unavailable");
+	const routed = exec.agent?.session.requestHeader()?.config;
+	const provider = routed?.provider ?? exec.agent?.options.provider;
+	const model = routed?.model ?? exec.agent?.options.model;
+	const llm = ctx.get("llm");
+	if (provider === void 0 || model === void 0 || llm === void 0) throw new Error("model route unavailable");
+	let info;
+	try {
+		info = await llm.resolveModelInfo(provider, model, exec.signal);
+	} catch {
+		throw new Error("model route unavailable");
+	}
+	if (info.inputModalities === void 0 || !info.inputModalities.includes("image")) throw new Error("model route is not image-capable");
+	if (exec.signal.aborted) throw new Error("tool call canceled");
+	return attachments;
+}
+function admissionDiagnostic(error) {
+	switch (error?.code) {
+		case "TOO_MANY_IMAGES": return "image batch exceeds the active count limit";
+		case "IMAGES_TOO_LARGE":
+		case "IMAGE_TOO_LARGE": return "image exceeds the active size limit";
+		case "UNSUPPORTED_IMAGE_TYPE":
+		case "IMAGE_TYPE_MISMATCH": return "image type is not accepted";
+		default: return isImageAdmissionError(error) ? "invalid image data" : "image storage unavailable";
+	}
+}
+async function prepareImageProjection(ctx, exec, content, toolName) {
+	let attachments;
+	try {
+		attachments = await resolveImageAdmission(ctx, exec);
+	} catch (error) {
+		const reason = error?.message === "model route is not image-capable" ? "model route is not image-capable" : error?.message === "tool call canceled" ? "tool call canceled" : error?.message === "attachment store unavailable" ? "attachment store unavailable" : "model route unavailable";
+		return projectContent(content, toolName, () => ({ type: "text", text: imageDiagnostic(reason) }));
+	}
+	const preflight = preflightImages(content, attachments.imageLimits);
+	if (preflight.reason !== void 0) return projectContent(content, toolName, () => ({ type: "text", text: imageDiagnostic(preflight.reason) }));
+	let decoded;
+	try {
+		decoded = preflight.images.map(({ block }) => decodeImage(block));
+	} catch {
+		return projectContent(content, toolName, () => ({ type: "text", text: imageDiagnostic("invalid image data") }));
+	}
+	try {
+		const refs = await attachments.saveImages(decoded);
+		const byIndex = new Map(preflight.images.map(({ index }, offset) => [index, refs[offset]]));
+		return projectContent(content, toolName, (_block, index) => ({ type: "image", attachment: byIndex.get(index) }));
+	} catch (error) {
+		return projectContent(content, toolName, () => ({ type: "text", text: imageDiagnostic(admissionDiagnostic(error)) }));
+	}
+}
 function extractText(mcpContent, toolName) {
-	const parts = [];
-	for (const value of mcpContent) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) {
-			parts.push("[unsupported content type: unknown]");
+	return projectContent(mcpContent, toolName).map((block) => block.text).join("\n");
+}
+function projectContent(mcpContent, toolName, image = () => ({ type: "text", text: imageDiagnostic("this result was not admitted to model image context") })) {
+	const projected = [];
+	const text = [];
+	const flushText = () => {
+		if (text.length === 0) return;
+		projected.push({ type: "text", text: text.splice(0).join("\n") });
+	};
+	for (const [index, value] of mcpContent.entries()) {
+		if (!isRecord(value)) {
+			text.push("[unsupported MCP content block: expected an object]");
 			continue;
 		}
 		const block = value;
 		switch (block.type) {
-			case "text":
-				if (block.text !== void 0) parts.push(block.text);
-				break;
-			case "image":
-				parts.push(`[image: ${block.mimeType ?? "unknown"}, content discarded]`);
-				break;
-			case "audio":
-				parts.push(`[audio: ${block.mimeType ?? "unknown"}, content discarded]`);
-				break;
-			case "resource":
+			case "text": if (block.text !== void 0) text.push(block.text); break;
+			case "image": flushText(); projected.push(image(block, index)); break;
 			case "resource_link":
-				parts.push("[resource: content discarded]");
+				if (block.name === void 0 || block.uri === void 0) text.push("[resource link unavailable: the MCP block is missing its name or URI]");
+				else text.push(`Resource link: ${block.name} (${block.uri})`);
 				break;
-			default: parts.push(`[unsupported content type: ${block.type}]`);
+			case "audio": text.push("[audio result unsupported; audio bytes were not added to text context]"); break;
+			case "resource": text.push("[embedded resource unsupported; resource bytes were not added to text context]"); break;
+			default: text.push(`[unsupported MCP content type: ${block.type}]`);
 		}
 	}
-	return parts.join("\n") || `(${toolName} returned no text content)`;
+	flushText();
+	return projected.length > 0 ? projected : [{ type: "text", text: `(${toolName} returned no model-visible content)` }];
 }
 //#endregion
 //#region lib/types/connection.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "MCP 管理界面 + tool search：可视化配置/启停/刷新 MCP 服务器与工具勾选，按需检索（tool search）热注入；工具列表稳定命中缓存、不撑爆上下文。DeepSeek Harness plugin: MCP management UI + tool search — stable tool list, cache-friendly, no context bloat.",
   "type": "module",
   "main": "lib/index.js",