@kolbo/mcp 1.119.1 → 1.120.0

package/README.md

@@ -321,6 +321,7 @@ Requires DaVinci Resolve Studio with the Kolbo plugin open (Workspace → Workfl
 | `generate_character_sheet` | Generate a multi-angle character sheet from reference images (credits) → pass URL to create_visual_dna or update_visual_dna |
 | `list_visual_dna_folders` / `create_visual_dna_folder` / `update_visual_dna_folder` / `delete_visual_dna_folder` / `move_visual_dna_to_folder` | Organize Visual DNA characters into user folders (create/rename/recolor/delete + move DNAs in/out) |
 | `create_project` / `update_project` / `archive_project` / `unarchive_project` | Project lifecycle (create/rename/describe/archive; deletion stays in-app) |
+| `transfer_visual_dna` / `list_visual_dna_transfers` / `respond_visual_dna_transfer` | Send Visual DNAs you own to another Kolbo account (they accept a copy with new ids; optionally move instead of copy) |
 | `transfer_project` / `list_project_transfers` / `respond_project_transfer` | Hand a project you own to another Kolbo account (they accept; same ids; cast assets copied; payer history unchanged) |
 | `list_skills` / `create_skill` / `update_skill` / `delete_skill` | Skills — reusable named personas for the chat tool; `description` is the system instruction |
 | `list_agents` / `create_agent` / `update_agent` / `delete_agent` | Same four tools under their original names. Still supported and unchanged; new integrations should use the `*_skill` names |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kolbo/mcp",
-  "version": "1.119.1",
+  "version": "1.120.0",
   "description": "Kolbo AI MCP Server - Generate images, videos, music, speech, and sound effects from Claude Code",
   "main": "src/index.js",
   "bin": {

package/src/apps/bridge.js

@@ -55,10 +55,32 @@ const BRIDGE_JS = `
 
   function post(msg) { window.parent.postMessage(msg, '*'); }
 
+  // Longer than the 180s stdio status wait plus transport overhead.
+  // This bounds tracking only; it never cancels or resubmits a paid job.
+  var REQUEST_TIMEOUT_MS = 240000;
+  function timeoutError() {
+    var error = new Error('The host did not answer. Tracking paused; the job may still be running.');
+    error.code = 'KOLBO_HOST_TIMEOUT';
+    return error;
+  }
+  function boundedCall(run) {
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () { reject(timeoutError()); }, REQUEST_TIMEOUT_MS);
+      Promise.resolve().then(run).then(function (value) {
+        clearTimeout(timer); resolve(value);
+      }, function (error) { clearTimeout(timer); reject(error); });
+    });
+  }
+
   function request(method, params) {
     return new Promise(function (resolve, reject) {
       var id = nextId++;
-      pending[id] = { resolve: resolve, reject: reject };
+      var timer = setTimeout(function () {
+        delete pending[id];
+        queue = queue.filter(function (item) { return item.id !== id; });
+        reject(timeoutError());
+      }, REQUEST_TIMEOUT_MS);
+      pending[id] = { resolve: resolve, reject: reject, timer: timer };
       var msg = { jsonrpc: '2.0', id: id, method: method, params: params || {} };
       if (initialized || method === 'ui/initialize') post(msg);
       else queue.push(msg);
@@ -78,6 +100,7 @@ const BRIDGE_JS = `
       var p = pending[m.id];
       if (!p) return;
       delete pending[m.id];
+      clearTimeout(p.timer);
       if (m.error) p.reject(new Error(m.error.message || 'host error'));
       else p.resolve(m.result);
       return;
@@ -282,7 +305,7 @@ const BRIDGE_JS = `
     var oaCall = function (method) { return typeof oa[method] === 'function'; };
     window.kolbo.callTool = function (name, args) {
       if (!oaCall('callTool')) return Promise.reject(new Error('host cannot call tools'));
-      return Promise.resolve(oa.callTool(name, args || {})).then(function (r) {
+      return boundedCall(function () { return oa.callTool(name, args || {}); }).then(function (r) {
         // The SDK resolves with the CallToolResult (content + structuredContent);
         // some builds unwrap to the structured payload — normalise either.
         if (r && (r.structuredContent || r.content)) return r;

package/src/apps/widgets/generation.js

@@ -802,7 +802,10 @@ function schedulePoll(sc) {
   // (~45s over the remote connector — see WAIT_WINDOW_MS in tools/generate.js).
   // This short pause only separates successive wait windows — the FIRST call
   // goes out immediately, so a card revealed by scrolling resolves at once.
-  var delay = pollStart ? 1500 : 0;
+  // After failed calls, back off exponentially (capped at 30s): a host that
+  // rejects tools/call for a while (busy, rate-limited, reconnecting) used to
+  // burn all MAX_POLL_ERRORS retries in ~45s and strand finished generations.
+  var delay = pollStart ? Math.min(1500 * Math.pow(2, pollErrors), 30000) : 0;
   if (!pollStart) pollStart = Date.now();
   clearTimeout(pollTimer);
   pollTimer = setTimeout(function () { poll(sc); }, delay);
@@ -813,6 +816,9 @@ function poll(sc) {
     return renderTrackingIssue('This is still running longer than the tracking window. Do not retry it — any completed result will appear in your Kolbo library.');
   }
   var args = sc.status_args || { generation_id: sc.generation_id, wait: true };
+  // Host-bridged calls may not reset their timeout on progress: keep each
+  // wait window inside the common 60s request timeout.
+  if (args.wait) args = Object.assign({}, args, { wait_seconds: 45 });
   pollInFlight = true;
   window.kolbo.callTool(sc.poll_tool || 'get_generation_status', args).then(function (res) {
     pollInFlight = false;
@@ -870,7 +876,7 @@ function poll(sc) {
       pollErrors = 0; // a valid in-progress response resets the failure streak
       schedulePoll(sc);
     }
-  }).catch(function () {
+  }).catch(function (error) {
     pollInFlight = false;
     if (cancelRequested || (state && (state.phase === 'completed' || state.phase === 'failed'))) return;
     if (++pollErrors >= MAX_POLL_ERRORS) return renderTrackingIssue('Tracking paused after repeated connection errors. The generation may still be running.');
@@ -1270,13 +1276,18 @@ function renderError(msg) {
 
 function renderTrackingIssue(msg) {
   clearTimeout(pollTimer);
-  setPhaseChip('Still working', false);
+  setPhaseChip('Tracking paused', false);
   el('stage').innerHTML = '<div class="k-error">' + ICONS.clock + ' ' + esc(msg) + '</div>';
   el('actions').innerHTML = '<button class="k-btn primary" id="status-btn">' + ICONS.clock + ' Check status</button>' +
     '<button class="k-btn ghost" id="tracking-open">Open in Kolbo ' + ICONS.open + '</button>';
+  // Resume tracking in place: the card re-checks the SAME generation ids
+  // (never a resubmit). A chat message alone left the card red even after
+  // the agent learned the job had finished.
   el('status-btn').onclick = function () {
-    window.kolbo.sendMessage('Check the existing Kolbo generation status without retrying it.' +
-      (state && state.generation_id ? '\\nGeneration ID: ' + state.generation_id : ''));
+    if (!state) return;
+    pollErrors = 0; pollStart = 0;
+    setPhaseChip('Checking', true);
+    schedulePoll(state);
   };
   el('tracking-open').onclick = function () {
     window.kolbo.openLink(kolboUrl(state));

package/src/apps/widgets/transcript.js

@@ -40,6 +40,7 @@ var state = null, pollTimer = null, originArgs = {};
 
 function boot(sc) {
   if (!sc) return;
+  clearTimeout(pollTimer);
   state = sc;
   el('credits').textContent = sc.credits_used != null ? fmtCredits(sc.credits_used) : '';
   if (sc.phase === 'generating') {
@@ -93,6 +94,8 @@ function poll() {
     return trackingIssue('This transcription is still running longer than the tracking window. Do not retry it — any completed result will appear in your Kolbo library.');
   }
   var args = state.status_args || { generation_id: state.generation_id, wait: true };
+  // Keep each host-bridged wait inside the common 60s request timeout.
+  if (args.wait) args = Object.assign({}, args, { wait_seconds: 45 });
   window.kolbo.callTool(state.poll_tool || 'get_generation_status', args)
     .then(function (res) {
       var st = structured(res) || {};
@@ -107,7 +110,8 @@ function poll() {
       } else if (s === 'failed' || s === 'cancelled') {
         boot(Object.assign({}, state, { phase: 'failed', error: st.error }));
       } else { pollErrors = 0; pollTimer = setTimeout(poll, pollDelay()); }
-    }).catch(function () {
+    }).catch(function (error) {
+      if (state && state.phase !== 'generating') return;
       if (++pollErrors >= MAX_POLL_ERRORS) return trackingIssue('Tracking paused after repeated connection errors. The transcription may still be running.');
       pollTimer = setTimeout(poll, pollDelay());
     });
@@ -115,20 +119,24 @@ function poll() {
 
 function pollDelay() {
   // The call itself long-waits server-side; only briefly back off between
-  // successive wait windows.
-  return 1500;
+  // successive wait windows; after failed calls, back off exponentially
+  // (capped at 30s) so a briefly unavailable host can't exhaust the retries.
+  return Math.min(1500 * Math.pow(2, pollErrors), 30000);
 }
 
 function trackingIssue(msg) {
   clearTimeout(pollTimer);
   el('phase-chip').style.display = '';
-  el('phase-chip').textContent = 'Still working';
+  el('phase-chip').textContent = 'Tracking paused';
   el('stage').classList.remove('k-empty');
   el('stage').innerHTML = '<div class="k-error">' + ICONS.clock + ' ' + esc(msg) + '</div>';
   el('actions').innerHTML = '<button class="k-btn primary" id="transcript-status">' + ICONS.clock + ' Check status</button>';
+  // Resume tracking in place (same generation id, never a resubmit).
   el('transcript-status').onclick = function () {
-    window.kolbo.sendMessage('Check the existing Kolbo transcription status without retrying it.' +
-      (state && state.generation_id ? '\\nGeneration ID: ' + state.generation_id : ''));
+    if (!state) return;
+    pollErrors = 0;
+    el('actions').innerHTML = '';
+    boot(Object.assign({}, state, { phase: 'generating' }));
   };
   window.kolbo.notifySize();
 }

package/src/tools/generate.js

@@ -604,16 +604,17 @@ function registerGenerateTools(server, client, options = {}) {
     'Check the status of a Creative Director batch (from generate_creative_director) by its generation_id. Returns overall state ("processing" until EVERY scene is terminal, then "completed"/"failed") plus each scene\'s number, title, per-scene status, and image_urls/video_urls. Set wait=true to block until the batch is terminal or the wait window closes, whichever comes first — a batch longer than one window returns state="processing" and you simply call again with wait=true. Prefer this over the generic get_generation_status for Creative Director ids — the generic tool now returns the same scene data (it delegates here), but this one is the direct route.',
     {
       generation_id: z.string().describe('The Creative Director generation_id returned by generate_creative_director.'),
-      wait: z.boolean().optional().describe(`If true, block until the batch is terminal, for at most ~${WAIT_WINDOW_S}s per call. A batch that outlives one window comes back state="processing" (not an error) — call again with wait=true until it is terminal. Always prefer this over polling with wait=false.`)
+      wait: z.boolean().optional().describe(`If true, block until the batch is terminal, for at most ~${WAIT_WINDOW_S}s per call. A batch that outlives one window comes back state="processing" (not an error) — call again with wait=true until it is terminal. Always prefer this over polling with wait=false.`),
+      wait_seconds: z.number().min(1).max(180).optional().describe('Optional cap on one wait=true window, in seconds (default and maximum: the transport window). Interactive cards pass 45 so each call fits a host 60s request timeout.')
     },
-    async ({ generation_id, wait }) => {
+    async ({ generation_id, wait, wait_seconds }) => {
       const statusUrl = `/v1/generate/creative-director/${encodeURIComponent(generation_id)}/status`;
       let status;
       if (wait) {
         try {
           status = await pollUntilDone(client, generation_id, {
             interval: 15000,
-            timeout: WAIT_WINDOW_MS,
+            timeout: wait_seconds ? Math.min(wait_seconds * 1000, WAIT_WINDOW_MS) : WAIT_WINDOW_MS,
             statusUrl
           });
         } catch (err) {
@@ -1348,14 +1349,20 @@ function registerGenerateTools(server, client, options = {}) {
     {
       generation_id: z.string().optional().describe('A single generation ID to check'),
       generation_ids: z.array(z.string()).max(MAX_STATUS_IDS).optional().describe(`Multiple generation IDs to check in ONE call (max ${MAX_STATUS_IDS}). Returns { all_done, pending, generations[] } — always prefer this over checking IDs one by one.`),
-      wait: z.boolean().optional().describe(`If true, block until every generation reaches a terminal state (completed/failed), for at most ~${WAIT_WINDOW_S}s per call, then return whatever state they are in. Anything still processing is reported, not errored — re-issue with wait=true and only the still-pending ids. This is always better than polling with wait=false.`)
+      wait: z.boolean().optional().describe(`If true, block until every generation reaches a terminal state (completed/failed), for at most ~${WAIT_WINDOW_S}s per call, then return whatever state they are in. Anything still processing is reported, not errored — re-issue with wait=true and only the still-pending ids. This is always better than polling with wait=false.`),
+      wait_seconds: z.number().min(1).max(180).optional().describe('Optional cap on one wait=true window, in seconds (default and maximum: the transport window). Interactive cards pass 45 so each call fits a host 60s request timeout.')
     },
-    async ({ generation_id, generation_ids, wait }) => {
+    async ({ generation_id, generation_ids, wait, wait_seconds }) => {
       const ids = (generation_ids && generation_ids.length > 0)
         ? [...new Set(generation_ids)]
         : (generation_id ? [generation_id] : []);
       if (ids.length === 0) throw new Error('Provide generation_id or generation_ids');
       if (ids.length > MAX_STATUS_IDS) throw new Error(`At most ${MAX_STATUS_IDS} generation IDs can be checked at once.`);
+      // Widget polls arrive through the host's iframe bridge, which (unlike the
+      // model's own calls) need not reset its request timeout on our progress
+      // ticks — a 180s stdio window there timed out every poll, stranding cards
+      // on Generating and then "Tracking paused". Widgets pass wait_seconds.
+      const windowMs = wait_seconds ? Math.min(wait_seconds * 1000, WAIT_WINDOW_MS) : WAIT_WINDOW_MS;
 
       // One status check (or blocking poll) per id. Never let one bad id
       // reject the whole batch — surface it as a failed entry instead.
@@ -1366,7 +1373,7 @@ function registerGenerateTools(server, client, options = {}) {
             // completion responsive without multiplying backend traffic for
             // every card left open in a host conversation. The window itself is
             // bounded by the transport — see WAIT_WINDOW_MS above.
-            const result = await pollUntilDone(client, id, { interval: 15000, timeout: WAIT_WINDOW_MS });
+            const result = await pollUntilDone(client, id, { interval: 15000, timeout: windowMs });
             return { generation_id: id, ...result };
           }
           const result = await client.get(`/v1/generate/${encodeURIComponent(id)}/status`);

package/src/tools/presets.js

@@ -44,16 +44,17 @@ function registerPresetTools(server, client, options = {}) {
           : 'Pass search next time if you already know the name. Pass the chosen exact id as preset_id.',
       });
 
-      if (lookup) return { content: [{ type: 'text', text }] };
-
       // TOOL_WIDGETS declares mediaGrid for this tool, so hosts that mount from
-      // the declaration (Claude desktop) rendered a media grid fed a list-shaped
-      // 8-item page with no page_tool: a "Load more" that could never load. Ship
-      // the whole catalog (a few hundred small rows) to the grid it actually mounts.
+      // the declaration (Claude desktop) prepare a grid on EVERY call — the
+      // search lookup included. A text-only lookup left that grid guessing from
+      // the compact JSON: thumbnail-less file tiles under the UNFILTERED total.
+      // structuredContent also shadows the text on those hosts, so it carries
+      // the ids, total and note the agent needs.
+      const total = search && !result.search ? presets.length : (result.count || presets.length);
       return uiResult(UI.mediaGrid, text, {
         widget: 'mediaGrid',
         title: 'Presets' + (type ? ' — ' + type : ''),
-        items: presets.slice(0, 300).map(p => ({
+        items: presets.slice(0, lookup ? 8 : 300).map(p => ({
           id: p.id,
           title: p.name,
           subtitle: p.category,
@@ -63,8 +64,10 @@ function registerPresetTools(server, client, options = {}) {
           url: p.thumbnail_url || p.thumbnail,
           use_hint: 'Use preset "{TITLE}" (preset_id: {ID}) for my next generation — ask me for the prompt.'
         })),
-        total: result.count || presets.length,
-        has_more: presets.length > 300
+        total,
+        has_more: presets.length > (lookup ? 8 : 300),
+        ...(lookup ? { _lookup: true, note: 'Pick the closest id and pass it as preset_id.' } : {}),
+        ...(result.warning ? { warning: result.warning } : {}),
       });
     }
   );