@mokuyoaxis/dsh-iris 0.1.3 → 0.1.4

package/lib/provider-adapters.js

@@ -0,0 +1,279 @@
+'use strict';
+
+/**
+ * 已支持协议到 Provider Adapter v0 的映射。
+ *
+ * 凭据和 baseUrl 只被操作闭包捕获，不进入 Adapter 描述或能力快照。
+ * transport 默认为现有低层 HTTP 实现；测试可注入零网络 fixture。
+ */
+import * as defaultTransport from './adapters.js';
+import { ProviderContractError, providerErrorRecord } from './provider-contract.js';
+import { defineProviderAdapter } from './provider-adapter.js';
+import { inferMediaProtocol } from './provider-protocol.js';
+
+const AMBIGUOUS_4XX = new Set([408, 409, 425, 499]);
+
+function providerIdentity(provider) {
+  const id = String(provider?.id || '').trim();
+  const key = String(provider?.apiKey || '');
+  const baseUrl = String(provider?.baseUrl || '').trim();
+  if (!id) throw new TypeError('Provider 配置缺少 id');
+  if (!baseUrl) throw new TypeError('Provider 配置缺少 baseUrl');
+  return { id, key, baseUrl };
+}
+
+function mappedCategory(error, status) {
+  const raw = String(error?.category || '').toLowerCase();
+  if (error?.name === 'AbortError' || error?.code === 'ABORT_ERR') return 'aborted';
+  if (error?.name === 'TimeoutError' || /timeout|timed out|超时/i.test(String(error?.message || ''))) return 'timeout';
+  if (status === 401 || status === 403 || raw === 'auth') return 'authentication';
+  if (status === 429 && raw === 'quota') return 'quota';
+  if (status === 429 || raw === 'rate_limit') return 'rate_limit';
+  if (raw === 'invalid_parameter') return 'invalid_request';
+  if (raw === 'network' || error instanceof TypeError) return 'network';
+  if (raw === 'server' || status >= 500) return 'provider';
+  if (!status && /未返回|响应|协议|结构|json/i.test(String(error?.message || ''))) return 'protocol';
+  return 'provider';
+}
+
+/** 当前两个协议共享的错误映射；不保留 cause、rootCause、正文、URL 或凭据。 */
+export function mapProviderAdapterError(error, context = {}) {
+  const statusValue = Number(error?.httpStatus ?? error?.status);
+  const httpStatus = Number.isInteger(statusValue) && statusValue >= 100 && statusValue <= 599
+    ? statusValue
+    : undefined;
+  const stage = String(context.stage || error?.stage || 'submit');
+  const category = mappedCategory(error, httpStatus);
+  let acceptance = context.acceptance || error?.acceptance;
+  if (stage === 'validate' || stage === 'prepare' || stage === 'upload') {
+    acceptance = 'not_accepted';
+  } else if (stage === 'submit') {
+    acceptance = httpStatus && httpStatus >= 400 && httpStatus < 500 && !AMBIGUOUS_4XX.has(httpStatus)
+      ? 'not_accepted'
+      : (error?.acceptance === 'not_accepted' ? 'not_accepted' : 'unknown');
+  } else if (!acceptance) {
+    acceptance = 'accepted';
+  }
+  const retryable = Boolean(
+    context.retryable ?? error?.retryable
+    ?? (httpStatus === 429 || (httpStatus && httpStatus >= 500)
+      || category === 'network' || category === 'timeout')
+  );
+  return providerErrorRecord(error, {
+    stage,
+    category,
+    acceptance,
+    retryable,
+    ...(httpStatus ? { httpStatus } : {})
+  });
+}
+
+function unsupportedCapability(capability, protocol) {
+  return new ProviderContractError(
+    '协议 ' + protocol + ' 不支持任务能力 ' + String(capability || ''),
+    { stage: 'validate', category: 'invalid_request', acceptance: 'not_accepted' }
+  );
+}
+
+function pollFailureKind(status) {
+  const value = String(status || '').toUpperCase();
+  if (value === 'CANCELED' || value === 'CANCELLED') return 'canceled';
+  if (value === 'UNKNOWN') return 'unknown';
+  return 'failed';
+}
+
+function operationsForDashScope(provider, transport) {
+  const { key, baseUrl } = providerIdentity(provider);
+  return {
+    async discover({ signal, timeoutMs } = {}) {
+      return { models: await transport.listModels({ key, baseUrl, signal, timeoutMs }) };
+    },
+
+    async submit(request = {}) {
+      const input = request.input || {};
+      const common = {
+        key, baseUrl, model: request.model, signal: request.signal,
+        ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
+      };
+      if (request.capability === 'image') {
+        if (transport.dashscopeImageMode(request.model) === 'legacy-async') {
+          const remoteTaskId = await transport.submitImage({
+            ...common, prompt: input.prompt, size: input.size, n: input.n
+          });
+          return { kind: 'accepted', remoteTaskId };
+        }
+        const urls = await transport.generateImageMultimodal({
+          ...common, prompt: input.prompt, size: input.size, n: input.n
+        });
+        return { kind: 'completed', value: { kind: 'urls', items: urls } };
+      }
+      if (request.capability === 'video') {
+        const remoteTaskId = await transport.submitVideo({
+          ...common,
+          prompt: input.prompt,
+          imgDataUrl: input.imgDataUrl,
+          size: input.size,
+          duration: input.duration,
+          audioUrl: input.audioUrl,
+          resolution: input.resolution
+        });
+        return { kind: 'accepted', remoteTaskId };
+      }
+      if (request.capability === 'transcribe') {
+        const remoteTaskId = await transport.submitTranscription({
+          ...common, audioUrl: input.audioUrl
+        });
+        return { kind: 'accepted', remoteTaskId };
+      }
+      if (request.capability === 'tts') {
+        const value = await transport.synthesizeTts({
+          ...common, text: input.text, voice: input.voice
+        });
+        return { kind: 'completed', value };
+      }
+      throw unsupportedCapability(request.capability, 'dashscope');
+    },
+
+    async poll(request = {}) {
+      const common = {
+        key, baseUrl, remoteTaskId: request.remoteTaskId, signal: request.signal,
+        ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
+      };
+      if (request.capability === 'transcribe') {
+        const result = await transport.pollTranscriptionTask(common);
+        if (!result.done) return { kind: 'pending', progress: result.status || 'running' };
+        if (!result.ok) {
+          return {
+            kind: pollFailureKind(result.status),
+            error: mapProviderAdapterError(result.message || '转写任务失败', {
+              stage: 'poll', acceptance: 'accepted'
+            })
+          };
+        }
+        return { kind: 'succeeded', value: { kind: 'text', text: String(result.text || '') } };
+      }
+      if (request.capability === 'image' || request.capability === 'video') {
+        const result = await transport.pollTask(common);
+        if (!result.done) return { kind: 'pending', progress: result.status || 'running' };
+        if (!result.ok) {
+          return {
+            kind: pollFailureKind(result.status),
+            error: mapProviderAdapterError(result.message || '生成任务失败', {
+              stage: 'poll', acceptance: 'accepted'
+            })
+          };
+        }
+        return {
+          kind: 'succeeded',
+          artifacts: (result.urls || []).map((url) => ({ kind: 'remote-url', url }))
+        };
+      }
+      throw unsupportedCapability(request.capability, 'dashscope');
+    },
+
+    async download(request = {}) {
+      const artifact = request.artifact || {};
+      if (artifact.kind !== 'remote-url' || !artifact.url) {
+        throw new ProviderContractError('download 需要 remote-url artifact', {
+          stage: 'download', category: 'protocol', acceptance: 'accepted'
+        });
+      }
+      const targetPath = String(request.targetPath || '').trim();
+      if (!targetPath) {
+        throw new ProviderContractError('download 需要 targetPath', {
+          stage: 'download', category: 'local_io', acceptance: 'accepted'
+        });
+      }
+      return {
+        bytes: await transport.downloadTo(artifact.url, targetPath, {
+          signal: request.signal,
+          ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
+        })
+      };
+    },
+
+    mapError: mapProviderAdapterError
+  };
+}
+
+export function createDashScopeProviderAdapter(provider, { transport = defaultTransport } = {}) {
+  return defineProviderAdapter({
+    id: providerIdentity(provider).id,
+    protocol: 'dashscope',
+    capabilities: ['image', 'video', 'tts', 'transcribe'],
+    operations: operationsForDashScope(provider, transport),
+    unsupported: {
+      cancel: '当前 DashScope 媒体协议未提供经过验证的远端取消实现'
+    }
+  });
+}
+
+function operationsForOpenAiImages(provider, transport) {
+  const { key, baseUrl } = providerIdentity(provider);
+  return {
+    async discover({ signal, timeoutMs } = {}) {
+      return { models: await transport.listModels({ key, baseUrl, signal, timeoutMs }) };
+    },
+
+    async submit(request = {}) {
+      if (request.capability !== 'image') {
+        throw unsupportedCapability(request.capability, 'openai-images');
+      }
+      const input = request.input || {};
+      const items = await transport.openAiGenerateImage({
+        key,
+        baseUrl,
+        model: request.model,
+        prompt: input.prompt,
+        size: input.size,
+        n: input.n,
+        signal: request.signal,
+        ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
+      });
+      return { kind: 'completed', value: { kind: 'openai', items } };
+    },
+
+    async download(request = {}) {
+      const artifact = request.artifact || {};
+      if (artifact.kind !== 'remote-url' || !artifact.url) {
+        throw new ProviderContractError('download 需要 remote-url artifact', {
+          stage: 'download', category: 'protocol', acceptance: 'accepted'
+        });
+      }
+      const targetPath = String(request.targetPath || '').trim();
+      if (!targetPath) {
+        throw new ProviderContractError('download 需要 targetPath', {
+          stage: 'download', category: 'local_io', acceptance: 'accepted'
+        });
+      }
+      return {
+        bytes: await transport.downloadTo(artifact.url, targetPath, {
+          signal: request.signal,
+          ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {})
+        })
+      };
+    },
+
+    mapError: mapProviderAdapterError
+  };
+}
+
+export function createOpenAiImagesProviderAdapter(provider, { transport = defaultTransport } = {}) {
+  return defineProviderAdapter({
+    id: providerIdentity(provider).id,
+    protocol: 'openai-images',
+    capabilities: ['image'],
+    operations: operationsForOpenAiImages(provider, transport),
+    unsupported: {
+      poll: 'OpenAI Images 兼容路径在当前实现中同步返回结果',
+      cancel: '同步图片响应没有可验证的远端取消任务'
+    }
+  });
+}
+
+export function createConfiguredProviderAdapter(provider, options = {}) {
+  const protocol = options.protocol || provider?.mediaProtocol || inferMediaProtocol(provider?.baseUrl);
+  if (protocol === 'dashscope') return createDashScopeProviderAdapter(provider, options);
+  if (protocol === 'openai-images') return createOpenAiImagesProviderAdapter(provider, options);
+  throw new TypeError('iris: 不支持的 Provider 协议：' + String(protocol));
+}

