openzoo 0.36.0 → 0.37.0

package/lib/gui.html

@@ -172,10 +172,23 @@ async function send() {
     if (state.ctx) headers["x-hrr-context"] = state.ctx;
     const r = await fetch("/v1/chat/completions", {
       method: "POST", headers,
-      body: JSON.stringify({ model: $("model").value, messages: state.messages, max_tokens: 2048 }),
+      // reasoning models bill their thinking inside max_tokens — 2048 bought
+      // a whole essay of invisible reasoning and zero visible words (measured
+      // live: deepseek, finish_reason "length", empty content, $0.0172)
+      body: JSON.stringify({
+        model: $("model").value,
+        messages: state.messages,
+        max_tokens: /deepseek|grok|thinking|fable|sonnet-5|-r1|reason/i.test($("model").value) ? 16384 : 4096,
+      }),
     });
     const d = await r.json();
-    const content = d.choices?.[0]?.message?.content || d.error?.message || JSON.stringify(d).slice(0, 300);
+    const ch = d.choices?.[0];
+    let content = ch?.message?.content || "";
+    if (!content && ch?.finish_reason === "length") {
+      content = "🦥 the animal thought so hard it ran out of room before saying anything. try again — the cage just got bigger.";
+    } else if (!content) {
+      content = d.error?.message || "🦉 the zoo returned something unusual: " + JSON.stringify(d).slice(0, 200);
+    }
     thinking.textContent = content;
     state.messages.push({ role: "assistant", content });
     const x = d.x402 || {};

package/lib/mcp.js

@@ -41,6 +41,17 @@ export function buildMcpServer() {
       'Never search the machine for API keys or endpoints — there are none to find. zoo_wallet shows funding',
       'state, zoo_models lists what is served with live pricing.',
       '',
+      // Agents previously probed zoo_ask, got text back, and concluded the zoo
+      // could not do media at all — the text upstream serves NO video models.
+      'IMAGE AND VIDEO ARE SERVED, on their own tools — zoo_ask cannot emit them.',
+      '  zoo_image        synchronous, returns hosted URLs (FLUX, Imagen, Seedream, Qwen-Image, gpt-image…)',
+      '  zoo_video        asynchronous, returns a job id (Sora 2, Veo 3.1, Kling, Seedance, Wan, pixverse…)',
+      '  zoo_video_result poll the job id — free, the render was paid for at submit',
+      'In zoo_models these carry kind="image" / kind="video" and are priced per image or per clip, not per token.',
+      'leCore does NOT participate in a render: a diffusion prompt never reaches the spill threshold, so do not',
+      'claim holographic memory improved the picture. To ground a render in your own material, use zoo_ask to',
+      'WRITE the prompt from a bound corpus, then pass that prompt to zoo_image / zoo_video.',
+      '',
       // ROUTING, STATED UNCONDITIONALLY. An agent whose OWN inference is not
       // routed through the proxy never receives lib/brief.js, so it answers
       // "I have no visibility into the routing layer" while this very server
@@ -168,6 +179,121 @@ export function buildMcpServer() {
     }
   });
 
