@khanglvm/relay 0.14.2 → 0.16.0

package/src/mcp-ui/board.js

@@ -219,6 +219,7 @@
       allowPartial: raw.allowPartial !== false,
       note: raw.note !== false,
       autoClose: raw.autoClose !== false,
+      responseRequired: raw.responseRequired !== false,
       questions: [],
       submitLabel: typeof raw.submitLabel === 'string' ? raw.submitLabel : '',
     };
@@ -388,7 +389,13 @@
       questionId: questionId == null ? null : questionId,
       // No annotation during the streaming preview (it re-renders); on the final
       // interactive render, wire the engine so blocks register their targets.
-      annotate: composing ? null : Annotate,
+      annotate: composing || (spec && spec.responseRequired === false) ? null : Annotate,
+      canComment: Boolean(spec && spec.responseRequired !== false),
+      saveArtifact: async ({ dataUrl, mime, width, height }) => {
+        const comma = typeof dataUrl === 'string' ? dataUrl.indexOf(',') : -1;
+        if (comma < 0) throw new Error('invalid image crop');
+        return { data: dataUrl.slice(comma + 1), mime: mime || 'image/png', width, height };
+      },
       edits: state.blockEdits,
       onBlockEdit: (blockId, codeOrNull) => {
         if (codeOrNull === null || codeOrNull === undefined) delete state.blockEdits[blockId];
@@ -882,7 +889,7 @@
       app.append(card);
     });
 
-    if (spec.note) {
+    if (spec.note && spec.responseRequired !== false) {
       const note = el('textarea', { placeholder: 'optional note back to the agent…' });
       note.value = state.comment || '';
       note.addEventListener('input', () => { state.comment = note.value; });
@@ -898,6 +905,12 @@
       reportSize();
       return;
     }
+    if (spec.responseRequired === false) {
+      app.append(el('div', { class: 'submitbar display-only' },
+        el('span', { class: 'hint' }, 'Display only · no response requested')));
+      reportSize();
+      return;
+    }
     const submitBtn = el('button', { class: 'submit', type: 'button' }, spec.submitLabel);
     const saveEl = el('span', { class: 'savestate' }, '');
     const hint = el('span', { class: 'hint' }, QS.length && spec.allowPartial ? 'Unanswered questions are returned as skipped.' : '');
@@ -940,7 +953,9 @@
       lines.push('', 'Inline comments (' + data.annotations.length + '):');
       for (const a of data.annotations) {
         const where = (a.target && (a.target.label || a.target.text || a.target.kind)) || a.blockId || 'element';
-        lines.push('- [' + where + ']: ' + a.text);
+        const crop = a.target && a.target.crop;
+        const cropNote = crop && crop.path ? ' · crop: ' + crop.path : crop && crop.data ? ' · image crop attached' : '';
+        lines.push('- [' + where + ']: ' + a.text + cropNote);
       }
     }
     if (data.blockEdits) lines.push('', 'Edited diagrams: ' + Object.keys(data.blockEdits).join(', '));
@@ -964,24 +979,43 @@
       annotations: data.annotations,
     };
     const text = summarize(data);
+    const messageContent = [{ type: 'text', text }];
+    for (const a of data.annotations || []) {
+      const crop = a && a.target && a.target.crop;
+      if (!crop || typeof crop.data !== 'string' || !crop.data) continue;
+      messageContent.push({ type: 'image', data: crop.data, mimeType: crop.mime || 'image/png' });
+    }
     let messageDelivered = false;
     let contextDelivered = false;
     try {
       // A completed relay form is a user reply, not passive context. Some hosts
       // ACK `ui/update-model-context` without starting a new model turn, so send
       // the transcript as a user message first to wake the agent reliably.
-      await request('ui/message', { role: 'user', content: { type: 'text', text } });
+      await request('ui/message', { role: 'user', content: messageContent });
       messageDelivered = true;
     } catch {
-      // Older/leaner hosts may not expose app-initiated messages.
+      // Older hosts may not advertise image content or may implement the early
+      // single-content draft. Preserve the text wake path before giving up.
+      try {
+        await request('ui/message', { role: 'user', content: [{ type: 'text', text }] });
+        messageDelivered = true;
+      } catch {
+        try {
+          await request('ui/message', { role: 'user', content: { type: 'text', text } });
+          messageDelivered = true;
+        } catch { /* app-initiated messages unavailable */ }
+      }
     }
     try {
       // Keep the structured payload available to hosts that attach app context.
       // This is best-effort because context updates are intentionally silent.
-      await request('ui/update-model-context', { content: [{ type: 'text', text }], structuredContent: structured });
+      await request('ui/update-model-context', { content: messageContent, structuredContent: structured });
       contextDelivered = true;
     } catch {
-      // If ui/message worked, the agent still receives the submission transcript.
+      try {
+        await request('ui/update-model-context', { content: [{ type: 'text', text }], structuredContent: structured });
+        contextDelivered = true;
+      } catch { /* ui/message may still have delivered the result */ }
     }
     submitted = true;
     showDone(messageDelivered, contextDelivered);
