privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-PB3PZJL5.mjs

@@ -0,0 +1,1276 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  effectiveMediaModel
+} from "./c-5JCEPRIY.mjs";
+import "./c-RVJU4O6P.mjs";
+import {
+  apiRequest
+} from "./c-EC3LJ2KF.mjs";
+import {
+  globalDir
+} from "./c-YGQHSVSK.mjs";
+import {
+  require_undici
+} from "./c-P63T3XL2.mjs";
+import "./c-4WVR32AP.mjs";
+import {
+  typebox_exports
+} from "./c-RQJJ26T4.mjs";
+import "./c-L5GHWG5G.mjs";
+import {
+  __name,
+  __toESM
+} from "./c-CN77DCGF.mjs";
+
+// src/tools/media.ts?ext=privateer-gate
+var import_undici = __toESM(require_undici());
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, statSync, readdirSync } from "node:fs";
+import { createDecipheriv, randomBytes } from "node:crypto";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { tmpdir } from "node:os";
+var MEDIA_TOOL_NAMES = [
+  "generate_image",
+  "generate_video",
+  "generate_model",
+  "generate_sprite",
+  "generate_speech",
+  "generate_music",
+  "generate_sfx",
+  "media_capabilities"
+];
+var VIDEO_POLL_TIMEOUT_MS = Number(process.env.PRIVATEER_VIDEO_TIMEOUT_MS) || 25 * 6e4;
+var VIDEO_POLL_INTERVAL_MS = 5e3;
+var MESH_POLL_TIMEOUT_MS = Number(process.env.PRIVATEER_MESH_TIMEOUT_MS) || 10 * 6e4;
+var SPRITE_POLL_TIMEOUT_MS = Number(process.env.PRIVATEER_SPRITE_TIMEOUT_MS) || 25 * 6e4;
+var SPRITE_POLL_INTERVAL_MS = 6e3;
+var MESH_POLL_INTERVAL_MS = 5e3;
+var MAX_MESH_VIEWS = 4;
+var MAX_MESH_INPUT_TOTAL_BYTES = 12 * 1024 * 1024;
+var MAX_INPUT_IMAGE_BYTES = 8 * 1024 * 1024;
+function text(t) {
+  return { content: [{ type: "text", text: t }], details: {} };
+}
+__name(text, "text");
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+function mimeForImage(path) {
+  return IMAGE_MIME[extname(path).toLowerCase()] ?? "image/jpeg";
+}
+__name(mimeForImage, "mimeForImage");
+function extForMime(mimeType, fallback) {
+  const m = (mimeType || "").toLowerCase();
+  if (m.includes("png")) return ".png";
+  if (m.includes("jpeg") || m.includes("jpg")) return ".jpg";
+  if (m.includes("webp")) return ".webp";
+  if (m.includes("mp4")) return ".mp4";
+  if (m.includes("webm")) return ".webm";
+  if (m.includes("mpeg") || m.includes("mp3")) return ".mp3";
+  if (m.includes("wav")) return ".wav";
+  if (m.includes("ogg")) return ".ogg";
+  return fallback;
+}
+__name(extForMime, "extForMime");
+function abs(cwd, p) {
+  return isAbsolute(p) ? p : resolve(cwd, p);
+}
+__name(abs, "abs");
+function writeOut(target, bytes) {
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, bytes);
+  const kb = bytes.length / 1024;
+  return `${target} (${kb >= 1024 ? `${(kb / 1024).toFixed(1)} MB` : `${Math.round(kb)} KB`})`;
+}
+__name(writeOut, "writeOut");
+function readInputImage(cwd, p) {
+  const target = abs(cwd, p);
+  if (!existsSync(target)) throw new Error(`input image not found: ${p}`);
+  const stat = statSync(target);
+  if (stat.isDirectory()) throw new Error(`${p} is a directory, not an image`);
+  if (stat.size === 0) throw new Error(`${p} is empty`);
+  if (stat.size > MAX_INPUT_IMAGE_BYTES) {
+    throw new Error(`${p} is ${(stat.size / 1048576).toFixed(1)} MB; the limit for an input image is ${MAX_INPUT_IMAGE_BYTES / 1048576} MB`);
+  }
+  return { data: readFileSync(target).toString("base64"), mimeType: mimeForImage(target) };
+}
+__name(readInputImage, "readInputImage");
+var MEDIA_HTTP_TIMEOUT_MS = 20 * 6e4;
+var _mediaDispatcher = null;
+function mediaDispatcher() {
+  return _mediaDispatcher ??= new import_undici.Agent({
+    headersTimeout: MEDIA_HTTP_TIMEOUT_MS,
+    bodyTimeout: MEDIA_HTTP_TIMEOUT_MS,
+    connect: { autoSelectFamilyAttemptTimeout: 2e3 }
+  });
+}
+__name(mediaDispatcher, "mediaDispatcher");
+function describeTransportFailure(e) {
+  if (e instanceof Error && e.name === "AbortError") return "the request was cancelled";
+  const top = e instanceof Error ? e.message : String(e);
+  const cause = e?.cause;
+  const code = String(cause?.code ?? e?.code ?? "");
+  const causeMsg = cause instanceof Error ? cause.message : "";
+  if (/^UND_ERR_(HEADERS|BODY)_TIMEOUT$/.test(code)) {
+    return `Privateer did not answer within ${Math.round(MEDIA_HTTP_TIMEOUT_MS / 6e4)} minutes (${code}). The generation may still have finished and been billed on the server, so check the output path before retrying, and retry once rather than in a loop`;
+  }
+  const detail = [code, causeMsg].filter(Boolean).join(": ");
+  return `could not reach Privateer: ${top}${detail && !top.includes(detail) ? ` (${detail})` : ""}`;
+}
+__name(describeTransportFailure, "describeTransportFailure");
+async function callAccount(path, init) {
+  let res;
+  try {
+    res = await apiRequest(path, {
+      // npm undici's Agent vs the undici-types Dispatcher in RequestInit: same runtime
+      // contract (verified against both Node's bundled fetch and Pi's undici 8).
+      ...{ dispatcher: mediaDispatcher() },
+      method: init.method,
+      ...init.body === void 0 ? {} : { headers: { "Content-Type": "application/json" }, body: JSON.stringify(init.body) },
+      ...init.signal ? { signal: init.signal } : {}
+    });
+  } catch (e) {
+    return { ok: false, message: describeTransportFailure(e) };
+  }
+  return interpretAccountResponse(res);
+}
+__name(callAccount, "callAccount");
+async function interpretAccountResponse(res) {
+  if (res.ok || res.status === 202) {
+    try {
+      return { ok: true, data: await res.json() };
+    } catch {
+      return { ok: false, message: "Privateer returned a malformed response" };
+    }
+  }
+  let code = "";
+  let serverMessage = "";
+  try {
+    const err = await res.json();
+    code = String(err?.code ?? err?.error?.code ?? "");
+    serverMessage = String(err?.message ?? err?.error?.message ?? "");
+  } catch {
+  }
+  if (code === "ZDR_MEDIA_BLOCKED") {
+    return {
+      ok: false,
+      status: res.status,
+      message: (serverMessage || "this account requires Zero Data Retention and the media model has no ZDR endpoint") + " \u2014 this is a privacy setting only the account owner can change (Settings \u2192 Privacy), so do not retry."
+    };
+  }
+  if (code === "ZDR_KEY_UNAVAILABLE") {
+    return { ok: false, status: res.status, message: serverMessage || "no zero-retention provider key is available right now \u2014 try again later" };
+  }
+  if (/DAILY_CAP|LIMIT_REACHED/i.test(code) || res.status === 429) {
+    return { ok: false, status: res.status, message: serverMessage || "the account's daily media allowance is used up \u2014 it resets tomorrow" };
+  }
+  if (res.status === 402 || /INSUFFICIENT|QUOTA|TOP_?UP/i.test(code)) {
+    return { ok: false, status: res.status, message: serverMessage || "the account is out of credit for media generation \u2014 top up or upgrade to continue" };
+  }
+  if (res.status === 401) {
+    return {
+      ok: false,
+      status: res.status,
+      message: serverMessage || "Privateer refused this agent's session (401) \u2014 running the command again opens a fresh one; if it keeps failing, check `privateer auth status`"
+    };
+  }
+  if (res.status === 403) {
+    return {
+      ok: false,
+      status: res.status,
+      message: serverMessage || "Privateer refused this media request (403) \u2014 the plan may not include it; this is not a sign-in problem"
+    };
+  }
+  if (res.status === 400 || res.status === 413) {
+    return { ok: false, status: res.status, message: serverMessage || `Privateer rejected the request${code ? ` (${code})` : ""}` };
+  }
+  if (res.status === 503 || res.status === 504) {
+    return {
+      ok: false,
+      status: res.status,
+      message: `${serverMessage || "that media service is temporarily unavailable"} \u2014 this is on Privateer's side, not the prompt's; try again in a few minutes`
+    };
+  }
+  return { ok: false, status: res.status, message: serverMessage || `media generation failed (HTTP ${res.status}${code ? ` ${code}` : ""})` };
+}
+__name(interpretAccountResponse, "interpretAccountResponse");
+var DEFERRED_SYNC_PATH = {
+  image: "/api/agent/media/images",
+  speech: "/api/audio/speech",
+  music: "/api/audio/music",
+  sfx: "/api/audio/sfx"
+};
+var DEFERRED_TOOL = {
+  image: "generate_image",
+  speech: "generate_speech",
+  music: "generate_music",
+  sfx: "generate_sfx"
+};
+var DEFERRED_POLL_MS = 3e3;
+var DEFERRED_KEY_TTL_MS = 2 * 60 * 6e4;
+function deferredKeyDir() {
+  return join(globalDir(), "media-jobs");
+}
+__name(deferredKeyDir, "deferredKeyDir");
+function saveDeferredKey(jobId, kind, key) {
+  const dir = deferredKeyDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    for (const f of readdirSync(dir)) {
+      const p = join(dir, f);
+      try {
+        const { createdAt } = JSON.parse(readFileSync(p, "utf8"));
+        if (!createdAt || Date.now() - createdAt > DEFERRED_KEY_TTL_MS) unlinkSync(p);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  writeFileSync(join(dir, `${jobId}.json`), JSON.stringify({ kind, key: key.toString("base64"), createdAt: Date.now() }), { mode: 384 });
+}
+__name(saveDeferredKey, "saveDeferredKey");
+function loadDeferredKey(jobId) {
+  if (!/^amj_[0-9a-f]+$/.test(jobId)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(join(deferredKeyDir(), `${jobId}.json`), "utf8"));
+    return { kind: raw.kind, key: Buffer.from(raw.key, "base64") };
+  } catch {
+    return null;
+  }
+}
+__name(loadDeferredKey, "loadDeferredKey");
+function forgetDeferredKey(jobId) {
+  try {
+    unlinkSync(join(deferredKeyDir(), `${jobId}.json`));
+  } catch {
+  }
+}
+__name(forgetDeferredKey, "forgetDeferredKey");
+function openSealedResult(key, sealedB64) {
+  const buf = Buffer.from(sealedB64, "base64");
+  const d = createDecipheriv("aes-256-gcm", key, buf.subarray(0, 12));
+  d.setAuthTag(buf.subarray(12, 28));
+  return JSON.parse(Buffer.concat([d.update(buf.subarray(28)), d.final()]).toString("utf8"));
+}
+__name(openSealedResult, "openSealedResult");
+function deferredResumeHint(kind, jobId) {
+  return `Collect it with ${DEFERRED_TOOL[kind]} { resumeJobId: "${jobId}", path: <same path> } \u2014 that waits on this same job and bills nothing further.`;
+}
+__name(deferredResumeHint, "deferredResumeHint");
+async function callDeferred(kind, body, opts) {
+  let jobId = String(opts.resumeJobId ?? "").trim();
+  let key;
+  if (jobId) {
+    const held = loadDeferredKey(jobId);
+    if (!held) {
+      return { ok: false, message: `no key for job ${jobId} on this machine \u2014 it was started elsewhere, already collected, or is over two hours old. Its result cannot be opened here.` };
+    }
+    if (held.kind !== kind) {
+      return { ok: false, message: `job ${jobId} is a ${held.kind} job; collect it with ${DEFERRED_TOOL[held.kind]}.` };
+    }
+    key = held.key;
+  } else {
+    key = randomBytes(32);
+    const submitted = await callAccount("/api/agent/media/jobs", {
+      method: "POST",
+      signal: opts.signal,
+      body: { kind, sealKey: key.toString("base64"), request: body }
+    });
+    if (!submitted.ok) {
+      if (submitted.status === 404 || submitted.status === 405) {
+        return callAccount(DEFERRED_SYNC_PATH[kind], { method: "POST", body, signal: opts.signal });
+      }
+      return submitted;
+    }
+    jobId = String(submitted.data.jobId ?? "");
+    if (!jobId) return { ok: false, message: "Privateer accepted the job but returned no job id" };
+    saveDeferredKey(jobId, kind, key);
+    if (opts.wait === false) return { ok: "started", jobId };
+  }
+  const hint = deferredResumeHint(kind, jobId);
+  const deadline = Date.now() + MEDIA_HTTP_TIMEOUT_MS;
+  let failures = 0;
+  while (Date.now() < deadline) {
+    if (opts.signal?.aborted) {
+      return { ok: false, message: `stopped waiting \u2014 job ${jobId} keeps running on the server. ${hint}` };
+    }
+    const poll = await callAccount(`/api/agent/media/jobs/${encodeURIComponent(jobId)}`, { method: "GET", signal: opts.signal });
+    if (!poll.ok) {
+      if (spritePollWorthRetrying(poll.status) && ++failures < SPRITE_POLL_FAILURE_BUDGET) {
+        await sleep(DEFERRED_POLL_MS * 2, opts.signal);
+        continue;
+      }
+      if (poll.status === 404) forgetDeferredKey(jobId);
+      return { ok: false, status: poll.status, message: `job ${jobId} could not be collected: ${poll.message}${poll.status === 404 ? "" : `. ${hint}`}` };
+    }
+    failures = 0;
+    const status = String(poll.data.status ?? "");
+    if (status === "failed") {
+      forgetDeferredKey(jobId);
+      return { ok: false, message: poll.data.message ?? `job ${jobId} failed on the server` };
+    }
+    if (status === "done" && poll.data.sealed) {
+      let opened;
+      try {
+        opened = openSealedResult(key, poll.data.sealed);
+      } catch {
+        return { ok: false, message: `job ${jobId}'s result could not be opened with this machine's key` };
+      }
+      forgetDeferredKey(jobId);
+      void callAccount(`/api/agent/media/jobs/${encodeURIComponent(jobId)}`, { method: "DELETE" }).catch(() => {
+      });
+      return interpretAccountResponse(new Response(opened.body, { status: opened.status, headers: { "Content-Type": "application/json" } }));
+    }
+    await sleep(DEFERRED_POLL_MS, opts.signal);
+  }
+  return { ok: false, message: `job ${jobId} is still running after ${Math.round(MEDIA_HTTP_TIMEOUT_MS / 6e4)} minutes. ${hint}` };
+}
+__name(callDeferred, "callDeferred");
+var deferredParams = {
+  resumeJobId: typebox_exports.Optional(typebox_exports.String({
+    description: "Collect a job started earlier (with wait:false, or one that timed out) instead of starting a new one. Nothing is generated and nothing is billed: it only waits and saves. Other generation fields are ignored; `path` still says where to save."
+  })),
+  wait: typebox_exports.Optional(typebox_exports.Boolean({
+    description: "Default true. Set false to start the generation and return its job id immediately, so you can start several at once and collect each later with resumeJobId. The job runs on Privateer's servers either way."
+  }))
+};
+function startedText(kind, jobId) {
+  return `Started ${kind} job ${jobId}; it is generating on Privateer's servers (results are held for up to an hour, sealed to this machine). ${deferredResumeHint(kind, jobId)}`;
+}
+__name(startedText, "startedText");
+var generateImageToolDefinition = {
+  name: "generate_image",
+  label: "Generate Image",
+  description: "Generate an image from a text prompt and save it to disk. Optionally pass `images` \u2014 paths to images already on disk \u2014 to EDIT or COMPOSE instead: one input means 'change this picture per the prompt', several means 'combine these into one'. Billed to the user's Privateer account and subject to its privacy settings; the prompt and any input images pass through Privateer's servers in plaintext. The finished result is held on the server for up to an hour, encrypted to a key only this machine holds, until it is collected \u2014 the only readable copy is the file you name. Use the resulting path as the first frame of generate_video, or as slideshow material for video_compose.",
+  parameters: typebox_exports.Object({
+    prompt: typebox_exports.String({ description: "What the image should show. Be specific about subject, style, lighting and framing." }),
+    path: typebox_exports.String({ description: "Where to write the image, relative to cwd or absolute (e.g. 'frames/opening.png')." }),
+    images: typebox_exports.Optional(
+      typebox_exports.Array(typebox_exports.String(), {
+        description: "Paths to existing images to edit or combine. One = edit that image; several = use the first as the base and incorporate the rest. Omit to generate from the prompt alone."
+      })
+    ),
+    count: typebox_exports.Optional(typebox_exports.Number({ description: "How many variations to produce, 1-4. Above 1, files are suffixed -1, -2, \u2026 Defaults to 1." })),
+    aspectRatio: typebox_exports.Optional(typebox_exports.String({ description: "Aspect ratio, e.g. '16:9', '9:16', '1:1'. Defaults to the model's own." })),
+    size: typebox_exports.Optional(typebox_exports.String({ description: "Explicit pixel size if the model supports one, e.g. '1024x1024'." })),
+    model: typebox_exports.Optional(typebox_exports.String({ description: "Override the image model (e.g. 'google/gemini-3.1-flash-image'). Leave unset to use the one the user chose with /image-model, or the account default." })),
+    ...deferredParams
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const prompt = String(params.prompt ?? "").trim();
+    const resuming = Boolean(String(params.resumeJobId ?? "").trim());
+    if (!prompt && !resuming) return text("Error: prompt is required.");
+    if (!params.path) return text("Error: path is required \u2014 say where to save the image.");
+    let inputs;
+    try {
+      inputs = resuming ? [] : (params.images ?? []).map((p) => readInputImage(cwd, p));
+    } catch (e) {
+      return text(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const count = Math.min(Math.max(1, Math.round(params.count ?? 1)), 4);
+    const model = effectiveMediaModel("image", params.model);
+    const r = await callDeferred("image", {
+      prompt,
+      n: count,
+      ...inputs.length ? { images: inputs } : {},
+      ...params.aspectRatio ? { aspectRatio: params.aspectRatio } : {},
+      ...params.size ? { imageSize: params.size } : {},
+      ...model ? { model } : {}
+    }, { signal, resumeJobId: params.resumeJobId, wait: params.wait });
+    if (r.ok === "started") return text(startedText("image", r.jobId));
+    if (!r.ok) return text(`Image generation failed: ${r.message}`);
+    const images = r.data.images ?? [];
+    if (images.length === 0) return text("Image generation returned no images.");
+    const target = abs(cwd, params.path);
+    const ext = extname(target) || extForMime(images[0].mimeType ?? "", ".png");
+    const stem = target.slice(0, target.length - extname(target).length);
+    const written = [];
+    for (const [i, img] of images.entries()) {
+      if (!img.data) continue;
+      const out = images.length === 1 ? `${stem}${ext}` : `${stem}-${i + 1}${ext}`;
+      written.push(writeOut(out, Buffer.from(img.data, "base64")));
+    }
+    if (written.length === 0) return text("Image generation returned no usable image data.");
+    const verb = resuming ? "Collected" : inputs.length ? inputs.length === 1 ? "Edited" : "Composed" : "Generated";
+    return text(`${verb} ${written.length} image${written.length === 1 ? "" : "s"} with ${r.data.model ?? "the account image model"}:
+${written.map((w) => `  ${w}`).join("\n")}`);
+  }
+};
+var generateVideoToolDefinition = {
+  name: "generate_video",
+  label: "Generate Video",
+  description: "Generate a video clip from a text prompt and save it to disk. Give `firstFrame` (a path to an image) to animate an existing picture, and `lastFrame` as well to interpolate between two stills \u2014 that pairing is how you keep several clips visually continuous: end one clip on a frame you extracted with video_compose, then start the next from it. Generation takes minutes and this tool waits for it. Expensive (roughly $0.10-$1 a clip) and billed to the user's Privateer account, so plan the shot before calling. Clip lengths and aspect ratios are model-specific \u2014 check media_capabilities first if unsure. Stitch the finished clips with video_compose.\nIf a call comes back saying the job is still running, DO NOT call this again with the same prompt \u2014 that bills a second generation. Call it with `resumeJobId` set to the job id it reported (and the same `path`) to keep waiting on the clip the account has already paid for.",
+  parameters: typebox_exports.Object({
+    prompt: typebox_exports.String({ description: "What happens in the shot: subject, action, camera move, style." }),
+    path: typebox_exports.String({ description: "Where to write the video, relative to cwd or absolute (e.g. 'clips/01-opening.mp4')." }),
+    resumeJobId: typebox_exports.Optional(typebox_exports.String({
+      description: "Resume waiting on a job already submitted (from a previous call that timed out). Nothing is generated and nothing is billed: it only polls and saves. `prompt` is ignored."
+    })),
+    firstFrame: typebox_exports.Optional(typebox_exports.String({ description: "Path to an image to use as the opening frame (image-to-video)." })),
+    lastFrame: typebox_exports.Optional(typebox_exports.String({ description: "Path to an image to use as the closing frame. Requires firstFrame." })),
+    seconds: typebox_exports.Optional(typebox_exports.Number({ description: "Clip length in seconds. Only certain values are legal per model \u2014 see media_capabilities." })),
+    aspectRatio: typebox_exports.Optional(typebox_exports.String({ description: "Aspect ratio, e.g. '16:9', '9:16'. Model-specific." })),
+    resolution: typebox_exports.Optional(typebox_exports.String({ description: "Resolution, e.g. '720p' or '1080p'." })),
+    audio: typebox_exports.Optional(typebox_exports.Boolean({ description: "Ask the model to generate a soundtrack too, where it supports one. Costs more. Defaults to false." })),
+    model: typebox_exports.Optional(typebox_exports.String({ description: "Override the video model (e.g. 'google/veo-3.1-lite'). Leave unset to use the one the user chose with /video-model, or the account default." }))
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    if (!params.path) return text("Error: path is required \u2014 say where to save the video.");
+    const resumeJobId = String(params.resumeJobId ?? "").trim();
+    if (resumeJobId) {
+      return awaitVideoJob(resumeJobId, cwd, params.path, null, signal);
+    }
+    const prompt = String(params.prompt ?? "").trim();
+    if (!prompt) return text("Error: prompt is required.");
+    if (params.lastFrame && !params.firstFrame) return text("Error: lastFrame needs firstFrame alongside it.");
+    let firstFrame;
+    let lastFrame;
+    try {
+      if (params.firstFrame) firstFrame = readInputImage(cwd, params.firstFrame);
+      if (params.lastFrame) lastFrame = readInputImage(cwd, params.lastFrame);
+    } catch (e) {
+      return text(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const model = effectiveMediaModel("video", params.model);
+    const submitted = await callAccount("/api/agent/media/videos", {
+      method: "POST",
+      signal,
+      body: {
+        prompt,
+        ...params.seconds != null ? { seconds: params.seconds } : {},
+        ...params.aspectRatio ? { aspectRatio: params.aspectRatio } : {},
+        ...params.resolution ? { resolution: params.resolution } : {},
+        ...params.audio ? { generateAudio: true } : {},
+        ...model ? { model } : {},
+        ...firstFrame ? { firstFrame } : {},
+        ...lastFrame ? { lastFrame } : {}
+      }
+    });
+    if (!submitted.ok) return text(`Video generation failed: ${submitted.message}`);
+    const jobId = submitted.data.jobId;
+    if (!jobId) return text("Video generation failed: Privateer did not return a job id.");
+    return awaitVideoJob(jobId, cwd, params.path, submitted.data.model ?? null, signal);
+  }
+};
+async function awaitVideoJob(jobId, cwd, path, submittedModel, signal) {
+  const deadline = Date.now() + VIDEO_POLL_TIMEOUT_MS;
+  const resumeHint = `Resume it with generate_video { resumeJobId: "${jobId}", path: "${path}" } \u2014 that waits on this same clip and bills nothing further.`;
+  const cancelled = /* @__PURE__ */ __name(() => text(`Video job ${jobId} is still running and will still be billed; the wait was cancelled. ${resumeHint}`), "cancelled");
+  for (; ; ) {
+    if (signal?.aborted) return cancelled();
+    await sleep(VIDEO_POLL_INTERVAL_MS, signal);
+    if (signal?.aborted) return cancelled();
+    const poll = await callAccount(`/api/agent/media/videos/${encodeURIComponent(jobId)}`, {
+      method: "GET",
+      signal
+    });
+    if (!poll.ok) return text(`Video job ${jobId} could not be polled: ${poll.message}. ${resumeHint}`);
+    const status = String(poll.data.status ?? "").toLowerCase();
+    if (status === "failed") return text(`Video generation failed: ${poll.data.message ?? "the provider reported a failure"}.`);
+    if (status === "completed") {
+      if (!poll.data.data) {
+        return text(`Video job ${jobId} already delivered its bytes on an earlier poll; they were not saved. Generate again if the file is missing.`);
+      }
+      const target = abs(cwd, path);
+      const ext = extname(target) || extForMime(poll.data.mimeType ?? "", ".mp4");
+      const out = `${target.slice(0, target.length - extname(target).length)}${ext}`;
+      const summary = writeOut(out, Buffer.from(poll.data.data, "base64"));
+      return text(`Generated video with ${poll.data.model ?? submittedModel ?? "the account video model"}: ${summary}`);
+    }
+    if (Date.now() > deadline) {
+      return text(
+        `Video job ${jobId} is still ${status || "running"} after ${Math.round(VIDEO_POLL_TIMEOUT_MS / 6e4)} minutes. It will still complete and is already billed \u2014 do NOT generate it again. ${resumeHint}`
+      );
+    }
+  }
+}
+__name(awaitVideoJob, "awaitVideoJob");
+function sleep(ms, signal) {
+  return new Promise((resolve_) => {
+    const t = setTimeout(resolve_, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve_();
+    }, { once: true });
+  });
+}
+__name(sleep, "sleep");
+var generateModelToolDefinition = {
+  name: "generate_model",
+  label: "Generate 3D Model",
+  description: "Generate a 3D MESH \u2014 a .glb (or .obj) file for a game engine or DCC tool \u2014 from one or more reference images. (This makes 3D geometry; it has nothing to do with language models.) There is no text-to-mesh here: generate the concept art with generate_image first, look at it, and pass that path as `images` \u2014 which also means the shape is generated from a look someone approved rather than from a sentence. Supply up to four views (front, back, left, right) of the SAME object to stop the model inventing the sides it cannot see; on some models that costs more and it is usually worth it. Generation takes a minute or more and this tool waits for it. EXPENSIVE and billed to the user's Privateer account: $0.14 to $2.41 a mesh depending on WHICH model and which options, so plan the asset before calling and tell the user the total before batching dozens of them.\nThere are ten models from five vendors and they are not interchangeable \u2014 the dearest costs seventeen times the cheapest, and each takes DIFFERENT options. Call media_capabilities (with `model` set) to see a model's own options and price before choosing; pass what you picked as `axes`. Blocking out a shape is a job for the cheap end; a hero asset is not. PRIVACY: 3D generation runs on a provider with no zero-retention option, so it is gated \u2014 a ZDR account must have enabled non-ZDR media. Call media_capabilities first if unsure.",
+  parameters: typebox_exports.Object({
+    images: typebox_exports.Array(typebox_exports.String(), {
+      description: "Paths to reference images of one object, best view first. 1-4 of them, read as front, back, left, right. How many are actually USED is per-model \u2014 media_capabilities reports `maxViews`, and several models take a single view and will quietly ignore the rest, so check before generating four images to feed one. Where extra views are used they give the model the sides it would otherwise invent; on the Hunyuan models they add $0.15 in total (not each) and are free elsewhere."
+    }),
+    path: typebox_exports.String({
+      description: "Where to write the mesh, relative to cwd or absolute (e.g. 'assets/props/crate.glb'). The extension is corrected to whatever container is actually delivered."
+    }),
+    format: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Container: 'glb' (default) or 'obj'. Prefer glb \u2014 it is the only one that carries the materials, so an 'obj' of a textured mesh arrives as bare geometry, and 'obj' is not produced at all for generateType 'Geometry'. Falls back to glb whenever the provider doesn't render it."
+      })
+    ),
+    // `additionalProperties`, not Type.Record: TypeBox compiles a Record to
+    // `patternProperties`, which several providers' tool-schema validators
+    // reject outright — and a tool whose schema is refused fails at the provider
+    // with a message about JSON Schema rather than about 3D.
+    axes: typebox_exports.Optional(
+      typebox_exports.Object({}, {
+        additionalProperties: typebox_exports.Union([typebox_exports.String(), typebox_exports.Number(), typebox_exports.Boolean()]),
+        description: "The chosen model's own options, as {name: value} \u2014 the ONLY way to reach the options on any model except the Hunyuan ones, since no two endpoints share their levers (one takes `resolution`, another a `texture` ladder, another a `highPack` flag). Get the exact names and legal values from media_capabilities with the same `model`; an option this model does not have is REFUSED, not ignored, so do not guess. Omit an option to take the model's own default, which for a numeric budget means letting the provider choose \u2014 on some models setting it at all is what costs extra."
+      })
+    ),
+    generateType: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Hunyuan models only (prefer `axes` elsewhere). 'Normal' ($0.375, default) \u2014 textured mesh. 'LowPoly' ($0.45) \u2014 retopologised, best for a game asset that will deform or needs clean edges; dearer because it is more work, not less. 'Geometry' ($0.225) \u2014 untextured geometry only, for blockouts and greyboxing."
+      })
+    ),
+    polygonType: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Hunyuan models only (prefer `axes` elsewhere). 'triangle' (default) or 'quadrilateral'. Quads deform far better under animation, so choose them for anything that will be rigged; triangles are fine for static props."
+      })
+    ),
+    faceCount: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "Target face budget, honoured exactly; the legal range is per-model (media_capabilities reports it). On the Hunyuan models it ADDS $0.15 because the provider charges for a custom count, and leaving it unset uses their 500k default \u2014 measured at 8.6 MB untextured and 64 MB textured, against 15 MB for a textured 60k mesh. Free on most other models. Set it for anything going into a game."
+      })
+    ),
+    pbr: typebox_exports.Optional(
+      typebox_exports.Boolean({
+        description: "Generate PBR materials (base colour, normal, roughness/metallic) instead of a flat texture. Essential for anything lit by a modern engine. ADDS $0.15 on the Hunyuan models and is free on Tripo and Meshy \u2014 which is why the price comes from media_capabilities and not from here. Refused on any model generating untextured geometry."
+      })
+    ),
+    model: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Which 3D model to use, e.g. 'fal-ai/hyper3d/rodin/v2.5/fast' for a cheap blockout or 'meshy/v7/image-to-3d' for a game-ready hero asset. media_capabilities lists every id with its price. Leave unset to use the account default."
+      })
+    )
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const paths = params.images ?? [];
+    if (paths.length === 0) return text("Error: at least one reference image is required \u2014 generate one with generate_image first.");
+    if (paths.length > MAX_MESH_VIEWS) {
+      return text(`Error: at most ${MAX_MESH_VIEWS} reference views (front, back, left, right); got ${paths.length}.`);
+    }
+    if (!params.path) return text("Error: path is required \u2014 say where to save the mesh.");
+    let images;
+    try {
+      images = paths.map((p) => readInputImage(cwd, p));
+    } catch (e) {
+      return text(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const totalBytes = images.reduce((sum, img) => sum + Math.floor(img.data.length * 3 / 4), 0);
+    if (totalBytes > MAX_MESH_INPUT_TOTAL_BYTES) {
+      return text(
+        `Error: the reference views total ${(totalBytes / 1048576).toFixed(1)} MB; the limit for one request is ${MAX_MESH_INPUT_TOTAL_BYTES / 1048576} MB. Use fewer views, or downscale them first.`
+      );
+    }
+    const submitted = await callAccount("/api/agent/media/models", {
+      method: "POST",
+      signal,
+      body: {
+        images,
+        ...params.format ? { format: params.format } : {},
+        // `axes` wins over the named fields server-side, so a model passing both
+        // gets what it spelled out per-axis. The named four are sent alongside
+        // rather than folded in here: which of them the chosen model actually
+        // has is the server's business, and duplicating that judgement in the
+        // tool is how the two get to disagree.
+        ...params.axes && typeof params.axes === "object" ? { axes: params.axes } : {},
+        ...params.generateType ? { generateType: params.generateType } : {},
+        ...params.polygonType ? { polygonType: params.polygonType } : {},
+        ...params.faceCount != null ? { faceCount: params.faceCount } : {},
+        ...params.pbr ? { pbr: true } : {},
+        ...params.model ? { model: params.model } : {}
+      }
+    });
+    if (!submitted.ok) return text(`3D generation failed: ${submitted.message}`);
+    const jobId = submitted.data.jobId;
+    if (!jobId) return text("3D generation failed: Privateer did not return a job id.");
+    const deadline = Date.now() + MESH_POLL_TIMEOUT_MS;
+    const cancelled = /* @__PURE__ */ __name(() => text(`3D job ${jobId} was submitted but the wait was cancelled. It is still running and will still be billed.`), "cancelled");
+    for (; ; ) {
+      if (signal?.aborted) return cancelled();
+      await sleep(MESH_POLL_INTERVAL_MS, signal);
+      if (signal?.aborted) return cancelled();
+      const poll = await callAccount(`/api/agent/media/models/${encodeURIComponent(jobId)}`, {
+        method: "GET",
+        signal
+      });
+      if (!poll.ok) return text(`3D job ${jobId} could not be polled: ${poll.message}`);
+      const status = String(poll.data.status ?? "").toLowerCase();
+      if (status === "failed") return text(`3D generation failed: ${poll.data.message ?? "the provider reported a failure"}.`);
+      if (status === "completed") {
+        if (!poll.data.data) {
+          return text(`3D job ${jobId} already delivered its bytes on an earlier poll; they were not saved. Generate again if the file is missing.`);
+        }
+        const delivered = String(poll.data.format || "glb").toLowerCase();
+        const target = abs(cwd, params.path);
+        const asked = extname(target).replace(/^\./, "").toLowerCase();
+        const out = `${target.slice(0, target.length - extname(target).length)}.${delivered}`;
+        const summary = writeOut(out, Buffer.from(poll.data.data, "base64"));
+        const note = asked && asked !== delivered ? `
+(Asked for .${asked}; the provider returned ${delivered.toUpperCase()}, so the file was saved with that extension.)` : "";
+        return text(`Generated 3D model with ${poll.data.model ?? submitted.data.model ?? "the account 3D model"}: ${summary}${note}`);
+      }
+      if (Date.now() > deadline) {
+        return text(
+          `3D job ${jobId} is still ${status || "running"} after ${Math.round(MESH_POLL_TIMEOUT_MS / 6e4)} minutes. It will still complete and still be billed; nothing was saved here.`
+        );
+      }
+    }
+  }
+};
+var generateSpeechToolDefinition = {
+  name: "generate_speech",
+  label: "Generate Speech",
+  description: "Turn text into spoken audio and save it to disk. Use it to narrate a video you are assembling, or to produce a spoken version of a written answer. Billed to the user's Privateer account; the account's default voice model is a confidential-compute one, so the text is processed inside an enclave rather than by a retaining provider. Mux the result onto video with video_compose. Call media_capabilities first if you want to override `voice` or `model` \u2014 it lists the exact wire voice ids for the account's current TTS model (and any model you pass it), which is not the same as a spoken character or brand name.",
+  parameters: typebox_exports.Object({
+    text: typebox_exports.String({ description: "The words to speak. Write them as they should be read aloud." }),
+    path: typebox_exports.String({ description: "Where to write the audio, relative to cwd or absolute (e.g. 'audio/narration.mp3')." }),
+    voice: typebox_exports.Optional(typebox_exports.String({
+      description: "Voice id, if the account's TTS model offers a choice. Leave unset for its default. These are PROVIDER wire ids, not free text \u2014 e.g. Deepgram Aura-2 voices are 'aura-2-<name>-<lang>' ('aura-2-jupiter-en', not 'jupiter' or 'Jupiter'). Get the exact legal list for the model in play from media_capabilities' `speech.voices` before guessing one; an unrecognised id is refused with VOICE_UNSUPPORTED rather than silently served on a different voice."
+    })),
+    model: typebox_exports.Optional(typebox_exports.String({ description: "Override the account's text-to-speech model." })),
+    ...deferredParams
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const body = String(params.text ?? "").trim();
+    if (!body && !String(params.resumeJobId ?? "").trim()) return text("Error: text is required.");
+    if (!params.path) return text("Error: path is required \u2014 say where to save the audio.");
+    const r = await callDeferred("speech", {
+      text: body,
+      ...params.voice ? { voice: params.voice } : {},
+      ...params.model ? { ttsModelId: params.model } : {}
+    }, { signal, resumeJobId: params.resumeJobId, wait: params.wait });
+    if (r.ok === "started") return text(startedText("speech", r.jobId));
+    if (!r.ok) return text(`Speech generation failed: ${r.message}`);
+    if (!r.data.audioBase64) return text("Speech generation returned no audio.");
+    const target = abs(cwd, params.path);
+    const ext = extname(target) || extForMime(r.data.mimeType ?? "", ".mp3");
+    const out = `${target.slice(0, target.length - extname(target).length)}${ext}`;
+    const via = [r.data.model, r.data.voice].filter(Boolean).join(" / ");
+    return text(
+      `Generated speech${via ? ` with ${via}` : ""}: ${writeOut(out, Buffer.from(r.data.audioBase64, "base64"))}`
+    );
+  }
+};
+var generateMusicToolDefinition = {
+  name: "generate_music",
+  label: "Generate Music",
+  description: "Generate an instrumental music clip from a text prompt and save it to disk \u2014 a soundtrack for a video you are assembling. PRIVACY: music is the one media type with no zero-retention or confidential option anywhere in the catalog, so the prompt reaches a provider that may retain it. Privateer sends it unattributed (no account id, no history), but it is not private the way the other media tools are. Do not put anything sensitive or personal in a music prompt, and say so if the user's own wording would carry something identifying.",
+  parameters: typebox_exports.Object({
+    prompt: typebox_exports.String({ description: "The music to generate: genre, mood, instrumentation, tempo. Keep it about the music, not about the user." }),
+    path: typebox_exports.String({ description: "Where to write the audio, relative to cwd or absolute (e.g. 'audio/score.mp3')." }),
+    model: typebox_exports.Optional(typebox_exports.String({ description: "Override the account's music model." })),
+    ...deferredParams
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const prompt = String(params.prompt ?? "").trim();
+    if (!prompt && !String(params.resumeJobId ?? "").trim()) return text("Error: prompt is required.");
+    if (!params.path) return text("Error: path is required \u2014 say where to save the audio.");
+    const r = await callDeferred(
+      "music",
+      { prompt, ...params.model ? { musicModelId: params.model } : {} },
+      { signal, resumeJobId: params.resumeJobId, wait: params.wait }
+    );
+    if (r.ok === "started") return text(startedText("music", r.jobId));
+    if (!r.ok) return text(`Music generation failed: ${r.message}`);
+    if (!r.data.audioBase64) return text("Music generation returned no audio.");
+    const target = abs(cwd, params.path);
+    const ext = extname(target) || extForMime(r.data.mimeType ?? "", ".mp3");
+    const out = `${target.slice(0, target.length - extname(target).length)}${ext}`;
+    return text(
+      `Generated music with ${r.data.model ?? "the account music model"}: ${writeOut(out, Buffer.from(r.data.audioBase64, "base64"))}
+(Reminder for the answer you give the user: music prompts are sent to a provider with no zero-retention option, unattributed.)`
+    );
+  }
+};
+var SFX_MIN_SECONDS = 1;
+var SFX_MAX_SECONDS = 30;
+var generateSfxToolDefinition = {
+  name: "generate_sfx",
+  label: "Generate Sound Effect",
+  description: "Generate a single sound effect from a text prompt and save it to disk \u2014 an impact, a whoosh, a UI click, a room ambience. Cheap (about $0.01-$0.02 a call) and quick. This is for ONE sound, not for a score: use generate_music for a bed and generate_speech for narration. Place the result in time with video_compose's mix_audio, which is what makes an effect land on the frame it belongs to.\nPRIVACY: every effect model is a non-zero-retention provider, so this is gated exactly like image and video generation \u2014 an account with Require ZDR on is REFUSED until its owner enables non-ZDR media. That is a setting only they can change, so do not retry a refusal. (Do not reach for generate_music instead on privacy grounds: music has no ZDR gate at all, which is looser, not safer.) Check media_capabilities if you need to know whether this account can use it before you plan a sequence around a dozen effects.",
+  parameters: typebox_exports.Object({
+    prompt: typebox_exports.String({
+      description: "The sound itself, described as a sound: 'heavy wooden door slamming shut, close mic, reverberant hall'. Effect models are tuned for one event, so keep it to one \u2014 a scene comes out muddy."
+    }),
+    path: typebox_exports.String({ description: "Where to write the audio, relative to cwd or absolute (e.g. 'audio/sfx/door-slam.mp3')." }),
+    seconds: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: `How long the effect should be, ${SFX_MIN_SECONDS}-${SFX_MAX_SECONDS} whole seconds. Defaults to 5. One of the models is billed by the second, so ask for what you need.`
+      })
+    ),
+    model: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Override the account's effect model. 'fal-ai/elevenlabs/sound-effects/v2' is the most convincing foley in the catalog; the default is a cheaper model tuned for single sounds."
+      })
+    ),
+    ...deferredParams
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const prompt = String(params.prompt ?? "").trim();
+    if (!prompt && !String(params.resumeJobId ?? "").trim()) return text("Error: prompt is required.");
+    if (!params.path) return text("Error: path is required \u2014 say where to save the audio.");
+    let seconds;
+    if (params.seconds != null) {
+      seconds = Number(params.seconds);
+      if (!Number.isFinite(seconds) || seconds < SFX_MIN_SECONDS || seconds > SFX_MAX_SECONDS) {
+        return text(
+          `Error: seconds must be between ${SFX_MIN_SECONDS} and ${SFX_MAX_SECONDS} (got ${params.seconds}). For anything longer, generate a few effects and place them with video_compose mix_audio, or use generate_music for a bed.`
+        );
+      }
+      seconds = Math.round(seconds);
+    }
+    const r = await callDeferred("sfx", {
+      prompt,
+      ...seconds != null ? { duration: seconds } : {},
+      ...params.model ? { sfxModelId: params.model } : {}
+    }, { signal, resumeJobId: params.resumeJobId, wait: params.wait });
+    if (r.ok === "started") return text(startedText("sfx", r.jobId));
+    if (!r.ok) return text(`Sound-effect generation failed: ${r.message}`);
+    if (!r.data.audioBase64) return text("Sound-effect generation returned no audio.");
+    const target = abs(cwd, params.path);
+    const ext = extname(target) || extForMime(r.data.mimeType ?? "", ".mp3");
+    const out = `${target.slice(0, target.length - extname(target).length)}${ext}`;
+    const length = r.data.durationSeconds ? `${r.data.durationSeconds}s ` : "";
+    return text(
+      `Generated a ${length}sound effect with ${r.data.model ?? "the account effect model"}: ` + writeOut(out, Buffer.from(r.data.audioBase64, "base64"))
+    );
+  }
+};
+function describeModel3d(model3d) {
+  if (model3d?.configured === false) {
+    return ["3D model generation: NOT AVAILABLE on this deployment (no provider key). Do not call generate_model."];
+  }
+  const lines = [
+    `3D model: ${model3d?.model ?? "unknown"}${model3d?.blockedByZdr ? "  [BLOCKED by this account's ZDR setting]" : ""}`,
+    `  formats: ${model3d?.formats?.length ? model3d.formats.join(", ") : "glb"}; up to ${model3d?.maxViews ?? 4} reference view(s)`,
+    `  cost: $${(model3d?.priceUsd?.min ?? 0).toFixed(2)}-$${(model3d?.priceUsd?.max ?? 0).toFixed(2)} charged per mesh, depending on the options below`
+  ];
+  if (model3d?.axes?.length) {
+    lines.push(`  options (pass as generate_model's \`axes\`, e.g. {"${model3d.axes[0].name}": ...}):`);
+    for (const a of model3d.axes) lines.push(describeAxis(a));
+  }
+  for (const c of model3d?.conflicts ?? []) {
+    lines.push(`    NOTE: ${c.forbids} cannot be used when ${c.whenAxis} is ${JSON.stringify(c.is)}.`);
+  }
+  if (model3d?.catalog?.length) {
+    lines.push("  every 3D model available (pass `model` to generate_model, or to this tool to see its options):");
+    for (const m of model3d.catalog) {
+      const p = m.priceUsd ? ` $${(m.priceUsd.min ?? 0).toFixed(2)}-$${(m.priceUsd.max ?? 0).toFixed(2)}` : "";
+      lines.push(`    ${m.id}${p}${m.id === model3d.model ? "  [described above]" : ""}`);
+    }
+  }
+  return lines;
+}
+__name(describeModel3d, "describeModel3d");
+function describeAxis(a) {
+  const cost = a.priced ? "  [affects price]" : "";
+  if (a.kind === "int") return `    ${a.name}: number ${a.min ?? "?"}-${a.max ?? "?"}, omit to let the provider choose${cost}`;
+  if (a.kind === "views") return `    ${a.name}: driven by how many images you pass${cost}`;
+  if (a.kind === "bool") return `    ${a.name}: true | false (default ${a.default === true})${cost}`;
+  return `    ${a.name}: ${(a.values ?? []).join(" | ")} (default ${String(a.default)})${cost}`;
+}
+__name(describeAxis, "describeAxis");
+var usd = /* @__PURE__ */ __name((n) => `$${(n ?? 0).toFixed(2)}`, "usd");
+function describeImageVideo(image, video) {
+  const imagePrice = typeof image?.priceUsdEach === "number" ? `, about ${usd(image.priceUsdEach)} each` : ", price not reported";
+  const lines = [
+    `Image model: ${image?.model ?? "unknown"}${image?.blockedByZdr ? "  [BLOCKED by this account's ZDR setting]" : ""}`,
+    `  up to ${image?.maxPerCall ?? 1} image(s) per call${imagePrice}`,
+    `Video model: ${video?.model ?? "unknown"}${video?.blockedByZdr ? "  [BLOCKED by this account's ZDR setting]" : ""}`,
+    `  clip lengths: ${video?.durations?.length ? `${video.durations.join(", ")}s` : "model default only"}`,
+    `  aspect ratios: ${video?.aspectRatios?.length ? video.aspectRatios.join(", ") : "model default only"}`
+  ];
+  const table = video?.priceTable ?? [];
+  if (video?.priceUsd && table.length) {
+    const fallback = video.priceSource === "fallback" ? " (no price row for this model \u2014 a conservative estimate)" : "";
+    lines.push(`  cost: ${usd(video.priceUsd.min)}-${usd(video.priceUsd.max)} a clip${fallback}, reserved up front and settled at the real cost`);
+    const plain = table.filter((r) => r.resolution === null && !r.audio && r.seconds !== null);
+    if (plain.length) lines.push(`  by length (default resolution, no audio): ${plain.map((r) => `${r.seconds}s ${usd(r.usd)}`).join(", ")}`);
+    const resolutions = [...new Set(table.map((r) => r.resolution).filter((r) => !!r))];
+    if (resolutions.length) lines.push(`  resolution changes the price: ${resolutions.join(", ")} (pass generate_video's \`resolution\`)`);
+    if (table.some((r) => r.audio)) lines.push("  audio: true costs more on this model");
+  } else {
+    lines.push("  cost: not reported by this server \u2014 roughly $0.10-$1 a clip, more for long or high-resolution clips");
+  }
+  return lines;
+}
+__name(describeImageVideo, "describeImageVideo");
+function quoteMediaCallUsd(tool, input, caps) {
+  const args = input && typeof input === "object" ? input : {};
+  const num = /* @__PURE__ */ __name((v) => typeof v === "number" && Number.isFinite(v) ? v : void 0, "num");
+  const clip = /* @__PURE__ */ __name((seconds, resolution, audio) => {
+    const table = caps.video?.priceTable ?? [];
+    if (!table.length) return null;
+    const exact = table.find(
+      (r) => r.seconds === (seconds ?? r.seconds) && r.resolution === (resolution ?? null) && r.audio === audio
+    );
+    if (exact && seconds !== void 0) return exact.usd;
+    const candidates = table.filter((r) => r.resolution === (resolution ?? null) && (audio || !r.audio));
+    const pool = candidates.length ? candidates : table;
+    return Math.max(...pool.map((r) => r.usd));
+  }, "clip");
+  switch (tool) {
+    case "generate_image": {
+      if (typeof args.model === "string" && args.model && args.model !== caps.image?.model) return null;
+      const each = caps.image?.priceUsdEach;
+      if (typeof each !== "number") return null;
+      const n = Math.min(Math.max(Math.trunc(num(args.count) ?? 1), 1), caps.image?.maxPerCall ?? 4);
+      return each * n;
+    }
+    case "generate_video":
+      return clip(num(args.seconds), typeof args.resolution === "string" ? args.resolution : void 0, args.audio === true);
+    case "generate_model":
+      return typeof caps.model3d?.priceUsd?.max === "number" ? caps.model3d.priceUsd.max : null;
+    case "generate_sprite": {
+      const set = typeof args.directions === "string" ? args.directions : "one";
+      const row = caps.sprites?.directionSets?.find((d) => d.id === set);
+      const silent = (caps.video?.priceTable ?? []).filter((r) => !r.audio);
+      const clipUsd = silent.length ? Math.max(...silent.map((r) => r.usd)) : null;
+      if (!row || clipUsd === null) return null;
+      const stills = row.billedTurnStills ?? 0;
+      const each = caps.image?.priceUsdEach;
+      if (stills > 0 && (typeof each !== "number" || typeof args.image_model === "string" && args.image_model && args.image_model !== caps.image?.model)) return null;
+      return clipUsd * (row.billedClips ?? 1) + stills * (each ?? 0);
+    }
+    case "generate_sfx":
+      return 0.02;
+    default:
+      return null;
+  }
+}
+__name(quoteMediaCallUsd, "quoteMediaCallUsd");
+async function readMediaCapabilities(query = {}, signal) {
+  const q = new URLSearchParams();
+  if (query.imageModel) q.set("imageModel", query.imageModel);
+  if (query.videoModel) q.set("videoModel", query.videoModel);
+  if (query.model) q.set("model", query.model);
+  const qs = q.toString();
+  const r = await callAccount(`/api/agent/media/capabilities${qs ? `?${qs}` : ""}`, { method: "GET", signal });
+  return r.ok ? { ok: true, data: r.data } : { ok: false, message: r.message };
+}
+__name(readMediaCapabilities, "readMediaCapabilities");
+function describeSfx(sfx) {
+  if (sfx?.configured === false) {
+    return ["Sound effects: NOT AVAILABLE on this deployment (no provider key). Do not call generate_sfx."];
+  }
+  if (sfx?.blockedByZdr) {
+    return [
+      `Sound effects: ${sfx.model ?? "unknown"}  [BLOCKED by this account's ZDR setting]`,
+      "  Every effect model is non-ZDR, so this account cannot generate one until its owner enables non-ZDR media (Settings \u2192 Privacy). Do not substitute generate_music for an effect \u2014 it is ungated, not more private."
+    ];
+  }
+  return [
+    `Sound effects: ${sfx?.model ?? "unknown"}`,
+    `  up to ${sfx?.maxDurationSeconds ?? SFX_MAX_SECONDS}s per effect, one sound per call, ~$0.01-$0.02 each`
+  ];
+}
+__name(describeSfx, "describeSfx");
+function describeSpeech(speech) {
+  const blocked = speech?.blockedByZdr ? "  [BLOCKED by this account's ZDR setting]" : "";
+  const lines = [`Speech model: ${speech?.model ?? "unknown"}${blocked}`];
+  if (speech?.blockedByZdr) {
+    lines.push(
+      "  This voice model is non-ZDR, so this account cannot use it until its owner enables non-ZDR media (Settings \u2192 Privacy). Omit `model` to use the account's confidential-compute default instead of retrying this one."
+    );
+  }
+  if (speech?.voices?.length) {
+    lines.push(
+      `  ${speech.voices.length} voice id(s) for this model \u2014 pass one of these EXACTLY as generate_speech's \`voice\`, never a guessed name: ${speech.voices.join(", ")}`
+    );
+  } else {
+    lines.push("  No enumerable voice list for this model; omit `voice` to use its default.");
+  }
+  if (speech?.catalog?.length) {
+    lines.push("  every TTS model available (pass `ttsModel` to this tool to see its voices):");
+    for (const m of speech.catalog) {
+      const tags = [m.isTee ? "confidential" : m.isZdr ? "ZDR" : "non-ZDR", `${m.voiceCount ?? 0} voice(s)`];
+      if (m.blockedByZdr) tags.push("BLOCKED");
+      lines.push(
+        `    ${m.id}  (${tags.join(", ")})${m.id === speech.model ? "  [described above]" : ""}`
+      );
+    }
+  }
+  return lines;
+}
+__name(describeSpeech, "describeSpeech");
+var mediaCapabilitiesToolDefinition = {
+  name: "media_capabilities",
+  label: "Media Capabilities",
+  description: "Report what this Privateer account can generate right now: which image and video models it resolves to, what an image and a clip cost, the clip lengths and aspect ratios that video model accepts, and whether the account's privacy settings currently block media generation. Free and instant. Call it before planning a multi-clip video so you pick a legal clip length instead of discovering it through a rejected \u2014 or worse, billed \u2014 call.\nIt is also the ONLY way to find out which 3D models exist and what options each one takes: they range from $0.14 to $2.41 a mesh and no two take the same options, so call this with `model` set to the id you are considering BEFORE generate_model, or you will pay the default model's price for a job a cheaper one could have done.\nIt is also the ONLY way to find a text-to-speech model's real voice ids \u2014 Deepgram Aura-2's are 'aura-2-<name>-<lang>', not a bare character name \u2014 so call this with `ttsModel` set BEFORE generate_speech whenever you plan to pass `voice`.",
+  parameters: typebox_exports.Object({
+    model: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "A 3D model id to describe instead of the account default (e.g. 'fal-ai/trellis-2'). The response's 3D catalog lists every legal id; every field reported \u2014 the options, their legal values and the price \u2014 is per-model."
+      })
+    ),
+    imageModel: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "An image model id to describe instead of the default (e.g. 'google/gemini-3.1-flash-image'), so the price per image is the one generate_image will charge for it."
+      })
+    ),
+    videoModel: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "A video model id to describe instead of the default (e.g. 'bytedance/seedance-2.0'). Clip lengths, aspect ratios and the price per clip are all per-model \u2014 check the one you will pass as generate_video's `model` before you spend on it."
+      })
+    ),
+    ttsModel: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "A text-to-speech model id to describe instead of the account default (e.g. 'deepgram/aura-2'). The response's `speech.voices` lists every legal voice id for THIS model \u2014 voice ids are not shared across models."
+      })
+    )
+  }),
+  async execute(_toolCallId, params, signal) {
+    const imageModel = effectiveMediaModel("image", params?.imageModel);
+    const videoModel = effectiveMediaModel("video", params?.videoModel);
+    const query = new URLSearchParams();
+    if (params?.model) query.set("model", params.model);
+    if (imageModel) query.set("imageModel", imageModel);
+    if (videoModel) query.set("videoModel", videoModel);
+    if (params?.ttsModel) query.set("ttsModel", params.ttsModel);
+    const qs = query.toString();
+    const r = await callAccount(
+      `/api/agent/media/capabilities${qs ? `?${qs}` : ""}`,
+      { method: "GET", signal }
+    );
+    if (!r.ok) return text(`Could not read media capabilities: ${r.message}`);
+    const { image, video, model3d, sfx, speech, privacy } = r.data;
+    const lines = describeImageVideo(image, video);
+    if (imageModel && image?.model && image.model !== imageModel) {
+      lines.push(`  (generate_image will use ${imageModel}; this server described the account default instead)`);
+    }
+    lines.push(...describeModel3d(model3d));
+    lines.push(...describeSfx(sfx));
+    lines.push(...describeSpeech(speech));
+    lines.push(`Privacy: requireZdr=${privacy?.requireZdr ?? "?"}, allowNonZdrMedia=${privacy?.allowNonZdrMedia ?? "?"}`);
+    if (image?.blockedByZdr || video?.blockedByZdr || model3d?.blockedByZdr || sfx?.blockedByZdr || speech?.blockedByZdr) {
+      lines.push(
+        "A [BLOCKED] model means the account requires Zero Data Retention and that model has no ZDR endpoint. Only the account owner can change it (Settings \u2192 Privacy); do not keep retrying."
+      );
+    }
+    lines.push(
+      "Music is always available; sound effects and (per above) speech's CURRENT model may not be. Music has no ZDR gate at all; effects are gated like image and video, so a blocked effect must never be answered with music instead."
+    );
+    return text(lines.join("\n"));
+  }
+};
+function pathInside(root, target) {
+  const rel = relative(root, target);
+  return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + sep);
+}
+__name(pathInside, "pathInside");
+function archiveEntryPath(name, root) {
+  const rel = name.split("\\").join("/");
+  const traverses = rel.startsWith("/") || /^[A-Za-z]:/.test(rel) || rel.split("/").some((seg) => seg === "..");
+  if (traverses || !pathInside(root, resolve(root, rel))) {
+    throw new Error(`archive entry "${name}" escapes the destination directory ${root}`);
+  }
+  return rel;
+}
+__name(archiveEntryPath, "archiveEntryPath");
+function extractStoredZip(zip, destDir) {
+  const written = [];
+  const root = resolve(destDir);
+  let at = 0;
+  while (at + 30 <= zip.length && zip.readUInt32LE(at) === 67324752) {
+    const method = zip.readUInt16LE(at + 8);
+    const size = zip.readUInt32LE(at + 18);
+    const nameLen = zip.readUInt16LE(at + 26);
+    const extraLen = zip.readUInt16LE(at + 28);
+    const name = zip.toString("utf8", at + 30, at + 30 + nameLen);
+    const dataAt = at + 30 + nameLen + extraLen;
+    if (method !== 0) throw new Error(`archive entry "${name}" is compressed; only stored entries are expected`);
+    if (dataAt + size > zip.length) throw new Error(`archive entry "${name}" is truncated`);
+    const target = resolve(root, archiveEntryPath(name, root));
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, zip.subarray(dataAt, dataAt + size));
+    written.push(name);
+    at = dataAt + size;
+  }
+  if (!written.length) throw new Error("the archive contained no files");
+  return written;
+}
+__name(extractStoredZip, "extractStoredZip");
+function guessResPath(cwd, dir) {
+  const target = resolve(abs(cwd, dir));
+  const root = resolve(cwd);
+  if (target === root || !pathInside(root, target)) return void 0;
+  return `res://${relative(root, target).split("\\").join("/")}/`;
+}
+__name(guessResPath, "guessResPath");
+var SPRITE_DIRECTION_SETS = {
+  one: { animations: 1, billed: 1 },
+  four: { animations: 4, billed: 3 },
+  eight: { animations: 8, billed: 5 }
+};
+function spritePollWorthRetrying(status) {
+  return status === void 0 || status === 429 || status >= 500;
+}
+__name(spritePollWorthRetrying, "spritePollWorthRetrying");
+var SPRITE_POLL_FAILURE_BUDGET = 10;
+function stashBundle(bundle, jobId) {
+  try {
+    const path = join(tmpdir(), `privateer-sprite-${jobId.replace(/[^A-Za-z0-9_-]/g, "")}.zip`);
+    writeFileSync(path, bundle);
+    return path;
+  } catch {
+    return null;
+  }
+}
+__name(stashBundle, "stashBundle");
+async function awaitSpriteJob(jobId, cwd, dir, expectedAnimations, billed, signal) {
+  const deadline = Date.now() + SPRITE_POLL_TIMEOUT_MS;
+  const resumeHint = `Resume it with generate_sprite { resumeJobId: "${jobId}", dir: "${dir}" } \u2014 that waits on this same job and bills nothing further.`;
+  const cancelled = /* @__PURE__ */ __name(() => text(
+    `Sprite job ${jobId} was submitted but the wait was cancelled. Its ${billed ?? "queued"} clip(s) are still rendering and will still be billed. ` + resumeHint
+  ), "cancelled");
+  let consecutiveFailures = 0;
+  for (; ; ) {
+    if (signal?.aborted) return cancelled();
+    await sleep(SPRITE_POLL_INTERVAL_MS, signal);
+    if (signal?.aborted) return cancelled();
+    const poll = await callAccount(
+      `/api/agent/media/sprites/${encodeURIComponent(jobId)}`,
+      { method: "GET", signal }
+    );
+    if (!poll.ok) {
+      if (!spritePollWorthRetrying(poll.status)) {
+        return text(`Sprite job ${jobId} could not be polled: ${poll.message}`);
+      }
+      if (++consecutiveFailures >= SPRITE_POLL_FAILURE_BUDGET || Date.now() > deadline) {
+        return text(
+          `Sprite job ${jobId} could not be polled ${consecutiveFailures} times in a row: ${poll.message}. The clips are still rendering and are still billed. ${resumeHint}`
+        );
+      }
+      continue;
+    }
+    consecutiveFailures = 0;
+    const status = String(poll.data.status ?? "").toLowerCase();
+    if (status === "failed") {
+      return text(`Sprite generation failed: ${poll.data.error?.message ?? poll.data.message ?? "the provider reported a failure"}.`);
+    }
+    if (status === "completed") {
+      if (!poll.data.zip_base64) {
+        return text(`Sprite job ${jobId} already delivered its bytes on an earlier poll; they were not saved. Generate again if the files are missing.`);
+      }
+      const destination = abs(cwd, dir);
+      const bundle = Buffer.from(poll.data.zip_base64, "base64");
+      const stash = stashBundle(bundle, jobId);
+      let written;
+      try {
+        written = extractStoredZip(bundle, destination);
+      } catch (e) {
+        const why = e instanceof Error ? e.message : String(e);
+        return text(
+          `Sprite job ${jobId} rendered but the bundle could not be unpacked into ${destination}: ${why}. ` + (stash ? `The archive itself was saved to ${stash} \u2014 unzip it there; the clips are already paid for and will not be delivered again.` : "The archive could not be saved either, so the clips are lost.")
+        );
+      }
+      if (stash) {
+        try {
+          unlinkSync(stash);
+        } catch {
+        }
+      }
+      const tres = written.find((f) => f.endsWith(".tres"));
+      const anims = poll.data.animations ?? [];
+      const mirrored = anims.filter((a) => a.origin === "mirrored").length;
+      const sheet = poll.data.sheet;
+      const missing = expectedAnimations != null ? expectedAnimations - anims.length : 0;
+      const lines = [
+        `Generated sprite animation: ${written.length} files in ${destination}`,
+        sheet ? `Sheet ${sheet.width}x${sheet.height}px, ${sheet.frame_width}x${sheet.frame_height} cells, ${sheet.columns}x${sheet.rows} grid.` : "",
+        anims.length ? `Animations: ${anims.map((a) => a.name).join(", ")}${mirrored ? ` (${mirrored} mirrored, not billed)` : ""}.` : "",
+        // Said out loud rather than left to be counted: a sheet short a facing is
+        // not the sheet that was asked for, and the animation GDScript plays for
+        // that direction is simply not in the resource.
+        missing > 0 ? `WARNING: ${missing} of ${expectedAnimations} facings did not render and are NOT in the sheet or the .tres \u2014 playing them will fail in Godot. The facings that did land were billed. Re-run to try for the missing ones.` : "",
+        tres ? `Set an AnimatedSprite2D's Sprite Frames to ${poll.data.res_path ?? "res://"}${tres.split("/").pop()}.` : "",
+        "Set the sheet's texture Filter to Nearest in the Import dock, or the pixel art imports blurry.",
+        // Surfaced rather than swallowed: the flat backdrop the clip was asked
+        // for is a prompt the model can ignore, and when it does the key leaves
+        // a rim. The caller can see it here instead of finding it in-game.
+        poll.data.key_residue != null && poll.data.key_residue > 0.08 ? `NOTE: the background did not key cleanly (residue ${poll.data.key_residue.toFixed(2)}) \u2014 the frames may have a fringe. Re-run, or clean them up before shipping.` : ""
+      ].filter(Boolean);
+      return text(lines.join("\n"));
+    }
+    if (Date.now() > deadline) {
+      return text(
+        `Sprite job ${jobId} is still ${status || "running"} after ${Math.round(SPRITE_POLL_TIMEOUT_MS / 6e4)} minutes. It will still complete and still be billed; nothing was saved here. ${resumeHint}`
+      );
+    }
+  }
+}
+__name(awaitSpriteJob, "awaitSpriteJob");
+var generateSpriteToolDefinition = {
+  name: "generate_sprite",
+  label: "Generate Sprite Animation",
+  description: "Generate a 2D SPRITE ANIMATION for a game engine \u2014 a packed sprite sheet, the individual frame PNGs, and a Godot 4 SpriteFrames .tres resource \u2014 from ONE picture of a character plus a description of how it moves. The files are written straight into your project directory, so an AnimatedSprite2D can use them without any further conversion. There is no text-to-sprite here: generate or find the character art first (generate_image works), look at it, and pass that path as `image` \u2014 every facing is derived from that one picture, which is what stops the character changing between frames.\nHOW IT IS BILLED, because it is not one generation: the motion is rendered as a short video per FACING and then sampled into frames. `directions: 'one'` costs one video generation, 'four' costs THREE, and 'eight' costs FIVE \u2014 the left-facing animations are mirrored from the right-facing ones rather than rendered, which is why eight animations cost five clips and not eight. Each clip is charged at the account's video rate, so an eight-way set is genuinely expensive; say the total to the user before batching characters.\nTWO models are involved, which matters when one of them is down AND when you are quoting a price: an IMAGE model turns the picture to face each direction (only for `directions` 'four' and 'eight'), then a VIDEO model renders the motion per facing. `image_model` and `model` override them separately. The turns are billed too, at the image rate \u2014 one still per billed facing after the first, so 'four' draws two and 'eight' draws four. They are small beside a clip, but a total that counts only clips is short; media_capabilities reports both numbers per direction set (`billedClips` and `billedTurnStills`).\nIt takes several minutes \u2014 the picture is turned to face each direction one at a time before anything is billed, then the clips render together \u2014 and this tool waits. Frame count, cell size and frame rate are chosen here and cost nothing extra.\nIf a call comes back saying the job is still running, or that it could not be polled, DO NOT call this again with the same image and prompt \u2014 that bills a whole second fan-out. Call it with `resumeJobId` set to the job id it reported (and the same `dir`) to keep waiting on the clips the account has already paid for.\nAVAILABILITY: this needs a video decoder on the Privateer API and some deployments do not have one \u2014 call media_capabilities and check `sprites.available` before spending, or you will get a clear refusal instead of a sheet. PRIVACY: video and image models have no zero-retention option, so this is gated the way 3D is \u2014 a ZDR account must have enabled non-ZDR media.",
+  parameters: typebox_exports.Object({
+    image: typebox_exports.String({
+      description: "Path to ONE picture of the character, ideally full-body, centred and facing the viewer. Every other facing is generated as an edit of this image, so its framing sets the framing of the whole sheet."
+    }),
+    prompt: typebox_exports.String({
+      description: "How the character MOVES, not what it looks like \u2014 'walking at a steady pace', 'swinging a sword overhead', 'idle, breathing'. The appearance comes from `image`; describing it again here only competes with the picture."
+    }),
+    dir: typebox_exports.String({
+      description: "Directory to write the sheet, frames and .tres into, relative to cwd or absolute (e.g. 'sprites/knight'). It is created if missing. When it sits inside cwd, the res:// path baked into the .tres is derived from it, so running at your Godot project root means the resource resolves with nothing to edit."
+    }),
+    resumeJobId: typebox_exports.Optional(typebox_exports.String({
+      description: "Resume waiting on a job already submitted (from a previous call that timed out or lost its poll). Nothing is generated and nothing is billed: it only polls and unpacks. `image`, `prompt` and every other setting are ignored \u2014 pass the same `dir`."
+    })),
+    action: typebox_exports.Optional(
+      typebox_exports.String({
+        description: `The animation-name stem, e.g. 'walk' \u2014 GDScript will play "walk_down", "walk_left" and so on. Defaults to 'anim'. Keep it lowercase and ASCII; it ends up in game code.`
+      })
+    ),
+    directions: typebox_exports.Optional(
+      typebox_exports.Union(
+        [typebox_exports.Literal("one"), typebox_exports.Literal("four"), typebox_exports.Literal("eight")],
+        {
+          description: "'one' (default, one animation, ONE clip billed), 'four' (down/right/up/left, THREE billed) or 'eight' (adds the diagonals, FIVE billed). Four is the usual choice for a top-down or 2.5D character; eight only if the game actually turns that finely. These three words are the only accepted values \u2014 not '4', not 'four-way'."
+        }
+      )
+    ),
+    frames: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "Frames per animation, 2-24 (default 8). Sampled out of the rendered clip, so this costs nothing extra and can be chosen for the look: 8 is a classic walk cycle, 12+ is smoother and makes a larger sheet."
+      })
+    ),
+    frame_size: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "Cell size in pixels, 8-512 (default 64). Frames are downscaled with nearest-neighbour, so pixel art stays crisp. Pick the size the game actually draws at."
+      })
+    ),
+    fps: typebox_exports.Optional(
+      typebox_exports.Number({ description: "Playback rate written into the resource, 1-120 (default 12)." })
+    ),
+    loop: typebox_exports.Optional(
+      typebox_exports.Boolean({ description: "Whether the animations loop (default true)." })
+    ),
+    name: typebox_exports.Optional(
+      typebox_exports.String({ description: "Name for the sprite; sets the file names. Defaults to `action`." })
+    ),
+    res_path: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Override the res:// folder the .tres points at, e.g. 'res://art/mobs/'. Only needed when `dir` is not inside your Godot project root \u2014 otherwise it is derived from `dir`."
+      })
+    ),
+    model: typebox_exports.Optional(
+      typebox_exports.String({ description: "Video model id to render the motion with. Omit for the one chosen with /video-model, or the account default." })
+    ),
+    image_model: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "Image model id used to TURN the picture to face each direction, e.g. 'google/gemini-3.1-flash-image'. Omit for the one chosen with /image-model, or the account default. Only used when `directions` is 'four' or 'eight' \u2014 'one' renders no turns and never touches an image model. Worth setting when a run fails with SPRITE_IMAGE_MODEL_UNAVAILABLE: that is the image provider being down, not the request being wrong, and naming another model here retries the whole run for nothing (the turns are drawn before any clip is billed). media_capabilities lists the account's current image model."
+      })
+    )
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    if (!params.dir) return text("Error: dir is required \u2014 say where to write the sheet and the .tres.");
+    const resumeJobId = String(params.resumeJobId ?? "").trim();
+    if (resumeJobId) return awaitSpriteJob(resumeJobId, cwd, params.dir, null, null, signal);
+    if (!params.image) return text("Error: image is required \u2014 sprite generation derives every facing from one picture.");
+    if (!params.prompt?.trim()) return text("Error: prompt is required \u2014 describe how the character moves.");
+    const directions = params.directions ?? "one";
+    if (!Object.prototype.hasOwnProperty.call(SPRITE_DIRECTION_SETS, directions)) {
+      return text(`Error: directions must be 'one', 'four' or 'eight' \u2014 got ${JSON.stringify(params.directions)}.`);
+    }
+    const ranges = [
+      ["frames", params.frames, 2, 24],
+      ["frame_size", params.frame_size, 8, 512],
+      ["fps", params.fps, 1, 120]
+    ];
+    for (const [label, value, min, max] of ranges) {
+      if (value == null) continue;
+      if (!Number.isFinite(value) || value < min || value > max) {
+        return text(`Error: ${label} must be between ${min} and ${max} \u2014 got ${value}.`);
+      }
+    }
+    let seed;
+    try {
+      seed = readInputImage(cwd, params.image);
+    } catch (e) {
+      return text(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const submitted = await callAccount("/api/agent/media/sprites", {
+      method: "POST",
+      signal,
+      body: {
+        image: seed.data,
+        prompt: params.prompt,
+        ...params.action ? { action: params.action } : {},
+        ...params.name ? { name: params.name } : {},
+        directions,
+        ...params.frames != null ? { frames: params.frames } : {},
+        ...params.frame_size != null ? { frame_size: params.frame_size } : {},
+        ...params.fps != null ? { fps: params.fps } : {},
+        ...params.loop != null ? { loop: params.loop } : {},
+        // The caller's own res:// wins; otherwise derive it from where the files
+        // are going, which is right whenever the agent runs at the project root.
+        ...params.res_path ? { res_path: params.res_path } : (() => {
+          const guessed = guessResPath(cwd, params.dir);
+          return guessed ? { res_path: guessed } : {};
+        })(),
+        .../* @__PURE__ */ ((m) => m ? { model: m } : {})(effectiveMediaModel("video", params.model)),
+        .../* @__PURE__ */ ((m) => m ? { image_model: m } : {})(effectiveMediaModel("image", params.image_model))
+      }
+    });
+    if (!submitted.ok) return text(`Sprite generation failed: ${submitted.message}`);
+    const jobId = submitted.data.id;
+    if (!jobId) return text("Sprite generation failed: Privateer did not return a job id.");
+    const expected = submitted.data.animations ?? SPRITE_DIRECTION_SETS[directions].animations;
+    return awaitSpriteJob(jobId, cwd, params.dir, expected, submitted.data.billed_facings ?? null, signal);
+  }
+};
+function makeMediaTools() {
+  return (pi) => {
+    pi.registerTool?.(generateImageToolDefinition);
+    pi.registerTool?.(generateVideoToolDefinition);
+    pi.registerTool?.(generateModelToolDefinition);
+    pi.registerTool?.(generateSpriteToolDefinition);
+    pi.registerTool?.(generateSpeechToolDefinition);
+    pi.registerTool?.(generateMusicToolDefinition);
+    pi.registerTool?.(generateSfxToolDefinition);
+    pi.registerTool?.(mediaCapabilitiesToolDefinition);
+  };
+}
+__name(makeMediaTools, "makeMediaTools");
+export {
+  MEDIA_HTTP_TIMEOUT_MS,
+  MEDIA_TOOL_NAMES,
+  deferredResumeHint,
+  describeImageVideo,
+  describeModel3d,
+  describeSfx,
+  describeSpeech,
+  describeTransportFailure,
+  extractStoredZip,
+  generateImageToolDefinition,
+  generateModelToolDefinition,
+  generateMusicToolDefinition,
+  generateSfxToolDefinition,
+  generateSpeechToolDefinition,
+  generateSpriteToolDefinition,
+  generateVideoToolDefinition,
+  guessResPath,
+  makeMediaTools,
+  mediaCapabilitiesToolDefinition,
+  openSealedResult,
+  pathInside,
+  quoteMediaCallUsd,
+  readMediaCapabilities,
+  spritePollWorthRetrying
+};