package/lib/provider-health.js

@@ -0,0 +1,59 @@
+'use strict';
+
+export const PROVIDER_HEALTH_SCHEMA_VERSION = 1;
+export const PROVIDER_HEALTH_FRESH_MS = 7 * 24 * 60 * 60 * 1000;
+export const PROVIDER_HEALTH_STATES = Object.freeze([
+  'unconfigured',
+  'configured',
+  'verified',
+  'failed'
+]);
+
+const DEFINITIVE_FAILURES = new Set(['authentication', 'auth', 'permission']);
+
+function validTime(value) {
+  const ms = Date.parse(String(value || ''));
+  return Number.isFinite(ms) ? ms : 0;
+}
+
+export function isDefinitiveHealthFailure(value) {
+  const status = Number(value && (value.httpStatus ?? value.status));
+  const category = String(value && value.category || '').toLowerCase();
+  return status === 401 || status === 403 || DEFINITIVE_FAILURES.has(category);
+}
+
+export function healthObservationState(observation, {
+  now = Date.now(),
+  freshMs = PROVIDER_HEALTH_FRESH_MS
+} = {}) {
+  if (!observation || typeof observation !== 'object') return 'configured';
+  const successAt = validTime(observation.lastSuccess && observation.lastSuccess.at);
+  const failureAt = validTime(observation.lastFailure && observation.lastFailure.at);
+  const cutoff = Number(now) - Number(freshMs);
+
+  if (failureAt >= cutoff && failureAt >= successAt
+      && isDefinitiveHealthFailure(observation.lastFailure)) {
+    return 'failed';
+  }
+  if (successAt >= cutoff && successAt > failureAt) return 'verified';
+  return 'configured';
+}
+
+export function aggregateHealthStates(states) {
+  const list = (Array.isArray(states) ? states : []).filter((state) =>
+    PROVIDER_HEALTH_STATES.includes(state) && state !== 'unconfigured');
+  if (!list.length) return 'unconfigured';
+  if (list.includes('verified')) return 'verified';
+  if (list.includes('configured')) return 'configured';
+  return 'failed';
+}
+
+export function newestHealthEvidence(observation) {
+  const entries = [
+    observation && observation.lastSuccess,
+    observation && observation.lastFailure,
+    observation && observation.lastTransient
+  ].filter((item) => item && validTime(item.at));
+  entries.sort((a, b) => validTime(b.at) - validTime(a.at));
+  return entries[0] || null;
+}

