dsh-mcp 1.5.0 → 1.7.0

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,129 @@ 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": return "image batch exceeds the active size limit";
+		case "IMAGE_TOO_LARGE": return "image exceeds the active size limit";
+		case "UNSUPPORTED_IMAGE_TYPE": return "image type is not accepted";
+		case "IMAGE_TYPE_MISMATCH": return "declared image type does not match image bytes";
+		case "INVALID_IMAGE_BASE64": return "invalid image Base64";
+		case "INVALID_IMAGE": return "malformed or unsupported image data";
+		case "IMAGE_TOO_MANY_PIXELS": return "image exceeds the decoded-pixel limit";
+		case "IMAGE_DIMENSION_TOO_LARGE": return "image exceeds the maximum side dimension";
+		default: return isImageAdmissionError(error) ? "image admission failed" : "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.7.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",
@@ -21,7 +21,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "node scripts/build.mjs"
+    "build": "node scripts/build.mjs",
+    "test": "node --test test/mcp-image-projection.test.mjs"
   },
   "author": "Arvin.qi <arvin.qi@qq.com>",
   "license": "MIT",

package/src/client/ServersJsonEditor.tsx

@@ -1,23 +1,25 @@
 /**
  * JSON server-config editor: view and edit the whole MCP server list as one
- * JSON document. The document is an array of server definitions (the same
- * shape the add/edit form submits); applying it replaces the whole list —
- * listed servers are created or updated, existing servers absent from the
- * document are removed. Secret env values are never exported (a `configured`
- * flag marks them) and a blank secret value keeps the stored one.
+ * key-value JSON document (server name → config). Applying it replaces the
+ * whole list — listed servers are created or updated, existing servers
+ * absent from the document are removed. Secret env values are never
+ * exported (a `configured` flag marks them) and a blank secret value keeps
+ * the stored one.
  *
- *   [
- *     {
- *       "serverName": "feishu-mcp",
- *       "transport": "streamable-http",
- *       "enabled": true,
+ *   {
+ *     "feishu-mcp": {
+ *       "type": "streamable_http",
  *       "url": "https://.../mcp",
  *       "headers": { "Authorization": "Bearer ..." },
- *       "toolCallTimeoutMs": 60000,
- *       "failOnStartupError": true,
- *       "env": []
+ *       "disabled": false
+ *     },
+ *     "local": {
+ *       "type": "stdio",
+ *       "command": "npx",
+ *       "args": ["-y", "some-server"],
+ *       "disabled": false
  *     }
- *   ]
+ *   }
  * @module dsh-mcp/client/ServersJsonEditor
  */
 
@@ -48,13 +50,13 @@ export interface ServersJsonEditorProps {
   readonly onApplied: () => void
 }
 
-/** Serialize the current server list into the JSON document text. */
+/** Serialize the current server list into the JSON document text (key-value). */
 export function serversToJsonText(servers: readonly McpServerView[]): string {
-  const document = servers.map((server) => {
+  const document: Record<string, Record<string, unknown>> = {}
+  for (const server of servers) {
     const entry: Record<string, unknown> = {
-      serverName: server.serverName,
-      transport: server.transport,
-      enabled: server.enabled,
+      type: server.transport === 'stdio' ? 'stdio' : 'streamable_http',
+      disabled: !server.enabled,
     }
     if (server.transport === 'stdio') {
       entry.command = server.command
@@ -71,8 +73,8 @@ export function serversToJsonText(servers: readonly McpServerView[]): string {
     entry.env = server.env.map(row => row.secret
       ? { name: row.name, secret: true, configured: row.configured }
       : { name: row.name, secret: false, ...(row.value !== undefined && row.value.length > 0 ? { value: row.value } : {}) })
-    return entry
-  })
+    document[server.serverName] = entry
+  }
   return `${JSON.stringify(document, null, 2)}\n`
 }
 
@@ -84,40 +86,38 @@ export function parseServersJson(text: string): { ok: true; servers: readonly Se
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) }
   }
-  if (!Array.isArray(value)) {
-    return { ok: false, error: 'JSON 顶层必须是服务器配置数组：[ { serverName, transport, ... }, ... ]' }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return { ok: false, error: 'JSON 顶层必须是对象：{ "服务器名": { "type": "streamable_http", ... } }' }
   }
