litevision 0.1.1 → 0.2.0

package/dist/cli.js

@@ -14154,6 +14154,7 @@ function defaultDirs(home = homedir()) {
 var fetchTransport = (input, init) => fetch(input, init);
 
 // src/server.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { resolve as resolve2 } from "node:path";
 
 // node_modules/zod/v3/helpers/util.js
@@ -21697,6 +21698,23 @@ var EMPTY_COMPLETION_RESULT = {
 // src/config.ts
 import { readFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
+
+// src/protocols/protocol.ts
+var aspectRatios = ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"];
+var modalities = ["image", "video"];
+function formatSize(size) {
+  return `${size.width}x${size.height}`;
+}
+
+class ProviderError extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+}
+
+// src/config.ts
 var providerSchema = object({
   id: string2().min(1),
   baseUrl: string2().url()
@@ -21713,13 +21731,15 @@ var modelSchema = object({
   provider: string2().min(1),
   modelId: string2().min(1),
   protocol: string2().min(1),
+  modality: _enum(modalities).default("image"),
   notes: string2().optional(),
   notesHistory: notesHistorySchema.optional()
 });
 var configSchema = object({
   providers: array(providerSchema).default([]),
   models: array(modelSchema).default([]),
-  defaultImageModel: string2().optional()
+  defaultImageModel: string2().optional(),
+  defaultVideoModel: string2().optional()
 });
 var credentialsSchema = record(string2(), object({ apiKey: string2().min(1) }));
 
@@ -21760,23 +21780,31 @@ async function requireCredential(dirs, provider) {
     throw needsSettings(`Provider "${provider.id}" has no Credential saved.`);
   return credential;
 }
-function defaultModelAlias(config) {
-  const wanted = config.defaultImageModel;
-  return config.models.some((model) => model.alias === wanted) ? wanted : undefined;
+var defaultKey = { image: "defaultImageModel", video: "defaultVideoModel" };
+function defaultModelAlias(config, modality = "image") {
+  const wanted = config[defaultKey[modality]];
+  return config.models.some((model) => model.alias === wanted && model.modality === modality) ? wanted : undefined;
 }
-function resolveModel(config, alias) {
-  if (config.models.length === 0)
-    throw needsSettings("litevision has no image Model configured yet.");
-  const known = config.models.map((model) => model.alias).join(", ");
-  const wanted = alias ?? config.defaultImageModel;
+function resolveModel(config, alias, modality = "image") {
+  const ofModality = config.models.filter((model) => model.modality === modality);
+  const wanted = alias ?? config[defaultKey[modality]];
+  const model = config.models.find((candidate) => candidate.alias === wanted);
+  if (ofModality.length === 0 && (alias === undefined || model === undefined))
+    throw needsSettings(`litevision has no ${modality} Model configured yet.`);
+  const known = ofModality.map((candidate) => candidate.alias).join(", ");
   if (wanted === undefined) {
-    throw needsSettings(`No default image Model is set. Pass \`model\` with one of: ${known}. Or:`);
+    throw needsSettings(`No default ${modality} Model is set. Pass \`model\` with one of: ${known}. Or:`);
   }
-  const model = config.models.find((candidate) => candidate.alias === wanted);
   if (model === undefined) {
     if (alias === undefined)
-      throw needsSettings(`The default image Model "${wanted}" does not exist. Known Aliases: ${known}.`);
-    throw new ConfigError(`Unknown Model Alias "${wanted}". Known Aliases: ${known}.`);
+      throw needsSettings(`The default ${modality} Model "${wanted}" does not exist. Known Aliases: ${known}.`);
+    throw new ConfigError(`Unknown Model Alias "${wanted}". Known ${modality} Model Aliases: ${known}.`);
+  }
+  if (model.modality !== modality) {
+    if (alias === undefined)
+      throw needsSettings(`The default ${modality} Model "${wanted}" makes ${model.modality}s. Pass \`model\` with one of: ${known}. Or:`);
+    const tool = model.modality === "video" ? "generate_video" : "generate_image";
+    throw new ConfigError(`Model "${model.alias}" generates ${model.modality}s, not ${modality}s. Use \`${tool}\` for it${ofModality.length === 0 ? "" : `, or one of these ${modality} Models: ${known}`}.`);
   }
   const provider = config.providers.find((candidate) => candidate.id === model.provider);
   if (provider === undefined) {
@@ -21790,6 +21818,9 @@ import { appendFile, mkdir, readFile as readFile2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 var verdicts = ["good", "bad"];
 var ratingReasonMaxLength = 200;
+function ratingOf({ ratings }, result) {
+  return ratings.find((rating) => rating.result === result);
+}
 
 class RatingError extends Error {
   kind;
@@ -21799,6 +21830,15 @@ class RatingError extends Error {
     this.name = "RatingError";
   }
 }
+
+class PickError extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "PickError";
+  }
+}
 var historyPath = (dirs) => join3(dirs.data, "jobs.jsonl");
 async function appendHistory(dirs, record) {
   await mkdir(dirs.data, { recursive: true });
@@ -21812,8 +21852,11 @@ async function readJob(dirs, id) {
   return (await readJobs(dirs)).find((job) => job.id === id);
 }
 async function readRatedJobs(dirs) {
-  const { jobs, ratings } = await readRecords(dirs);
-  return jobs.map((job) => ({ job, ...ratings.has(job.id) ? { rating: ratings.get(job.id) } : {} })).sort((a, b) => Date.parse(b.job.createdAt) - Date.parse(a.job.createdAt));
+  const { jobs, ratings, picks } = await readRecords(dirs);
+  return jobs.map((job) => {
+    const pick = job.comparison === undefined ? undefined : picks.get(job.comparison);
+    return { job, ratings: [...ratings.get(job.id)?.values() ?? []], ...pick === undefined ? {} : { pick } };
+  }).sort((a, b) => Date.parse(b.job.createdAt) - Date.parse(a.job.createdAt));
 }
 async function rateJob(dirs, rating, now) {
   const reason = rating.reason.replace(/\s+/g, " ").trim();
@@ -21825,15 +21868,56 @@ async function rateJob(dirs, rating, now) {
   const job = await readJob(dirs, rating.jobId);
   if (job === undefined)
     throw new RatingError("unknown-job", `litevision has no Job "${rating.jobId}".`);
+  const { result } = rating;
+  const problem = whyNotChosen(job, result, "rate");
+  if (problem !== undefined)
+    throw new RatingError(problem.kind, problem.message);
+  const record = {
+    type: "rating",
+    jobId: job.id,
+    ...result === undefined ? {} : { result },
+    verdict: rating.verdict,
+    reason,
+    ratedAt: now.toISOString()
+  };
+  await appendHistory(dirs, record);
+  return record;
+}
+async function pickResult(dirs, pick, now) {
+  const ofComparison = (await readJobs(dirs)).filter((job) => job.comparison === pick.comparison);
+  if (ofComparison.length === 0)
+    throw new PickError("unknown-comparison", `litevision has no Comparison "${pick.comparison}".`);
+  const job = ofComparison.find((job) => job.id === pick.jobId);
+  if (job === undefined) {
+    const ids = ofComparison.map((job) => job.id).join(", ");
+    throw new PickError("not-in-comparison", `Job "${pick.jobId}" is not part of Comparison ${pick.comparison}, whose Jobs are ${ids}.`);
+  }
+  const { result } = pick;
+  const problem = whyNotChosen(job, result, "pick");
+  if (problem !== undefined)
+    throw new PickError(problem.kind, problem.message);
+  const record = {
+    type: "pick",
+    comparison: pick.comparison,
+    jobId: job.id,
+    ...result === undefined ? {} : { result },
+    pickedAt: now.toISOString()
+  };
+  await appendHistory(dirs, record);
+  return record;
+}
+function whyNotChosen(job, result, act) {
   if (job.outcome === "running") {
-    throw new RatingError("not-completed", `Job ${job.id} is still running; it can be rated once it has completed.`);
+    return { kind: "not-completed", message: `Job ${job.id} is still running; it can be ${act === "rate" ? "rated" : "picked"} once it has completed.` };
   }
   if (job.outcome === "failed") {
-    throw new RatingError("not-completed", `Job ${job.id} failed and saved no images, so there is nothing to rate.`);
+    return { kind: "not-completed", message: `Job ${job.id} failed and saved no images, so there is nothing to ${act}.` };
   }
-  const record = { type: "rating", jobId: job.id, verdict: rating.verdict, reason, ratedAt: now.toISOString() };
-  await appendHistory(dirs, record);
-  return record;
+  if (result !== undefined && !(Number.isInteger(result) && result >= 1 && result <= job.files.length)) {
+    const count = job.files.length === 1 ? "1 result" : `${job.files.length} results`;
+    return { kind: "invalid", message: `Job ${job.id} has ${count}, numbered from 1 in the order of its files.` };
+  }
+  return;
 }
 async function readRecords(dirs) {
   let text;
@@ -21841,11 +21925,12 @@ async function readRecords(dirs) {
     text = await readFile2(historyPath(dirs), "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
-      return { jobs: [], ratings: new Map };
+      return { jobs: [], ratings: new Map, picks: new Map };
     throw error;
   }
   const jobs = new Map;
   const ratings = new Map;
+  const picks = new Map;
   for (const line of text.split(`
 `)) {
     if (line.trim() === "")
@@ -21857,7 +21942,14 @@ async function readRecords(dirs) {
       continue;
     }
     if (isRatingRecord(record)) {
-      ratings.set(record.jobId, record);
+      const ofJob = ratings.get(record.jobId) ?? new Map;
+      ratings.set(record.jobId, ofJob);
+      ofJob.delete(record.result ?? 0);
+      ofJob.set(record.result ?? 0, record);
+      continue;
+    }
+    if (isPickRecord(record)) {
+      picks.set(record.comparison, record);
       continue;
     }
     if (!isJobRecord(record))
@@ -21865,7 +21957,7 @@ async function readRecords(dirs) {
     jobs.delete(record.id);
     jobs.set(record.id, record);
   }
-  return { jobs: [...jobs.values()], ratings };
+  return { jobs: [...jobs.values()], ratings, picks };
 }
 function isJobRecord(value) {
   const record = value;
@@ -21873,18 +21965,73 @@ function isJobRecord(value) {
 }
 function isRatingRecord(value) {
   const record = value;
-  return typeof record === "object" && record !== null && record.type === "rating" && typeof record.jobId === "string" && verdicts.includes(record.verdict) && typeof record.reason === "string";
+  return typeof record === "object" && record !== null && record.type === "rating" && typeof record.jobId === "string" && verdicts.includes(record.verdict) && typeof record.reason === "string" && (record.result === undefined || Number.isInteger(record.result) && record.result >= 1);
 }
-function knownGoodOptions(jobs, model) {
-  const options = {};
-  for (const job of jobs) {
+function isPickRecord(value) {
+  const record = value;
+  return typeof record === "object" && record !== null && record.type === "pick" && typeof record.comparison === "string" && typeof record.jobId === "string" && typeof record.pickedAt === "string" && (record.result === undefined || Number.isInteger(record.result) && record.result >= 1);
+}
+function ranOn(job, model) {
+  return job.provider === model.provider && job.protocol === model.protocol && job.modelId === model.modelId;
+}
+function recentRatings(jobs, model, limit) {
+  return jobs.filter(({ job }) => ranOn(job, model)).flatMap(({ job, ratings }) => ratings.map((rating) => ({ rating, job }))).sort((a, b) => Date.parse(b.rating.ratedAt) - Date.parse(a.rating.ratedAt)).slice(0, limit);
+}
+function recentPicks(jobs, model, limit) {
+  const byId = new Map(jobs.map(({ job }) => [job.id, job]));
+  const entries = jobs.flatMap(({ job, pick }) => {
+    if (pick === undefined || !ranOn(job, model))
+      return [];
+    const picked = byId.get(pick.jobId);
+    return [{ pick, job, ...picked === undefined ? {} : { picked } }];
+  }).sort((a, b) => Date.parse(b.pick.pickedAt) - Date.parse(a.pick.pickedAt));
+  const comparisons = new Set;
+  return entries.filter(({ pick }) => {
+    if (comparisons.size === limit && !comparisons.has(pick.comparison))
+      return false;
+    comparisons.add(pick.comparison);
+    return true;
+  });
+}
+function optionsRating({ job, ratings }) {
+  return ratings.findLast((rating) => rating.result === undefined || rating.result === 1 && job.files.length === 1);
+}
+function optionsRecord(jobs, model) {
+  const state = new Map;
+  const ratedBad = new Map;
+  const ordered = [...jobs].sort((a, b) => Date.parse(a.job.createdAt) - Date.parse(b.job.createdAt));
+  for (const ratedJob of ordered) {
+    const { job } = ratedJob;
     if (job.outcome !== "completed")
       continue;
-    if (job.provider !== model.provider || job.protocol !== model.protocol || job.modelId !== model.modelId)
+    const rating = optionsRating(ratedJob);
+    if (!ranOn(job, model))
       continue;
-    Object.assign(options, job.parameters?.providerOptions);
+    for (const [key, value] of Object.entries(job.parameters?.providerOptions ?? {})) {
+      const asJson = JSON.stringify(value);
+      const badValues = ratedBad.get(key) ?? new Map;
+      ratedBad.set(key, badValues);
+      if (rating?.verdict === "bad")
+        badValues.set(asJson, { value, cause: "rating", reason: rating.reason, jobId: job.id });
+      if (rating?.verdict === "good")
+        badValues.delete(asJson);
+      const verdict = badValues.get(asJson);
+      if (verdict !== undefined)
+        state.set(key, { value, suspect: verdict });
+      else if (job.mismatch !== undefined && rating?.verdict !== "good") {
+        state.set(key, { value, suspect: { value, cause: "mismatch", reason: job.mismatch, jobId: job.id } });
+      } else
+        state.set(key, { value });
+    }
   }
-  return options;
+  const record = { knownGood: {}, suspect: {} };
+  for (const [key, { value, suspect }] of state) {
+    if (suspect === undefined)
+      record.knownGood[key] = value;
+    else
+      record.suspect[key] = suspect;
+  }
+  return record;
 }
 
 // src/jobs.ts
@@ -21929,18 +22076,261 @@ async function readReferences(paths, cwd) {
   }));
 }
 
-// src/protocols/protocol.ts
-var aspectRatios = ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"];
-function formatSize(size) {
-  return `${size.width}x${size.height}`;
+// src/media.ts
+function fileTypeOf(bytes) {
+  const image = imageTypeOf(bytes);
+  if (image !== undefined)
+    return image;
+  if (ascii(bytes, 4, 8) === "ftyp") {
+    const brand = ascii(bytes, 8, 12);
+    if (brand === "avif" || brand === "avis")
+      return { extension: "avif", mimeType: "image/avif" };
+    if (["heic", "heix", "heim", "heis", "mif1", "msf1"].includes(brand))
+      return { extension: "heic", mimeType: "image/heic" };
+    return brand.startsWith("qt") ? { extension: "mov", mimeType: "video/quicktime" } : { extension: "mp4", mimeType: "video/mp4" };
+  }
+  if (bytes[0] === 26 && bytes[1] === 69 && bytes[2] === 223 && bytes[3] === 163)
+    return { extension: "webm", mimeType: "video/webm" };
+  return;
+}
+function mediaFactsOf(bytes) {
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    switch (fileTypeOf(bytes)?.extension) {
+      case "png":
+        return { width: view.getUint32(16), height: view.getUint32(20) };
+      case "gif":
+        return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+      case "jpg":
+        return jpegSize(bytes, view);
+      case "webp":
+        return webpSize(bytes, view);
+      case "mp4":
+      case "mov":
+        return mp4Facts(bytes, view);
+      default:
+        return;
+    }
+  } catch {
+    return;
+  }
+}
+function ascii(bytes, start, end) {
+  return String.fromCharCode(...bytes.subarray(start, end));
+}
+function jpegSize(bytes, view) {
+  let offset = 2;
+  let turned = false;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 255)
+      return;
+    const marker = bytes[offset + 1];
+    if (marker === 225 && ascii(bytes, offset + 4, offset + 10) === "Exif\x00\x00")
+      turned = exifTurnsQuarter(view, offset + 10);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      const width = view.getUint16(offset + 7);
+      const height = view.getUint16(offset + 5);
+      return turned ? { width: height, height: width } : { width, height };
+    }
+    offset += 2 + view.getUint16(offset + 2);
+  }
+  return;
+}
+function exifTurnsQuarter(view, tiff) {
+  try {
+    const little = view.getUint16(tiff) === 18761;
+    const ifd = tiff + view.getUint32(tiff + 4, little);
+    const entries = view.getUint16(ifd, little);
+    for (let index = 0;index < entries; index++) {
+      const entry = ifd + 2 + index * 12;
+      if (view.getUint16(entry, little) !== 274)
+        continue;
+      const orientation = view.getUint16(entry + 8, little);
+      return orientation >= 5 && orientation <= 8;
+    }
+  } catch {}
+  return false;
+}
+function webpSize(bytes, view) {
+  const chunk = ascii(bytes, 12, 16);
+  if (chunk === "VP8X") {
+    const read24 = (at) => bytes[at] | bytes[at + 1] << 8 | bytes[at + 2] << 16;
+    return { width: read24(24) + 1, height: read24(27) + 1 };
+  }
+  if (chunk === "VP8 ")
+    return { width: view.getUint16(26, true) & 16383, height: view.getUint16(28, true) & 16383 };
+  if (chunk === "VP8L") {
+    const bits = view.getUint32(21, true);
+    return { width: (bits & 16383) + 1, height: (bits >> 14 & 16383) + 1 };
+  }
+  return;
+}
+function mp4Facts(bytes, view) {
+  let seconds;
+  let size;
+  const walk = (start, end) => {
+    let offset = start;
+    while (offset + 8 <= end) {
+      let length = view.getUint32(offset);
+      const type = ascii(bytes, offset + 4, offset + 8);
+      let header = 8;
+      if (length === 1) {
+        length = Number(view.getBigUint64(offset + 8));
+        header = 16;
+      } else if (length === 0) {
+        length = end - offset;
+      }
+      if (length < header)
+        return;
+      const body = offset + header;
+      if (type === "moov" || type === "trak")
+        walk(body, Math.min(offset + length, end));
+      if (type === "mvhd") {
+        const version = bytes[body];
+        const timescale = view.getUint32(body + (version === 1 ? 20 : 12));
+        const duration = version === 1 ? Number(view.getBigUint64(body + 24)) : view.getUint32(body + 16);
+        if (timescale > 0 && duration > 0)
+          seconds = duration / timescale;
+      }
+      if (type === "tkhd" && size === undefined) {
+        const at = body + (bytes[body] === 1 ? 88 : 76);
+        const width = view.getUint32(at) / 65536;
+        const height = view.getUint32(at + 4) / 65536;
+        if (width >= 1 && height >= 1)
+          size = { width: Math.round(width), height: Math.round(height) };
+      }
+      offset += length;
+    }
+  };
+  walk(0, bytes.length);
+  if (size === undefined)
+    return;
+  return { ...size, ...seconds === undefined ? {} : { seconds: Math.round(seconds * 100) / 100 } };
 }
 
-class ProviderError extends Error {
-  kind;
-  constructor(kind, message) {
-    super(message);
-    this.kind = kind;
+// src/protocols/capabilities.ts
+function describeCapabilities(capabilities) {
+  const ratios = capabilities.sizes.map((size) => `${size.aspectRatio} (${formatSize(size)})`).join(", ");
+  const references = capabilities.maxReferences === 0 ? "no reference images" : `up to ${capabilities.maxReferences} reference image${capabilities.maxReferences === 1 ? "" : "s"}`;
+  return `aspect ratios ${ratios}; up to ${capabilities.maxImages} image${capabilities.maxImages === 1 ? "" : "s"} per Job; ${references}.`;
+}
+function closestSize(sizes, wanted) {
+  const exact = sizes.find((size) => size.aspectRatio === wanted);
+  if (exact !== undefined)
+    return { size: exact, adjusted: false };
+  return { size: sizeClosestTo(sizes, ratioOf(wanted)), adjusted: true };
+}
+function sizeClosestTo(sizes, ratio) {
+  const target = Math.log(ratio);
+  const distance = (size) => Math.abs(Math.log(size.width / size.height) - target);
+  const [first, ...rest] = sizes;
+  if (first === undefined)
+    throw new Error("A Protocol adapter declared no supported sizes.");
+  return rest.reduce((best, size) => distance(size) < distance(best) ? size : best, first);
+}
+function ratioOf(aspectRatio) {
+  const [width, height] = aspectRatio.split(":").map(Number);
+  return width / height;
+}
+async function normaliseImageRequest(parameters, model, adapter, described, cwd) {
+  const { capabilities } = described;
+  const unsupported = (problem) => new ConfigError(`${problem} Model "${model.alias}" supports: ${describeCapabilities(capabilities)} Choose another Model or change the request.`);
+  if (parameters.n > capabilities.maxImages) {
+    throw unsupported(`Model "${model.alias}" cannot generate ${parameters.n} images in one Job.`);
+  }
+  if (parameters.references.length > 0 && capabilities.maxReferences === 0) {
+    throw unsupported(`Model "${model.alias}" cannot take reference images.`);
+  }
+  if (parameters.references.length > capabilities.maxReferences) {
+    throw unsupported(`Model "${model.alias}" cannot take ${parameters.references.length} reference images.`);
   }
+  const reserved = Object.keys(parameters.providerOptions).filter((key) => adapter.reservedOptions.includes(key));
+  if (reserved.length > 0) {
+    throw new ConfigError(`provider_options may not set ${reserved.map((key) => `\`${key}\``).join(", ")}: litevision sets ${reserved.length === 1 ? "it" : "them"} from the \`generate_image\` parameters. Use those instead.`);
+  }
+  const { size, adjusted } = closestSize(capabilities.sizes, parameters.aspectRatio);
+  const references = await readReferences(parameters.references, cwd);
+  return {
+    request: {
+      prompt: parameters.prompt,
+      n: parameters.n,
+      size,
+      references,
+      providerOptions: parameters.providerOptions,
+      model: { capabilities, ...described.parameterSchema === undefined ? {} : { parameterSchema: described.parameterSchema } }
+    },
+    requestedAspectRatio: parameters.aspectRatio,
+    aspectRatioAdjusted: adjusted
+  };
+}
+function describeVideoCapabilities(capabilities) {
+  const tiers = capabilities.resolutions.map((tier) => {
+    const ratios = tier.sizes.map((size) => `${size.aspectRatio} (${formatSize(size)})`).join(", ");
+    return tier.name === undefined ? `aspect ratios ${ratios}` : `${tier.name}: ${ratios}`;
+  }).join("; ");
+  const { durations } = capabilities;
+  const lengths = isRun(durations) && durations.length > 2 ? `${durations[0]}–${durations.at(-1)} s` : `${durations.join(", ")} s`;
+  const frames = [capabilities.firstFrame && "a first frame", capabilities.lastFrame && "a last frame"].filter(Boolean).join(" and ");
+  const references = capabilities.maxReferences === 0 ? "no reference images" : `up to ${capabilities.maxReferences} reference image${capabilities.maxReferences === 1 ? "" : "s"}`;
+  const named = capabilities.resolutions.some((tier) => tier.name !== undefined);
+  return `${named ? "resolutions " : ""}${tiers}; ${lengths} (default ${capabilities.defaultDuration} s); ${frames || "no first or last frame"}; ${references}.`;
+}
+function isRun(values) {
+  return values.every((value, index) => index === 0 || value === values[index - 1] + 1);
+}
+async function normaliseVideoRequest(parameters, model, adapter, capabilities, cwd) {
+  const unsupported = (problem) => new ConfigError(`${problem} Model "${model.alias}" supports: ${describeVideoCapabilities(capabilities)} Choose another Model or change the request.`);
+  const [defaultTier] = capabilities.resolutions;
+  if (defaultTier === undefined)
+    throw new Error("A Protocol adapter declared no video resolutions.");
+  let tier = defaultTier;
+  if (parameters.resolution !== undefined) {
+    const wanted = parameters.resolution.toLowerCase();
+    const named = capabilities.resolutions.find((candidate) => candidate.name?.toLowerCase() === wanted);
+    if (named === undefined)
+      throw unsupported(`Model "${model.alias}" has no resolution "${parameters.resolution}".`);
+    tier = named;
+  }
+  if (parameters.firstFrame !== undefined && !capabilities.firstFrame)
+    throw unsupported(`Model "${model.alias}" cannot start from a given first frame.`);
+  if (parameters.lastFrame !== undefined && !capabilities.lastFrame)
+    throw unsupported(`Model "${model.alias}" cannot end on a given last frame.`);
+  if (parameters.references.length > 0 && capabilities.maxReferences === 0)
+    throw unsupported(`Model "${model.alias}" cannot take reference images.`);
+  if (parameters.references.length > capabilities.maxReferences) {
+    throw unsupported(`Model "${model.alias}" cannot take ${parameters.references.length} reference images.`);
+  }
+  const reservedOptions = adapter.reservedVideoOptions ?? [];
+  const reserved = Object.keys(parameters.providerOptions).filter((key) => reservedOptions.includes(key));
+  if (reserved.length > 0) {
+    throw new ConfigError(`provider_options may not set ${reserved.map((key) => `\`${key}\``).join(", ")}: litevision sets ${reserved.length === 1 ? "it" : "them"} from the \`generate_video\` parameters. Use those instead.`);
+  }
+  const frame = async (path) => path === undefined ? undefined : (await readReferences([path], cwd))[0];
+  const [firstFrame, lastFrame, references] = await Promise.all([
+    frame(parameters.firstFrame),
+    frame(parameters.lastFrame),
+    readReferences(parameters.references, cwd)
+  ]);
+  const frameFacts = parameters.aspectRatio === undefined && firstFrame !== undefined ? mediaFactsOf(firstFrame.bytes) : undefined;
+  const { size, adjusted } = frameFacts === undefined ? closestSize(tier.sizes, parameters.aspectRatio ?? "16:9") : { size: sizeClosestTo(tier.sizes, frameFacts.width / frameFacts.height), adjusted: false };
+  const seconds = parameters.duration === undefined ? capabilities.defaultDuration : capabilities.durations.reduce((best, candidate) => Math.abs(candidate - parameters.duration) < Math.abs(best - parameters.duration) ? candidate : best);
+  return {
+    request: {
+      prompt: parameters.prompt,
+      size,
+      ...tier.name === undefined ? {} : { resolution: tier.name },
+      seconds,
+      ...firstFrame === undefined ? {} : { firstFrame },
+      ...lastFrame === undefined ? {} : { lastFrame },
+      references,
+      providerOptions: parameters.providerOptions
+    },
+    requestedAspectRatio: frameFacts === undefined ? parameters.aspectRatio ?? "16:9" : size.aspectRatio,
+    aspectRatioAdjusted: adjusted,
+    followsFirstFrame: frameFacts !== undefined || firstFrame !== undefined && adjusted,
+    ...parameters.duration === undefined ? {} : { requestedDuration: parameters.duration },
+    durationAdjusted: parameters.duration !== undefined && seconds !== parameters.duration
+  };
 }
 
 // src/protocols/errors.ts
@@ -21953,6 +22343,7 @@ var explanations = {
   refusal: "refused the request on content grounds. Rephrase the prompt, change the reference images, or choose another Model.",
   rate_limit: "is rate limiting requests. Wait a little and try again, or choose another Model.",
   unsupported: "does not support this request. Choose another Model or change the request.",
+  rejected_option: "rejected an option in the request. Fix it using what the Provider said and the Model's docs, and try again; if it names the prompt or the number of images, change that instead.",
   other: "failed to complete the Job."
 };
 function providerError(kind, providerId, detail) {
@@ -21977,20 +22368,87 @@ function kindOfStatus(status) {
     return "rate_limit";
   return;
 }
+function namedParameters(response) {
+  if (response.status !== 400 && response.status !== 422)
+    return [];
+  const message = response.message ?? "";
+  const mentioned = (response.options ?? []).filter((name) => new RegExp(`(^|[^\\w])${escapeRegExp(name)}($|[^\\w])`).test(message));
+  return [...response.param ? [response.param] : [], ...mentioned];
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function classifyProviderError(response) {
   const codes = (response.codes ?? []).filter((code) => typeof code === "string");
-  return matchKind(codes) ?? kindOfStatus(response.status) ?? matchKind([response.message ?? ""]) ?? "other";
+  const named = namedParameters(response);
+  const wording = named.reduce((text, name) => text.split(name).join(""), response.message ?? "");
+  return matchKind(codes) ?? kindOfStatus(response.status) ?? matchKind([wording]) ?? (named.length > 0 ? "rejected_option" : "other");
 }
 function httpProviderError(providerId, response) {
   const detail = response.message === undefined ? `HTTP ${response.status}` : `HTTP ${response.status}: ${response.message}`;
   return providerError(classifyProviderError(response), providerId, detail);
 }
-async function sendToProvider(http, providerId, url, init) {
-  try {
-    return await http(url, init);
-  } catch (error) {
-    throw new ProviderError("other", `Could not reach ${providerLabel(providerId)}: ${error.message}`);
-  }
+
+// src/protocols/send.ts
+var maxRetries = 2;
+async function sendToProvider(http, providerId, url, init, { context, poll = false }) {
+  for (let attempt = 1;; attempt++) {
+    const last = attempt > maxRetries;
+    try {
+      const response = await http(url, init);
+      if (last || !retryableStatus(response.status, poll))
+        return response;
+      await response.body?.cancel().catch(() => {
+        return;
+      });
+    } catch (error) {
+      const stage = stageOf(error);
+      if (last || !poll && stage !== "before-send")
+        throw networkError(providerId, error, stage, poll, attempt);
+    }
+    await context.backoff(attempt);
+  }
+}
+function retryableStatus(status, poll) {
+  if (poll)
+    return status >= 500 || status === 429;
+  return status === 502 || status === 503 || status === 504;
+}
+var beforeSendCodes = new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  "ENETDOWN",
+  "EHOSTUNREACH",
+  "EHOSTDOWN",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+var timeoutCodes = new Set(["UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT", "ETIMEDOUT", "TimeoutError", "Timeout"]);
+function stageOf(error) {
+  const layers = [error, error?.cause].filter((layer) => typeof layer === "object" && layer !== null);
+  const names = layers.flatMap((layer) => [layer.code, layer.name]).filter((name) => typeof name === "string");
+  if (layers.some((layer) => layer.syscall === "connect" || layer.syscall === "getaddrinfo"))
+    return "before-send";
+  if (names.some((name) => beforeSendCodes.has(name)))
+    return "before-send";
+  if (names.some((name) => timeoutCodes.has(name)))
+    return "timeout";
+  return "unknown";
+}
+function describe2(error) {
+  const message = error?.message ?? String(error);
+  const cause = error?.cause;
+  const reason = cause instanceof Error ? cause.message : undefined;
+  return reason === undefined || reason === message ? message : `${message}: ${reason}`;
+}
+function networkError(providerId, error, stage, poll, attempts) {
+  const label = providerLabel(providerId);
+  const tries = attempts > 1 ? ` (tried ${attempts} times)` : "";
+  if (poll || stage === "before-send")
+    return new ProviderError("other", `Could not reach ${label}${tries}: ${describe2(error)}`);
+  const what = stage === "timeout" ? `${label} did not answer in time` : `The connection to ${label} failed`;
+  return new ProviderError("other", `${what} after the request was sent: ${describe2(error)}. The Provider may have processed the request and charged for it, so litevision did not send it again. Tell the User before trying again.`);
 }
 
 // src/protocols/apimart.ts
@@ -22096,7 +22554,7 @@ var unknownModel = {
 var known = (modelId) => knownModels.find((model) => model.matches.test(modelId));
 var headers = (credential) => ({ authorization: `Bearer ${credential}` });
 var baseUrlOf = (target) => target.baseUrl.replace(/\/+$/, "");
-async function errorOf(response, providerId) {
+async function errorOf(response, providerId, options = []) {
   const parsed = errorSchema.safeParse(await response.json().catch(() => {
     return;
   }));
@@ -22104,17 +22562,19 @@ async function errorOf(response, providerId) {
   return httpProviderError(providerId, {
     status: response.status,
     codes: [error?.type],
-    message: error?.message ?? (response.statusText || undefined)
+    message: error?.message ?? (response.statusText || undefined),
+    options
   });
 }
-async function submitTask(body, target, http) {
-  const response = await sendToProvider(http, target.providerId, `${baseUrlOf(target)}/images/generations`, {
+async function submitTask(body, options, target, http, context) {
+  const init = {
     method: "POST",
     headers: { ...headers(target.credential), "content-type": "application/json" },
     body: JSON.stringify(body)
-  });
+  };
+  const response = await sendToProvider(http, target.providerId, `${baseUrlOf(target)}/images/generations`, init, { context });
   if (!response.ok)
-    throw await errorOf(response, target.providerId);
+    throw await errorOf(response, target.providerId, options);
   const parsed = submittedSchema.safeParse(await response.json().catch(() => {
     return;
   }));
@@ -22122,50 +22582,35 @@ async function submitTask(body, target, http) {
     throw providerError("other", target.providerId, "its answer to the submission had no task id.");
   return parsed.data.data[0].task_id;
 }
-var toleratedPollFailures = 5;
 async function pollTask(taskId, target, http, context) {
   const url = `${baseUrlOf(target)}/tasks/${encodeURIComponent(taskId)}?language=en`;
-  let failures = 0;
   for (;; ) {
-    let response;
-    try {
-      response = await sendToProvider(http, target.providerId, url, { headers: headers(target.credential) });
-    } catch (error) {
-      if (++failures > toleratedPollFailures)
-        throw error;
-    }
-    if (response !== undefined && !response.ok) {
-      const transient = response.status >= 500 || response.status === 429;
-      if (!transient || ++failures > toleratedPollFailures)
-        throw await errorOf(response, target.providerId);
-      response = undefined;
-    }
-    if (response !== undefined) {
-      failures = 0;
-      const parsed = taskSchema.safeParse(await response.json().catch(() => {
-        return;
-      }));
-      if (!parsed.success)
-        throw providerError("other", target.providerId, `its status for task ${taskId} could not be read.`);
-      const task = parsed.data.data;
-      if (task.status === "completed") {
-        const images = (task.result?.images ?? []).flatMap((image) => Array.isArray(image.url) ? image.url : [image.url]).map((url) => ({ url }));
-        if (images.length === 0)
-          throw providerError("other", target.providerId, `task ${taskId} completed without images.`);
-        return { images, ...task.cost === undefined ? {} : { cost: task.cost } };
-      }
-      if (task.status === "failed") {
-        const error = task.error ?? undefined;
-        const kind = classifyProviderError({
-          status: typeof error?.code === "number" ? error.code : 0,
-          codes: [error?.type],
-          message: error?.message
-        });
-        throw providerError(kind, target.providerId, error?.message ?? `task ${taskId} failed.`);
-      }
-      if (task.status === "cancelled")
-        throw providerError("other", target.providerId, `task ${taskId} was cancelled.`);
+    const response = await sendToProvider(http, target.providerId, url, { headers: headers(target.credential) }, { context, poll: true });
+    if (!response.ok)
+      throw await errorOf(response, target.providerId);
+    const parsed = taskSchema.safeParse(await response.json().catch(() => {
+      return;
+    }));
+    if (!parsed.success)
+      throw providerError("other", target.providerId, `its status for task ${taskId} could not be read.`);
+    const task = parsed.data.data;
+    if (task.status === "completed") {
+      const images = (task.result?.images ?? []).flatMap((image) => Array.isArray(image.url) ? image.url : [image.url]).map((url) => ({ url }));
+      if (images.length === 0)
+        throw providerError("other", target.providerId, `task ${taskId} completed without images.`);
+      return { images, ...task.cost === undefined ? {} : { cost: task.cost } };
+    }
+    if (task.status === "failed") {
+      const error = task.error ?? undefined;
+      const kind = classifyProviderError({
+        status: typeof error?.code === "number" ? error.code : 0,
+        codes: [error?.type],
+        message: error?.message
+      });
+      throw providerError(kind, target.providerId, error?.message ?? `task ${taskId} failed.`);
     }
+    if (task.status === "cancelled")
+      throw providerError("other", target.providerId, `task ${taskId} was cancelled.`);
     await context.pause();
   }
 }
@@ -22278,7 +22723,7 @@ var apimart = {
       ...request.references.length === 0 ? {} : { image_urls: request.references.map((reference) => `data:${reference.mimeType};base64,${Buffer.from(reference.bytes).toString("base64")}`) },
       ...request.providerOptions
     };
-    const settled = await Promise.allSettled(Array.from({ length: batches ? 1 : request.n }, () => submitTask(body, target, http)));
+    const settled = await Promise.allSettled(Array.from({ length: batches ? 1 : request.n }, () => submitTask(body, Object.keys(request.providerOptions), target, http, context)));
     const taskIds = settled.flatMap((outcome) => outcome.status === "fulfilled" ? [outcome.value] : []);
     const failures = settled.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
     if (taskIds.length === 0)
@@ -22414,18 +22859,19 @@ function interactionBody(request, target) {
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function kindOf(status, codes, message) {
+function kindOf(status, codes, message, options = []) {
   const bare = codes.filter((code) => code !== undefined).map((code) => code.split(/[/#]/).pop().toLowerCase());
   if (bare.some((code) => blockedCodes.has(code)))
     return "refusal";
-  return classifyProviderError({ status, codes, message });
+  return classifyProviderError({ status, codes, message, options });
 }
-async function sendInteraction(request, target, http) {
-  const response = await sendToProvider(http, target.providerId, `${trimmed(target.baseUrl)}/interactions`, {
+async function sendInteraction(request, target, http, context) {
+  const init = {
     method: "POST",
     headers: { "x-goog-api-key": target.credential, "content-type": "application/json" },
     body: JSON.stringify(interactionBody(request, target))
-  });
+  };
+  const response = await sendToProvider(http, target.providerId, `${trimmed(target.baseUrl)}/interactions`, init, { context });
   const body = await response.json().catch(() => {
     return;
   });
@@ -22435,7 +22881,7 @@ async function sendInteraction(request, target, http) {
     const message = error?.message ?? (response.statusText || undefined);
     const codes = [typeof error?.code === "string" ? error.code : undefined, error?.status, ...(error?.details ?? []).map((detail) => detail.reason)];
     const detail = message === undefined ? `HTTP ${response.status}` : `HTTP ${response.status}: ${message}`;
-    throw providerError(kindOf(response.status, codes, message), target.providerId, detail);
+    throw providerError(kindOf(response.status, codes, message, Object.keys(request.providerOptions)), target.providerId, detail);
   }
   const parsed = interactionSchema.safeParse(body);
   if (!parsed.success) {
@@ -22457,10 +22903,10 @@ async function sendInteraction(request, target, http) {
 }
 var gemini = {
   builtInCapabilities: (modelId) => geminiModel(modelId).capabilities,
-  docsUrl: () => "https://ai.google.dev/api/interactions-api",
+  docsUrl: () => "https://ai.google.dev/gemini-api/docs/image-generation",
   reservedOptions: ["model", "input"],
-  async submit(request, target, http) {
-    return { wait: () => inParallel(request.n, target.providerId, () => sendInteraction(request, target, http)) };
+  async submit(request, target, http, context) {
+    return { wait: () => inParallel(request.n, target.providerId, () => sendInteraction(request, target, http, context)) };
   },
   async testConnection(target, http) {
     const list = await fetchModelIds2(target, http);
@@ -22546,7 +22992,8 @@ var errorSchema3 = object({
   error: object({
     message: string2().optional(),
     code: string2().nullish(),
-    type: string2().nullish()
+    type: string2().nullish(),
+    param: string2().nullish()
   })
 });
 var gptImage = {
@@ -22602,9 +23049,9 @@ var openaiImages = {
   },
   docsUrl: () => "https://platform.openai.com/docs/api-reference/images/create",
   reservedOptions: ["model", "prompt", "n", "size", "image", "image[]"],
-  async submit(request, target, http) {
+  async submit(request, target, http, context) {
     const { url, init } = buildRequest(request, target);
-    const response = await sendToProvider(http, target.providerId, url, init);
+    const response = await sendToProvider(http, target.providerId, url, init, { context });
     const body = await response.json().catch(() => {
       return;
     });
@@ -22614,7 +23061,9 @@ var openaiImages = {
       throw httpProviderError(target.providerId, {
         status: response.status,
         codes: [error?.code, error?.type],
-        message: error?.message ?? (response.statusText || undefined)
+        message: error?.message ?? (response.statusText || undefined),
+        param: error?.param,
+        options: Object.keys(request.providerOptions)
       });
     }
     const parsed = successSchema.safeParse(body);
@@ -22664,6 +23113,393 @@ async function fetchModelIds3(target, http) {
   return { ok: true, modelIds: parsed.data.data.map((model) => model.id).sort() };
 }
 
+// src/protocols/together.ts
+var docs = {
+  flux: "https://docs.together.ai/docs/quickstart-flux",
+  imageParameters: "https://docs.together.ai/docs/inference/images/parameters",
+  referenceImages: "https://docs.together.ai/docs/inference/images/reference-images",
+  wan: "https://docs.together.ai/docs/wan2.7-quickstart",
+  seedance: "https://docs.together.ai/docs/seedance2.5-quickstart",
+  videoParameters: "https://docs.together.ai/docs/inference/videos/parameters"
+};
+var sizes3 = (entries) => entries.map(([aspectRatio, width, height]) => ({ aspectRatio, width, height }));
+var megapixelSizes = sizes3([
+  ["1:1", 1024, 1024],
+  ["16:9", 1344, 768],
+  ["9:16", 768, 1344],
+  ["4:3", 1152, 896],
+  ["3:4", 896, 1152],
+  ["3:2", 1216, 832],
+  ["2:3", 832, 1216]
+]);
+var cappedSizes = sizes3([
+  ["1:1", 1024, 1024],
+  ["16:9", 1024, 576],
+  ["9:16", 576, 1024],
+  ["4:3", 1024, 768],
+  ["3:4", 768, 1024],
+  ["3:2", 1024, 680],
+  ["2:3", 680, 1024]
+]);
+var maxImagesPerJob2 = 4;
+var imageFamilies = [
+  {
+    matches: /^black-forest-labs\/FLUX\.1-kontext-/i,
+    capabilities: { sizes: megapixelSizes, maxReferences: 1, maxImages: maxImagesPerJob2 },
+    sizing: "ratio",
+    references: "image_url",
+    docsUrl: docs.flux
+  },
+  {
+    matches: /^black-forest-labs\/FLUX\.2-(pro|flex|dev)$/i,
+    capabilities: { sizes: megapixelSizes, maxReferences: 4, maxImages: maxImagesPerJob2 },
+    sizing: "pixels",
+    references: "reference_images",
+    docsUrl: docs.flux
+  },
+  {
+    matches: /^black-forest-labs\//i,
+    capabilities: { sizes: megapixelSizes, maxReferences: 0, maxImages: maxImagesPerJob2 },
+    sizing: "pixels",
+    references: "reference_images",
+    docsUrl: docs.flux
+  },
+  {
+    matches: /^google\/gemini-3-pro-image$/i,
+    capabilities: {
+      sizes: sizes3([
+        ["1:1", 1024, 1024],
+        ["16:9", 1376, 768],
+        ["9:16", 768, 1376],
+        ["4:3", 1200, 896],
+        ["3:4", 896, 1200],
+        ["3:2", 1264, 848],
+        ["2:3", 848, 1264]
+      ]),
+      maxReferences: 14,
+      maxImages: maxImagesPerJob2
+    },
+    sizing: "pixels",
+    references: "reference_images",
+    docsUrl: docs.referenceImages
+  },
+  {
+    matches: /^google\/flash-image-2\.5$/i,
+    capabilities: {
+      sizes: sizes3([
+        ["1:1", 1024, 1024],
+        ["16:9", 1344, 768],
+        ["9:16", 768, 1344],
+        ["4:3", 1184, 864],
+        ["3:4", 864, 1184],
+        ["3:2", 1248, 832],
+        ["2:3", 832, 1248]
+      ]),
+      maxReferences: 3,
+      maxImages: maxImagesPerJob2
+    },
+    sizing: "pixels",
+    references: "reference_images",
+    docsUrl: docs.referenceImages
+  }
+];
+var otherImages = {
+  matches: /.*/,
+  capabilities: { sizes: cappedSizes, maxReferences: 0, maxImages: maxImagesPerJob2 },
+  sizing: "pixels",
+  references: "reference_images",
+  docsUrl: docs.imageParameters
+};
+var imageFamily = (modelId) => imageFamilies.find((family) => family.matches.test(modelId)) ?? otherImages;
+var range = (from, to) => Array.from({ length: to - from + 1 }, (_, index) => from + index);
+var wanResolutions = [
+  {
+    name: "1080P",
+    sizes: sizes3([
+      ["16:9", 1920, 1080],
+      ["9:16", 1080, 1920],
+      ["1:1", 1440, 1440],
+      ["4:3", 1632, 1248],
+      ["3:4", 1248, 1632]
+    ])
+  },
+  {
+    name: "720P",
+    sizes: sizes3([
+      ["16:9", 1280, 720],
+      ["9:16", 720, 1280],
+      ["1:1", 960, 960],
+      ["4:3", 1088, 832],
+      ["3:4", 832, 1088]
+    ])
+  }
+];
+var wan = (capabilities) => ({
+  resolutions: wanResolutions,
+  defaultDuration: 5,
+  ...capabilities
+});
+var videoFamilies = [
+  {
+    matches: /^Wan-AI\/wan2\.7-t2v$/i,
+    capabilities: wan({ durations: range(2, 15), firstFrame: false, lastFrame: false, maxReferences: 0 }),
+    sizing: "tier+ratio",
+    docsUrl: docs.wan
+  },
+  {
+    matches: /^Wan-AI\/wan2\.7-i2v$/i,
+    capabilities: wan({ durations: range(2, 15), firstFrame: true, lastFrame: true, maxReferences: 0 }),
+    sizing: "tier+ratio",
+    docsUrl: docs.wan
+  },
+  {
+    matches: /^Wan-AI\/wan2\.7-r2v$/i,
+    capabilities: wan({ durations: range(2, 10), firstFrame: false, lastFrame: false, maxReferences: 5 }),
+    sizing: "tier+ratio",
+    docsUrl: docs.wan
+  },
+  {
+    matches: /^ByteDance\/Seedance-2\.5$/i,
+    capabilities: {
+      resolutions: [
+        { name: "720p", sizes: sizes3([["16:9", 1280, 720]]) },
+        { name: "480p", sizes: sizes3([["16:9", 854, 480]]) }
+      ],
+      durations: range(4, 30),
+      defaultDuration: 5,
+      firstFrame: true,
+      lastFrame: true,
+      maxReferences: 30
+    },
+    sizing: "tier",
+    docsUrl: docs.seedance
+  }
+];
+var otherVideos = {
+  matches: /.*/,
+  capabilities: {
+    resolutions: [
+      {
+        sizes: sizes3([
+          ["16:9", 1280, 720],
+          ["9:16", 720, 1280],
+          ["1:1", 960, 960],
+          ["4:3", 1088, 816],
+          ["3:4", 816, 1088],
+          ["3:2", 1152, 768],
+          ["2:3", 768, 1152]
+        ])
+      }
+    ],
+    durations: range(1, 10),
+    defaultDuration: 5,
+    firstFrame: true,
+    lastFrame: true,
+    maxReferences: 4
+  },
+  sizing: "pixels",
+  docsUrl: docs.videoParameters
+};
+var videoFamily = (modelId) => videoFamilies.find((family) => family.matches.test(modelId)) ?? otherVideos;
+var errorSchema4 = object({
+  error: object({
+    message: string2().optional(),
+    code: string2().nullish(),
+    type: string2().nullish(),
+    param: string2().nullish()
+  })
+});
+var imagesSchema = object({
+  data: array(object({ b64_json: string2().nullish(), url: string2().nullish() }))
+});
+var videoSchema = object({
+  id: string2(),
+  status: string2(),
+  outputs: object({ video_url: string2().optional(), cost: number2().optional() }).nullish(),
+  error: object({ message: string2().optional(), code: string2().nullish() }).nullish()
+});
+var resumeSchema2 = object({ videoId: string2().min(1) });
+var modelListSchema4 = array(object({ id: string2(), type: string2().optional() }));
+var rootOf = (target) => target.baseUrl.replace(/\/+$/, "").replace(/\/v[12]$/, "");
+var authorization = (credential) => ({ authorization: `Bearer ${credential}` });
+var dataUrl = (image) => `data:${image.mimeType};base64,${Buffer.from(image.bytes).toString("base64")}`;
+var passthroughBlocked = "third_party_data_sharing_blocked";
+function passthroughError(providerId) {
+  return new ProviderError("unsupported", `${providerLabel(providerId)} runs this model through its maker, which the User's Together organization does not allow yet. ` + `Only the User can change that: in Together's dashboard (https://api.together.ai/settings), Organization → General → Privacy → "Passthrough models", which sends prompts for such models to their makers. ` + "Tell the User, or choose a model Together serves itself.");
+}
+async function errorOf2(response, providerId, options = []) {
+  const text = await response.text().catch(() => "");
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = undefined;
+  }
+  const parsed = errorSchema4.safeParse(body);
+  const error = parsed.success ? parsed.data.error : undefined;
+  if (error?.code === passthroughBlocked)
+    return passthroughError(providerId);
+  const plain = body === undefined ? text.trim().slice(0, 300) : "";
+  return httpProviderError(providerId, {
+    status: response.status,
+    codes: [error?.code, error?.type],
+    message: error?.message ?? (plain || response.statusText || undefined),
+    param: error?.param,
+    options
+  });
+}
+async function postJson(url, body, providerOptions, target, http, context) {
+  const init = {
+    method: "POST",
+    headers: { ...authorization(target.credential), "content-type": "application/json" },
+    body: JSON.stringify(body)
+  };
+  const response = await sendToProvider(http, target.providerId, url, init, { context });
+  if (!response.ok)
+    throw await errorOf2(response, target.providerId, Object.keys(providerOptions));
+  return response.json().catch(() => {
+    return;
+  });
+}
+function waitForVideo(videoId, target, http, context) {
+  const url = `${rootOf(target)}/v2/videos/${encodeURIComponent(videoId)}`;
+  return {
+    resumeHandle: { videoId },
+    async wait() {
+      for (;; ) {
+        const response = await sendToProvider(http, target.providerId, url, { headers: authorization(target.credential) }, { context, poll: true });
+        if (!response.ok)
+          throw await errorOf2(response, target.providerId);
+        const parsed = videoSchema.safeParse(await response.json().catch(() => {
+          return;
+        }));
+        if (!parsed.success)
+          throw providerError("other", target.providerId, `its status for video ${videoId} could not be read.`);
+        const job = parsed.data;
+        if (job.status === "completed") {
+          const link = job.outputs?.video_url;
+          if (link === undefined)
+            throw providerError("other", target.providerId, `video ${videoId} completed without a link to it.`);
+          return { video: { url: link }, ...job.outputs?.cost === undefined ? {} : { cost: job.outputs.cost } };
+        }
+        if (job.status === "failed")
+          throw videoFailure(job.error ?? undefined, target.providerId, videoId);
+        if (job.status === "cancelled")
+          throw providerError("other", target.providerId, `video ${videoId} was cancelled.`);
+        await context.pause();
+      }
+    }
+  };
+}
+function videoFailure(error, providerId, videoId) {
+  if (error?.code === passthroughBlocked)
+    return passthroughError(providerId);
+  const rejected = /^(unsupported|invalid)/i.test(error?.code ?? "");
+  const kind = rejected ? "unsupported" : classifyProviderError({ status: 0, codes: [error?.code], message: error?.message });
+  const detail = [error?.code, error?.message].filter(Boolean).join(": ");
+  return providerError(kind, providerId, detail || `video ${videoId} failed.`);
+}
+async function fetchModelIds4(target, http) {
+  const label = providerLabel(target.providerId);
+  let response;
+  try {
+    response = await http(`${rootOf(target)}/v1/models`, { headers: authorization(target.credential) });
+  } catch (error) {
+    return { ok: false, message: `Could not reach ${label}: ${error.message}` };
+  }
+  if (!response.ok)
+    return { ok: false, message: (await errorOf2(response, target.providerId)).message };
+  const parsed = modelListSchema4.safeParse(await response.json().catch(() => {
+    return;
+  }));
+  if (!parsed.success)
+    return { ok: false, message: `${label} answered, but not with a Together model list. Check the base URL.` };
+  const modalities = {};
+  for (const model of parsed.data) {
+    if (model.type === "image" || model.type === "video")
+      modalities[model.id] = model.type;
+  }
+  return { ok: true, modelIds: Object.keys(modalities).sort(), modalities };
+}
+var together = {
+  builtInCapabilities: (modelId) => imageFamily(modelId).capabilities,
+  builtInVideoCapabilities: (modelId) => videoFamily(modelId).capabilities,
+  docsUrl: (modelId, modality = "image") => (modality === "video" ? videoFamily(modelId) : imageFamily(modelId)).docsUrl,
+  reservedOptions: ["model", "prompt", "n", "width", "height", "aspect_ratio", "response_format", "reference_images", "image_url"],
+  reservedVideoOptions: ["model", "prompt", "seconds", "resolution", "ratio", "media"],
+  async submit(request, target, http, context) {
+    const family = imageFamily(target.modelId);
+    const { size, references } = request;
+    const body = {
+      model: target.modelId,
+      prompt: request.prompt,
+      n: request.n,
+      ...family.sizing === "ratio" ? { aspect_ratio: size.aspectRatio } : { width: size.width, height: size.height },
+      response_format: "base64",
+      ...references.length === 0 ? {} : family.references === "image_url" ? { image_url: dataUrl(references[0]) } : { reference_images: references.map(dataUrl) },
+      ...request.providerOptions
+    };
+    const parsed = imagesSchema.safeParse(await postJson(`${rootOf(target)}/v1/images/generations`, body, request.providerOptions, target, http, context));
+    if (!parsed.success)
+      throw providerError("other", target.providerId, "its response could not be read as Together images.");
+    const images = parsed.data.data.map((item) => {
+      if (item.b64_json)
+        return { bytes: Buffer.from(item.b64_json, "base64") };
+      if (item.url)
+        return { url: item.url };
+      throw providerError("other", target.providerId, "it returned an image with neither data nor a link.");
+    });
+    if (images.length === 0)
+      throw providerError("other", target.providerId, "it returned no images.");
+    const shortfall = images.length < request.n ? `${providerLabel(target.providerId)} returned ${images.length} of ${request.n} images without saying why.` : undefined;
+    return { wait: async () => ({ images, ...shortfall === undefined ? {} : { shortfall } }) };
+  },
+  async submitVideo(request, target, http, context) {
+    const family = videoFamily(target.modelId);
+    const { size } = request;
+    const frames = [
+      ...request.firstFrame === undefined ? [] : [{ input_image: dataUrl(request.firstFrame), frame: "first" }],
+      ...request.lastFrame === undefined ? [] : [{ input_image: dataUrl(request.lastFrame), frame: "last" }]
+    ];
+    const media = {
+      ...frames.length === 0 ? {} : { frame_images: frames },
+      ...request.references.length === 0 ? {} : { reference_images: request.references.map(dataUrl) }
+    };
+    const sizing = family.sizing === "pixels" ? { width: size.width, height: size.height } : { resolution: request.resolution, ...family.sizing === "tier+ratio" ? { ratio: size.aspectRatio } : {} };
+    const body = {
+      model: target.modelId,
+      prompt: request.prompt,
+      seconds: String(request.seconds),
+      ...sizing,
+      ...Object.keys(media).length === 0 ? {} : { media },
+      ...request.providerOptions
+    };
+    const parsed = videoSchema.safeParse(await postJson(`${rootOf(target)}/v2/videos`, body, request.providerOptions, target, http, context));
+    if (!parsed.success)
+      throw providerError("other", target.providerId, "its answer to the submission had no video id.");
+    if (parsed.data.status === "failed")
+      throw videoFailure(parsed.data.error ?? undefined, target.providerId, parsed.data.id);
+    return waitForVideo(parsed.data.id, target, http, context);
+  },
+  resumeVideo(handle, target, http, context) {
+    const parsed = resumeSchema2.safeParse(handle);
+    if (!parsed.success)
+      throw providerError("other", target.providerId, "the Job history holds no video id to pick the Job up from.");
+    return waitForVideo(parsed.data.videoId, target, http, context);
+  },
+  async testConnection(target, http) {
+    const list = await fetchModelIds4(target, http);
+    if (!list.ok)
+      return list;
+    const count = (modality) => Object.values(list.modalities ?? {}).filter((value) => value === modality).length;
+    return {
+      ok: true,
+      message: `Connected to Provider "${target.providerId}". It offers ${count("image")} image and ${count("video")} video model id(s).`
+    };
+  },
+  listModelIds: fetchModelIds4
+};
+
 // src/protocols/venice.ts
 var generateDocs = "https://docs.venice.ai/api-reference/endpoint/image/generate";
 var editDocs = "https://docs.venice.ai/api-reference/endpoint/image/edit";
@@ -22675,7 +23511,7 @@ var constraintsSchema = object({
   maxInputImages: number2().int().positive().optional()
 });
 var sizingOf = (constraints) => (constraints.widthHeightDivisor ?? 1) > 1 ? "pixels" : "ratio";
-var modelListSchema4 = object({
+var modelListSchema5 = object({
   data: array(object({
     id: string2(),
     type: string2().optional(),
@@ -22685,10 +23521,11 @@ var modelListSchema4 = object({
     }).passthrough().optional()
   }))
 });
-var errorSchema4 = object({
+var errorSchema5 = object({
   error: union([string2(), object({ message: string2().optional(), code: string2().nullish() })]),
   code: string2().optional(),
-  suggested_prompt: string2().optional()
+  suggested_prompt: string2().optional(),
+  details: record(string2(), unknown()).optional()
 });
 var generateSchema = object({
   images: array(string2()),
@@ -22758,12 +23595,12 @@ function describeModel(listed, listType) {
   };
 }
 var apiUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path}`;
-var authorization = (credential) => ({ authorization: `Bearer ${credential}` });
+var authorization2 = (credential) => ({ authorization: `Bearer ${credential}` });
 async function listModels(target, type, http) {
   const label = providerLabel(target.providerId);
   let response;
   try {
-    response = await http(apiUrl(target.baseUrl, `/models?type=${type}`), { headers: authorization(target.credential) });
+    response = await http(apiUrl(target.baseUrl, `/models?type=${type}`), { headers: authorization2(target.credential) });
   } catch (error) {
     return { ok: false, message: `Could not reach ${label}: ${error.message}` };
   }
@@ -22773,7 +23610,7 @@ async function listModels(target, type, http) {
   if (!response.ok) {
     return { ok: false, message: `${label} returned HTTP ${response.status}: ${errorMessage(body) ?? response.statusText}` };
   }
-  const parsed = modelListSchema4.safeParse(body);
+  const parsed = modelListSchema5.safeParse(body);
   if (!parsed.success) {
     return { ok: false, message: `${label} answered, but not with a Venice model list. Check the base URL.` };
   }
@@ -22799,28 +23636,38 @@ async function lookUpModel(target, http) {
   return;
 }
 function errorMessage(body) {
-  const parsed = errorSchema4.safeParse(body);
+  const parsed = errorSchema5.safeParse(body);
   if (!parsed.success)
     return;
   return typeof parsed.data.error === "string" ? parsed.data.error : parsed.data.error.message;
 }
-async function veniceError(response, providerId) {
+var fieldErrorsSchema = object({ _errors: array(string2()) });
+function fieldProblems(details) {
+  return Object.entries(details ?? {}).flatMap(([field, value]) => {
+    const parsed = fieldErrorsSchema.safeParse(value);
+    return field === "_errors" || !parsed.success || parsed.data._errors.length === 0 ? [] : [`${field}: ${parsed.data._errors.join(", ")}`];
+  });
+}
+async function veniceError(response, providerId, options) {
   const body = await response.json().catch(() => {
     return;
   });
-  const parsed = errorSchema4.safeParse(body);
+  const parsed = errorSchema5.safeParse(body);
   const error = parsed.success ? parsed.data : undefined;
   const nested = typeof error?.error === "object" ? error.error : undefined;
-  const message = errorMessage(body) ?? (response.statusText || undefined);
+  const problems = fieldProblems(error?.details);
+  const said = errorMessage(body) ?? (response.statusText || undefined);
+  const message = said === undefined ? undefined : problems.length === 0 ? said : `${said}: ${problems.join("; ")}`;
   const suggestion = error?.suggested_prompt === undefined ? "" : ` Venice suggests this prompt instead: ${error.suggested_prompt}`;
   return httpProviderError(providerId, {
     status: response.status,
     codes: [error?.code, nested?.code],
-    message: message === undefined ? undefined : `${message}${suggestion}`
+    message: message === undefined ? undefined : `${message}${suggestion}`,
+    options
   });
 }
 var sharedDefaults = { safe_mode: false, enhance_prompt: false };
-async function generate(request, target, model, http) {
+async function generate(request, target, model, http, context) {
   const { size } = request;
   const sizing = model.sizing === "pixels" ? { width: size.width, height: size.height } : { aspect_ratio: size.aspectRatio };
   const body = {
@@ -22836,11 +23683,11 @@ async function generate(request, target, model, http) {
   };
   const response = await sendToProvider(http, target.providerId, apiUrl(target.baseUrl, "/image/generate"), {
     method: "POST",
-    headers: { ...authorization(target.credential), "content-type": "application/json" },
+    headers: { ...authorization2(target.credential), "content-type": "application/json" },
     body: JSON.stringify(body)
-  });
+  }, { context });
   if (!response.ok)
-    throw await veniceError(response, target.providerId);
+    throw await veniceError(response, target.providerId, Object.keys(request.providerOptions));
   const parsed = generateSchema.safeParse(await response.json().catch(() => {
     return;
   }));
@@ -22858,7 +23705,7 @@ async function generate(request, target, model, http) {
   }
   return result;
 }
-async function edit(request, target, http) {
+async function edit(request, target, http, context) {
   const encoded = request.references.map((reference) => Buffer.from(reference.bytes).toString("base64"));
   const [path, inputs] = encoded.length === 1 ? ["/image/edit", { model: target.modelId, image: encoded[0] }] : ["/image/multi-edit", { modelId: target.modelId, images: encoded }];
   const body = {
@@ -22871,11 +23718,11 @@ async function edit(request, target, http) {
   };
   const response = await sendToProvider(http, target.providerId, apiUrl(target.baseUrl, path), {
     method: "POST",
-    headers: { ...authorization(target.credential), "content-type": "application/json" },
+    headers: { ...authorization2(target.credential), "content-type": "application/json" },
     body: JSON.stringify(body)
-  });
+  }, { context });
   if (!response.ok)
-    throw await veniceError(response, target.providerId);
+    throw await veniceError(response, target.providerId, Object.keys(request.providerOptions));
   if (response.headers.get("content-type")?.includes("json")) {
     throw providerError("other", target.providerId, "it answered an edit with JSON rather than an image.");
   }
@@ -22894,15 +23741,15 @@ var venice = {
   },
   docsUrl: (modelId) => looksLikeEdit(modelId) ? editDocs : generateDocs,
   reservedOptions: ["model", "modelId", "prompt", "variants", "return_binary", "width", "height", "aspect_ratio", "image", "images"],
-  async submit(request, target, http) {
+  async submit(request, target, http, context) {
     const model = describedModel(request.model, target.modelId);
     if (request.references.length > 0) {
-      return { wait: () => inParallel(request.n, target.providerId, () => edit(request, target, http)) };
+      return { wait: () => inParallel(request.n, target.providerId, () => edit(request, target, http, context)) };
     }
     if (model.kind === "edit") {
       throw providerError("unsupported", target.providerId, `"${target.modelId}" is an edit model and needs at least one reference image. Pass \`references\`, or choose a text-to-image Model.`);
     }
-    const images = await generate(request, target, model, http);
+    const images = await generate(request, target, model, http, context);
     return { wait: async () => images };
   },
   async testConnection(target, http) {
@@ -22926,7 +23773,8 @@ var adapters = {
   "openai-images": openaiImages,
   gemini,
   apimart,
-  venice
+  venice,
+  together
 };
 function supportedProtocols() {
   return Object.keys(adapters);
@@ -22945,6 +23793,7 @@ function adapterFor(model) {
 // src/jobs.ts
 var defaultWaitLimitMs = 120000;
 var defaultPollIntervalMs = 3000;
+var defaultRetryDelayMs = 2000;
 
 class JobFailedError extends Error {
   jobId;
@@ -22961,7 +23810,7 @@ class JobAbandoned extends Error {
     super("litevision shut down while the Job was running.");
   }
 }
-var lostMessage = "litevision stopped before this Job finished, so its result is lost; generate the images again.";
+var lostMessage = "litevision stopped before this Job finished, so its result is lost; start it again.";
 
 class JobRunner {
   deps;
@@ -22970,37 +23819,24 @@ class JobRunner {
   closed = false;
   waitLimitMs;
   pollIntervalMs;
+  retryDelayMs;
   constructor(deps) {
     this.deps = deps;
     this.waitLimitMs = deps.waitLimitMs ?? defaultWaitLimitMs;
     this.pollIntervalMs = deps.pollIntervalMs ?? defaultPollIntervalMs;
+    this.retryDelayMs = deps.retryDelayMs ?? defaultRetryDelayMs;
   }
   async start(spec) {
     const { request } = spec.normalised;
-    const base = {
-      type: "job",
-      id: randomUUID2(),
-      createdAt: this.deps.now().toISOString(),
-      model: spec.model.alias,
-      provider: spec.provider.id,
-      protocol: spec.model.protocol,
-      modelId: spec.model.modelId,
-      prompt: request.prompt,
-      parameters: {
-        n: request.n,
-        aspectRatio: spec.normalised.requestedAspectRatio,
-        size: request.size,
-        references: request.references.map((reference) => reference.path),
-        ...spec.outputDir === undefined ? {} : { outputPath: spec.outputDir },
-        providerOptions: request.providerOptions
-      }
-    };
-    const target = {
-      providerId: spec.provider.id,
-      baseUrl: spec.provider.baseUrl,
-      modelId: spec.model.modelId,
-      credential: spec.credential
-    };
+    const base = this.baseFor(spec, "image", request.prompt, {
+      n: request.n,
+      aspectRatio: spec.normalised.requestedAspectRatio,
+      size: request.size,
+      references: request.references.map((reference) => reference.path),
+      ...spec.outputDir === undefined ? {} : { outputPath: spec.outputDir },
+      providerOptions: request.providerOptions
+    });
+    const target = targetOf(spec);
     await this.append(base, "running");
     const job = this.track(base, spec.credential, async (context) => {
       const submitted = await spec.adapter.submit(request, target, this.deps.http, context);
@@ -23010,6 +23846,49 @@ class JobRunner {
     });
     return this.waitFor(base.model, base.id, this.register(base.id, job));
   }
+  async startVideo(spec) {
+    const { request } = spec.normalised;
+    const submitVideo = spec.adapter.submitVideo;
+    if (submitVideo === undefined) {
+      throw new ConfigError(`Model "${spec.model.alias}" uses Protocol "${spec.model.protocol}", which litevision cannot make videos with.`);
+    }
+    const base = this.baseFor(spec, "video", request.prompt, {
+      n: 1,
+      aspectRatio: spec.normalised.requestedAspectRatio,
+      size: request.size,
+      references: request.references.map((reference) => reference.path),
+      seconds: request.seconds,
+      ...request.resolution === undefined ? {} : { resolution: request.resolution },
+      ...spec.normalised.followsFirstFrame ? { followsFirstFrame: true } : {},
+      ...request.firstFrame === undefined ? {} : { firstFrame: request.firstFrame.path },
+      ...request.lastFrame === undefined ? {} : { lastFrame: request.lastFrame.path },
+      ...spec.outputDir === undefined ? {} : { outputPath: spec.outputDir },
+      providerOptions: request.providerOptions
+    });
+    const target = targetOf(spec);
+    await this.append(base, "running");
+    const job = this.track(base, spec.credential, async (context) => {
+      const submitted = await submitVideo.call(spec.adapter, request, target, this.deps.http, context);
+      await this.append(base, "running", { resume: submitted.resumeHandle });
+      return videoAsImages(await submitted.wait());
+    });
+    return this.waitFor(base.model, base.id, this.register(base.id, job));
+  }
+  baseFor(spec, modality, prompt, parameters) {
+    return {
+      type: "job",
+      id: randomUUID2(),
+      createdAt: this.deps.now().toISOString(),
+      model: spec.model.alias,
+      provider: spec.provider.id,
+      protocol: spec.model.protocol,
+      modelId: spec.model.modelId,
+      modality,
+      prompt,
+      parameters,
+      ...spec.comparison === undefined ? {} : { comparison: spec.comparison }
+    };
+  }
   async get(id) {
     const record = await readJob(this.deps.dirs, id);
     if (record === undefined) {
@@ -23023,7 +23902,9 @@ class JobRunner {
           id,
           model: record.model,
           files: record.files,
-          ...record.shortfall === undefined ? {} : { shortfall: record.shortfall }
+          observed: record.observed ?? record.files.map(() => null),
+          ...record.shortfall === undefined ? {} : { shortfall: record.shortfall },
+          ...record.mismatch === undefined ? {} : { mismatch: record.mismatch }
         };
       }
       if (record.outcome === "failed") {
@@ -23040,7 +23921,11 @@ class JobRunner {
     this.abandons.clear();
   }
   context = {
-    pause: () => new Promise((resolve, reject) => {
+    pause: () => this.sleep(this.pollIntervalMs),
+    backoff: (retry) => this.sleep(this.retryDelayMs * 2 ** (retry - 1))
+  };
+  sleep(ms) {
+    return new Promise((resolve, reject) => {
       if (this.closed)
         return reject(new JobAbandoned);
       const abandon = () => {
@@ -23050,10 +23935,10 @@ class JobRunner {
       const timer = setTimeout(() => {
         this.abandons.delete(abandon);
         resolve();
-      }, this.pollIntervalMs);
+      }, ms);
       this.abandons.add(abandon);
-    })
-  };
+    });
+  }
   register(id, job) {
     this.jobs.set(id, job);
     job.catch((error) => {
@@ -23082,7 +23967,8 @@ class JobRunner {
     const handle = record.resume;
     const base = baseOf(record);
     const adapter = adapterForProtocol(record.protocol);
-    const resume = adapter?.resume;
+    const video = record.modality === "video";
+    const resume = video ? adapter?.resumeVideo : adapter?.resume;
     if (handle === undefined || adapter === undefined || resume === undefined) {
       await this.append(base, "failed", { error: { kind: "other", message: lostMessage } });
       throw new JobFailedError(record.id, "other", lostMessage);
@@ -23093,7 +23979,12 @@ class JobRunner {
     }
     const credential = await requireCredential(this.deps.dirs, provider);
     const target = { providerId: provider.id, baseUrl: provider.baseUrl, modelId: record.modelId, credential };
-    return this.track(base, credential, (context) => resume.call(adapter, handle, target, this.deps.http, context).wait());
+    if (video) {
+      const resumeVideo = adapter.resumeVideo;
+      return this.track(base, credential, async (context) => videoAsImages(await resumeVideo.call(adapter, handle, target, this.deps.http, context).wait()));
+    }
+    const resumeImages = adapter.resume;
+    return this.track(base, credential, (context) => resumeImages.call(adapter, handle, target, this.deps.http, context).wait());
   }
   async track(base, credential, run) {
     const safe = (text) => redact(text, credential);
@@ -23104,14 +23995,22 @@ class JobRunner {
         throw new JobAbandoned;
       const startedAt = new Date(base.createdAt);
       const folder = base.parameters.outputPath ?? join4(this.deps.dirs.output, localDate(startedAt));
-      const saved = await saveImages(this.deps.http, folder, base.id, startedAt, result.images, base.provider);
+      const saved = await saveFiles(this.deps.http, folder, base.id, startedAt, result.images, base.provider);
       const reasons = [result.shortfall, ...saved.failures.map((failure) => failure.message)].filter((reason) => reason !== undefined);
       if (saved.files.length === 0) {
-        throw saved.failures[0] ?? providerError("other", base.provider, reasons[0] ?? "it returned no images.");
+        throw saved.failures[0] ?? providerError("other", base.provider, reasons[0] ?? "it returned nothing.");
       }
+      const observed = saved.facts;
+      const mismatch = mismatchOf(base.parameters, observed);
       const shortfall = saved.files.length >= n ? undefined : safe(`Got ${saved.files.length} of ${n} images from ${providerLabel(base.provider)}.${reasons.length === 0 ? "" : ` ${reasons.join(" ")}`}`);
-      await this.append(base, "completed", { files: saved.files, shortfall, cost: result.cost });
-      return { id: base.id, files: saved.files, ...shortfall === undefined ? {} : { shortfall } };
+      await this.append(base, "completed", { files: saved.files, shortfall, cost: result.cost, observed, mismatch });
+      return {
+        id: base.id,
+        files: saved.files,
+        observed,
+        ...shortfall === undefined ? {} : { shortfall },
+        ...mismatch === undefined ? {} : { mismatch }
+      };
     } catch (error) {
       if (error instanceof JobAbandoned || this.closed)
         throw new JobAbandoned;
@@ -23135,18 +24034,50 @@ class JobRunner {
   }
 }
 function baseOf(record) {
-  const { type, id, createdAt, model, provider, protocol, modelId, prompt, parameters } = record;
-  return { type, id, createdAt, model, provider, protocol, modelId, prompt, parameters };
+  const { type, id, createdAt, model, provider, protocol, modelId, modality, prompt, parameters, comparison } = record;
+  return { type, id, createdAt, model, provider, protocol, modelId, ...modality === undefined ? {} : { modality }, prompt, parameters, ...comparison === undefined ? {} : { comparison } };
+}
+function targetOf(spec) {
+  return { providerId: spec.provider.id, baseUrl: spec.provider.baseUrl, modelId: spec.model.modelId, credential: spec.credential };
+}
+function videoAsImages(result) {
+  return { images: [result.video], ...result.cost === undefined ? {} : { cost: result.cost } };
+}
+var aspectTolerance = Math.log(1.05);
+var durationToleranceSeconds = 0.5;
+function expectedShape(parameters) {
+  const { width, height } = parameters.providerOptions;
+  if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
+    return { ratio: width / height, asked: `${width}x${height} in provider_options` };
+  }
+  return { ratio: ratioOf(parameters.size.aspectRatio), asked: `${parameters.size.aspectRatio} (${formatSize(parameters.size)})` };
+}
+function mismatchOf(parameters, observed) {
+  const { seconds, followsFirstFrame } = parameters;
+  const expected = expectedShape(parameters);
+  const problems = new Set;
+  for (const facts of observed) {
+    if (facts === null)
+      continue;
+    if (!followsFirstFrame && Math.abs(Math.log(facts.width / facts.height / expected.ratio)) > aspectTolerance) {
+      problems.add(`asked for ${expected.asked}, got ${facts.width}x${facts.height}`);
+    }
+    if (seconds !== undefined && facts.seconds !== undefined && Math.abs(facts.seconds - seconds) > durationToleranceSeconds) {
+      problems.add(`asked for ${seconds} s, got ${facts.seconds} s`);
+    }
+  }
+  return problems.size === 0 ? undefined : [...problems].join("; ");
 }
 function redact(text, credential) {
   return text.split(credential).join("[redacted]");
 }
-async function saveImages(http, folder, jobId, startedAt, images, providerId) {
+async function saveFiles(http, folder, jobId, startedAt, results, providerId) {
   await mkdir2(folder, { recursive: true });
   const base = `${localTime(startedAt)}-${jobId.slice(0, 8)}`;
   const files = [];
+  const facts = [];
   const failures = [];
-  for (const [index, image] of images.entries()) {
+  for (const [index, image] of results.entries()) {
     let bytes;
     try {
       bytes = "bytes" in image ? image.bytes : await download(http, image.url, providerId);
@@ -23156,12 +24087,13 @@ async function saveImages(http, folder, jobId, startedAt, images, providerId) {
       failures.push(error);
       continue;
     }
-    const suffix = images.length === 1 ? "" : `-${index + 1}`;
-    const file = join4(folder, `${base}${suffix}.${imageTypeOf(bytes)?.extension ?? "bin"}`);
+    const suffix = results.length === 1 ? "" : `-${index + 1}`;
+    const file = join4(folder, `${base}${suffix}.${fileTypeOf(bytes)?.extension ?? "bin"}`);
     await writeFile(file, bytes);
     files.push(file);
+    facts.push(mediaFactsOf(bytes) ?? null);
   }
-  return { files, failures };
+  return { files, facts, failures };
 }
 async function download(http, url, providerId) {
   const response = await http(url).catch((error) => {
@@ -23271,6 +24203,13 @@ function isPlainObject3(value) {
 }
 
 // src/model-info.ts
+function videoModelInfo({ model }) {
+  const adapter = adapterFor(model);
+  if (adapter.builtInVideoCapabilities === undefined || adapter.submitVideo === undefined) {
+    throw new ConfigError(`Model "${model.alias}" is a video Model, but its Protocol "${model.protocol}" makes no videos in litevision.`);
+  }
+  return { capabilities: adapter.builtInVideoCapabilities(model.modelId), docsUrl: adapter.docsUrl(model.modelId, "video") };
+}
 var modelInfoTtlMs = 24 * 60 * 60 * 1000;
 var defaultModelInfoTimeoutMs = 5000;
 var sizeSchema = object({
@@ -23297,7 +24236,7 @@ async function modelInfo(deps, resolved, options = {}) {
   const builtIn = {
     capabilities: adapter.builtInCapabilities(resolved.model.modelId),
     source: "built-in",
-    docsUrl: adapter.docsUrl(resolved.model.modelId)
+    docsUrl: adapter.docsUrl(resolved.model.modelId, "image")
   };
   const fetchModelInfo = adapter.fetchModelInfo;
   if (fetchModelInfo === undefined)
@@ -23427,7 +24366,7 @@ function updateNotesAsAgent(dirs, alias, text, at) {
       throw needsSettings(`The Models in config.json are invalid: ${prettifyError(parsed.error)}`);
     const stored = models;
     if (stored.length === 0)
-      throw needsSettings("litevision has no image Model configured yet.");
+      throw needsSettings("litevision has no Model configured yet.");
     const model = stored.find((candidate) => candidate.alias === alias);
     if (model === undefined) {
       throw new ConfigError(`Unknown Model Alias "${alias}". Known Aliases: ${stored.map((candidate) => candidate.alias).join(", ")}.`);
@@ -23438,60 +24377,6 @@ function updateNotesAsAgent(dirs, alias, text, at) {
   });
 }
 
-// src/protocols/capabilities.ts
-function describeCapabilities(capabilities) {
-  const ratios = capabilities.sizes.map((size) => `${size.aspectRatio} (${formatSize(size)})`).join(", ");
-  const references = capabilities.maxReferences === 0 ? "no reference images" : `up to ${capabilities.maxReferences} reference image${capabilities.maxReferences === 1 ? "" : "s"}`;
-  return `aspect ratios ${ratios}; up to ${capabilities.maxImages} image${capabilities.maxImages === 1 ? "" : "s"} per Job; ${references}.`;
-}
-function closestSize(sizes, wanted) {
-  const exact = sizes.find((size) => size.aspectRatio === wanted);
-  if (exact !== undefined)
-    return { size: exact, adjusted: false };
-  const target = Math.log(ratioOf(wanted));
-  const distance = (size) => Math.abs(Math.log(size.width / size.height) - target);
-  const [first, ...rest] = sizes;
-  if (first === undefined)
-    throw new Error("A Protocol adapter declared no supported sizes.");
-  const size = rest.reduce((best, size) => distance(size) < distance(best) ? size : best, first);
-  return { size, adjusted: true };
-}
-function ratioOf(aspectRatio) {
-  const [width, height] = aspectRatio.split(":").map(Number);
-  return width / height;
-}
-async function normaliseImageRequest(parameters, model, adapter, described, cwd) {
-  const { capabilities } = described;
-  const unsupported = (problem) => new ConfigError(`${problem} Model "${model.alias}" supports: ${describeCapabilities(capabilities)} Choose another Model or change the request.`);
-  if (parameters.n > capabilities.maxImages) {
-    throw unsupported(`Model "${model.alias}" cannot generate ${parameters.n} images in one Job.`);
-  }
-  if (parameters.references.length > 0 && capabilities.maxReferences === 0) {
-    throw unsupported(`Model "${model.alias}" cannot take reference images.`);
-  }
-  if (parameters.references.length > capabilities.maxReferences) {
-    throw unsupported(`Model "${model.alias}" cannot take ${parameters.references.length} reference images.`);
-  }
-  const reserved = Object.keys(parameters.providerOptions).filter((key) => adapter.reservedOptions.includes(key));
-  if (reserved.length > 0) {
-    throw new ConfigError(`provider_options may not set ${reserved.map((key) => `\`${key}\``).join(", ")}: litevision sets ${reserved.length === 1 ? "it" : "them"} from the \`generate_image\` parameters. Use those instead.`);
-  }
-  const { size, adjusted } = closestSize(capabilities.sizes, parameters.aspectRatio);
-  const references = await readReferences(parameters.references, cwd);
-  return {
-    request: {
-      prompt: parameters.prompt,
-      n: parameters.n,
-      size,
-      references,
-      providerOptions: parameters.providerOptions,
-      model: { capabilities, ...described.parameterSchema === undefined ? {} : { parameterSchema: described.parameterSchema } }
-    },
-    requestedAspectRatio: parameters.aspectRatio,
-    aspectRatioAdjusted: adjusted
-  };
-}
-
 // src/settings/browser.ts
 import { spawn } from "node:child_process";
 var openInBrowser = (url) => {
@@ -23522,7 +24407,8 @@ var providerPresets = [
   { id: "openai", label: "OpenAI", baseUrl: "https://api.openai.com/v1", protocol: "openai-images" },
   { id: "gemini", label: "Gemini", baseUrl: "https://generativelanguage.googleapis.com/v1beta", protocol: "gemini" },
   { id: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1", protocol: "venice" },
-  { id: "apimart", label: "APIMart", baseUrl: "https://api.apimart.ai/v1", protocol: "apimart" }
+  { id: "apimart", label: "APIMart", baseUrl: "https://api.apimart.ai/v1", protocol: "apimart" },
+  { id: "together", label: "Together AI", baseUrl: "https://api.together.ai", protocol: "together" }
 ];
 function shortName(what) {
   return string2().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/, `${what} is 1–64 letters, digits, '.', '_' or '-', starting with a letter or digit.`);
@@ -23632,7 +24518,7 @@ async function testConnection(dirs, http, providerId, protocol) {
   }
   return { result: outcome.ok ? "success" : "failure", message: call.redact(outcome.message) };
 }
-async function fetchModelIds4(dirs, http, providerId, protocol) {
+async function fetchModelIds5(dirs, http, providerId, protocol) {
   const typeInstead = "You can still type the model id.";
   const call = await prepare(dirs, providerId, protocol, (adapter) => adapter.listModelIds);
   if (call === "unsupported") {
@@ -23644,7 +24530,7 @@ async function fetchModelIds4(dirs, http, providerId, protocol) {
   try {
     const list = await call.run(http);
     if (list.ok)
-      return { result: "success", modelIds: list.modelIds };
+      return { result: "success", modelIds: list.modelIds, ...list.modalities === undefined ? {} : { modalities: list.modalities } };
     message = list.message;
   } catch (error) {
     message = unreachable(providerId, error);
@@ -23675,24 +24561,69 @@ function unreachable(providerId, error) {
 // src/settings/job-history.ts
 import { readFile as readFile6 } from "node:fs/promises";
 var rateJobInput = object({
+  result: number2({ message: "Choose a result by its number." }).int("Choose a result by its number.").positive("Choose a result by its number.").optional(),
   verdict: _enum(verdicts, { message: "Choose good or bad." }),
   reason: string2().max(ratingReasonMaxLength, `Keep the reason to at most ${ratingReasonMaxLength} characters.`)
 });
+var pickInput = object({
+  jobId: string2({ message: "Choose one of the Comparison's Jobs." }).min(1, "Choose one of the Comparison's Jobs."),
+  result: number2({ message: "Choose a result by its number." }).int("Choose a result by its number.").positive("Choose a result by its number.").optional()
+});
 async function listJobHistory(dirs) {
-  return (await readRatedJobs(dirs)).map(({ job, rating }) => ({
-    id: job.id,
-    createdAt: job.createdAt,
-    model: job.model,
-    modelId: job.modelId,
-    provider: job.provider,
-    prompt: job.prompt,
-    durationMs: job.durationMs,
-    outcome: job.outcome,
-    files: job.files.map((path, index) => ({ path, thumbnail: `/api/jobs/${encodeURIComponent(job.id)}/files/${index}` })),
-    rating: rating === undefined ? null : listedRating(rating),
-    ...job.error === undefined ? {} : { error: job.error.message },
-    ...job.shortfall === undefined ? {} : { shortfall: job.shortfall }
-  }));
+  const listed = (await readRatedJobs(dirs)).map((rated) => {
+    const { job, pick } = rated;
+    const listedRatingOf = (result) => {
+      const current = ratingOf(rated, result);
+      return current === undefined ? null : listedRating(current);
+    };
+    return {
+      id: job.id,
+      createdAt: job.createdAt,
+      model: job.model,
+      modelId: job.modelId,
+      provider: job.provider,
+      prompt: job.prompt,
+      durationMs: job.durationMs,
+      outcome: job.outcome,
+      modality: job.modality ?? "image",
+      files: job.files.map((path, index) => ({
+        path,
+        thumbnail: `/api/jobs/${encodeURIComponent(job.id)}/files/${index}`,
+        rating: listedRatingOf(index + 1)
+      })),
+      rating: listedRatingOf(),
+      ...job.error === undefined ? {} : { error: job.error.message },
+      ...job.shortfall === undefined ? {} : { shortfall: job.shortfall },
+      ...job.mismatch === undefined ? {} : { mismatch: `The result does not match the request: ${job.mismatch}.` },
+      ...job.comparison === undefined ? {} : { comparison: { id: job.comparison, pick: pick === undefined ? null : listedPick(pick) } }
+    };
+  });
+  const byComparison = new Map;
+  for (const job of listed) {
+    if (job.comparison === undefined)
+      continue;
+    const ofComparison = byComparison.get(job.comparison.id) ?? [];
+    byComparison.set(job.comparison.id, ofComparison);
+    ofComparison.unshift(job);
+  }
+  return listed.flatMap((job) => {
+    if (job.comparison === undefined)
+      return [job];
+    const ofComparison = byComparison.get(job.comparison.id);
+    if (ofComparison === undefined)
+      return [];
+    byComparison.delete(job.comparison.id);
+    return ofComparison;
+  });
+}
+async function pickFromPage(dirs, comparison, input, now) {
+  try {
+    return listedPick(await pickResult(dirs, { comparison, ...input }, now));
+  } catch (error) {
+    if (!(error instanceof PickError))
+      throw error;
+    throw new SettingsError({ "unknown-comparison": 404, "not-in-comparison": 400, "not-completed": 409, invalid: 400 }[error.kind], error.message);
+  }
 }
 async function rateJobFromPage(dirs, jobId, input, now) {
   try {
@@ -23707,18 +24638,21 @@ async function jobImage(dirs, jobId, index) {
   const job = await readJob(dirs, jobId);
   const path = /^\d+$/.test(index) ? job?.files[Number(index)] : undefined;
   if (path === undefined)
-    throw new SettingsError(404, "No such image in the Job history.");
+    throw new SettingsError(404, "No such file in the Job history.");
   let bytes;
   try {
     bytes = await readFile6(path);
   } catch {
-    throw new SettingsError(404, "The image is no longer on disk.");
+    throw new SettingsError(404, "The file is no longer on disk.");
   }
-  const type = imageTypeOf(bytes);
+  const type = fileTypeOf(bytes);
   if (type === undefined)
-    throw new SettingsError(404, "The file is no longer an image.");
+    throw new SettingsError(404, "The file is no longer an image or a video.");
   return { bytes, contentType: type.mimeType };
 }
+function listedPick(pick) {
+  return { jobId: pick.jobId, ...pick.result === undefined ? {} : { result: pick.result }, pickedAt: pick.pickedAt };
+}
 function listedRating(rating) {
   return { verdict: rating.verdict, reason: rating.reason, ratedAt: rating.ratedAt };
 }
@@ -23731,14 +24665,18 @@ var addModelInput = object({
   provider: string2().min(1, "Choose a Provider."),
   modelId: string2().trim().min(1, "Enter a model id.").max(200, "A model id is at most 200 characters."),
   protocol: string2().refine((value) => supportedProtocols().includes(value), { error: () => `Choose a supported Protocol: ${supportedProtocols().join(", ")}.` }),
+  modality: _enum(modalities, { error: () => "Choose whether the Model makes images or videos." }).default("image"),
   notes: notes.optional()
 });
-var updateModelInput = addModelInput.partial();
+var updateModelInput = addModelInput.omit({ modality: true }).partial().extend({ modality: addModelInput.shape.modality.unwrap().optional() });
 var storedModels = array(modelSchema);
 async function listModels2(dirs) {
   const config = await readConfigObject(dirs);
-  const defaultImageModel = typeof config.defaultImageModel === "string" ? config.defaultImageModel : null;
-  return { models: modelsOf(config).map((model) => view2(model, defaultImageModel)), defaultImageModel };
+  const defaults = {
+    defaultImageModel: typeof config.defaultImageModel === "string" ? config.defaultImageModel : null,
+    defaultVideoModel: typeof config.defaultVideoModel === "string" ? config.defaultVideoModel : null
+  };
+  return { models: modelsOf(config).map((model) => view2(model, defaults)), ...defaults };
 }
 async function getModel(dirs, wanted) {
   const model = (await listModels2(dirs)).models.find((candidate) => candidate.alias === wanted);
@@ -23751,7 +24689,13 @@ async function addModel(dirs, input, at) {
     const models = modelsOf(config);
     requireFreeAlias(models, input.alias);
     requireProvider(config, input.provider);
-    const stored = { alias: input.alias, provider: input.provider, modelId: input.modelId, protocol: input.protocol };
+    const stored = {
+      alias: input.alias,
+      provider: input.provider,
+      modelId: input.modelId,
+      protocol: input.protocol,
+      modality: input.modality
+    };
     if (input.notes) {
       stored.notes = input.notes;
       stored.notesHistory = { changedBy: "User", changedAt: at.toISOString() };
@@ -23769,8 +24713,14 @@ async function updateModel(dirs, wanted, input, at) {
     if (input.alias !== undefined && input.alias !== wanted) {
       requireFreeAlias(models, input.alias);
       model.alias = input.alias;
-      if (config.defaultImageModel === wanted)
-        config.defaultImageModel = input.alias;
+      for (const key of Object.values(defaultKey))
+        if (config[key] === wanted)
+          config[key] = input.alias;
+    }
+    if (input.modality !== undefined && input.modality !== modalityOf(model)) {
+      if (config[defaultKey[modalityOf(model)]] === model.alias)
+        delete config[defaultKey[modalityOf(model)]];
+      model.modality = input.modality;
     }
     if (input.provider !== undefined) {
       requireProvider(config, input.provider);
@@ -23801,22 +24751,28 @@ async function removeModel(dirs, wanted) {
     if (!models.some((model) => model.alias === wanted))
       throw notFound2(wanted);
     config.models = models.filter((model) => model.alias !== wanted);
-    if (config.defaultImageModel === wanted)
-      delete config.defaultImageModel;
+    for (const key of Object.values(defaultKey))
+      if (config[key] === wanted)
+        delete config[key];
   });
 }
 var setDefaultInput = object({ alias: string2().nullable() });
-async function setDefaultImageModel(dirs, wanted) {
+async function setDefaultModel(dirs, modality, wanted) {
+  const key = defaultKey[modality];
   await updateConfig(dirs, (config) => {
     if (wanted === null) {
-      delete config.defaultImageModel;
+      delete config[key];
       return;
     }
-    if (!modelsOf(config).some((model) => model.alias === wanted))
+    const model = modelsOf(config).find((candidate) => candidate.alias === wanted);
+    if (model === undefined)
       throw notFound2(wanted);
-    config.defaultImageModel = wanted;
+    if (modalityOf(model) !== modality) {
+      throw new SettingsError(400, `"${wanted}" is ${modalityOf(model) === "image" ? "an image" : "a video"} Model, so it cannot be the default ${modality} Model.`);
+    }
+    config[key] = wanted;
   });
-  return { defaultImageModel: wanted };
+  return { alias: wanted };
 }
 function requireFreeAlias(models, wanted) {
   if (models.some((model) => model.alias === wanted)) {
@@ -23837,15 +24793,20 @@ function modelsOf(config) {
     throw new SettingsError(409, `The Models in config.json are invalid: ${prettifyError(parsed.error)}`);
   return config.models;
 }
-function view2(model, defaultImageModel) {
+function modalityOf(model) {
+  return model.modality ?? "image";
+}
+function view2(model, defaults) {
+  const modality = modalityOf(model);
   return {
     alias: model.alias,
     provider: model.provider,
     modelId: model.modelId,
     protocol: model.protocol,
+    modality,
     notes: model.notes ?? "",
     ...model.notesHistory && { notesHistory: model.notesHistory },
-    default: model.alias === defaultImageModel
+    default: model.alias === (modality === "video" ? defaults.defaultVideoModel : defaults.defaultImageModel)
   };
 }
 function notFound2(wanted) {
@@ -23910,7 +24871,7 @@ var routes = [
     path: "/api/providers/:id/model-ids",
     handler: async ({ dirs, http, params, body }) => {
       const { protocol } = parse6(protocolInput, body);
-      return { body: await fetchModelIds4(dirs, http, params.id, protocol) };
+      return { body: await fetchModelIds5(dirs, http, params.id, protocol) };
     }
   },
   {
@@ -23957,7 +24918,16 @@ var routes = [
   {
     method: "PUT",
     path: "/api/default-image-model",
-    handler: async ({ dirs, body }) => ({ body: await setDefaultImageModel(dirs, parse6(setDefaultInput, body).alias) })
+    handler: async ({ dirs, body }) => ({
+      body: { defaultImageModel: (await setDefaultModel(dirs, "image", parse6(setDefaultInput, body).alias)).alias }
+    })
+  },
+  {
+    method: "PUT",
+    path: "/api/default-video-model",
+    handler: async ({ dirs, body }) => ({
+      body: { defaultVideoModel: (await setDefaultModel(dirs, "video", parse6(setDefaultInput, body).alias)).alias }
+    })
   },
   {
     method: "GET",
@@ -23971,6 +24941,13 @@ var routes = [
       body: { rating: await rateJobFromPage(dirs, params.id, parse6(rateJobInput, body), now()) }
     })
   },
+  {
+    method: "POST",
+    path: "/api/comparisons/:id/pick",
+    handler: async ({ dirs, now, params, body }) => ({
+      body: { pick: await pickFromPage(dirs, params.id, parse6(pickInput, body), now()) }
+    })
+  },
   {
     method: "GET",
     path: "/api/jobs/:id/files/:index",
@@ -24119,11 +25096,20 @@ function renderPage(nonce) {
   .prompt { white-space: pre-wrap; overflow-wrap: anywhere; }
   .thumbs { display: flex; flex-wrap: wrap; gap: 8px; }
   .thumb { width: 96px; height: 96px; object-fit: cover; border-radius: 8px; border: 1px solid var(--border); background: var(--bg); }
+  .thumb.video { width: 192px; height: 108px; }
   .thumb.placeholder { display: flex; align-items: center; justify-content: center; text-align: center; padding: 6px;
     font-size: 11px; color: var(--muted); border-style: dashed; }
+  .result-thumb { margin: 0; display: grid; gap: 4px; width: min-content; }
+  .result-thumb figcaption { font-size: 12px; color: var(--muted); overflow-wrap: anywhere; }
   .actions.rate { display: grid; gap: 10px; }
+  .inline > select.rate-target { flex: 0 0 auto; }
   .rating { font-size: 13px; }
   .rating.good { color: var(--ok); } .rating.bad { color: var(--danger); }
+  .comparison { display: grid; gap: 12px; border: 1px solid var(--border); border-left: 3px solid var(--accent);
+    border-radius: 12px; padding: 16px; margin-bottom: 12px; }
+  .comparison > .card { margin-bottom: 0; }
+  .comparison-head p { font-size: 13px; color: var(--muted); margin-top: 2px; }
+  .picked { color: var(--accent); font-weight: 500; }
 
   #status { position: fixed; left: 50%; bottom: 20px; transform: translateX(-50%); max-width: calc(100% - 32px);
     background: var(--text); color: var(--bg); padding: 8px 14px; border-radius: 8px; font-size: 13px; display: none;
@@ -24166,6 +25152,7 @@ function renderPage(nonce) {
       <div class="fields">
         <div class="field"><label for="model-provider">Provider</label><select id="model-provider" required></select></div>
         <div class="field"><label for="model-protocol">Protocol</label><select id="model-protocol" required></select></div>
+        <div class="field"><label for="model-modality">Makes</label><select id="model-modality" required><option value="image">Images</option><option value="video">Videos</option></select></div>
         <div class="field wide">
           <label for="model-id">Model id</label>
           <div class="inline"><input id="model-id" required spellcheck="false" list="model-ids" placeholder="gpt-image-1"><button id="fetch-models" type="button">Fetch model list</button></div>
@@ -24182,7 +25169,7 @@ function renderPage(nonce) {
   <section id="history">
     <div class="section-head">
       <h2>Job history</h2>
-      <p>Newest first. Rate a Job to keep your verdict on it; rating it again replaces the earlier Rating.</p>
+      <p>Newest first. Rate a Job, or one of its results, to keep your verdict on it; rating it again replaces the earlier Rating. In a Comparison, pick the result you prefer; picking again replaces the earlier Pick.</p>
     </div>
     <div id="job-list"><p class="muted">Loading…</p></div>
   </section>
@@ -24395,20 +25382,21 @@ function modelCard(model) {
   const provider = el("select", {}, ...options(providerIds.includes(model.provider) ? providerIds : [model.provider, ...providerIds], model.provider));
   const modelId = el("input", { value: model.modelId, spellcheck: false });
   const protocol = el("select", {}, ...options(protocols.includes(model.protocol) ? protocols : [model.protocol, ...protocols], model.protocol));
+  const modality = el("select", {}, ...options(["image", "video"], model.modality));
   const notes = notesField(model.notes);
   const path = "/api/models/" + encodeURIComponent(model.alias);
 
   const save = el("button", { type: "button", className: "primary", textContent: "Save" });
   save.onclick = () => act(save, async () => {
-    await api("PATCH", path, { alias: alias.value, provider: provider.value, modelId: modelId.value, protocol: protocol.value, notes: notes.textarea.value });
+    await api("PATCH", path, { alias: alias.value, provider: provider.value, modelId: modelId.value, protocol: protocol.value, modality: modality.value, notes: notes.textarea.value });
     await loadModels();
   }, "Model saved.");
 
   const makeDefault = el("button", { type: "button", className: "small", textContent: "Make default" });
   makeDefault.onclick = () => act(makeDefault, async () => {
-    await api("PUT", "/api/default-image-model", { alias: model.alias });
+    await api("PUT", "/api/default-" + model.modality + "-model", { alias: model.alias });
     await loadModels();
-  }, model.alias + " is now the default image Model.");
+  }, model.alias + " is now the default " + model.modality + " Model.");
 
   const remove = el("button", { type: "button", className: "danger", textContent: "Remove Model" });
   remove.onclick = () => {
@@ -24423,9 +25411,9 @@ function modelCard(model) {
 
   return el("div", { className: "card" },
     el("div", { className: "card-head" }, el("h3", { textContent: model.alias }),
-      model.default ? el("span", { className: "chip accent", textContent: "Default" }) : makeDefault),
+      model.default ? el("span", { className: "chip accent", textContent: "Default " + model.modality }) : makeDefault),
     el("div", { className: "fields" },
-      field("Alias", alias), field("Provider", provider), field("Model id", modelId), field("Protocol", protocol), notes.wrapper),
+      field("Alias", alias), field("Provider", provider), field("Model id", modelId), field("Protocol", protocol), field("Makes", modality), notes.wrapper),
     el("div", { className: "actions" }, save, el("span", { className: "spacer" }), remove),
   );
 }
@@ -24447,6 +25435,9 @@ function setUpAddModelForm() {
   const fetchButton = document.getElementById("fetch-models");
   const fetchResult = document.getElementById("fetch-result");
   const ids = document.getElementById("model-ids");
+  const modality = document.getElementById("model-modality");
+  // What the fetched model list says each model id makes, when the Provider says.
+  let knownModalities = {};
   protocol.replaceChildren(...options(protocols));
 
   // Suggest the Protocol a preset Provider's Models usually speak; the User can still change it.
@@ -24454,16 +25445,21 @@ function setUpAddModelForm() {
     const suggested = presets.find((p) => p.id === provider.value);
     if (suggested && protocols.includes(suggested.protocol)) protocol.value = suggested.protocol;
     ids.replaceChildren();
+    knownModalities = {};
     fetchResult.textContent = "";
   };
-  protocol.onchange = () => ids.replaceChildren();
+  protocol.onchange = () => {
+    ids.replaceChildren();
+    knownModalities = {};
+  };
 
   fetchButton.onclick = () => act(fetchButton, async () => {
     fetchResult.textContent = "Fetching…";
     fetchResult.className = "result";
     const outcome = await api("POST", "/api/providers/" + encodeURIComponent(provider.value) + "/model-ids", { protocol: protocol.value });
     if (outcome.result === "success") {
-      ids.replaceChildren(...outcome.modelIds.map((id) => el("option", { value: id })));
+      knownModalities = outcome.modalities || {};
+      ids.replaceChildren(...outcome.modelIds.map((id) => el("option", { value: id, label: knownModalities[id] ? id + " (" + knownModalities[id] + ")" : id })));
       fetchResult.textContent = outcome.modelIds.length + " model id(s) found. Pick one in the Model id field, or type your own.";
       fetchResult.className = "result success";
       modelId.focus();
@@ -24477,13 +25473,15 @@ function setUpAddModelForm() {
   let aliasEdited = false;
   alias.oninput = () => (aliasEdited = alias.value !== "");
   modelId.oninput = () => {
+    const known = knownModalities[modelId.value.trim()];
+    if (known) modality.value = known;
     if (!aliasEdited) alias.value = modelId.value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, 64);
   };
 
   const form = document.getElementById("add-model");
   form.onsubmit = (event) => {
     event.preventDefault();
-    const body = { alias: alias.value, provider: provider.value, modelId: modelId.value, protocol: protocol.value };
+    const body = { alias: alias.value, provider: provider.value, modelId: modelId.value, protocol: protocol.value, modality: modality.value };
     if (notes.value.trim() !== "") body.notes = notes.value;
     act(form.querySelector("button[type=submit]"), async () => {
       await api("POST", "/api/models", body);
@@ -24524,61 +25522,147 @@ function setUpAddForm() {
   };
 }
 
-/** An image of a Job, or a placeholder once the file is gone. */
-function thumbnail(file) {
-  const img = el("img", { className: "thumb", src: file.thumbnail + "?token=" + encodeURIComponent(token), alt: file.path, title: file.path, loading: "lazy" });
-  img.onerror = () => img.replaceWith(el("div", { className: "thumb placeholder", title: file.path, textContent: "Image no longer on disk" }));
-  return img;
+/** An image or video of a Job, or a placeholder once the file is gone. */
+function thumbnail(job, file) {
+  const src = file.thumbnail + "?token=" + encodeURIComponent(token);
+  const media = job.modality === "video"
+    ? el("video", { className: "thumb video", src, title: file.path, controls: true, muted: true, preload: "metadata" })
+    : el("img", { className: "thumb", src, alt: file.path, title: file.path, loading: "lazy" });
+  media.onerror = () => media.replaceWith(el("div", { className: "thumb placeholder", title: file.path, textContent: "File no longer on disk" }));
+  return media;
 }
 
 function formatDuration(ms) {
   return ms < 1000 ? ms + " ms" : (ms / 1000).toFixed(1) + " s";
 }
 
-/** The current Rating, and a one-line reason with Good and Bad buttons to rate the Job. Only completed Jobs can be rated. */
+function ratingText(rating) {
+  return (rating.verdict === "good" ? "Good" : "Bad") + ": " + rating.reason;
+}
+
+/** Whether this Job is its Comparison's Pick: as a whole, or with \`result\` that one result of it. */
+function isPicked(job, result) {
+  const pick = job.comparison && job.comparison.pick;
+  return !!pick && pick.jobId === job.id && (result === undefined || pick.result === result);
+}
+
+/**
+ * A thumbnail, captioned with its number, its own Rating and whether it is its Comparison's Pick, when the Job has
+ * several results or this one is rated or picked.
+ */
+function resultThumbnail(job, file, index) {
+  const media = thumbnail(job, file);
+  const picked = job.files.length > 1 && isPicked(job, index + 1);
+  if (job.files.length === 1 && !file.rating) return media;
+  const caption = el("figcaption", { textContent: "Result " + (index + 1) + (picked ? " · Picked" : "") + (file.rating ? " · " + ratingText(file.rating) : "") });
+  if (file.rating) caption.className = "rating " + file.rating.verdict;
+  else if (picked) caption.className = "picked";
+  return el("figure", { className: "result-thumb" }, media, caption);
+}
+
+/**
+ * For a completed Job of a Comparison: a Pick button for the Job or, when it has several results, the one selected.
+ * A Pick says which of the Comparison's results the User prefers; it is not a Rating.
+ */
+function pickRow(job) {
+  if (!job.comparison || job.outcome !== "completed") return [];
+  const target = el("select", { className: "rate-target", title: "What you pick" },
+    el("option", { value: "", textContent: "Whole Job" }),
+    ...job.files.map((_, index) => el("option", { value: String(index + 1), textContent: "Result " + (index + 1) })));
+  const button = el("button", { type: "button", textContent: "Pick" });
+  button.onclick = () => act(button, async () => {
+    const body = { jobId: job.id };
+    if (target.value !== "") body.result = Number(target.value);
+    await api("POST", "/api/comparisons/" + encodeURIComponent(job.comparison.id) + "/pick", body);
+    await loadJobs();
+  }, "Pick saved.");
+  const controls = job.files.length > 1 ? [target, button] : [button];
+  return [el("div", { className: "actions" }, el("span", { className: "spacer muted", textContent: "Prefer this one?" }), ...controls)];
+}
+
+/**
+ * The whole Job's Rating, and a one-line reason with Good and Bad buttons to rate the Job or, when it has several
+ * results, one of them. Only completed Jobs can be rated.
+ */
 function ratingRow(job) {
   if (job.outcome !== "completed") return [];
+  const whole = job.files.length > 1 ? "Whole Job · " : "";
   const current = job.rating
-    ? el("span", { className: "rating " + job.rating.verdict, textContent: (job.rating.verdict === "good" ? "Good" : "Bad") + ": " + job.rating.reason })
-    : el("span", { className: "rating muted", textContent: "Not rated yet." });
+    ? el("span", { className: "rating " + job.rating.verdict, textContent: whole + ratingText(job.rating) })
+    : el("span", { className: "rating muted", textContent: whole + "Not rated yet." });
   const reason = el("input", { maxLength: reasonMax, placeholder: "One-line reason, e.g. the text is misspelled" });
+  const target = el("select", { className: "rate-target", title: "What the Rating is about" },
+    el("option", { value: "", textContent: "Whole Job" }),
+    ...job.files.map((_, index) => el("option", { value: String(index + 1), textContent: "Result " + (index + 1) })));
   const rateAs = (verdict, label) => {
     const button = el("button", { type: "button", textContent: label });
     button.onclick = () => act(button, async () => {
-      await api("POST", "/api/jobs/" + encodeURIComponent(job.id) + "/rating", { verdict, reason: reason.value });
+      const body = { verdict, reason: reason.value };
+      if (target.value !== "") body.result = Number(target.value);
+      await api("POST", "/api/jobs/" + encodeURIComponent(job.id) + "/rating", body);
       await loadJobs();
     }, "Rating saved.");
     return button;
   };
-  return [el("div", { className: "actions rate" }, current, el("div", { className: "inline" }, reason, rateAs("good", "Good"), rateAs("bad", "Bad")))];
+  const controls = job.files.length > 1 ? [target, reason] : [reason];
+  return [el("div", { className: "actions rate" }, current, el("div", { className: "inline" }, ...controls, rateAs("good", "Good"), rateAs("bad", "Bad")))];
 }
 
 function jobCard(job) {
   const when = new Date(job.createdAt).toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" });
   const outcome = job.outcome === "completed"
-    ? job.files.length + " image(s)"
+    ? (job.modality === "video" ? "Video" : job.files.length + " image(s)")
     : job.outcome === "running" ? "Running…" : "Failed";
   const details = [];
   if (job.error) details.push(el("p", { className: "result failure", textContent: job.error }));
   if (job.shortfall) details.push(el("p", { className: "result unsupported", textContent: job.shortfall }));
+  if (job.mismatch) details.push(el("p", { className: "result unsupported", textContent: job.mismatch }));
   return el("div", { className: "card" },
     el("div", {},
       el("div", { className: "card-head" }, el("h3", { textContent: job.model }),
+        ...(isPicked(job) ? [el("span", { className: "chip accent", textContent: "Picked" })] : []),
         el("span", { className: "chip " + (job.outcome === "completed" ? "ok" : job.outcome), textContent: outcome })),
       el("p", { className: "job-meta", textContent: job.modelId + " on " + job.provider + " · " + when + " · " + formatDuration(job.durationMs) })),
     el("p", { className: "prompt", textContent: job.prompt }),
-    ...(job.files.length === 0 ? [] : [el("div", { className: "thumbs" }, ...job.files.map(thumbnail))]),
+    ...(job.files.length === 0 ? [] : [el("div", { className: "thumbs" }, ...job.files.map((file, index) => resultThumbnail(job, file, index)))]),
     ...details,
     ...ratingRow(job),
+    ...pickRow(job),
   );
 }
 
+/** A Comparison's Jobs together, under what the User picked among them. */
+function comparisonCard(jobs) {
+  const pick = jobs[0].comparison.pick;
+  const picked = pick && jobs.find((job) => job.id === pick.jobId);
+  const status = !pick ? "Not picked yet."
+    : "Picked: " + (pick.result === undefined ? "" : "result " + pick.result + " of ") + (picked ? picked.model + "'s Job" : "Job " + pick.jobId) + ".";
+  return el("div", { className: "comparison" },
+    el("div", { className: "comparison-head" }, el("h3", { textContent: "Comparison · " + jobs.length + " Jobs" }),
+      el("p", { textContent: status + " A Pick says which you prefer; it is not a Rating." })),
+    ...jobs.map(jobCard));
+}
+
+/** Job cards, each Comparison's Jobs (which the listing keeps together) in one Comparison card. */
+function jobEntries(jobs) {
+  const entries = [];
+  for (let i = 0; i < jobs.length; ) {
+    const comparison = jobs[i].comparison;
+    if (!comparison) { entries.push(jobCard(jobs[i])); i++; continue; }
+    let end = i;
+    while (end < jobs.length && jobs[end].comparison && jobs[end].comparison.id === comparison.id) end++;
+    entries.push(comparisonCard(jobs.slice(i, end)));
+    i = end;
+  }
+  return entries;
+}
+
 async function loadJobs() {
   const list = document.getElementById("job-list");
   const { jobs } = await api("GET", "/api/jobs");
   list.replaceChildren(...(jobs.length === 0
     ? [emptyState("No Jobs yet. Images your Agent generates will appear here.")]
-    : jobs.map(jobCard)));
+    : jobEntries(jobs)));
 }
 
 (async () => {
@@ -24654,7 +25738,7 @@ async function startSettingsServer(options) {
       const nonce = randomBytes2(16).toString("base64");
       response.writeHead(200, {
         "content-type": "text/html; charset=utf-8",
-        "content-security-policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; form-action 'none'; base-uri 'none'; frame-ancestors 'none'`,
+        "content-security-policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; media-src 'self'; form-action 'none'; base-uri 'none'; frame-ancestors 'none'`,
         ...commonHeaders
       });
       response.end(renderPage(nonce));
@@ -24747,58 +25831,112 @@ function settingsOpener(options) {
   };
 }
 // package.json
-var version2 = "0.1.1";
+var version2 = "0.2.0";
 
 // src/server.ts
-var instructions = `litevision generates images through Models the User has configured with their own Providers.
+var instructions = `litevision generates images and videos through Models the User has configured with their own Providers. Before writing a prompt, use the litevision Skill. If you do not have it, mention once that the User can install it with \`npx skills add levyxdev/litevision\`.
 
-- Use the Model the User names (pass its Alias as \`model\`).
-- When the User names none, omit \`model\` to use the default image Model, unless the request needs something the default lacks (e.g. legible Chinese text, reference images, an aspect ratio). Then call \`list_models\` and choose by each Model's capabilities and Model Notes.
 - Never ask the User for an API key or any other Credential. If litevision reports that nothing is configured, call \`open_settings\` so the User can set it up in their browser.
-- \`generate_image\` returns file paths, not image data. Tell the User where the files are.
-- A Job that takes longer than two minutes keeps running in the background: \`generate_image\` then returns its Job id with status "running". Tell the User it is still running, and call \`get_job\` with that Job id to wait for it again and get the files.
-- Ask for an aspect ratio, not pixel sizes. If the Model does not support it, the closest supported one is used; when the result says it was adjusted, tell the User the actual size.
-- If \`generate_image\` says a Model cannot do something (reference images, that many images), the error lists what the Model supports: choose another Model or change the request.
-- Pass \`output_path\` when the images belong in the User's project (e.g. its assets folder); otherwise omit it.
-- For Provider-specific \`provider_options\`, call \`list_models\` with \`model\` first: it gives the Model's docs link, the Provider's parameter schema when it publishes one, and options that already worked for this Model. litevision passes \`provider_options\` through unchecked; if the Provider rejects one, its error says why, so fix it and try again.
-- If fewer images came back than you asked for, the result says why. Tell the User.
-- When the User says what they think of a result ("this one's great", "the text is wrong"), call \`rate_job\` with that Job's id, their verdict (good or bad) and a one-line reason in their words. Call it only when the User actually states a verdict; never invent one, and never rate a result yourself.
-- Model Notes say what each Model is good or bad at. When the User learns something worth keeping, you may propose new Model Notes: short, replacing the old text whole rather than adding to it. Before calling \`update_model_notes\`, show the User the old and new Model Notes and get their agreement; never change them without it.`;
+- Use the Model the User names. When they name none, omit \`model\` for the default, unless the request needs something the default lacks; then choose with \`list_models\`.
+- For \`provider_options\`, reuse the Model's Known-good Options. For any other option, or one marked suspect, read the Model's docs and parameter schema first (\`list_models\` with \`model\`).
+- If the Provider rejects an option (the error says it "rejected an option"), fix it from the Provider's message and the docs and try again, at most twice. If it is still rejected, stop and tell the User what the Provider said.
+- Tell the User where the files are, and pass on whatever a result says was adjusted, did not match the request, or came back short.
+- \`generate_comparison\` costs as much as all its Jobs. Start a Comparison only when the User asks for one or agrees to it.
+- When the User says what they think of a result, call \`rate_job\` with their verdict and a one-line reason in their words; when it is about one result of a Job with several, pass \`result\`. Never invent a verdict, and never rate a result yourself.
+- When the User chooses among a Comparison's results, call \`pick_result\`, only when the User actually chooses. A Pick is not a Rating: if they also give a verdict, call \`rate_job\` too.
+- Before calling \`update_model_notes\`, show the User the old and new Model Notes and get their agreement; never change them without it.`;
+var recentRatingsShown = 5;
+var recentPicksShown = 5;
+var promptStartLength = 80;
 var listedModelSchema = object({
   alias: string2(),
   provider: string2(),
   protocol: string2(),
   model_id: string2().describe("The Provider's own name for the model."),
-  default: boolean2(),
+  modality: _enum(modalities).describe("What the Model generates: images with `generate_image`, videos with `generate_video`."),
+  default: boolean2().describe("True for the default Model of its Modality."),
   notes: string2().describe("Model Notes: what the Model is good or bad at, agreed with the User."),
   capabilities: object({
     aspect_ratios: array(object({ aspect_ratio: _enum(aspectRatios), size: string2() })),
     reference_images: boolean2(),
     max_reference_images: number2(),
     max_images_per_job: number2()
-  }).nullable().describe("Null when the Model cannot be used; `problem` then says why."),
+  }).nullable().describe("An image Model's capabilities; null for a video Model, or when the Model cannot be used (`problem` then says why)."),
+  video_capabilities: object({
+    resolutions: array(object({
+      resolution: string2().nullable().describe("The tier's name to pass as `resolution`; null when the Model takes none."),
+      aspect_ratios: array(object({ aspect_ratio: _enum(aspectRatios), size: string2() }))
+    })),
+    durations: array(number2()).describe("Every clip length in seconds the Model can make."),
+    default_duration: number2(),
+    first_frame: boolean2(),
+    last_frame: boolean2(),
+    max_reference_images: number2()
+  }).optional().describe("A video Model's capabilities; the first resolution is the default."),
   docs_url: string2().nullable().describe("Where to read which `provider_options` this Model accepts."),
+  known_good_options: record(string2(), unknown()).optional().describe("Known-good Options: `provider_options` whose results matched the request and that the User has not rated bad. Reuse them."),
+  suspect_options: record(string2(), object({ value: unknown(), reason: string2(), job_id: string2(), cause: _enum(["rating", "mismatch"]) })).optional().describe('`provider_options` last used by a Job the User rated bad (cause "rating", with the User\'s reason) or whose result did not match the request (cause "mismatch"). Check the docs before sending them again.'),
   problem: string2().optional(),
-  parameter_schema: unknown().optional().describe("Only with `model`: the Provider's own description of the Model's parameters, when it publishes one."),
-  known_good_options: record(string2(), unknown()).optional().describe("Only with `model`: `provider_options` that completed Jobs on this Model have sent, with the latest value of each.")
-});
-async function listedModel(deps, config, model, isDefault, detailed) {
+  recent_ratings: array(object({
+    job_id: string2(),
+    result: number2().optional().describe("Which result of the Job, from 1; absent when the Rating is about the whole Job."),
+    verdict: _enum(verdicts),
+    reason: string2().describe("The User's reason, in their words."),
+    rated_at: string2(),
+    prompt: string2().describe("The start of the Job's prompt.")
+  })).optional().describe(`Only with \`model\`: the Model's ${recentRatingsShown} most recent Ratings, newest first. When they say something the Model Notes do not, propose new Model Notes to the User.`),
+  recent_picks: array(object({
+    comparison_id: string2(),
+    job_id: string2().describe("This Model's Job in the Comparison."),
+    picked: boolean2().describe("Whether the User picked this Model's Job."),
+    result: number2().optional().describe("When picked: which result of the Job the User picked, from 1; absent when they picked the whole Job."),
+    picked_model: string2().optional().describe("Alias of the Model whose Job the User picked."),
+    picked_at: string2(),
+    prompt: string2().describe("The start of this Model's Job's prompt.")
+  })).optional().describe(`Only with \`model\`: the current Picks of up to ${recentPicksShown} Comparisons this Model took part in, most recently picked first, one entry per Job of this Model in them. A Pick is a relative preference among the Comparison's results, not a Rating.`),
+  parameter_schema: unknown().optional().describe("Only with `model`: the Provider's own description of the Model's parameters, when it publishes one.")
+});
+async function listedModel(deps, config, model, isDefault, detailed, ratedJobs) {
   const base = {
     alias: model.alias,
     provider: model.provider,
     protocol: model.protocol,
     model_id: model.modelId,
+    modality: model.modality,
     default: isDefault,
     notes: model.notes ?? ""
   };
-  const heading = `${model.alias}${isDefault ? " (default)" : ""}: ${model.modelId} on ${model.provider} via ${model.protocol}.`;
+  const heading = `${model.alias}${isDefault ? ` (default ${model.modality})` : ""}: ${model.modality} Model ${model.modelId} on ${model.provider} via ${model.protocol}.`;
   const notes = model.notes ? ` Notes: ${model.notes}` : "";
-  let info;
+  let described;
   try {
     const provider = config.providers.find((candidate) => candidate.id === model.provider);
     if (provider === undefined)
       throw needsSettings(`Model "${model.alias}" refers to Provider "${model.provider}", which is not configured.`);
-    info = await modelInfo(deps, { model, provider });
+    if (model.modality === "video") {
+      const info = videoModelInfo({ model, provider });
+      described = {
+        output: { capabilities: null, video_capabilities: videoCapabilitiesOutput(info.capabilities) },
+        summary: describeVideoCapabilities(info.capabilities),
+        docsUrl: info.docsUrl
+      };
+    } else {
+      const info = await modelInfo(deps, { model, provider });
+      const { capabilities } = info;
+      described = {
+        output: {
+          capabilities: {
+            aspect_ratios: capabilities.sizes.map((size) => ({ aspect_ratio: size.aspectRatio, size: formatSize(size) })),
+            reference_images: capabilities.maxReferences > 0,
+            max_reference_images: capabilities.maxReferences,
+            max_images_per_job: capabilities.maxImages
+          }
+        },
+        summary: describeCapabilities(capabilities),
+        docsUrl: info.docsUrl,
+        ...info.parameterSchema === undefined ? {} : { parameterSchema: info.parameterSchema }
+      };
+    }
   } catch (error) {
     if (!(error instanceof ConfigError))
       throw error;
@@ -24807,31 +25945,156 @@ async function listedModel(deps, config, model, isDefault, detailed) {
       text: `${heading} Cannot be used: ${error.message}${notes}`
     };
   }
-  const { capabilities } = info;
+  const record2 = optionsOf(ratedJobs, model);
   const output = {
     ...base,
-    capabilities: {
-      aspect_ratios: capabilities.sizes.map((size) => ({ aspect_ratio: size.aspectRatio, size: formatSize(size) })),
-      reference_images: capabilities.maxReferences > 0,
-      max_reference_images: capabilities.maxReferences,
-      max_images_per_job: capabilities.maxImages
-    },
-    docs_url: info.docsUrl
+    capabilities: null,
+    ...described.output,
+    docs_url: described.docsUrl,
+    known_good_options: record2.knownGood,
+    suspect_options: suspectOutput(record2)
   };
-  let text = `${heading} Supports ${describeCapabilities(capabilities)}${notes} provider_options: ${info.docsUrl}`;
+  let text = `${heading} Supports ${described.summary}${notes} provider_options docs: ${described.docsUrl}`;
+  const goodKeys = Object.keys(record2.knownGood);
+  const suspectKeys = Object.keys(record2.suspect);
   if (detailed) {
-    const knownGood = knownGoodOptions(await readJobs(deps.dirs), { provider: model.provider, protocol: model.protocol, modelId: model.modelId });
-    output.known_good_options = knownGood;
     text += `
-Known-good provider_options: ${Object.keys(knownGood).length === 0 ? "none recorded yet" : JSON.stringify(knownGood)}`;
-    if (info.parameterSchema !== undefined) {
-      output.parameter_schema = info.parameterSchema;
+Known-good Options: ${goodKeys.length === 0 ? "none recorded yet" : JSON.stringify(record2.knownGood)}`;
+    for (const [key, suspect] of Object.entries(record2.suspect)) {
+      text += `
+Suspect: ${key}=${JSON.stringify(suspect.value)}, used by Job ${suspect.jobId}, ${suspectWhy(suspect)}`;
+    }
+    const ratings = recentRatings(ratedJobs, model, recentRatingsShown);
+    output.recent_ratings = ratings.map(recentRatingOutput);
+    text += ratings.length === 0 ? `
+Recent Ratings: none recorded yet.` : `
+Recent Ratings, newest first:`;
+    for (const rated of ratings)
+      text += `
+- ${describeRecentRating(rated)}`;
+    const picks = recentPicks(ratedJobs, model, recentPicksShown);
+    output.recent_picks = picks.map(recentPickOutput);
+    text += picks.length === 0 ? `
+Recent Picks: none recorded yet.` : `
+Recent Picks in Comparisons, newest first:`;
+    for (const picked of picks)
       text += `
-Parameter schema from the Provider: ${JSON.stringify(info.parameterSchema)}`;
+- ${describeRecentPick(picked)}`;
+    if (described.parameterSchema !== undefined) {
+      output.parameter_schema = described.parameterSchema;
+      text += `
+Parameter schema from the Provider: ${JSON.stringify(described.parameterSchema)}`;
     }
+  } else {
+    if (goodKeys.length > 0)
+      text += ` Known-good Options: ${goodKeys.join(", ")}.`;
+    if (suspectKeys.length > 0)
+      text += ` Suspect options: ${suspectKeys.join(", ")}.`;
   }
   return { output, text };
 }
+function ratingOutput(rating) {
+  return {
+    job_id: rating.jobId,
+    ...rating.result === undefined ? {} : { result: rating.result },
+    verdict: rating.verdict,
+    reason: rating.reason,
+    rated_at: rating.ratedAt
+  };
+}
+function ratingSubject(rating) {
+  return rating.result === undefined ? `Job ${rating.jobId}` : `result ${rating.result} of Job ${rating.jobId}`;
+}
+function recentRatingOutput({ rating, job }) {
+  return { ...ratingOutput(rating), prompt: promptStart(job.prompt) };
+}
+function describeRecentRating({ rating, job }) {
+  return `${rating.verdict} on ${ratingSubject(rating)} (${JSON.stringify(promptStart(job.prompt))}): ${rating.reason}`;
+}
+function pickOutput(pick) {
+  return {
+    comparison_id: pick.comparison,
+    job_id: pick.jobId,
+    ...pick.result === undefined ? {} : { result: pick.result },
+    picked_at: pick.pickedAt
+  };
+}
+function recentPickOutput({ pick, job, picked }) {
+  const isPicked = pick.jobId === job.id;
+  return {
+    comparison_id: pick.comparison,
+    job_id: job.id,
+    picked: isPicked,
+    ...isPicked && pick.result !== undefined ? { result: pick.result } : {},
+    ...picked === undefined ? {} : { picked_model: picked.model },
+    picked_at: pick.pickedAt,
+    prompt: promptStart(job.prompt)
+  };
+}
+function describeRecentPick({ pick, job, picked }) {
+  const subject = `Job ${job.id} in Comparison ${pick.comparison} (${JSON.stringify(promptStart(job.prompt))})`;
+  if (pick.jobId === job.id)
+    return `${subject}: picked${pick.result === undefined ? "" : `, result ${pick.result}`}`;
+  return `${subject}: not picked; the User picked ${picked === undefined ? `Job ${pick.jobId}` : `a Job on ${picked.model}`}`;
+}
+function promptStart(prompt) {
+  const line = prompt.replace(/\s+/g, " ").trim();
+  return line.length <= promptStartLength ? line : `${line.slice(0, promptStartLength).trimEnd()}…`;
+}
+function videoCapabilitiesOutput(capabilities) {
+  return {
+    resolutions: capabilities.resolutions.map((tier) => ({
+      resolution: tier.name ?? null,
+      aspect_ratios: tier.sizes.map((size) => ({ aspect_ratio: size.aspectRatio, size: formatSize(size) }))
+    })),
+    durations: capabilities.durations,
+    default_duration: capabilities.defaultDuration,
+    first_frame: capabilities.firstFrame,
+    last_frame: capabilities.lastFrame,
+    max_reference_images: capabilities.maxReferences
+  };
+}
+function suspectOutput(record2) {
+  return Object.fromEntries(Object.entries(record2.suspect).map(([key, suspect]) => [
+    key,
+    { value: suspect.value, reason: suspect.reason, job_id: suspect.jobId, cause: suspect.cause }
+  ]));
+}
+async function modelOptions(deps, model) {
+  return optionsOf(await readRatedJobs(deps.dirs), model);
+}
+function optionsOf(ratedJobs, model) {
+  return optionsRecord(ratedJobs, { provider: model.provider, protocol: model.protocol, modelId: model.modelId });
+}
+async function jobDocs(dirs, jobId) {
+  const job = await readJob(dirs, jobId);
+  const docsUrl = job === undefined ? undefined : adapterForProtocol(job.protocol)?.docsUrl(job.modelId, job.modality ?? "image");
+  if (job === undefined || docsUrl === undefined)
+    return;
+  return { docsUrl, options: optionsRecord(await readRatedJobs(dirs), job) };
+}
+function suspectWhy(suspect) {
+  return suspect.cause === "rating" ? `which the User rated bad: "${suspect.reason}"` : `whose result did not match the request: ${suspect.reason}`;
+}
+function optionsHint(docsUrl, record2) {
+  const good = Object.keys(record2.knownGood).length === 0 ? "none recorded yet" : JSON.stringify(record2.knownGood);
+  const suspect = Object.entries(record2.suspect).map(([key, entry]) => ` Suspect: ${key}=${JSON.stringify(entry.value)}, used by a Job ${suspectWhy(entry)}.`).join("");
+  return ` Docs for this Model's provider_options: ${docsUrl}. Known-good Options: ${good}.${suspect}`;
+}
+var observedSchema = array(object({ width: number2(), height: number2(), seconds: number2().optional() }).nullable()).describe("What each saved file turned out to be, in the order of `files`, read from the file itself; null where litevision could not tell.");
+var mismatchSchema = string2().optional().describe("Present when the result's shape or length differs from the request: an option may not have taken effect. Tell the User.");
+function observedText(observed) {
+  const known = [...new Set(observed.flatMap((facts) => facts === null ? [] : [describeFacts(facts)]))];
+  return known.length === 0 ? "" : ` Got ${known.join(", ")}.`;
+}
+function describeFacts(facts) {
+  return `${facts.width}x${facts.height}${facts.seconds === undefined ? "" : `, ${facts.seconds} s`}`;
+}
+function mismatchText(mismatch, docsUrl) {
+  if (mismatch === undefined)
+    return "";
+  return ` The result does not match the request: ${mismatch}. A provider_option may not have taken effect, so these options are not recorded as Known-good; check ${docsUrl} before trying again.`;
+}
 var jobStatusSchema = _enum(["completed", "running"]).describe('"running" when the Job outlasted the wait limit and continues in the background; call `get_job` with its `job_id`.');
 function jobOutput(job) {
   return {
@@ -24839,7 +26102,9 @@ function jobOutput(job) {
     status: job.status,
     model: job.model,
     files: job.status === "completed" ? job.files : [],
-    ...job.status === "completed" && job.shortfall !== undefined ? { shortfall: job.shortfall } : {}
+    observed: job.status === "completed" ? job.observed : [],
+    ...job.status === "completed" && job.shortfall !== undefined ? { shortfall: job.shortfall } : {},
+    ...job.status === "completed" && job.mismatch !== undefined ? { mismatch: job.mismatch } : {}
   };
 }
 function jobText(job) {
@@ -24848,12 +26113,153 @@ function jobText(job) {
 function toolError(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
+async function failure2(error, hint) {
+  const reason = await failureReason(error, hint);
+  return toolError(error instanceof JobFailedError ? `Job ${error.jobId} failed: ${reason}` : reason);
+}
+async function failureReason(error, hint) {
+  if (error instanceof ConfigError)
+    return error.message;
+  if (error instanceof JobFailedError) {
+    const helpful = hint !== undefined && (error.kind === "unsupported" || error.kind === "rejected_option" || error.kind === "other");
+    return `${error.message}${helpful ? await hint() : ""}`;
+  }
+  throw error;
+}
+var imageJobShape = {
+  job_id: string2(),
+  status: jobStatusSchema,
+  model: string2().describe("Alias of the Model that ran the Job."),
+  files: array(string2()).describe("Paths of the saved images; empty while the Job is running."),
+  aspect_ratio: _enum(aspectRatios).describe("Aspect ratio actually used."),
+  size: string2().describe("Size actually requested from the Provider, e.g. 1536x1024."),
+  requested_aspect_ratio: _enum(aspectRatios),
+  aspect_ratio_adjusted: boolean2().describe("True when the Model does not support the requested aspect ratio and the closest one was used."),
+  shortfall: string2().optional().describe("Present when fewer images than `n` were saved: how many, and why."),
+  observed: observedSchema,
+  mismatch: mismatchSchema
+};
+var videoJobShape = {
+  job_id: string2(),
+  status: jobStatusSchema,
+  model: string2().describe("Alias of the Model that ran the Job."),
+  files: array(string2()).describe("Path of the saved video; empty while the Job is running."),
+  aspect_ratio: _enum(aspectRatios).describe("Aspect ratio actually used."),
+  size: string2().describe("Size the request implies, e.g. 1280x720."),
+  resolution: string2().nullable().describe("Resolution tier actually requested; null when the Model takes none."),
+  duration: number2().describe("Length in seconds actually requested."),
+  requested_aspect_ratio: _enum(aspectRatios),
+  aspect_ratio_adjusted: boolean2(),
+  duration_adjusted: boolean2().describe("True when the Model cannot make the requested length and the closest one was used."),
+  observed: observedSchema,
+  mismatch: mismatchSchema
+};
+var failedJobSchema = object({
+  job_id: string2().nullable().describe("Null when the Job could not start."),
+  status: literal("failed"),
+  model: string2().describe("Alias of the Model the Job ran on."),
+  files: array(string2()).describe("Always empty."),
+  error: string2().describe("Why the Job failed.")
+});
+var maxComparisonVariants = 4;
+function comparisonModality(config, variants, wanted) {
+  const named = variants.flatMap((variant) => config.models.filter((model) => model.alias === variant.model));
+  const found = new Set([...wanted === undefined ? [] : [wanted], ...named.map((model) => model.modality)]);
+  if (found.size > 1) {
+    const makes = [...new Map(named.map((model) => [model.alias, `${model.alias} makes ${model.modality}s`])).values()].join(", ");
+    const asked = wanted === undefined ? "" : ` and \`modality\` is ${wanted}`;
+    throw new ConfigError(`A Comparison's Models must share one Modality, but ${makes}${asked}. Compare image Models or video Models, not both.`);
+  }
+  return [...found][0] ?? "image";
+}
 function createServer2(deps) {
   const server = new McpServer({ name: "litevision", version: version2 }, { instructions });
   const now = deps.now ?? (() => new Date);
   const cwd = deps.cwd ?? process.cwd();
   const infoDeps = { dirs: deps.dirs, http: deps.http, now };
-  const jobs = new JobRunner({ dirs: deps.dirs, http: deps.http, now, waitLimitMs: deps.waitLimitMs, pollIntervalMs: deps.pollIntervalMs });
+  const jobs = new JobRunner({ dirs: deps.dirs, http: deps.http, now, waitLimitMs: deps.waitLimitMs, pollIntervalMs: deps.pollIntervalMs, retryDelayMs: deps.retryDelayMs });
+  const prepareImage = async (resolved, args) => {
+    const { model } = resolved;
+    const adapter = adapterFor(model);
+    const credential = await requireCredential(deps.dirs, resolved.provider);
+    const info = await modelInfo(infoDeps, resolved);
+    const normalised = await normaliseImageRequest({ prompt: args.prompt, n: args.n, aspectRatio: args.aspect_ratio, references: args.references, providerOptions: args.provider_options }, model, adapter, info, cwd);
+    const outputDir = args.output_path === undefined ? undefined : resolve2(cwd, args.output_path);
+    return {
+      model,
+      start: (comparison) => jobs.start({ ...resolved, adapter, credential, normalised, outputDir, ...comparison === undefined ? {} : { comparison } }),
+      hint: async () => optionsHint(info.docsUrl, await modelOptions(deps, model)),
+      report: (job) => {
+        const { size } = normalised.request;
+        const output = {
+          ...jobOutput(job),
+          aspect_ratio: size.aspectRatio,
+          size: formatSize(size),
+          requested_aspect_ratio: normalised.requestedAspectRatio,
+          aspect_ratio_adjusted: normalised.aspectRatioAdjusted
+        };
+        const adjustment = normalised.aspectRatioAdjusted ? ` ${model.alias} does not support ${normalised.requestedAspectRatio}, so the closest supported aspect ratio was used.` : "";
+        const text = job.status === "running" ? `${jobText(job)} It asks ${model.alias} for ${size.aspectRatio} (${formatSize(size)}).${adjustment}` : `Saved ${job.files.length} image(s) from ${model.alias} at ${size.aspectRatio} (${formatSize(size)}), Job ${job.id}.${adjustment}${observedText(job.observed)}${mismatchText(job.mismatch, info.docsUrl)}${job.shortfall === undefined ? "" : ` ${job.shortfall}`}
+${job.files.join(`
+`)}`;
+        return { output, text };
+      }
+    };
+  };
+  const prepareVideo = async (resolved, args) => {
+    const { model } = resolved;
+    const adapter = adapterFor(model);
+    const info = videoModelInfo(resolved);
+    const credential = await requireCredential(deps.dirs, resolved.provider);
+    const normalised = await normaliseVideoRequest({
+      prompt: args.prompt,
+      ...args.aspect_ratio === undefined ? {} : { aspectRatio: args.aspect_ratio },
+      ...args.duration === undefined ? {} : { duration: args.duration },
+      ...args.resolution === undefined ? {} : { resolution: args.resolution },
+      ...args.first_frame === undefined ? {} : { firstFrame: args.first_frame },
+      ...args.last_frame === undefined ? {} : { lastFrame: args.last_frame },
+      references: args.references,
+      providerOptions: args.provider_options
+    }, model, adapter, info.capabilities, cwd);
+    const outputDir = args.output_path === undefined ? undefined : resolve2(cwd, args.output_path);
+    return {
+      model,
+      start: (comparison) => jobs.startVideo({ ...resolved, adapter, credential, normalised, outputDir, ...comparison === undefined ? {} : { comparison } }),
+      hint: async () => optionsHint(info.docsUrl, await modelOptions(deps, model)),
+      report: (job) => {
+        const { size, seconds } = normalised.request;
+        const output = {
+          ...jobOutput(job),
+          aspect_ratio: size.aspectRatio,
+          size: formatSize(size),
+          resolution: normalised.request.resolution ?? null,
+          duration: seconds,
+          requested_aspect_ratio: normalised.requestedAspectRatio,
+          aspect_ratio_adjusted: normalised.aspectRatioAdjusted,
+          duration_adjusted: normalised.durationAdjusted
+        };
+        const asked = `${seconds} s at ${size.aspectRatio}${normalised.request.resolution === undefined ? "" : ` ${normalised.request.resolution}`} (${formatSize(size)})`;
+        const adjustments = [
+          normalised.aspectRatioAdjusted ? `${model.alias} does not support ${normalised.requestedAspectRatio}, so the closest supported aspect ratio was used.` : "",
+          normalised.durationAdjusted ? `${model.alias} cannot make ${normalised.requestedDuration} s, so the closest length it can was used.` : ""
+        ].filter(Boolean).map((sentence) => ` ${sentence}`).join("");
+        const text = job.status === "running" ? `${jobText(job)} It asks ${model.alias} for ${asked}.${adjustments}` : `Saved a video from ${model.alias}, ${asked}, Job ${job.id}.${adjustments}${observedText(job.observed)}${mismatchText(job.mismatch, info.docsUrl)}
+${job.files.join(`
+`)}`;
+        return { output, text };
+      }
+    };
+  };
+  const runSingle = async (prepare) => {
+    let prepared;
+    try {
+      prepared = await prepare();
+      const { output, text } = prepared.report(await prepared.start());
+      return { content: [{ type: "text", text }], structuredContent: output };
+    } catch (error) {
+      return failure2(error, prepared?.hint);
+    }
+  };
   server.registerTool("generate_image", {
     description: "Generate images from a text prompt with one of the User's configured Models. Saves the images locally and returns their file paths.",
     inputSchema: {
@@ -24865,94 +26271,137 @@ function createServer2(deps) {
       output_path: string2().min(1).optional().describe("Folder to save the images in, e.g. the project's assets folder; created if missing. Relative paths resolve against litevision's working directory. Omit to save under a dated folder in the User's home directory."),
       provider_options: record(string2(), unknown()).default({}).describe('Provider-specific request fields passed through untouched, e.g. { "quality": "high" } for OpenAI. Cannot override fields litevision sets from the other parameters.')
     },
+    outputSchema: imageJobShape
+  }, async ({ model: alias, ...args }) => runSingle(async () => prepareImage(resolveModel(await loadConfig(deps.dirs), alias), args)));
+  server.registerTool("generate_video", {
+    description: "Generate one video from a text prompt with one of the User's configured video Models, optionally from a first and last frame or reference images. Saves the video locally and returns its file path. Videos often take minutes: the Job then keeps running in the background.",
+    inputSchema: {
+      prompt: string2().min(1).describe("Sent to the Model verbatim. Describe motion and camera movement, not only the scene."),
+      model: string2().optional().describe("Alias of the video Model to use. Omit to use the default video Model."),
+      aspect_ratio: _enum(aspectRatios).optional().describe("Wanted aspect ratio. Omit for 16:9, or for the first frame's shape when `first_frame` is given. If the Model does not support it, the closest supported one is used and reported."),
+      duration: number2().int().positive().optional().describe("Wanted length in seconds. Omit for the Model's default. If the Model cannot make it, the closest length it can is used and reported."),
+      resolution: string2().min(1).optional().describe("A resolution tier the Model lists in `list_models`, e.g. 720P. Omit for the Model's default."),
+      first_frame: string2().min(1).optional().describe("Local path of an image the video starts from."),
+      last_frame: string2().min(1).optional().describe("Local path of an image the video ends on."),
+      references: array(string2().min(1)).default([]).describe("Local paths of reference images for characters, objects or style. Relative paths resolve against litevision's working directory."),
+      output_path: string2().min(1).optional().describe("Folder to save the video in; created if missing. Omit to save under a dated folder in the User's home directory."),
+      provider_options: record(string2(), unknown()).default({}).describe('Provider-specific request fields passed through untouched, e.g. { "generate_audio": true }. Reuse the Model\'s Known-good Options from `list_models`.')
+    },
+    outputSchema: videoJobShape
+  }, async ({ model: alias, ...args }) => runSingle(async () => prepareVideo(resolveModel(await loadConfig(deps.dirs), alias, "video"), args)));
+  server.registerTool("generate_comparison", {
+    description: `Start a Comparison: 2 to ${maxComparisonVariants} Jobs together for one request, differing in prompt, in Model, or both, so the User can choose among their results. All variants' Models must share one Modality. Start one only when the User asks for a Comparison or agrees to one: it costs as much as all its Jobs. Saves each Job's files locally and returns them under one Comparison id.`,
+    inputSchema: {
+      variants: array(object({
+        prompt: string2().min(1).describe("Sent to this variant's Model verbatim."),
+        model: string2().optional().describe("Alias of this variant's Model. Omit to use the default Model of the Comparison's Modality."),
+        n: number2().int().positive().optional().describe("Image Comparisons only: how many images this variant's Job makes, up to its Model's maximum. Defaults to 1.")
+      })).min(2).max(maxComparisonVariants).describe(`The Jobs to start, 2 to ${maxComparisonVariants}, one per variant.`),
+      modality: _enum(modalities).optional().describe("image or video. Omit to take it from the variants' Models; when no variant names one, image."),
+      aspect_ratio: _enum(aspectRatios).optional().describe("Wanted aspect ratio for every Job. Omit for 1:1 images or 16:9 videos. Each Model that does not support it uses its closest one."),
+      references: array(string2().min(1)).default([]).describe("Local paths of reference images every Job gets. Relative paths resolve against litevision's working directory."),
+      output_path: string2().min(1).optional().describe("Folder to save every Job's files in; created if missing. Omit to save under a dated folder in the User's home directory."),
+      duration: number2().int().positive().optional().describe("Video Comparisons only: wanted length in seconds. Omit for each Model's default.")
+    },
     outputSchema: {
-      job_id: string2(),
-      status: jobStatusSchema,
-      model: string2().describe("Alias of the Model that ran the Job."),
-      files: array(string2()).describe("Paths of the saved images; empty while the Job is running."),
-      aspect_ratio: _enum(aspectRatios).describe("Aspect ratio actually used."),
-      size: string2().describe("Size actually requested from the Provider, e.g. 1536x1024."),
-      requested_aspect_ratio: _enum(aspectRatios),
-      aspect_ratio_adjusted: boolean2().describe("True when the Model does not support the requested aspect ratio and the closest one was used."),
-      shortfall: string2().optional().describe("Present when fewer images than `n` were saved: how many, and why.")
-    }
-  }, async ({ prompt, model: alias, n, aspect_ratio, references, output_path, provider_options }) => {
+      comparison_id: string2(),
+      modality: _enum(modalities),
+      jobs: array(union([object(imageJobShape), object(videoJobShape), failedJobSchema])).describe('One per variant, in the order given: each as `generate_image` or `generate_video` returns it, or status "failed" with why. A "running" Job continues in the background; call `get_job` with its `job_id`.')
+    }
+  }, async ({ variants, modality: wanted, aspect_ratio, references, output_path, duration }) => {
+    let prepared;
+    let modality;
     try {
-      const resolved = resolveModel(await loadConfig(deps.dirs), alias);
-      const { model } = resolved;
-      const adapter = adapterFor(model);
-      const credential = await requireCredential(deps.dirs, resolved.provider);
-      const normalised = await normaliseImageRequest({ prompt, n, aspectRatio: aspect_ratio, references, providerOptions: provider_options }, model, adapter, await modelInfo(infoDeps, resolved), cwd);
-      const outputDir = output_path === undefined ? undefined : resolve2(cwd, output_path);
-      const job = await jobs.start({ ...resolved, adapter, credential, normalised, outputDir });
-      const { size } = normalised.request;
-      const output = {
-        ...jobOutput(job),
-        aspect_ratio: size.aspectRatio,
-        size: formatSize(size),
-        requested_aspect_ratio: normalised.requestedAspectRatio,
-        aspect_ratio_adjusted: normalised.aspectRatioAdjusted
-      };
-      const adjustment = normalised.aspectRatioAdjusted ? ` ${model.alias} does not support ${normalised.requestedAspectRatio}, so the closest supported aspect ratio was used.` : "";
-      const text = job.status === "running" ? `${jobText(job)} It asks ${model.alias} for ${size.aspectRatio} (${formatSize(size)}).${adjustment}` : `Saved ${job.files.length} image(s) from ${model.alias} at ${size.aspectRatio} (${formatSize(size)}), Job ${job.id}.${adjustment}${job.shortfall === undefined ? "" : ` ${job.shortfall}`}
-${job.files.join(`
-`)}`;
-      return { content: [{ type: "text", text }], structuredContent: output };
+      const config = await loadConfig(deps.dirs);
+      modality = comparisonModality(config, variants, wanted);
+      if (modality === "image" && duration !== undefined) {
+        throw new ConfigError("`duration` applies only to a video Comparison; leave it out for images.");
+      }
+      if (modality === "video" && variants.some((variant) => (variant.n ?? 1) > 1)) {
+        throw new ConfigError("A video Job makes one video, so leave `n` out of a video Comparison's variants.");
+      }
+      prepared = await Promise.all(variants.map((variant) => {
+        const resolved = resolveModel(config, variant.model, modality);
+        const shared = { prompt: variant.prompt, references, provider_options: {}, ...output_path === undefined ? {} : { output_path } };
+        return modality === "video" ? prepareVideo(resolved, { ...shared, ...aspect_ratio === undefined ? {} : { aspect_ratio }, ...duration === undefined ? {} : { duration } }) : prepareImage(resolved, { ...shared, n: variant.n ?? 1, aspect_ratio: aspect_ratio ?? "1:1" });
+      }));
     } catch (error) {
-      if (error instanceof ConfigError)
-        return toolError(error.message);
-      if (error instanceof JobFailedError)
-        return toolError(`Job ${error.jobId} failed: ${error.message}`);
-      throw error;
-    }
+      return failure2(error, undefined);
+    }
+    const comparisonId = randomUUID3();
+    const settled = await Promise.allSettled(prepared.map((job) => job.start(comparisonId)));
+    const results = await Promise.all(settled.map(async (outcome, index) => {
+      const job = prepared[index];
+      if (outcome.status === "fulfilled")
+        return job.report(outcome.value);
+      const reason = await failureReason(outcome.reason, job.hint).catch(() => `litevision could not run this Job: ${outcome.reason.message}`);
+      const jobId = outcome.reason instanceof JobFailedError ? outcome.reason.jobId : null;
+      return {
+        output: { job_id: jobId, status: "failed", model: job.model.alias, files: [], error: reason },
+        text: `Job${jobId === null ? "" : ` ${jobId}`} on ${job.model.alias} failed: ${reason}`
+      };
+    }));
+    const text = [
+      `Comparison ${comparisonId}: ${results.length} ${modality} Jobs. Show the User every result so they can choose; when they do, call \`pick_result\`.`,
+      ...results.map((result, index) => `Variant ${index + 1}: ${result.text}`)
+    ].join(`
+
+`);
+    return {
+      content: [{ type: "text", text }],
+      structuredContent: { comparison_id: comparisonId, modality, jobs: results.map((result) => result.output) }
+    };
   });
   server.registerTool("get_job", {
-    description: "Get a Job's status, waiting up to two minutes while it runs; once it has completed, the paths of its saved images. Use it when `generate_image` returned a Job that is still running.",
+    description: "Get a Job's status, waiting up to two minutes while it runs; once it has completed, the paths of its saved images or video. Use it when `generate_image`, `generate_video` or `generate_comparison` returned a Job that is still running.",
     inputSchema: {
-      job_id: string2().min(1).describe("The `job_id` that `generate_image` returned.")
+      job_id: string2().min(1).describe("The `job_id` that `generate_image`, `generate_video` or `generate_comparison` returned.")
     },
     outputSchema: {
       job_id: string2(),
       status: jobStatusSchema,
       model: string2().describe("Alias of the Model that ran the Job."),
-      files: array(string2()).describe("Paths of the saved images; empty while the Job is running."),
-      shortfall: string2().optional().describe("Present when fewer images than asked for were saved: how many, and why.")
+      files: array(string2()).describe("Paths of the saved images or video; empty while the Job is running."),
+      shortfall: string2().optional().describe("Present when fewer images than asked for were saved: how many, and why."),
+      observed: observedSchema,
+      mismatch: mismatchSchema
     }
   }, async ({ job_id }) => {
     try {
       const job = await jobs.get(job_id);
-      const text = job.status === "running" ? jobText(job) : `Job ${job.id} completed: saved ${job.files.length} image(s) from ${job.model}.${job.shortfall === undefined ? "" : ` ${job.shortfall}`}
+      const docsUrl = job.status === "completed" && job.mismatch !== undefined ? (await jobDocs(deps.dirs, job_id))?.docsUrl ?? "the Model's docs link in `list_models`" : "";
+      const text = job.status === "running" ? jobText(job) : `Job ${job.id} completed: saved ${job.files.length} file(s) from ${job.model}.${observedText(job.observed)}${mismatchText(job.mismatch, docsUrl)}${job.shortfall === undefined ? "" : ` ${job.shortfall}`}
 ${job.files.join(`
 `)}`;
       return { content: [{ type: "text", text }], structuredContent: jobOutput(job) };
     } catch (error) {
-      if (error instanceof ConfigError)
-        return toolError(error.message);
-      if (error instanceof JobFailedError)
-        return toolError(`Job ${error.jobId} failed: ${error.message}`);
-      throw error;
+      return failure2(error, async () => {
+        const docs = await jobDocs(deps.dirs, job_id);
+        return docs === undefined ? "" : optionsHint(docs.docsUrl, docs.options);
+      });
     }
   });
   server.registerTool("rate_job", {
-    description: "Record the User's Rating of a completed Job: good or bad, plus a one-line reason. Call it only when the User has actually said what they think of the result; never invent a verdict. A later Rating of the same Job replaces the earlier one.",
+    description: "Record the User's Rating of a completed Job, or of one result of it: good or bad, plus a one-line reason. Call it only when the User has actually said what they think of the result; never invent a verdict. A later Rating of the same Job and result replaces the earlier one; a Rating of the whole Job and one of a single result stand side by side.",
     inputSchema: {
-      job_id: string2().min(1).describe("The `job_id` that `generate_image` or `get_job` returned."),
+      job_id: string2().min(1).describe("The `job_id` that `generate_image`, `generate_video` or `get_job` returned."),
+      result: number2().int().positive().optional().describe("Which result the verdict is about, from 1 in the order of the Job's files. Omit when it is about the whole Job."),
       verdict: _enum(verdicts).describe("The User's verdict."),
       reason: string2().max(ratingReasonMaxLength).describe(`Why, in one line and in the User's words, e.g. "the text is misspelled". At most ${ratingReasonMaxLength} characters.`)
     },
     outputSchema: {
       job_id: string2(),
+      result: number2().optional().describe("The result rated; absent for a Rating of the whole Job."),
       verdict: _enum(verdicts),
       reason: string2().describe("The reason as recorded, on one line."),
       rated_at: string2().describe("When the Rating was recorded, ISO 8601.")
     }
-  }, async ({ job_id, verdict, reason }) => {
+  }, async ({ job_id, result, verdict, reason }) => {
     try {
-      const rating = await rateJob(deps.dirs, { jobId: job_id, verdict, reason }, now());
-      const output = { job_id: rating.jobId, verdict: rating.verdict, reason: rating.reason, rated_at: rating.ratedAt };
+      const rating = await rateJob(deps.dirs, { jobId: job_id, result, verdict, reason }, now());
       return {
-        content: [{ type: "text", text: `Recorded a ${rating.verdict} Rating on Job ${rating.jobId}: ${rating.reason}` }],
-        structuredContent: output
+        content: [{ type: "text", text: `Recorded a ${rating.verdict} Rating on ${ratingSubject(rating)}: ${rating.reason}` }],
+        structuredContent: ratingOutput(rating)
       };
     } catch (error) {
       if (error instanceof RatingError)
@@ -24960,21 +26409,50 @@ ${job.files.join(`
       throw error;
     }
   });
+  server.registerTool("pick_result", {
+    description: "Record the User's Pick within a Comparison: the Job, or the one result of it, the User chose among the Comparison's results. Call it only when the User actually chooses; never pick for them. A later Pick for the same Comparison replaces the earlier one. A Pick is a relative preference, not a Rating: it does not mark the result good or the others bad.",
+    inputSchema: {
+      comparison_id: string2().min(1).describe("The `comparison_id` that `generate_comparison` returned."),
+      job_id: string2().min(1).describe("The `job_id` of the chosen Job, one of the Comparison's Jobs."),
+      result: number2().int().positive().optional().describe("Which result of that Job the User chose, from 1 in the order of its files. Omit when the Job made one result or the User chose the Job as a whole.")
+    },
+    outputSchema: {
+      comparison_id: string2(),
+      job_id: string2(),
+      result: number2().optional().describe("The result picked; absent when the Job was picked as a whole."),
+      picked_at: string2().describe("When the Pick was recorded, ISO 8601.")
+    }
+  }, async ({ comparison_id, job_id, result }) => {
+    try {
+      const pick = await pickResult(deps.dirs, { comparison: comparison_id, jobId: job_id, result }, now());
+      const subject = pick.result === undefined ? `Job ${pick.jobId}` : `result ${pick.result} of Job ${pick.jobId}`;
+      return {
+        content: [{ type: "text", text: `Recorded the User's Pick in Comparison ${pick.comparison}: ${subject}.` }],
+        structuredContent: pickOutput(pick)
+      };
+    } catch (error) {
+      if (error instanceof PickError)
+        return toolError(error.message);
+      throw error;
+    }
+  });
   server.registerTool("list_models", {
-    description: "List the User's configured image Models: Alias, Provider, Protocol, capabilities, Model Notes and a docs link for `provider_options`, and which one is the default. Use it to choose a Model when the request needs something the default may lack. Pass `model` for one Model in detail, with the Provider's parameter schema and the `provider_options` known to work.",
+    description: "List the User's configured Models: Alias, Modality (image or video), Provider, Protocol, capabilities, Model Notes, the Known-good Options for `provider_options` and a docs link, and which Models are the defaults. Use it to choose a Model when the request needs something the default may lack. Pass `model` for one Model in detail, with the values of its Known-good and suspect options, its five most recent Ratings, the Picks of up to five Comparisons it took part in (most recently picked first), and the Provider's parameter schema.",
     inputSchema: {
       model: string2().optional().describe("Alias of one Model to describe in detail. Omit to list every Model.")
     },
     outputSchema: {
       default_model: string2().nullable().describe("Alias of the default image Model, used when `generate_image` gets no `model`."),
+      default_video_model: string2().nullable().describe("Alias of the default video Model, used when `generate_video` gets no `model`."),
       models: array(listedModelSchema)
     }
   }, async ({ model: alias }) => {
     try {
       const config = await loadConfig(deps.dirs);
       if (config.models.length === 0)
-        throw needsSettings("litevision has no image Model configured yet.");
-      const defaultModel = defaultModelAlias(config) ?? null;
+        throw needsSettings("litevision has no Model configured yet.");
+      const defaultModel = defaultModelAlias(config, "image") ?? null;
+      const defaultVideoModel = defaultModelAlias(config, "video") ?? null;
       let models = config.models;
       if (alias !== undefined) {
         models = models.filter((model) => model.alias === alias);
@@ -24982,12 +26460,13 @@ ${job.files.join(`
           throw new ConfigError(`Unknown Model Alias "${alias}". Known Aliases: ${config.models.map((model) => model.alias).join(", ")}.`);
         }
       }
-      const entries = await Promise.all(models.map((model) => listedModel(infoDeps, config, model, model.alias === defaultModel, alias !== undefined)));
+      const ratedJobs = await readRatedJobs(deps.dirs);
+      const entries = await Promise.all(models.map((model) => listedModel(infoDeps, config, model, model.alias === (model.modality === "video" ? defaultVideoModel : defaultModel), alias !== undefined, ratedJobs)));
       const text = entries.map((entry) => entry.text).join(`
 `);
       return {
         content: [{ type: "text", text }],
-        structuredContent: { default_model: defaultModel, models: entries.map((entry) => entry.output) }
+        structuredContent: { default_model: defaultModel, default_video_model: defaultVideoModel, models: entries.map((entry) => entry.output) }
       };
     } catch (error) {
       if (error instanceof ConfigError)
@@ -25054,6 +26533,19 @@ Now: ${change.notes || "(none)"}`;
     const text = "Opened the litevision settings page in the User's browser. Ask the User to finish setting up there and tell you when they are done. Never ask the User for a Credential in the conversation.";
     return { content: [{ type: "text", text }] };
   });
+  server.registerPrompt("settings", {
+    title: "litevision settings",
+    description: "Open litevision's settings page to add Providers, enter Credentials and set up Models."
+  }, async () => {
+    let text;
+    try {
+      await settings.open();
+      text = "I have already opened litevision's settings page in my browser. Do not call `open_settings`. Wait until I say I am done there. Never ask me for a Credential in the conversation.";
+    } catch {
+      text = "I tried to open litevision's settings page, but it could not open my browser. Tell me to run `litevision settings` in a terminal, which opens the page and prints its address.";
+    }
+    return { messages: [{ role: "user", content: { type: "text", text } }] };
+  });
   return server;
 }