@@ -1029,7 +1063,11 @@
     seedDefaults();
     indexHtmlBlocks(spec);
     setStatus('Preparing…');
-    if (Annotate) Annotate.init({ initial: [], onChange: (a) => { state.annotations = Array.isArray(a) ? a : []; } });
+    if (Annotate && spec.responseRequired !== false) {
+      Annotate.init({ initial: [], onChange: (a) => { state.annotations = Array.isArray(a) ? a : []; } });
+    } else if (Annotate && typeof Annotate.teardown === 'function') {
+      Annotate.teardown();
+    }
     try { await preloadVendors(spec); } catch { /* render anyway; blocks degrade individually */ }
     render();
     applyDisplayMode();

package/src/mcp.js

@@ -111,7 +111,7 @@ function tools() {
     {
       name: 'relay_show',
       description:
-        'Present work to the user on an inline board WITHOUT necessarily asking questions — a plan, an architecture diagram, data, a diff, a prototype — using rich blocks (markdown, mermaid, graphviz, chart, table, code, diff, image, html). The board shows a Submit/Acknowledge button. Same spec as relay_ask; typically blocks-only.',
+        'Present work to the user on an inline display-only board — a plan, architecture diagram, data, diff, prototype, or image — using rich blocks. It returns immediately and does not ask the user to acknowledge. Set responseRequired:true only when feedback or acknowledgement is actually needed.',
       inputSchema: schema,
       _meta: uiToolMeta(),
     },
@@ -157,7 +157,7 @@ async function buildResult(method, params, clientProtocol) {
         },
         serverInfo: { name: 'relay', version: PKG.version },
         instructions:
-          'relay renders interactive boards inline. Call relay_ask to collect decisions/feedback with real form controls, or relay_show to present plans/diagrams/data — instead of asking in plain text. When the user submits, relay sends their answers back as a user message so the agent continues.',
+          'relay renders boards inline. Call relay_ask to collect decisions/feedback and wait for its user-message submission. Call relay_show to present plans/diagrams/data without waiting; it is display-only unless responseRequired:true is explicit.',
       };
     case 'ping':
       return {};
@@ -209,9 +209,12 @@ async function callTool(params) {
     return { content: [{ type: 'text', text: 'unknown tool: ' + name }], isError: true };
   }
   const args = (params && params.arguments && typeof params.arguments === 'object') ? params.arguments : {};
+  const normalizedArgs = name === 'relay_show' && args.responseRequired === undefined
+    ? { ...args, responseRequired: false }
+    : args;
   let spec;
   try {
-    spec = normalizeSpec(args);
+    spec = normalizeSpec(normalizedArgs);
     await assertSpecReady(spec);
   } catch (err) {
     const msg = err instanceof CliError ? err.message : String((err && err.message) || err);
@@ -232,6 +235,9 @@ async function callTool(params) {
 // when the board clearly didn't render for the user.
 function boardText(spec) {
   const nQ = spec.questions.length;
+  if (spec.responseRequired === false) {
+    return `Relay board "${spec.title}" is now displayed to the user. No acknowledgement is requested; continue your work without waiting.`;
+  }
   if (!nQ) {
     return `Relay board "${spec.title}" is now displayed to the user. They can review it and acknowledge; any feedback will be delivered back to you.`;
   }