+  /* ------------------------------------------------------------------ *
+   * MEDIA — image and video.
+   *
+   * These exist because the honest answer to "can openzoo make me a picture"
+   * used to be no: zoo_ask rides /v1/chat/completions, whose upstream is
+   * text-only (of OpenRouter's 413 models, ZERO emit video). Agents worked
+   * that out the hard way and concluded the zoo was a dead end for media.
+   *
+   * DO NOT route these through leCore. A diffusion prompt is a few hundred
+   * characters and the spill threshold is 8,000 tokens, so binding would
+   * never engage — and implying otherwise would sell holographic memory as
+   * doing something it demonstrably does not do here. leCore's real use for
+   * media is upstream: ask zoo_ask (grounded in a bound corpus) to WRITE the
+   * prompt, then pass that prompt here.
+   * ------------------------------------------------------------------ */
+  server.registerTool('zoo_image', {
+    description:
+      'Generate an IMAGE through openzoo.fun, paid per call from the local burner wallet via x402 — no '
+      + 'Together/OpenAI account or API key needed. Returns hosted image URLs plus the payment receipt. '
+      + 'Pick a model with zoo_models (image models carry kind="image"); the default is a fast, cheap FLUX. '
+      + 'This is a RENDER call, not a reasoning call: the prompt is used verbatim, no corpus is bound, and '
+      + 'leCore holographic memory does not participate. To ground a prompt in your own material, call '
+      + 'zoo_ask first to write it, then pass the result here.',
+    inputSchema: {
+      prompt: z.string().describe('What to draw. Used verbatim by the diffusion model.'),
+      model: z.string().optional().describe('Image model id from zoo_models (kind="image"). Defaults to a fast cheap FLUX.'),
+      width: z.number().int().positive().optional().describe('Pixels. Default 1024. Priced per megapixel on some models.'),
+      height: z.number().int().positive().optional().describe('Pixels. Default 1024.'),
+      n: z.number().int().positive().optional().describe('How many images. Default 1. Multiplies the price.'),
+    },
+  }, async ({ prompt, model, width, height, n }) => {
+    try {
+      const { response, receipt } = await client.fetch(`${config.apiBase}/v1/images/generations`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ prompt, ...(model ? { model } : {}), ...(width ? { width } : {}),
+          ...(height ? { height } : {}), ...(n ? { n } : {}) }),
+      });
+      const data = await response.json();
+      if (!response.ok) throw new Error(`zoo returned HTTP ${response.status}: ${JSON.stringify(data).slice(0, 300)}`);
+      return text({
+        images: (data?.data ?? []).map((d) => d.url ?? (d.b64_json ? '<base64 inline>' : null)).filter(Boolean),
+        model: data?.model ?? model ?? null,
+        receipt: receipt ? { billedUsd: receipt.billedUsd, rail: receipt.rail, line: receipt.line } : 'free (no 402 issued)',
+      });
+    } catch (err) {
+      return text({ error: err?.message || String(err), hint: railFundingHint() });
+    }
+  });
+
+  server.registerTool('zoo_video', {
+    description:
+      'Generate a VIDEO through openzoo.fun, paid per call from the local burner wallet via x402. '
+      + 'ASYNCHRONOUS: this returns a job id immediately — poll zoo_video_result with that id until status '
+      + 'is "completed", then read outputs.video_url. Rendering typically takes tens of seconds to minutes. '
+      + 'Payment happens HERE, at submit; polling is free. Pick a model with zoo_models (kind="video"): '
+      + 'Sora 2, Veo 3.1, Kling, Seedance, Wan and others are served. Video is materially more expensive '
+      + 'than image — check the quote in the receipt.',
+    inputSchema: {
+      prompt: z.string().describe('What the clip should show.'),
+      model: z.string().optional().describe('Video model id from zoo_models (kind="video").'),
+      seconds: z.number().int().positive().optional().describe('Clip length in seconds. Default 5. Longer costs proportionally more.'),
+      resolution: z.enum(['720P', '1080P']).optional().describe('720P (default) or 1080P.'),
+      generate_audio: z.boolean().optional().describe('Ask the model for audio too, where supported.'),
+      negative_prompt: z.string().optional().describe('What to avoid.'),
+    },
+  }, async ({ prompt, model, seconds, resolution, generate_audio, negative_prompt }) => {
+    try {
+      const { response, receipt } = await client.fetch(`${config.apiBase}/v1/videos/generations`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ prompt, ...(model ? { model } : {}), ...(seconds ? { seconds } : {}),
+          ...(resolution ? { resolution } : {}), ...(generate_audio !== undefined ? { generate_audio } : {}),
+          ...(negative_prompt ? { negative_prompt } : {}) }),
+      });
+      const data = await response.json();
+      if (!response.ok) throw new Error(`zoo returned HTTP ${response.status}: ${JSON.stringify(data).slice(0, 300)}`);
+      return text({
+        jobId: data?.id ?? null,
+        status: data?.status ?? null,
+        next: data?.id ? `Call zoo_video_result with id="${data.id}" until status is "completed".` : null,
+        receipt: receipt ? { billedUsd: receipt.billedUsd, rail: receipt.rail, line: receipt.line } : 'free (no 402 issued)',
+      });
+    } catch (err) {
+      return text({ error: err?.message || String(err), hint: railFundingHint() });
+    }
+  });
+
+  server.registerTool('zoo_video_result', {
+    description:
+      'Fetch the state of a zoo_video job. FREE — the render was already paid for at submit, so poll as often '
+      + 'as you like. status is "in_progress", "completed" or "failed"; on completion outputs.video_url holds '
+      + 'the clip and outputs.cost the real upstream charge. A failed job reports why in error.message — note '
+      + 'that a bad parameter fails the job AFTER submit, so a failure here is not a payment failure.',
+    inputSchema: {
+      id: z.string().describe('The jobId returned by zoo_video.'),
+    },
+  }, async ({ id }) => {
+    try {
+      const r = await fetch(`${config.apiBase}/v1/videos/${encodeURIComponent(id)}`, {
+        headers: withNamespace({}),
+      });
+      const data = await r.json();
+      if (!r.ok) throw new Error(`zoo returned HTTP ${r.status}: ${JSON.stringify(data).slice(0, 300)}`);
+      return text({
+        status: data?.status ?? null,
+        videoUrl: data?.outputs?.video_url ?? null,
+        upstreamCost: data?.outputs?.cost ?? null,
+        error: data?.error ?? undefined,
+      });
+    } catch (err) {
+      return text({ error: err?.message || String(err) });
+    }
+  });
+
   // WHY A DEDICATED TOOL: MCP server `instructions` are advisory and several
   // clients (Cursor among them) never surface them to the model — so an agent
   // with this server attached still answers "I have no visibility into the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",