hydrilla-mcp 2.0.1 → 2.0.2

package/README.md

@@ -91,7 +91,7 @@ The path is relative to the folder that contains `.mcp.json`. The server reads `
 | `hydrilla_me` | Plan and credit balance. Free. |
 | `hydrilla_text_to_3d` | Generate a GLB from a prompt. `send_to` places it in an open app. |
 | `hydrilla_image_to_3d` | Generate a GLB from an image URL. `send_to` places it in an open app. |
-| `hydrilla_get_task` | Status and mesh URL of one task. |
+| `hydrilla_get_task` | Waits up to ~45 s on one task, then returns status, progress and mesh URL. `send_to` places it in an app once ready. |
 | `hydrilla_list_tasks` | Recent models on the account. Free. |
 | `hydrilla_cancel_task` | Stop a running task; unused credits are refunded. |
 | `hydrilla_list_apps` | Which apps have their Bridge running right now. |
@@ -105,5 +105,8 @@ Bridge running, `send_to: "blender"` on a generate tool, or `hydrilla_send_to_ap
 the plugin download the GLB and import it into the open scene. If the Bridge is off, the
 tool says which button to click and the model can be sent again without regenerating.
 
-A generate call waits up to 8 minutes and reports progress to clients that ask for it. If
-the model is not ready by then, it returns the task id to check with `hydrilla_get_task`.
+A model takes 10 to 20 minutes to generate. No tool call stays open longer than about a
+minute: a generate call returns the task id with the progress so far, and the agent calls
+`hydrilla_get_task` (which waits up to ~45 seconds per call) until the model is ready, telling
+the user the progress in between. Calls also send progress notifications to clients that ask
+for them. Hydrilla fails and refunds a task that runs longer than 20 minutes.

package/dist/api.js

@@ -2,7 +2,9 @@ import { API_KEYS_URL, SERVER_VERSION, resolveApiBase, resolveApiKey } from "./c
 const REQUEST_TIMEOUT_MS = 60_000;
 /** Text-to-3D creates its concept image before the request returns. */
 export const CREATE_TIMEOUT_MS = 240_000;
-const POLL_INTERVAL_MS = 2_000;
+const POLL_INTERVAL_MS = 3_000;
+/** Shortest timeout given to one status request, so a nearly spent wait still gets an answer. */
+const MIN_POLL_TIMEOUT_MS = 10_000;
 const MAX_POLL_FAILURES = 5;
 const NO_KEY_MESSAGE = `No Hydrilla API key found. Ask the user to add their key in the Hydrilla plugin (for example the Hydrilla tab in Blender), ` +
     `or to set HYDRILLA_API_KEY in this MCP server's config. Keys are created at ${API_KEYS_URL}. ` +
@@ -85,10 +87,10 @@ export async function api(path, init = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
     }
     return data;
 }
