@pixeldojo/mcp 0.8.0 → 0.9.0

package/dist/cli.cjs

@@ -188,7 +188,7 @@ var init_upload_helpers = __esm({
 function getFieldConstraints(apiId, client) {
   const cached = schemaCache.get(apiId);
   if (cached) return cached;
-  const pending = client.getModelSchema(apiId).then(
+  const pending = Promise.resolve().then(() => client.getModelSchema(apiId)).then(
     (res) => res.schema?.properties ?? {}
   ).catch(() => {
     schemaCache.delete(apiId);
@@ -256,10 +256,34 @@ async function snapDuration(apiId, requested, client, opts = {}) {
   }
   return requested;
 }
-var schemaCache;
+async function resolveImageRefs(apiId, urls, client) {
+  if (urls.length === 0) return null;
+  const props = await getFieldConstraints(apiId, client);
+  if (props === null) return null;
+  const key = REF_KEYS.find((k) => props[k] !== void 0);
+  if (!key) return null;
+  const field = props[key];
+  if (field.type === "array") {
+    const cap = typeof field.maxItems === "number" ? field.maxItems : urls.length;
+    const kept = urls.slice(0, Math.max(1, cap));
+    return { key, value: kept, dropped: urls.length - kept.length };
+  }
+  return { key, value: urls[0], dropped: urls.length - 1 };
+}
+var schemaCache, REF_KEYS;
 var init_schema_snap = __esm({
   "src/skills/schema-snap.ts"() {
     schemaCache = /* @__PURE__ */ new Map();
+    REF_KEYS = [
+      "image_urls",
+      "images",
+      "image_input",
+      "reference_images",
+      "reference_urls",
+      "image_url",
+      "input_image",
+      "image"
+    ];
   }
 });
 function buildPayload(apiId, input) {
@@ -411,12 +435,21 @@ function buildPayload2(apiId, input) {
         ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
       };
     case "flux-edit":
-    case "xai-image-edit":
+      return {
+        prompt: input.prompt,
+        input_image_1: urls[0],
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
     case "gpt-image-2-edit":
+      return {
+        prompt: input.prompt,
+        image_urls: urls.slice(0, 8),
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
+    case "xai-image-edit":
       return {
         prompt: input.prompt,
         image_url: urls[0],
-        ...urls.length > 1 ? { image_urls: urls } : {},
         ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
       };
     case "google-nano-banana":
@@ -432,6 +465,19 @@ function buildPayload2(apiId, input) {
       };
   }
 }
+async function buildBody(apiId, input, ctx) {
+  const urls = input.image_urls && input.image_urls.length > 0 ? input.image_urls : input.image_url ? [input.image_url] : [];
+  const refs = await resolveImageRefs(apiId, urls, ctx.client);
+  if (!refs) return { body: buildPayload2(apiId, input), dropped: 0 };
+  const fallback = buildPayload2(apiId, input);
+  const body = { ...fallback };
+  for (const key of ["image_url", "image_urls", "images", "image_input", "input_image_1"]) {
+    if (key !== refs.key) delete body[key];
+  }
+  body.prompt = input.prompt;
+  body[refs.key] = refs.value;
+  return { body, dropped: refs.dropped };
+}
 async function run2(input, ctx) {
   let resolved = input;
   try {
@@ -462,7 +508,8 @@ async function run2(input, ctx) {
     ...resolved,
     aspect_ratio: await snapAspectRatio(apiId, resolved.aspect_ratio, ctx.client)
   };
-  const body = buildPayload2(apiId, resolved);
+  const { body, dropped } = await buildBody(apiId, resolved, ctx);
+  const droppedNote = dropped > 0 ? ` (${dropped} reference${dropped === 1 ? "" : "s"} dropped \u2014 ${apiId} accepts fewer)` : "";
   const submitted = await ctx.client.run(apiId, body);
   const result = await pollJobUntilDoneOrHandoff(
     submitted.jobId,
@@ -475,7 +522,7 @@ async function run2(input, ctx) {
   );
   return pollResultToSkillResult(
     result,
-    (urls) => urls.length === 0 ? `Edit job ${submitted.jobId} completed but returned no assets.` : urls.length === 1 ? `Edit complete. Asset: ${urls[0]}` : `Edit produced ${urls.length} assets. URLs: ${urls.join(", ")}`
+    (urls) => urls.length === 0 ? `Edit job ${submitted.jobId} completed but returned no assets.` : urls.length === 1 ? `Edit complete${droppedNote}. Asset: ${urls[0]}` : `Edit produced ${urls.length} assets${droppedNote}. URLs: ${urls.join(", ")}`
   );
 }
 var DEFAULT_MODEL2, ALLOWED_MODELS, InputSchema2, InputJsonSchema2, editSkill;
@@ -935,7 +982,256 @@ var init_from_url = __esm({
     };
   }
 });
+async function filmApi(ctx, method, path, body) {
+  const res = await fetch(`${ctx.baseUrl}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${ctx.apiKey}`,
+      "Content-Type": "application/json",
+      "x-pixeldojo-source": `mcp/${ctx.mcpVersion}`,
+      "x-pixeldojo-skill": "film"
+    },
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+  });
+  const data = await res.json().catch(() => ({}));
+  return { status: res.status, data };
+}
+function progressLine(f) {
+  const all = shots(f);
+  const frames = all.filter((sh) => ["frame-ready", "approved", "clip-generating", "clip-ready"].includes(sh.status) || sh.frameUrl).length;
+  const clips = all.filter((sh) => sh.status === "clip-ready").length;
+  const rendering = all.filter((sh) => sh.status === "clip-generating").length;
+  return `frames ${frames}/${all.length}, clips ${clips}/${all.length}${rendering > 0 ? ` (${rendering} rendering)` : ""}`;
+}
+async function plan(input, ctx) {
+  if (!input.idea?.trim() && !input.script?.trim()) {
+    return { kind: "text", text: "Provide an `idea` (we write the script, free) or a full `script` to plan a film." };
+  }
+  const created = await filmApi(ctx, "POST", "/api/films", {
+    aspect: input.aspect,
+    look: input.look,
+    lengthTarget: input.length,
+    assetIds: []
+  });
+  if (!created.data.film) return { kind: "text", text: `Could not create the film: ${created.data.error ?? created.status}` };
+  const id = created.data.film.id;
+  let script = input.script?.trim() ?? "";
+  if (!script) {
+    const wrote = await filmApi(ctx, "POST", `/api/films/${id}/script`, { idea: input.idea.trim() });
+    script = wrote.data.film?.script ?? "";
+    if (!script) return { kind: "text", text: `Script writing failed: ${wrote.data.error ?? wrote.status}` };
+  }
+  const planned = await filmApi(ctx, "POST", `/api/films/${id}/plan`, { script });
+  const film = planned.data.film;
+  if (!film) return { kind: "text", text: `Shot planning failed: ${planned.data.error ?? planned.status}` };
+  const total = shots(film).length;
+  const sceneLines = film.scenes.map((s, i) => `  Scene ${i + 1} "${s.title}"${s.location ? ` [${s.location}]` : ""}: ${s.shots.length} shots`);
+  return {
+    kind: "text",
+    text: [
+      `Planned "${film.title}" (film_id: ${film.id}) \u2014 ${film.scenes.length} scenes, ${total} shots, ${input.look}, ${input.aspect}.`,
+      ...sceneLines,
+      "",
+      `Nothing has been charged yet. Producing renders every shot (roughly 20-25 credits per shot at default engines, charged as each renders) plus a few credits for the soundtrack.`,
+      `Review or edit at ${ctx.baseUrl}/film-studio/${film.id} \u2014 or call pixeldojo:film with {"film_id": "${film.id}", "action": "produce"} to start production.`
+    ].join("\n")
+  };
+}
+async function produce(filmId, ctx) {
+  const { data } = await filmApi(ctx, "GET", `/api/films/${filmId}`);
+  if (!data.film) return { kind: "text", text: `Film not found: ${data.error ?? filmId}` };
+  const pending = shots(data.film).filter((sh) => sh.status === "idle" || sh.status === "failed" && !sh.frameUrl);
+  let fired = 0;
+  for (const sh of pending.slice(0, 6)) {
+    const r = await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "frame" });
+    if (r.status === 200) fired += 1;
+  }
+  return {
+    kind: "text",
+    text: `Production started on "${data.film.title}": ${fired} frame(s) dispatched (each is a normal frame charge; the server's Frame check reviews every one). Poll pixeldojo:film with {"film_id": "${filmId}", "action": "status"} every ~30 seconds \u2014 each poll advances the pipeline.`
+  };
+}
+function buildScorePlanBody(film) {
+  const scenes = film.scenes.filter((s) => s.shots.length > 0);
+  const sections = scenes.flatMap((scene, i) => {
+    const runtime = Math.max(3e3, scene.shots.reduce((n, sh) => n + (sh.durationSec || 0), 0) * 1e3);
+    const styles = i === 0 ? ARC.opening : i === scenes.length - 1 ? ARC.finale : ARC.middle;
+    const parts = Math.max(1, Math.ceil(runtime / 12e4));
+    const partMs = Math.round(runtime / parts);
+    return Array.from({ length: parts }, (_, part) => ({
+      section_name: parts > 1 ? `${scene.title} (part ${part + 1})` : scene.title,
+      positive_local_styles: styles,
+      negative_local_styles: [],
+      duration_ms: part === parts - 1 ? runtime - partMs * (parts - 1) : partMs,
+      lines: []
+    }));
+  });
+  return {
+    composition_plan: {
+      positive_global_styles: (LOOK_MUSIC[film.look] ?? LOOK_MUSIC["live-action"]).split(", "),
+      negative_global_styles: ["vocals", "singing", "lyrics"],
+      sections
+    },
+    respect_sections_durations: true,
+    output_format: "mp3_standard"
+  };
+}
+function buildFlatMusicBody(film, all) {
+  const runtimeSec = all.reduce((n, sh) => n + (sh.durationSec || 0), 0);
+  const ms = Math.min(6e5, Math.max(5e3, Math.ceil(runtimeSec * 1e3 / 5e3) * 5e3));
+  return {
+    prompt: `${LOOK_MUSIC[film.look] ?? LOOK_MUSIC["live-action"]}. Instrumental only, no vocals. One consistent theme, loopable as a background bed under dialogue.`,
+    music_length_ms: ms,
+    force_instrumental: true,
+    output_format: "mp3_standard"
+  };
+}
+async function advance(filmId, soundtrack, musicJobId, ctx) {
+  const { data } = await filmApi(ctx, "GET", `/api/films/${filmId}?refresh=1`);
+  const film = data.film;
+  if (!film) return { kind: "text", text: `Film not found: ${data.error ?? filmId}` };
+  const all = shots(film);
+  if (film.status === "exported" && film.exportUrl) {
+    return {
+      kind: "text",
+      text: `Film finished: "${film.title}"
+Watch/download: ${film.exportUrl}
+Workspace: ${ctx.baseUrl}/film-studio/${film.id}
+It is saved in the Library folder "Film: ${film.title}".`
+    };
+  }
+  if (film.exportError) {
+    return { kind: "text", text: `Export failed: ${film.exportError} Poll again with action "status" to retry.` };
+  }
+  const idleFrames = all.filter((sh) => sh.status === "idle");
+  for (const sh of idleFrames.slice(0, 6)) {
+    await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "frame" });
+  }
+  const framesDone = all.every((sh) => ["frame-ready", "clip-generating", "clip-ready"].includes(sh.status));
+  if (framesDone && all.some((sh) => sh.status === "frame-ready" && !sh.approved)) {
+    await filmApi(ctx, "PATCH", `/api/films/${filmId}`, {
+      scenes: film.scenes.map((s) => ({
+        id: s.id,
+        title: s.title,
+        location: s.location,
+        shots: s.shots.map((sh) => ({
+          id: sh.id,
+          prompt: sh.prompt,
+          characterIds: sh.characterIds ?? [],
+          elementIds: sh.elementIds ?? [],
+          engine: sh.engine,
+          cameraPreset: sh.cameraPreset,
+          approved: true,
+          durationSec: sh.durationSec
+        }))
+      }))
+    });
+  }
+  const inFlight = count(film, (sh) => sh.status === "clip-generating");
+  const clipQueue = all.filter((sh) => (sh.status === "frame-ready" || sh.status === "failed" && Boolean(sh.frameUrl)) && framesDone);
+  for (const sh of clipQueue.slice(0, Math.max(0, 4 - inFlight))) {
+    await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "clip" });
+  }
+  const clipsDone = all.length > 0 && all.every((sh) => sh.status === "clip-ready");
+  if (clipsDone) {
+    const hasMusic = film.audioStems.some((st) => st.kind === "music");
+    if (soundtrack !== "none" && !hasMusic) {
+      if (musicJobId) {
+        const job = await ctx.client.getJob(musicJobId);
+        const out = job.output;
+        const outUrl = out?.audio ?? out?.video ?? out?.images?.[0];
+        if (job.status === "completed" && typeof outUrl === "string") {
+          await filmApi(ctx, "PATCH", `/api/films/${filmId}`, { audioStems: [{ kind: "music", url: outUrl }] });
+          await filmApi(ctx, "POST", `/api/films/${filmId}/export`, {});
+          return { kind: "text", text: `Score attached \u2014 export started. Poll again in ~60s with {"film_id": "${filmId}", "action": "status"} for the finished film URL.` };
+        }
+        if (job.status === "failed") {
+          return { kind: "text", text: `The score failed (${job.error ?? "unknown"}) and was refunded. Poll again to retry, or pass soundtrack "none" to export without music.` };
+        }
+        return { kind: "text", text: `Score still composing. Poll again in ~20s with {"film_id": "${filmId}", "action": "status", "music_job_id": "${musicJobId}"}.` };
+      }
+      const body = soundtrack === "scene-synced" ? buildScorePlanBody(film) : buildFlatMusicBody(film, all);
+      const dispatch = await ctx.client.run("text-to-music", body);
+      return { kind: "text", text: `All ${all.length} clips ready \u2014 the ${soundtrack} score is composing (charged like any music generation). Poll again in ~20s with {"film_id": "${filmId}", "action": "status", "music_job_id": "${dispatch.jobId}"}.` };
+    }
+    await filmApi(ctx, "POST", `/api/films/${filmId}/export`, {});
+    return { kind: "text", text: `All clips ready \u2014 export started (${progressLine(film)}). Poll again in ~60s with action "status" for the finished film URL.` };
+  }
+  const failed = all.filter((sh) => sh.status === "failed");
+  return {
+    kind: "text",
+    text: [
+      `In progress: ${progressLine(film)}.`,
+      failed.length > 0 ? `${failed.length} shot(s) failed and were re-queued (${failed[0]?.errorMessage?.slice(0, 100) ?? ""}).` : "",
+      `Poll again in ~30s with {"film_id": "${filmId}", "action": "status"}.`
+    ].filter(Boolean).join("\n")
+  };
+}
 async function run8(input, ctx) {
+  const action = input.action === "plan" && input.film_id ? "status" : input.action;
+  if (action === "plan") return plan(input, ctx);
+  if (!input.film_id) return { kind: "text", text: "produce/status need the film_id returned by the plan step." };
+  if (action === "produce") return produce(input.film_id, ctx);
+  return advance(input.film_id, input.soundtrack, input.music_job_id, ctx);
+}
+var LOOKS, InputSchema8, InputJsonSchema8, shots, count, LOOK_MUSIC, ARC, filmSkill;
+var init_film = __esm({
+  "src/skills/film.ts"() {
+    LOOKS = ["live-action", "anime", "3d-animation", "noir", "horror", "sci-fi", "documentary", "western"];
+    InputSchema8 = zod.z.object({
+      idea: zod.z.string().max(2e3).optional().describe("One-to-three sentence film idea. The studio writes the screenplay (free). Provide idea OR script for planning."),
+      script: zod.z.string().max(2e4).optional().describe("A full screenplay to plan instead of an idea (sluglines, action lines, dialogue)."),
+      look: zod.z.enum(LOOKS).default("live-action").describe("Visual style carried through frames, clips, and soundtrack."),
+      aspect: zod.z.enum(["16:9", "9:16"]).default("16:9"),
+      length: zod.z.enum(["30s", "60s", "2-3min"]).default("60s").describe("Target length; drives the shot count (~6/12/24 shots)."),
+      film_id: zod.z.string().max(40).optional().describe("Existing film id (from a previous call) for produce/status."),
+      action: zod.z.enum(["plan", "produce", "status"]).default("plan").describe("'plan' creates + storyboards (free). 'produce' starts charged generation. 'status' advances production and reports progress; poll it every ~30s until it returns the finished film."),
+      soundtrack: zod.z.enum(["scene-synced", "flat", "none"]).default("scene-synced").describe("scene-synced composes one musical section per scene, pinned to the scene lengths (default). flat is a single cohesive bed. none skips music."),
+      music_job_id: zod.z.string().max(80).optional().describe("Internal: pass back the music job id from a previous status reply so the composing score is attached instead of re-charged.")
+    });
+    InputJsonSchema8 = {
+      type: "object",
+      properties: {
+        idea: { type: "string", description: "One-to-three sentence film idea. The studio writes the screenplay (free)." },
+        script: { type: "string", description: "A full screenplay to plan instead of an idea." },
+        look: { type: "string", enum: [...LOOKS], description: "Visual style. Default live-action." },
+        aspect: { type: "string", enum: ["16:9", "9:16"], description: "Default 16:9." },
+        length: { type: "string", enum: ["30s", "60s", "2-3min"], description: "Target length (~6/12/24 shots). Default 60s." },
+        film_id: { type: "string", description: "Existing film id for produce/status." },
+        action: { type: "string", enum: ["plan", "produce", "status"], description: "plan (free) | produce (charged) | status (poll every ~30s)." },
+        soundtrack: { type: "string", enum: ["scene-synced", "flat", "none"], description: "Default scene-synced." },
+        music_job_id: { type: "string", description: "Pass back from a previous status reply while the score is composing." }
+      }
+    };
+    shots = (f) => f.scenes.flatMap((s) => s.shots);
+    count = (f, pred) => shots(f).filter(pred).length;
+    LOOK_MUSIC = {
+      "live-action": "modern cinematic underscore, warm strings and soft felt piano, subtle rhythmic pulse, slow emotional build",
+      anime: "sweeping anime film score, lush strings and piano, taiko drum accents, soaring heartfelt theme",
+      "3d-animation": "playful heartfelt family-animation score, pizzicato strings, celesta and warm woodwinds, gentle sense of wonder",
+      noir: "smoky film-noir jazz underscore, brushed drums, upright bass, distant muted trumpet, slow simmering tension",
+      horror: "sparse horror underscore, low cello drones, dissonant string swells, creeping heartbeat pulse, unsettling quiet",
+      "sci-fi": "atmospheric science-fiction score, analog synth pads, deep sub-bass pulses, shimmering arpeggios, vast and cold",
+      documentary: "understated documentary score, felt piano, soft string beds, organic percussion textures, reflective and true",
+      western: "cinematic western score, lonely twangy guitar, dusty strings, distant horns, wide-open desert tension"
+    };
+    ARC = {
+      opening: ["establishing the theme", "restrained", "quiet anticipation"],
+      middle: ["building tension", "rising intensity", "forward motion"],
+      finale: ["climactic", "full arrangement", "emotional peak resolving to stillness"]
+    };
+    filmSkill = {
+      name: "pixeldojo:film",
+      description: "Make a finished short film from one idea: screenplay, storyboard frames (AI-reviewed), video clips with spoken dialogue, scene-synced soundtrack, stitched export. Phased: plan is free and returns a cost estimate; produce starts charged generation; status advances production (poll every ~30s).",
+      inputZod: InputSchema8,
+      inputJsonSchema: InputJsonSchema8,
+      allowedModels: [],
+      defaultModel: "",
+      run: run8
+    };
+  }
+});
+async function run9(input, ctx) {
   const productImages = [
     ...input.product_image_urls ?? [],
     ...await Promise.all((input.product_image_paths ?? []).map((p) => uploadLocalFile(p, ctx.client)))
@@ -978,13 +1274,13 @@ async function run8(input, ctx) {
     (urls) => urls.length === 0 ? `Ad job ${submitted.jobId} completed but returned no assets.` : `Ad rendered (style: ${styleLabel}${submitted.ad?.product?.name ? `, product: ${submitted.ad.product.name}` : ""}). Video: ${urls[0]}`
   );
 }
-var InputSchema8, InputJsonSchema8, adSkill;
+var InputSchema9, InputJsonSchema9, adSkill;
 var init_ad = __esm({
   "src/skills/ad.ts"() {
     init_types();
     init_poll();
     init_upload_helpers();
-    InputSchema8 = zod.z.object({
+    InputSchema9 = zod.z.object({
       style: zod.z.string().max(80).optional().describe(
         "Ad style slug (default ugc-testimonial). Catalog: GET /api/v1/marketing/presets \u2014 e.g. ugc-testimonial, unboxing-reveal, unboxing-asmr, virtual-try-on, street-style, product-showcase, macro-details, crush-test, hyper-motion, before-after, day-in-the-life, the-gift, tv-spot."
       ),
@@ -1010,7 +1306,7 @@ var init_ad = __esm({
         path: ["product_url"]
       }
     );
-    InputJsonSchema8 = {
+    InputJsonSchema9 = {
       type: "object",
       properties: {
         style: {
@@ -1066,16 +1362,16 @@ var init_ad = __esm({
     adSkill = {
       name: "pixeldojo:ad",
       description: "Marketing Studio: turn any product into a video ad. Pass a product URL (auto-extracted) or product images, pick an ad style (UGC testimonial, unboxing, try-on, showcase, TV spot, and more via GET /api/v1/marketing/presets), optionally add presenter reference images, a location, a hook, and the exact spoken script. Renders with voiceover; returns the video or a statusUrl handoff to poll via pixeldojo:status. Ideal for automated generate-and-post workflows.",
-      inputZod: InputSchema8,
-      inputJsonSchema: InputJsonSchema8,
+      inputZod: InputSchema9,
+      inputJsonSchema: InputJsonSchema9,
       // Composition skill — the server routes to the ad engine internally.
       allowedModels: [],
       defaultModel: "",
-      run: run8
+      run: run9
     };
   }
 });
-async function run9(input, ctx) {
+async function run10(input, ctx) {
   const client = ctx.client;
   const result = await client.runCampaign(input);
   if (result.kind === "campaign") {
@@ -1102,10 +1398,10 @@ async function run9(input, ctx) {
     statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
   };
 }
-var InputSchema9, InputJsonSchema9, campaignSkill;
+var InputSchema10, InputJsonSchema10, campaignSkill;
 var init_campaign = __esm({
   "src/skills/campaign.ts"() {
-    InputSchema9 = zod.z.object({
+    InputSchema10 = zod.z.object({
       productUrl: zod.z.string().url().optional().describe("Product page URL. We extract name + description + images automatically."),
       product: zod.z.object({
         name: zod.z.string().min(1).max(200),
@@ -1121,7 +1417,7 @@ var init_campaign = __esm({
       message: "productUrl or product is required",
       path: ["productUrl"]
     });
-    InputJsonSchema9 = {
+    InputJsonSchema10 = {
       type: "object",
       properties: {
         productUrl: {
@@ -1152,17 +1448,17 @@ var init_campaign = __esm({
     campaignSkill = {
       name: "pixeldojo:campaign",
       description: "Generate a coherent product launch package (hero image + N lifestyle variants + optional vertical video) from one URL or product profile. Composes hero / lifestyle / video models server-side; returns assets in one call or a handoff with campaignId to poll via pixeldojo:campaign_status.",
-      inputZod: InputSchema9,
-      inputJsonSchema: InputJsonSchema9,
+      inputZod: InputSchema10,
+      inputJsonSchema: InputJsonSchema10,
       // Composition skill — internal sub-jobs route to per-tool models, no
       // single allowed-models list applies here.
       allowedModels: [],
       defaultModel: "",
-      run: run9
+      run: run10
     };
   }
 });
-async function run10(input, ctx) {
+async function run11(input, ctx) {
   const client = ctx.client;
   const result = await client.getCampaign(input.campaignId);
   if (result.kind === "campaign") {
@@ -1192,13 +1488,13 @@ async function run10(input, ctx) {
     statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
   };
 }
-var InputSchema10, InputJsonSchema10, campaignStatusSkill;
+var InputSchema11, InputJsonSchema11, campaignStatusSkill;
 var init_campaign_status = __esm({
   "src/skills/campaign-status.ts"() {
-    InputSchema10 = zod.z.object({
+    InputSchema11 = zod.z.object({
       campaignId: zod.z.string().min(1).max(200).describe("Campaign id returned from a prior pixeldojo:campaign handoff.")
     });
-    InputJsonSchema10 = {
+    InputJsonSchema11 = {
       type: "object",
       properties: {
         campaignId: {
@@ -1211,15 +1507,15 @@ var init_campaign_status = __esm({
     campaignStatusSkill = {
       name: "pixeldojo:campaign_status",
       description: "Poll a campaign by campaignId returned from pixeldojo:campaign. Returns assets when every sub-job is done, or a handoff describing what is still in flight.",
-      inputZod: InputSchema10,
-      inputJsonSchema: InputJsonSchema10,
+      inputZod: InputSchema11,
+      inputJsonSchema: InputJsonSchema11,
       allowedModels: [],
       defaultModel: "",
-      run: run10
+      run: run11
     };
   }
 });
-async function run11(input, ctx) {
+async function run12(input, ctx) {
   let url;
   try {
     url = await uploadLocalFile(input.path, ctx.client);
@@ -1235,16 +1531,16 @@ async function run11(input, ctx) {
 (temp storage; auto-deletes in ~24h \u2014 pass this URL as image_url to :generate or :edit)`
   };
 }
-var InputSchema11, InputJsonSchema11, uploadSkill;
+var InputSchema12, InputJsonSchema12, uploadSkill;
 var init_upload = __esm({
   "src/skills/upload.ts"() {
     init_upload_helpers();
-    InputSchema11 = zod.z.object({
+    InputSchema12 = zod.z.object({
       path: zod.z.string().min(1).max(4096).describe(
         "Absolute local file path to upload. JPEG, PNG, WebP, GIF (\u226450MB) or MP4, WebM, MOV (\u2264200MB). Returns a public URL on the temp CDN; storage auto-expires after 24 hours."
       )
     });
-    InputJsonSchema11 = {
+    InputJsonSchema12 = {
       type: "object",
       properties: {
         path: {
@@ -1257,15 +1553,15 @@ var init_upload = __esm({
     uploadSkill = {
       name: "pixeldojo:upload",
       description: "Upload a local image or video file and get back a public URL you can pass to :generate or :edit as image_url. Use when the user has a reference image on disk (drag-dropped into Claude Code, screenshot, etc.) and you need a URL. Storage auto-expires after 24 hours.",
-      inputZod: InputSchema11,
-      inputJsonSchema: InputJsonSchema11,
+      inputZod: InputSchema12,
+      inputJsonSchema: InputJsonSchema12,
       allowedModels: [],
       defaultModel: "",
-      run: run11
+      run: run12
     };
   }
 });
-async function run12(input, ctx) {
+async function run13(input, ctx) {
   const requested = input.model ?? DEFAULT_MODEL6;
   if (!ALLOWED4.includes(requested)) {
     return {
@@ -1314,7 +1610,7 @@ async function run12(input, ctx) {
     (urls) => urls.length === 0 ? `Job ${submitted.jobId} completed but returned no assets.` : `Audio ready. Asset: ${urls[0]}`
   );
 }
-var ALLOWED4, DEFAULT_MODEL6, InputSchema12, InputJsonSchema12, audioSkill;
+var ALLOWED4, DEFAULT_MODEL6, InputSchema13, InputJsonSchema13, audioSkill;
 var init_audio = __esm({
   "src/skills/audio.ts"() {
     init_poll();
@@ -1322,7 +1618,7 @@ var init_audio = __esm({
     init_types();
     ALLOWED4 = ["seed-audio", "text-to-speech"];
     DEFAULT_MODEL6 = "seed-audio";
-    InputSchema12 = zod.z.object({
+    InputSchema13 = zod.z.object({
       prompt: zod.z.string().min(1).describe(
         "A script for speech, or a scene description for cinematic audio (dialogue + effects + music). Reference uploaded clips as @Audio1..@Audio3."
       ),
@@ -1333,7 +1629,7 @@ var init_audio = __esm({
       output_format: zod.z.string().optional().describe("seed-audio: mp3 (default), wav, pcm, ogg_opus. text-to-speech: mp3, wav, flac, pcm."),
       speed: zod.z.number().min(0.5).max(2).optional().describe("Speech speed multiplier (0.5\u20132).")
     });
-    InputJsonSchema12 = {
+    InputJsonSchema13 = {
       type: "object",
       properties: {
         prompt: { type: "string" },
@@ -1349,15 +1645,15 @@ var init_audio = __esm({
     audioSkill = {
       name: "pixeldojo:audio",
       description: "Generate audio: speech, multi-character dialogue, sound effects, and background music from one prompt (Seed Audio 1.0 by default; plain TTS available).",
-      inputZod: InputSchema12,
-      inputJsonSchema: InputJsonSchema12,
+      inputZod: InputSchema13,
+      inputJsonSchema: InputJsonSchema13,
       allowedModels: [...ALLOWED4],
       defaultModel: DEFAULT_MODEL6,
-      run: run12
+      run: run13
     };
   }
 });
-async function run13(input, ctx) {
+async function run14(input, ctx) {
   const res = await ctx.client.listLibrary({
     q: input.q,
     model: input.model,
@@ -1388,16 +1684,16 @@ ${lines.join("\n")}
 Pass any URL back into :generate, :edit, :character, or :upscale as a reference input.`
   };
 }
-var InputSchema13, InputJsonSchema13, librarySkill;
+var InputSchema14, InputJsonSchema14, librarySkill;
 var init_library = __esm({
   "src/skills/library.ts"() {
-    InputSchema13 = zod.z.object({
+    InputSchema14 = zod.z.object({
       q: zod.z.string().optional().describe("Substring match against the prompt that produced the asset."),
       model: zod.z.string().optional().describe("Restrict to a single model (apiId)."),
       modality: zod.z.enum(["image", "video", "audio"]).optional().describe("Restrict to one output type."),
       limit: zod.z.number().int().min(1).max(50).optional().describe("Max results (default 10).")
     });
-    InputJsonSchema13 = {
+    InputJsonSchema14 = {
       type: "object",
       properties: {
         q: { type: "string" },
@@ -1410,15 +1706,15 @@ var init_library = __esm({
     librarySkill = {
       name: "pixeldojo:library",
       description: "Search your media library: saved My Media items (permanent) and recent API/MCP generations (expire after 24h), newest first. Returns asset URLs to reuse as reference inputs. Keep a result forever with pixeldojo:save.",
-      inputZod: InputSchema13,
-      inputJsonSchema: InputJsonSchema13,
+      inputZod: InputSchema14,
+      inputJsonSchema: InputJsonSchema14,
       allowedModels: [],
       defaultModel: "",
-      run: run13
+      run: run14
     };
   }
 });
-async function run14(input, ctx) {
+async function run15(input, ctx) {
   const res = await ctx.client.saveMedia({
     url: input.url,
     prompt: input.prompt,
@@ -1432,17 +1728,17 @@ async function run14(input, ctx) {
 It will appear at https://pixeldojo.ai/my-images and in pixeldojo:library searches.`
   };
 }
-var InputSchema14, InputJsonSchema14, saveSkill;
+var InputSchema15, InputJsonSchema15, saveSkill;
 var init_save = __esm({
   "src/skills/save.ts"() {
-    InputSchema14 = zod.z.object({
+    InputSchema15 = zod.z.object({
       url: zod.z.string().url().describe("The asset URL to save (image or video)."),
       prompt: zod.z.string().optional().describe("The prompt that produced it \u2014 makes it findable in the library later."),
       tool_name: zod.z.string().optional().describe("Tool/model slug that produced it."),
       modality: zod.z.enum(["image", "video", "audio"]).optional(),
       job_id: zod.z.string().optional().describe("The jobId that produced this asset, when known.")
     });
-    InputJsonSchema14 = {
+    InputJsonSchema15 = {
       type: "object",
       properties: {
         url: { type: "string", format: "uri" },
@@ -1456,11 +1752,11 @@ var init_save = __esm({
     saveSkill = {
       name: "pixeldojo:save",
       description: "Save a generated image or video into the user's My Media library permanently. Generation outputs otherwise expire after 24 hours \u2014 call this when the user wants to keep a result.",
-      inputZod: InputSchema14,
-      inputJsonSchema: InputJsonSchema14,
+      inputZod: InputSchema15,
+      inputJsonSchema: InputJsonSchema15,
       allowedModels: [],
       defaultModel: "",
-      run: run14
+      run: run15
     };
   }
 });
@@ -1678,6 +1974,7 @@ __export(skills_exports, {
   campaignStatusSkill: () => campaignStatusSkill,
   characterSkill: () => characterSkill,
   editSkill: () => editSkill,
+  filmSkill: () => filmSkill,
   findSkill: () => findSkill,
   fromUrlSkill: () => fromUrlSkill,
   generateSkill: () => generateSkill,
@@ -1704,6 +2001,7 @@ var init_skills = __esm({
     init_upscale();
     init_status();
     init_from_url();
+    init_film();
     init_ad();
     init_campaign();
     init_campaign_status();
@@ -1729,7 +2027,8 @@ var init_skills = __esm({
       uploadSkill,
       adSkill,
       campaignSkill,
-      campaignStatusSkill
+      campaignStatusSkill,
+      filmSkill
     ];
   }
 });
@@ -1784,7 +2083,7 @@ function makeRedactedLogger(target = console) {
 }
 
 // src/server.ts
-var PACKAGE_VERSION = "0.8.0" ;
+var PACKAGE_VERSION = "0.9.0" ;
 function buildServer(options) {
   if (!options.apiKey) {
     throw new Error(
@@ -1851,6 +2150,8 @@ function buildServer(options) {
     });
     const ctx = {
       client,
+      apiKey: options.apiKey,
+      baseUrl,
       mcpVersion: version,
       logger,
       buildStatusUrl: (jobId) => `${baseUrl}/api/v1/jobs/${encodeURIComponent(jobId)}`