package/lib/render.js

@@ -6,8 +6,8 @@
  *   Promise<{ png: Buffer }>
  *
  * BrowserHtmlRenderer：基于宿主 webServer 的 /iris/render/ 静态路由 +
- * dsh-builtin-browser 的 ctx.browser 服务（可选访问，软耦合）。
- * - 不 import dsh-builtin-browser 包，只在运行时探测 ctx.get('browser')
+ * DSH Host Adapter 注入的 browser 端口底层服务（可选访问，软耦合）。
+ * - 不 import dsh-builtin-browser 包，不在通用渲染层探测 DSH ctx
  * - HTML 通过宿主路由以同源 HTTP 打开（避免 file:// 的 CORS 限制）
  * - 每次调用独立临时渲染目录，用后即删
  */
@@ -25,14 +25,42 @@ export class RenderError extends Error {
   }
 }
 
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new RenderError('iris_html_screenshot: 已取消');
+  error.name = 'AbortError';
+  throw error;
+}
+
+function waitForRender(ms, signal) {
+  if (!(ms > 0)) return Promise.resolve();
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', canceled);
+      resolve();
+    };
+    const canceled = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', canceled);
+      const error = new RenderError('iris_html_screenshot: 已取消');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener?.('abort', canceled, { once: true });
+  });
+}
+
 /** 渲染临时目录根：$DSH_HOME/iris/v1/render/ */
 export function renderRoot() {
   return path.join(irisHome(), 'render');
 }
 
 /**
- * 基于 ctx.browser（dsh-builtin-browser）的 HTML → PNG 渲染器。
- * @param {{browser?: object, waitMs?: number}} opts browser 为 ctx.get('browser') 服务
+ * 基于 DSH Adapter 持有的原生 browser 服务完成 HTML → PNG。
+ * @param {{browser?: object, waitMs?: number}} opts browser 只在 DSH Adapter 内构造
  */
 export class BrowserHtmlRenderer {
   constructor({ browser, waitMs = 1200 }) {
@@ -40,13 +68,14 @@ export class BrowserHtmlRenderer {
     this.waitMs = waitMs;
   }
 
-  async render({ html, width, height, fullPage }) {
+  async render({ html, width, height, fullPage, signal }) {
     const b = this.browser;
     if (!b || typeof b.open !== 'function' || typeof b.openUrl !== 'function' || typeof b.screenshot !== 'function') {
-      throw new RenderError('iris: 浏览器服务不可用（ctx.get("browser") 为空）——需要启用 dsh-builtin-browser 插件');
+      throw new RenderError('iris: 浏览器服务不可用——需要启用兼容的 dsh-builtin-browser 插件');
     }
     const text = String(html || '').trim();
     if (!text) throw new RenderError('iris_html_screenshot: html 不能为空');
+    throwIfAborted(signal);
 
     // 每次调用独立子目录（随机名），写 index.html
     const dir = path.join(renderRoot(), crypto.randomBytes(6).toString('hex'));
@@ -63,13 +92,15 @@ export class BrowserHtmlRenderer {
     const pngPath = path.join(dir, 'render.png');
 
     try {
-      const session = await b.open();
+      const session = await b.open({ signal });
+      throwIfAborted(signal);
       try {
-        await b.openUrl(session, { url, newTab: true });
-        if (this.waitMs > 0) {
-          await new Promise((r) => setTimeout(r, this.waitMs)); // 等页面加载（无加载完成事件可用的折中）
-        }
-        await b.screenshot(session, { fullPage: fullPage !== false, savePath: pngPath });
+        await b.openUrl(session, { url, newTab: true, signal });
+        throwIfAborted(signal);
+        await waitForRender(this.waitMs, signal); // 等页面加载（无加载完成事件可用的折中）
+        throwIfAborted(signal);
+        await b.screenshot(session, { fullPage: fullPage !== false, savePath: pngPath, signal });
+        throwIfAborted(signal);
       } finally {
         try { await b.close(session); } catch (_) { /* 幂等 */ }
       }

package/lib/tasks.js

@@ -19,6 +19,7 @@ import { parseModelRef } from './models.js';
 import { attentionDisposition, deriveLegacyStatus, deriveUserState, semanticViolations } from './task-semantics.js';
 export { attentionDisposition } from './task-semantics.js';
 import { providerErrorRecord, redactProviderMessage } from './provider-contract.js';
+import { providerPollTaskView } from './provider-adapter.js';
 
 const FILE = () => path.join(irisHome(), 'tasks.json');
 /** 产物目录：$DSH_HOME/iris/v1/outputs */
@@ -508,8 +509,8 @@ export function stopWatchAll() {
  * 开始盯守一个异步任务（提交成功后调用）。
  * @param {object} task 已 create 的任务记录（须含 remoteTaskId）
  * @param {object} deps
- *   key(): string                                    —— 每次轮询现取凭据
- *   poll({key, remoteTaskId}): {done,ok,urls,message} —— 协议适配器的查询函数
+ *   key?(): string                                   —— 仅供旧 poll 兼容；v0 Adapter 自持凭据闭包
+ *   poll({key?, remoteTaskId}): Provider poll v0（兼容旧 done/ok 形状）—— 协议适配器查询
  *   onSuccess(task, {urls}): string[]                 —— 结果转存，返回相对 outputs/ 的文件名列表
  *   intervalMs?: number                               —— 轮询间隔（默认 2500）
  *   maxWatchMs?: number                               —— 盯守上限（默认 20 分钟）
@@ -551,7 +552,11 @@ export function watch(task, deps) {
     }
     let r;
     try {
-      r = await deps.poll({ key: deps.key(), remoteTaskId: t.remoteTaskId });
+      const raw = await deps.poll({
+        key: typeof deps.key === 'function' ? deps.key() : undefined,
+        remoteTaskId: t.remoteTaskId
+      });
+      r = providerPollTaskView(raw);
     } catch (err) {
       const n = (errStreak.get(task.id) || 0) + 1;
       errStreak.set(task.id, n);
@@ -571,10 +576,29 @@ export function watch(task, deps) {
     }
     if (!r.ok) {
       const message = redactProviderMessage(r.message || '任务失败');
-      if (!v2) return finishLegacy({ status: 'failed', error: message });
+      if (!v2) {
+        return finishLegacy({ status: r.kind === 'canceled' ? 'canceled' : 'failed', error: message });
+      }
+      if (r.kind === 'unknown') {
+        return finishV2({
+          phase: 'terminal', watchState: 'exhausted', outcome: 'unknown',
+          lastError: r.error || providerErrorRecord(message, {
+            stage: 'poll', category: 'provider', acceptance: 'accepted'
+          }),
+          error: message, finishedAt: new Date().toISOString()
+        });
+      }
+      if (r.kind === 'canceled') {
+        return finishV2({
+          phase: 'terminal', watchState: 'idle', outcome: 'canceled', cancelState: 'remote_confirmed',
+          lastError: r.error, error: message, finishedAt: new Date().toISOString()
+        });
+      }
       return finishV2({
         phase: 'terminal', watchState: 'idle', outcome: 'failed',
-        lastError: providerErrorRecord(message, { stage: 'poll', category: 'provider', acceptance: 'accepted' }),
+        lastError: r.error || providerErrorRecord(message, {
+          stage: 'poll', category: 'provider', acceptance: 'accepted'
+        }),
         error: message, finishedAt: new Date().toISOString()
       });
     }

package/lib/vision.js

@@ -5,12 +5,13 @@
  * 把“识图”拆成「VisionBackend 接口 +
  * 两个实现」，让自持栈与 DSH 全局模型可替换、按序降级。
  * - SelfStackVisionBackend：自持栈（OpenAI 兼容 /chat/completions，qwen-vl）
- * - GlobalLlmVisionBackend：DSH 全局视觉模型（ctx.llm.stream()）
+ * - HostVisionBackend：由 Host Adapter 提供的可选视觉模型
  *
- * 调用方（工具）不感知底层：buildVisionBackends 按 provider 顺序组装，
+ * 调用方（工具）不感知底层：buildVisionBackendsFromHost 按 provider 顺序组装，
  * askWithBackends 依次尝试、保留每个后端的失败现场。
  */
 import * as adapters from './adapters.js';
+import { hasHostPort } from './host-contract.js';
 
 /** 后端接口约定：id / kind / model 只读，analyze(request) → Promise<string> */
 
@@ -39,52 +40,16 @@ export class SelfStackVisionBackend {
   }
 }
 
-export class GlobalLlmVisionBackend {
-  constructor({ llm }) {
-    this.llm = llm;
-  }
-  get id() {
-    return 'global';
-  }
-  get kind() {
-    return 'global';
-  }
-  get model() {
-    return '全局视觉模型';
-  }
-  async analyze({ question, ref, signal }) {
-    const chunks = [];
-    for await (const chunk of this.llm.stream({
-      sessionId: undefined,
-      provider: undefined,
-      model: undefined,
-      signal,
-      messages: [
-        {
-          role: 'user',
-          content: [
-            { type: 'text', text: question },
-            { type: 'image', attachment: ref }
-          ]
-        }
-      ]
-    })) {
-      const t = chunk && chunk.delta;
-      if (typeof t === 'string' && t) chunks.push(t);
-      if (chunks.join('').length > 6000) break;
-    }
-    return chunks.join('').trim();
-  }
+export class HostVisionBackend {
+  constructor({ port }) { this.port = port; }
+  get id() { return this.port.id || 'host-vision'; }
+  get kind() { return this.port.kind || 'global'; }
+  get model() { return this.port.model || '宿主视觉模型'; }
+  async analyze(request) { return this.port.analyze(request); }
 }
 
-/**
- * 按 provider 顺序组装视觉后端链（自持栈在前，全局模型兜底在后）。
- * 只接受已声明/推断 vision 能力的 provider（由调用方用 capability 过滤）。
- * @param {object} ctx DSH ctx（用于取 llm 服务）
- * @param {{providers: Array, model?: string}} opts model 覆盖全部自持栈的 vision 模型
- * @returns {Array} 有序后端
- */
-export function buildVisionBackends(ctx, { providers, model }) {
+/** Host Adapter 入口；Command 不读取 DSH ctx。 */
+export function buildVisionBackendsFromHost(host, { providers, model }) {
   const backends = [];
   for (const p of providers || []) {
     if (p && p.type === 'openai') {
@@ -92,8 +57,9 @@ export function buildVisionBackends(ctx, { providers, model }) {
       backends.push(new SelfStackVisionBackend({ provider }));
     }
   }
-  const llm = ctx && typeof ctx.get === 'function' ? ctx.get('llm') : undefined;
-  if (llm && typeof llm.stream === 'function') backends.push(new GlobalLlmVisionBackend({ llm }));
+  if (hasHostPort(host, 'visionModel') && typeof host.ports.visionModel.analyze === 'function') {
+    backends.push(new HostVisionBackend({ port: host.ports.visionModel }));
+  }
   return backends;
 }
 
@@ -116,6 +82,7 @@ export async function askWithBackends(backends, request) {
       errors.push({
         backendId: b.id,
         kind: b.kind,
+        model: b.model,
         category: err && err.category,
         status: err && err.status,
         message: String((err && err.message) || err)
@@ -164,7 +131,14 @@ export async function testVisionCapability(backend, { timeoutMs = 10000, signal
     const ok = RED_HINTS.test(String(answer || ''));
     return { ok, answer: String(answer || '') };
   } catch (err) {
-    return { ok: false, answer: '', error: String((err && err.message) || err), timedOut: !!err.timedOut };
+    return {
+      ok: false,
+      answer: '',
+      error: String((err && err.message) || err),
+      timedOut: !!err.timedOut,
+      category: err && err.category,
+      status: err && err.status
+    };
   } finally {
     if (timer) clearTimeout(timer);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mokuyoaxis/dsh-iris",
-  "version": "0.1.3",
-  "description": "Multi-provider media generation, visual understanding, prompt optimization, and an integrated Iris workbench for DeepSeek Harness.",
+  "version": "0.1.4",
+  "description": "Multi-provider image, video, and speech generation, transcription, visual understanding, and prompt optimization with an integrated Iris workbench for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -24,13 +24,16 @@
     "CHANGELOG.md",
     "screenshots.json",
     "docs",
-    "!docs/assets/examples/orange-cat-reading.png",
+    "!docs/assets/diagrams/*.drawio",
+    "!docs/releases/0.1.1.md",
+    "!docs/releases/0.1.2.md",
+    "!docs/releases/0.1.3.md",
     ".dsh/skills/iris-verify-ui",
     ".dsh/skills/iris-compose-media"
   ],
   "dsh": {
     "engines": {
-      "dsh": ">=0.1.2-rc.1 <0.1.3-0"
+      "dsh": ">=0.1.2-rc.1 <0.1.3-0 || 0.1.5-rc.1"
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -49,11 +52,14 @@
   "keywords": [
     "deepseek-harness",
     "dsh-plugin",
-    "vision",
     "image-generation",
+    "video-generation",
+    "text-to-speech",
+    "transcription",
+    "vision",
     "dashscope",
-    "tts",
-    "prompt-optimization"
+    "prompt-optimization",
+    "media-workbench"
   ],
   "license": "MIT",
   "engines": {
@@ -103,6 +109,6 @@
     "url": "https://github.com/mokuyoaxis/dsh-iris/issues"
   },
   "bin": {
-    "dsh-iris": "./bin/dsh-iris.js"
+    "dsh-iris": "bin/dsh-iris.js"
   }
 }