-export const getTask = (taskId) => api(`/v1/3d/tasks/${encodeURIComponent(taskId)}`);
-const pollOnce = async (taskId) => {
+export const getTask = (taskId, timeoutMs = REQUEST_TIMEOUT_MS) => api(`/v1/3d/tasks/${encodeURIComponent(taskId)}`, {}, timeoutMs);
+const pollOnce = async (taskId, timeoutMs) => {
     try {
-        return await getTask(taskId);
+        return await getTask(taskId, timeoutMs);
     }
     catch (error) {
         // A brief network or server hiccup should not lose a paid task.
@@ -100,17 +102,22 @@ const pollOnce = async (taskId) => {
     }
 };
 /**
- * Poll until the task finishes or the wait budget runs out. On timeout the
- * task keeps running on Hydrilla and can be checked again with its id.
+ * Poll until the task finishes or the wait budget runs out. Always checks at
+ * least once, and no request outlives the deadline by more than
+ * MIN_POLL_TIMEOUT_MS. On timeout the task keeps running on Hydrilla and can
+ * be checked again with its id.
  */
 export async function waitForTask(taskId, maxWaitMs, onProgress) {
     const deadline = Date.now() + maxWaitMs;
     const state = {
+        polls: 0,
         failures: 0,
         last: { id: taskId, status: "PENDING" },
     };
-    while (Date.now() < deadline) {
-        const task = await pollOnce(taskId);
+    while (state.polls === 0 || Date.now() < deadline) {
+        state.polls += 1;
+        const timeoutMs = Math.max(MIN_POLL_TIMEOUT_MS, Math.min(REQUEST_TIMEOUT_MS, deadline - Date.now()));
+        const task = await pollOnce(taskId, timeoutMs);
         if (task) {
             state.failures = 0;
             state.last = task;
@@ -125,7 +132,11 @@ export async function waitForTask(taskId, maxWaitMs, onProgress) {
                 throw new HydrillaError("Lost contact with Hydrilla while waiting. Check the task again with hydrilla_get_task.");
             }
         }
-        await sleep(POLL_INTERVAL_MS);
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            break;
+        }
+        await sleep(Math.min(POLL_INTERVAL_MS, remainingMs));
     }
     return { task: state.last, timedOut: true };
 }

package/dist/bridge.js

@@ -6,8 +6,8 @@ export const APPS = ["blender", "maya", "3dsmax", "unreal", "unity", "godot"];
 const BRIDGE_HOST = "127.0.0.1";
 const BRIDGE_SERVICE = "hydrilla-bridge";
 const HEALTH_TIMEOUT_MS = 1_500;
-/** The plugin downloads the mesh before it replies. */
-const IMPORT_TIMEOUT_MS = 5 * 60_000;
+/** The plugin downloads the mesh before it replies; kept short so the tool call still answers. */
+const IMPORT_TIMEOUT_MS = 2 * 60_000;
 const BRIDGE_PORTS = {
     blender: 7345,
     maya: 7346,
@@ -73,7 +73,7 @@ const postImport = async (app, body) => {
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        throw new BridgeError(`${APP_NAMES[app]} stopped responding while receiving the model (${reason}).`);
+        throw new BridgeError(`${APP_NAMES[app]} did not confirm the import (${reason}). It may still be importing; ask the user to check the app before sending the model again.`);
     }
 };
 const readBridgeError = async (response) => {

package/dist/config.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-export const SERVER_VERSION = "2.0.1";
+export const SERVER_VERSION = "2.0.2";
 export const DEFAULT_API_BASE = "https://hydrilla-ai-g1bm.vercel.app";
 export const API_KEYS_URL = "https://hydrilla.ai/app/api-keys";
 /** Hosts that do not serve the developer API (old backend, GPU gateway). */

package/dist/index.js

@@ -7,8 +7,14 @@ import { CREATE_TIMEOUT_MS, api, getTask, waitForTask } from "./api.js";
 import { APPS, appName, listListeningApps, sendMeshToApp } from "./bridge.js";
 import { SERVER_VERSION, getPostHogHost, getPostHogProjectToken, loadLocalEnv } from "./config.js";
 loadLocalEnv();
-/** How long a generate call waits before handing back the task id to check later. */
-const MAX_WAIT_MS = 8 * 60_000;
+/**
+ * Longest a tool call waits on a running task before it answers. A generation
+ * takes 10 to 20 minutes, far longer than many clients let one tool call run
+ * (Codex stops at 60 seconds), and the user sees nothing while a call is open.
+ * So each call answers with the current progress, and the agent calls
+ * hydrilla_get_task again to keep waiting.
+ */
+const CALL_BUDGET_MS = 45_000;
 const jsonResult = (value) => ({
     content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
 });
@@ -60,21 +66,22 @@ const deliver = async (task, app, name) => {
         return { send_error: error instanceof Error ? error.message : String(error) };
     }
 };
-/** Wait for a created task and, if asked, place the model in the user's open app. */
-const finishGeneration = async (taskId, options, extra) => {
-    if (!options.wait) {
-        return jsonResult({
-            id: taskId,
-            status: "PENDING",
-            note: "Generation started. Check it with hydrilla_get_task; send it to an app with hydrilla_send_to_app once it has succeeded.",
-        });
-    }
-    const { task, timedOut } = await waitForTask(taskId, MAX_WAIT_MS, progressReporter(extra));
+const STILL_GENERATING_NOTE = "Still generating; a model usually takes 10 to 20 minutes in total. Tell the user the progress so far, " +
+    "then call hydrilla_get_task with this task_id (and the same send_to and name, if any) to keep waiting. " +
+    "Do not start the generation again.";
+const elapsedSecondsOf = (task) => typeof task.created_at === "number" ? Math.max(0, Math.round(Date.now() / 1000 - task.created_at)) : undefined;
+/**
+ * Wait on a task for at most waitMs, then report where it stands. Once it has
+ * succeeded, place the model in the user's open app if asked.
+ */
+const awaitTask = async (taskId, options, extra) => {
+    const { task, timedOut } = await waitForTask(taskId, options.waitMs, progressReporter(extra));
     if (timedOut) {
         return jsonResult({
             ...task,
             id: taskId,
-            note: "Still generating. Call hydrilla_get_task with this id in a minute; do not start the generation again.",
+            elapsed_seconds: elapsedSecondsOf(task),
+            note: STILL_GENERATING_NOTE,
         });
     }
     if (task.status !== "SUCCEEDED") {
@@ -83,6 +90,18 @@ const finishGeneration = async (taskId, options, extra) => {
     const delivery = await deliver({ ...task, id: taskId }, options.sendTo, options.name);
     return jsonResult({ ...task, id: taskId, ...delivery });
 };
+/** After the create request, wait only for what is left of this call's budget. */
+const finishGeneration = async (taskId, startedAt, options, extra) => {
+    if (!options.wait) {
+        return jsonResult({
+            id: taskId,
+            status: "PENDING",
+            note: "Generation started; it usually takes 10 to 20 minutes. Check it with hydrilla_get_task (pass send_to there to place it in an app when it is done).",
+        });
+    }
+    const waitMs = Math.max(0, CALL_BUDGET_MS - (Date.now() - startedAt));
+    return awaitTask(taskId, { waitMs, sendTo: options.sendTo, name: options.name }, extra);
+};
 const server = new McpServer({
     name: "hydrilla",
     version: SERVER_VERSION,
@@ -135,27 +154,41 @@ const nameSchema = z
     .optional()
     .describe("Short name for the imported object, e.g. 'treasure-chest'");
 server.tool("hydrilla_me", "Return the Hydrilla account plan and credit balance. Free; use it to check the connection.", {}, async () => guarded(async () => jsonResult(await api("/v1/user/me"))));
-server.tool("hydrilla_text_to_3d", "Generate a textured 3D model (GLB) from a text prompt. Costs credits and takes a few minutes. Set send_to to place it in the user's open Blender, Unity, Unreal, Godot, Maya or 3ds Max.", {
+server.tool("hydrilla_text_to_3d", "Generate a textured 3D model (GLB) from a text prompt. Costs credits and takes 10 to 20 minutes: the call returns a task_id within about a minute, then keep calling hydrilla_get_task with it until the model is ready. Set send_to to place it in the user's open Blender, Unity, Unreal, Godot, Maya or 3ds Max.", {
     prompt: z.string().min(1).describe("What to generate"),
-    wait: z.boolean().optional().describe("Wait until the model is ready (default true)"),
+    wait: z
+        .boolean()
+        .optional()
+        .describe("Wait up to about 45 seconds for progress before answering (default true). The model is rarely ready that fast; keep checking with hydrilla_get_task."),
     send_to: sendToSchema,
     name: nameSchema,
 }, async ({ prompt, wait = true, send_to, name }, extra) => guarded(async () => {
+    const startedAt = Date.now();
     const created = await api("/v1/3d/text-to-3d", { method: "POST", body: JSON.stringify({ prompt }) }, CREATE_TIMEOUT_MS);
-    return finishGeneration(created.id, { wait, sendTo: send_to, name }, extra);
+    return finishGeneration(created.id, startedAt, { wait, sendTo: send_to, name }, extra);
 }));
-server.tool("hydrilla_image_to_3d", "Generate a textured 3D model (GLB) from a public image URL. Costs credits and takes a few minutes. Set send_to to place it in the user's open app.", {
+server.tool("hydrilla_image_to_3d", "Generate a textured 3D model (GLB) from a public image URL. Costs credits and takes 10 to 20 minutes: the call returns a task_id within about a minute, then keep calling hydrilla_get_task with it until the model is ready. Set send_to to place it in the user's open app.", {
     image_url: z.string().url().describe("Public image URL"),
-    wait: z.boolean().optional().describe("Wait until the model is ready (default true)"),
+    wait: z
+        .boolean()
+        .optional()
+        .describe("Wait up to about 45 seconds for progress before answering (default true). The model is rarely ready that fast; keep checking with hydrilla_get_task."),
     send_to: sendToSchema,
     name: nameSchema,
 }, async ({ image_url, wait = true, send_to, name }, extra) => guarded(async () => {
+    const startedAt = Date.now();
     const created = await api("/v1/3d/image-to-3d", { method: "POST", body: JSON.stringify({ image_url }) }, CREATE_TIMEOUT_MS);
-    return finishGeneration(created.id, { wait, sendTo: send_to, name }, extra);
+    return finishGeneration(created.id, startedAt, { wait, sendTo: send_to, name }, extra);
 }));
-server.tool("hydrilla_get_task", "Check a Hydrilla 3D task by id. Returns its status and, once it has succeeded, the mesh URL.", {
+server.tool("hydrilla_get_task", "Check a Hydrilla 3D task by id, waiting up to about 45 seconds for it to finish. Returns its status and progress and, once it has succeeded, the mesh URL. While it is still generating, tell the user the progress and call this again with the same task_id. Pass send_to to place the model in an open app as soon as it is ready.", {
     task_id: z.string().min(1),
-}, async ({ task_id }) => guarded(async () => jsonResult(await getTask(task_id))));
+    wait: z
+        .boolean()
+        .optional()
+        .describe("Wait up to about 45 seconds for the task to finish (default true). Set false for an instant status check."),
+    send_to: sendToSchema,
+    name: nameSchema,
+}, async ({ task_id, wait = true, send_to, name }, extra) => guarded(async () => awaitTask(task_id, { waitMs: wait ? CALL_BUDGET_MS : 0, sendTo: send_to, name }, extra)));
 server.tool("hydrilla_list_tasks", "List the user's recent Hydrilla 3D models, newest first. Free. Use it to find a model that already exists instead of generating it again.", {
     limit: z.number().int().min(1).max(100).optional().describe("How many to return (default 20)"),
 }, async ({ limit = 20 }) => guarded(async () => jsonResult(await api(`/v1/3d/tasks?limit=${limit}`))));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hydrilla-mcp",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "MCP server for Hydrilla: generate 3D models and send them into Blender, Unity, Unreal, Godot, Maya or 3ds Max.",
   "keywords": [
     "mcp",