-  if (value.length === 0) {
+  const entries = Object.entries(value as Record<string, unknown>)
+  if (entries.length === 0) {
     return { ok: false, error: '配置列表不能为空' }
   }
   const servers: ServersJsonEntry[] = []
-  const seen = new Set<string>()
-  for (const item of value) {
-    if (item === null || typeof item !== 'object' || Array.isArray(item)) {
-      return { ok: false, error: '每个条目必须是对象：{ serverName, transport, ... }' }
+  for (const [serverName, raw] of entries) {
+    if (serverName.trim().length === 0) return { ok: false, error: '服务器名不能为空' }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+      return { ok: false, error: `服务器 "${serverName}" 的配置必须是对象` }
     }
-    const server = item as Record<string, unknown>
-    const serverName = typeof server.serverName === 'string' ? server.serverName.trim() : ''
-    if (serverName.length === 0) return { ok: false, error: 'serverName 不能为空' }
-    if (seen.has(serverName)) return { ok: false, error: `serverName "${serverName}" 重复` }
-    seen.add(serverName)
-    const transport = server.transport
-    if (transport !== 'stdio' && transport !== 'streamable-http') {
-      return { ok: false, error: `服务器 "${serverName}" 的 transport 必须是 stdio 或 streamable-http` }
+    const cfg = raw as Record<string, unknown>
+    const type = cfg.type
+    const transport = type === 'stdio' ? 'stdio' : type === 'streamable_http' ? 'streamable-http' : undefined
+    if (transport === undefined) {
+      return { ok: false, error: `服务器 "${serverName}" 的 type 必须是 streamable_http 或 stdio` }
     }
-    if (transport === 'stdio' && (typeof server.command !== 'string' || server.command.trim().length === 0)) {
+    if (transport === 'stdio' && (typeof cfg.command !== 'string' || cfg.command.trim().length === 0)) {
       return { ok: false, error: `服务器 "${serverName}"（stdio）缺少 command` }
     }
-    if (transport === 'streamable-http' && typeof server.url !== 'string') {
-      return { ok: false, error: `服务器 "${serverName}"（streamable-http）缺少 url` }
+    if (transport === 'streamable-http' && typeof cfg.url !== 'string') {
+      return { ok: false, error: `服务器 "${serverName}"（streamable_http）缺少 url` }
     }
-    if (server.headers !== undefined) {
-      const headers = server.headers as unknown
+    if (cfg.headers !== undefined) {
+      const headers = cfg.headers as unknown
       const okHeaders = (headers !== null && typeof headers === 'object' && !Array.isArray(headers))
         || (Array.isArray(headers) && headers.every(h => h !== null && typeof h === 'object' && typeof (h as { name?: unknown }).name === 'string'))
       if (!okHeaders) return { ok: false, error: `服务器 "${serverName}" 的 headers 必须是 { "名称": "值" } 对象或 { name, value } 数组` }
     }
-    const envValue = server.env
+    const envValue = cfg.env
     const env: unknown[] = Array.isArray(envValue) ? envValue : []
     for (const row of env) {
       const r = row as Record<string, unknown> | null
@@ -131,6 +131,20 @@ export function parseServersJson(text: string): { ok: true; servers: readonly Se
         return { ok: false, error: `服务器 "${serverName}" 的 env 条目 "${r.name}" 的 value 必须是字符串` }
       }
     }
+    // Map the key-value document into the wire server shape (host upsertJson
+    // consumes serverName/transport/enabled/...).
+    const server: Record<string, unknown> = {
+      serverName,
+      transport,
+      enabled: cfg.disabled !== true,
+      command: typeof cfg.command === 'string' ? cfg.command : '',
+      args: Array.isArray(cfg.args) ? cfg.args : [],
+      cwd: typeof cfg.cwd === 'string' ? cfg.cwd : '',
+      url: typeof cfg.url === 'string' ? cfg.url : '',
+      headers: cfg.headers,
+      toolCallTimeoutMs: typeof cfg.toolCallTimeoutMs === 'number' ? cfg.toolCallTimeoutMs : 60000,
+      failOnStartupError: cfg.failOnStartupError !== false,
+    }
     servers.push({ server, env })
   }
   return { ok: true, servers }

package/src/client/locales.ts

@@ -75,7 +75,7 @@ export const zh = {
   toolsCollapse: '收起工具',
   serversJson: 'JSON 维护配置',
   serversJsonLabel: '服务器配置 JSON',
-  serversJsonHint: '整个 MCP 服务器配置列表（数组）：应用后将按此列表替换——已列出的服务器创建/更新，未列出的将被删除；secret 环境变量值不会导出（configured 标记），留空则保留原值。',
+  serversJsonHint: '整个 MCP 服务器配置（key-value 对象，服务器名 → 配置）：应用后将按此替换——已列出的服务器创建/更新，未列出的将被删除；type 为 streamable_http 或 stdio，disabled 为 true 表示停用；secret 环境变量值不会导出（configured 标记），留空则保留原值。',
   serversJsonReseed: '重新导出',
   serversJsonApply: '应用',
   serversJsonSaving: '应用中…',
@@ -178,7 +178,7 @@ export const en = {
   toolsCollapse: 'Collapse tools',
   serversJson: 'JSON config editor',
   serversJsonLabel: 'Server-config JSON',
-  serversJsonHint: 'The whole MCP server list (array): applying replaces the list — listed servers are created/updated, existing servers absent from the document are removed; secret env values are never exported (a configured flag marks them), a blank value keeps the stored one.',
+  serversJsonHint: 'The whole MCP server config as a key-value object (server name → config): applying replaces the list — listed servers are created/updated, servers absent from the document are removed; type is streamable_http or stdio, disabled: true disables the server; secret env values are never exported (a configured flag marks them), a blank value keeps the stored one.',
   serversJsonReseed: 'Re-export',
   serversJsonApply: 'Apply',
   serversJsonSaving: 'Applying…',