litevision 0.1.1 → 0.3.0

package/dist/cli.js

@@ -12866,6 +12866,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function strictObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...normalizeParams(params)
+  });
+}
 function looseObject(shape, params) {
   return new ZodObject({
     type: "object",
@@ -14154,6 +14162,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 +21706,19 @@ 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 modalities = ["image", "video"];
+
+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 +21735,16 @@ 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()
+  notesHistory: notesHistorySchema.optional(),
+  standingOptions: record(string2(), unknown()).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 +21785,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 +21823,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 +21835,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 +21857,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 +21873,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 +21930,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 +21947,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 +21962,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 +21970,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 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 knownGoodOptions(jobs, model) {
-  const options = {};
-  for (const job of jobs) {
+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 +22081,223 @@ 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/parameter-guide.ts
+function guideSummary(guide) {
+  return `Parameter Guide for ${guide.family} (checked ${guide.checked}): ${guide.parameters.map((parameter) => parameter.name).join(", ")}.`;
+}
+function guideText(guide) {
+  const lines = [
+    `Parameter Guide for ${guide.family}, checked ${guide.checked} (sources: ${guide.sources.join(", ")}):`,
+    ...guide.parameters.map((parameter) => `- ${parameter.name}: ${parameter.values} Default: ${parameter.default}. Price: ${parameter.price}`),
+    ...(guide.notes ?? []).map((note) => `Note: ${note}`)
+  ];
+  return lines.join(`
+`);
+}
+function guideOutput(guide) {
+  return {
+    family: guide.family,
+    checked: guide.checked,
+    sources: guide.sources,
+    parameters: guide.parameters.map((parameter) => ({ ...parameter })),
+    notes: guide.notes ?? []
+  };
+}
+function guideFor(entries, modelId) {
+  const bare = modelId.replace(/^.*\//, "");
+  return entries.find((entry) => entry.matches.test(modelId) || entry.matches.test(bare))?.guide;
+}
+function fieldsToRead(adapter, modelId, modality) {
+  const guide = adapter.parameterGuide?.(modelId, modality);
+  const fallback = (modality === "video" ? adapter.requestFields.video : adapter.requestFields.image) ?? { shape: [] };
+  if (guide === undefined)
+    return fallback;
+  return {
+    shape: guide.shapeFields,
+    ...guide.durationField === undefined ? {} : { duration: guide.durationField },
+    ...fallback.resolution === undefined ? {} : { resolution: fallback.resolution }
+  };
+}
+function valueAt(body, path) {
+  return path.split(".").reduce((value, key) => typeof value === "object" && value !== null ? value[key] : undefined, body);
+}
+var positive = (value) => {
+  const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) && number > 0 ? number : undefined;
+};
+function parseShape(text) {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*([x×:])\s*(\d+(?:\.\d+)?)\s*$/i.exec(text);
+  if (match === null)
+    return;
+  const width = Number(match[1]);
+  const height = Number(match[3]);
+  if (!(width > 0 && height > 0))
+    return;
+  return { label: `${match[1]}${match[2] === ":" ? ":" : "x"}${match[3]}`, ratio: width / height };
+}
+function readShape(fields, body) {
+  for (const field of fields) {
+    if (typeof field === "string") {
+      const value = valueAt(body, field);
+      if (value === undefined)
+        continue;
+      return typeof value === "string" ? parseShape(value)?.label ?? null : null;
+    }
+    const width = valueAt(body, field.width);
+    const height = valueAt(body, field.height);
+    if (width === undefined && height === undefined)
+      continue;
+    const w = positive(width);
+    const h = positive(height);
+    return w === undefined || h === undefined ? null : `${w}x${h}`;
   }
+  return null;
+}
+function readResolution(field, body) {
+  const value = field === undefined ? undefined : valueAt(body, field);
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function readSeconds(field, body) {
+  return field === undefined ? null : positive(valueAt(body, field)) ?? null;
+}
+function readRequested(fields, body, modality) {
+  return {
+    shape: readShape(fields.shape, body),
+    resolution: readResolution(fields.resolution, body),
+    ...modality === "video" ? { seconds: readSeconds(fields.duration, body) } : {}
+  };
 }
 
 // src/protocols/errors.ts
@@ -21953,6 +22310,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,25 +22335,328 @@ 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/guides/apimart.ts
+var checked = "2026-11-05";
+var page = (path) => `https://docs.apimart.ai/en/api-reference/images/${path}`;
+var pricing = "https://apimart.ai/pricing";
+var pricingNote = "APIMart publishes prices only on its pricing page, which depends on the account tier; figures here are approximate.";
+var references = (count) => ({
+  name: "image_urls",
+  values: `${count}; litevision uploads \`references\` through APIMart's upload endpoint and fills this with the links.`,
+  default: "none",
+  price: "not documented."
+});
+var count = (range) => ({
+  name: "n",
+  values: `${range} images per task; litevision sends \`n\` here, or one task per image where the model makes one at a time.`,
+  default: "1",
+  price: "each image is billed."
+});
+var fifteenRatios = "1:1, 3:2, 2:3, 4:3, 3:4, 5:4, 4:5, 16:9, 9:16, 2:1, 1:2, 3:1, 1:3, 21:9, 9:21";
+var exactPixels = "or exact WIDTHxHEIGHT under OpenAI's rule (multiples of 16, at most 3840 a side and 3:1, 655,360–8,294,400 pixels)";
+var gptTiers = "1k, 2k, 4k (16:9 is 1536x864, 2048x1152 or 3840x2160).";
+var gptImage25 = {
+  family: "GPT Image 2.5 / 2.6 on APIMart",
+  parameters: [
+    { name: "size", values: `auto, ${fifteenRatios}, ${exactPixels}.`, default: "auto", price: "set by resolution." },
+    { name: "resolution", values: `${gptTiers} Ignored for exact pixels.`, default: "1k", price: "billed by output tokens, which grow with the tier and the quality." },
+    { name: "quality", values: "auto, low, medium, high, xhigh, max.", default: "auto", price: "at 1024x1024 about $0.006 low to $0.21 max ($30 per 1M output tokens)." },
+    { name: "background", values: "auto, opaque, transparent.", default: "auto", price: "no effect." },
+    { name: "moderation", values: "auto, low.", default: "low", price: "no effect." },
+    references("up to 16 public links"),
+    count("1–4")
+  ],
+  sources: [page("gpt-image-2.5/generation"), page("gpt-image-2.6/generation"), pricing],
+  checked,
+  notes: ["GPT Image 2.6 adds complexity, markup_url, GIF and SVG output.", pricingNote],
+  shapeFields: ["size"]
+};
+var gptImage2 = {
+  family: "GPT Image 2 on APIMart",
+  parameters: [
+    { name: "size", values: `auto (= 1:1), ${fifteenRatios}, ${exactPixels}.`, default: "1:1", price: "set by resolution." },
+    { name: "resolution", values: gptTiers, default: "1k", price: "about $0.0085 at 1K, $0.015 at 2K, $0.022 at 4K per image." },
+    references("up to 15 links or data URIs (gpt-image-2-official: up to 16 public links)"),
+    count("1 (gpt-image-2-official: 1–4)")
+  ],
+  sources: [page("gpt-image-2/generation"), page("gpt-image-2/official"), pricing],
+  checked,
+  notes: [
+    "Without size, the output takes the input image's resolution.",
+    "The gpt-image-2 page gives two pixel sizes for many 1k ratios (1:1 is 1024x1024 or 1254x1254), so the exact 1k output is uncertain.",
+    pricingNote
+  ],
+  shapeFields: ["size"]
+};
+var gptImageExt = {
+  family: "GPT Image 2.5 / 2.6 Ext on APIMart",
+  parameters: [
+    { name: "size", values: "auto, 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 5:4, 4:5, 21:9; no exact pixels.", default: "auto", price: "no effect." },
+    { name: "resolution", values: "1K, 2K, 4K (gpt-image-2.6-ext: only 1k today).", default: "1K", price: "about $0.0085 at 1K, $0.03 at 2K, $0.04 at 4K per image." },
+    { name: "version", values: "flare, sunburst.", default: "the Provider picks", price: "billed by version × resolution × images delivered." },
+    references("up to 16 links or data URIs"),
+    count("1–4 (gpt-image-2.6-ext: 1)")
+  ],
+  sources: [page("gpt-image-2.5-ext/generation"), page("gpt-image-2.6-ext/generation"), pricing],
+  checked,
+  notes: [pricingNote],
+  shapeFields: ["size"]
+};
+var gptImage1 = {
+  family: "GPT Image 1 / 1.5 on APIMart",
+  parameters: [
+    { name: "size", values: "1:1, 3:2, 2:3 (1024x1024, 1536x1024, 1024x1536).", default: "1:1", price: "not documented." },
+    { name: "quality", values: "auto, low, medium, high.", default: "auto", price: "not documented." },
+    { name: "background", values: "auto, opaque, transparent.", default: "auto", price: "no effect." },
+    references("up to 15 public links"),
+    count("1–4")
+  ],
+  sources: [page("gpt-image-1/generation")],
+  checked,
+  notes: ["OpenAI shut gpt-image-1 down on 2026-10-23."],
+  shapeFields: ["size"]
+};
+var geminiRatios10 = "auto, 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9";
+var gemini = (family, path, ratios, tiers, refs, n, notes) => ({
+  family,
+  parameters: [
+    { name: "size", values: `${ratios}.`, default: "auto: the model decides, and image-to-image follows the reference", price: "no effect." },
+    { name: "resolution", values: tiers, default: "1K", price: "higher tiers cost more." },
+    references(refs),
+    count(n)
+  ],
+  sources: [page(path), pricing],
+  checked,
+  notes: [...notes, pricingNote],
+  shapeFields: ["size"]
+});
+var seedream = (family, path, ratios, tiers, defaultTier, refs, n, notes, defaultSize = "1:1") => ({
+  family,
+  parameters: [
+    { name: "size", values: `${ratios}.`, default: defaultSize, price: "no effect." },
+    { name: "resolution", values: tiers, default: defaultTier, price: "higher tiers cost more." },
+    references(refs),
+    count(n)
+  ],
+  sources: [page(path), pricing],
+  checked,
+  notes: [...notes, pricingNote],
+  shapeFields: ["size"]
+});
+var seedreamRatios = "1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 2:1, 1:2, 21:9, 9:21, auto (needs reference images)";
+var flux2 = {
+  family: "FLUX.2 on APIMart",
+  parameters: [
+    { name: "size", values: "1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9, 9:21, auto, or WIDTHxHEIGHT.", default: "1:1", price: "set by resolution." },
+    { name: "resolution", values: "1MP, 2MP, 3MP, 4MP (1K, 2K, 4K are taken as 2MP, 3MP, 4MP; 16:9 is 1344x752 at 1MP, 2720x1536 at 4MP).", default: "2MP", price: "flux-2-pro about $0.024, $0.036, $0.048, $0.06." },
+    { name: "width", values: "with height, in place of size: at least 64 each, at most 4,194,304 pixels.", default: "none", price: "by megapixels." },
+    { name: "height", values: "with width, as above.", default: "none", price: "by megapixels." },
+    { name: "safety_tolerance", values: "0–5.", default: "the Provider picks", price: "no effect." },
+    { name: "seed", values: "any integer.", default: "random", price: "no effect." },
+    references("up to 8"),
+    count("1")
+  ],
+  sources: [page("flux-2/generation"), pricing],
+  checked,
+  notes: ["steps (1–50) and guidance (1.5–10) apply to flux-2-flex only.", pricingNote],
+  shapeFields: [{ width: "width", height: "height" }, "size"]
+};
+var fluxKontext = {
+  family: "FLUX.1 Kontext on APIMart",
+  parameters: [
+    { name: "size", values: "1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9, 9:21, auto; about a megapixel (16:9 is 1392x752). Pixels are mapped to the nearest ratio; width and height fail.", default: "1:1", price: "not documented." },
+    references("up to 4"),
+    count("1")
+  ],
+  sources: [page("flux-kontext/generation")],
+  checked,
+  shapeFields: ["size"]
+};
+var flux3 = {
+  family: "FLUX 3 Image on APIMart",
+  parameters: [
+    { name: "aspect_ratio", values: "21:9, 2:1, 16:9, 3:2, 7:5, 4:3, 5:4, 1:1, 4:5, 3:4, 5:7, 2:3, 9:16, 1:2, 9:21, auto; also taken as size. Pixels are rejected.", default: "auto", price: "no effect." },
+    { name: "resolution", values: "768sq, 1k, 1.5k, 2k, 4k (about 0.6, 1, 2, 4 and 16 MP).", default: "1k", price: "about $0.033, $0.038, $0.056, $0.08, $0.49." },
+    { name: "safety_tolerance", values: "0–4.", default: "the Provider picks", price: "no effect." },
+    references("up to 10"),
+    count("1")
+  ],
+  sources: [page("flux-3-image/generation"), pricing],
+  checked,
+  notes: ["seed, steps, guidance and negative_prompt are rejected.", pricingNote],
+  shapeFields: ["aspect_ratio", "size"]
+};
+var entries = [
+  { matches: /^gpt-image-2\.[56]-ext$/, guide: gptImageExt },
+  { matches: /^gpt-image-2\.[56]-(flare|sunburst)$/, guide: gptImage25 },
+  { matches: /^gpt-image-2(-ext|-official)?$/, guide: gptImage2 },
+  { matches: /^gpt-image-1(\.5)?(-official)?$/, guide: gptImage1 },
+  {
+    matches: /^gemini-nano-banana-2\.1(-ext)?$/,
+    guide: gemini("Nano Banana 2.1 on APIMart", "gemini-nano-banana-2.1/generation", `${geminiRatios10}, 1:4, 4:1, 1:8, 8:1`, "1K, 2K, 4K; 0.5K and 512 are rejected, an unknown tier is taken as 1K.", "no fixed count, links or data URIs, up to 20 MB each", "1–4 (Ext: 1)", [])
+  },
+  {
+    matches: /^(gemini-3\.1-flash-image-preview(-official)?|nano-banana-2(-ext)?)$/,
+    guide: gemini("Nano Banana 2 (Gemini 3.1 Flash Image) on APIMart", "gemini-3.1-flash/generation", `${geminiRatios10}, 1:4, 4:1, 1:8, 8:1`, "0.5K, 1K, 2K, 4K.", "up to 14", "1", ["APIMart calls the small tier 0.5K where Google's own API says 512."])
+  },
+  {
+    matches: /^(gemini-3\.1-flash-lite-image(-ext)?|nano-banana-2-lite)$/,
+    guide: gemini("Nano Banana 2 Lite on APIMart", "gemini-3.1-flash/generation-lite", geminiRatios10, "1K only; 2K, 4K and 0.5K are silently taken as 1K.", "up to 14", "1–4", [])
+  },
+  {
+    matches: /^(gemini-3-pro-image-preview(-official)?|nano-banana-pro(-ext)?)$/,
+    guide: gemini("Nano Banana Pro on APIMart", "gemini-3-pro/generation", geminiRatios10, "1K, 2K, 4K.", "up to 14", "1", [
+      "With size auto and no reference, the docs say the result is 1:1 or 16:9."
+    ])
+  },
+  {
+    matches: /^(gemini-2\.5-flash-image-preview(-official)?|nano-banana(-ext)?)$/,
+    guide: gemini("Nano Banana on APIMart", "gemini-2.5-flash/generation", geminiRatios10, "1K only.", "up to 14", "1", [
+      "APIMart allows 14 reference images; Google says the model works best with up to 3.",
+      "Prompts of at most 1000 characters."
+    ])
+  },
+  {
+    matches: /^seedream-4[.-]0$/i,
+    guide: seedream("Seedream 4.0 on APIMart", "seedream-4/generation", seedreamRatios, "1K, 2K, 4K.", "2K", "references and n together at most 15", "1–15", [])
+  },
+  {
+    matches: /^seedream-4[.-]5$/i,
+    guide: seedream("Seedream 4.5 on APIMart", "seedream-4.5/generation", seedreamRatios, "2K, 4K; no 1K (16:9 is 2560x1440 at 2K, 5404x3040 at 4K).", "2K", "references and n together at most 15", "1–15", [
+      "More than one image switches to sequential mode; text-to-image alone cannot make several."
+    ])
+  },
+  {
+    matches: /^seedream-5[.-]0-lite$/i,
+    guide: seedream("Seedream 5.0 Lite on APIMart", "seedream-5-lite/generation", seedreamRatios.replace(", 9:21", ""), "2K, 3K, 4K; no 1K.", "2K", "references and n together at most 15", "1–15", [
+      'The page header says "2K / 3K" while the field lists 2K, 3K and 4K.'
+    ])
+  },
+  {
+    matches: /^seedream-5[.-]0-(pro|flash)$/i,
+    guide: {
+      ...seedream("Seedream 5.0 Pro / Flash on APIMart", "seedream-5-0-pro/generation", "auto, 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 2:1, 1:2, 21:9, or exact pixels (921,600–4,624,220 pixels, ratio 1/16–16)", "1K, 1.5K, 2K; 3K and 4K are rejected.", "1K", "up to 10, the first free and each further one a fixed surcharge", "1", ['1.5K costs the same as 1K. The Flash page says "also accepted: seedream-5.0-pro", probably a copy error.'], "auto"),
+      sources: [page("seedream-5-0-pro/generation"), page("seedream-5-0-flash/generation"), pricing]
+    }
+  },
+  { matches: /^flux-2-(flex|pro|max)$/, guide: flux2 },
+  { matches: /^flux-kontext-(pro|max)$/, guide: fluxKontext },
+  { matches: /^flux-3-image$/, guide: flux3 }
+];
+var apimartGuide = (modelId) => guideFor(entries, modelId);
+
+// src/protocols/multipart.ts
+import { randomUUID } from "node:crypto";
+function multipartBody(fields, files) {
+  const boundary = `litevision-${randomUUID()}`;
+  const encoder = new TextEncoder;
+  const quote = (value) => value.replace(/["\r\n\\]/g, (char) => encodeURIComponent(char));
+  const parts = [];
+  for (const [name, value] of fields) {
+    parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${quote(name)}"\r
+\r
+${value}\r
+`));
+  }
+  for (const file of files) {
+    parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${quote(file.name)}"; filename="${quote(file.fileName)}"\r
+Content-Type: ${file.mimeType}\r
+\r
+`), file.bytes, encoder.encode(`\r
+`));
   }
+  parts.push(encoder.encode(`--${boundary}--\r
+`));
+  return { body: Buffer.concat(parts), contentType: `multipart/form-data; boundary=${boundary}` };
+}
+
+// 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
 var docsBase = "https://docs.apimart.ai/en/api-reference/images";
-var maxImagesPerJob = 4;
 var errorSchema = object({
   error: object({
     code: union([number2(), string2()]).nullish(),
@@ -22017,86 +22678,23 @@ var taskSchema = object({
   })
 });
 var resumeSchema = object({ taskIds: array(string2()).min(1) });
-var sizes = (entries) => entries.map(([aspectRatio, width, height]) => ({ aspectRatio, width, height }));
 var knownModels = [
-  {
-    matches: /^gpt-image-2(-ext|-official)?$/,
-    docsPage: "gpt-image-2/generation",
-    capabilities: {
-      sizes: sizes([
-        ["1:1", 1024, 1024],
-        ["3:2", 1536, 1024],
-        ["2:3", 1024, 1536],
-        ["4:3", 1024, 768],
-        ["3:4", 768, 1024],
-        ["16:9", 1536, 864],
-        ["9:16", 864, 1536]
-      ]),
-      maxReferences: 15,
-      maxImages: maxImagesPerJob
-    },
-    batches: false
-  },
-  {
-    matches: /^gpt-image-1(\.5)?(-official)?$/,
-    docsPage: "gpt-image-1/generation",
-    capabilities: {
-      sizes: sizes([
-        ["1:1", 1024, 1024],
-        ["3:2", 1536, 1024],
-        ["2:3", 1024, 1536]
-      ]),
-      maxReferences: 0,
-      maxImages: maxImagesPerJob
-    },
-    batches: true
-  },
-  {
-    matches: /^(gemini-3-pro-image-preview(-official)?|nano-banana-pro(-ext)?)$/,
-    docsPage: "gemini-3-pro/generation",
-    capabilities: {
-      sizes: sizes([
-        ["1:1", 1024, 1024],
-        ["3:2", 1264, 848],
-        ["2:3", 848, 1264],
-        ["4:3", 1200, 896],
-        ["3:4", 896, 1200],
-        ["16:9", 1376, 768],
-        ["9:16", 768, 1376]
-      ]),
-      maxReferences: 14,
-      maxImages: maxImagesPerJob
-    },
-    batches: false
-  },
-  {
-    matches: /^seedream-4[.-]5$/i,
-    docsPage: "seedream-4.5/generation",
-    capabilities: {
-      sizes: sizes([
-        ["1:1", 2048, 2048],
-        ["3:2", 2496, 1664],
-        ["2:3", 1664, 2496],
-        ["4:3", 2304, 1728],
-        ["3:4", 1728, 2304],
-        ["16:9", 2560, 1440],
-        ["9:16", 1440, 2560]
-      ]),
-      maxReferences: 14,
-      maxImages: maxImagesPerJob
-    },
-    batches: false
-  }
+  { matches: /^gpt-image-2-official$/, docsPage: "gpt-image-2/official", batches: true },
+  { matches: /^gpt-image-2(-ext)?$/, docsPage: "gpt-image-2/generation", batches: false },
+  { matches: /^gpt-image-2\.5-(flare|sunburst)$/, docsPage: "gpt-image-2.5/generation", batches: true },
+  { matches: /^gpt-image-2\.6-(flare|sunburst)$/, docsPage: "gpt-image-2.6/generation", batches: true },
+  { matches: /^gpt-image-2\.5-ext$/, docsPage: "gpt-image-2.5-ext/generation", batches: true },
+  { matches: /^gpt-image-2\.6-ext$/, docsPage: "gpt-image-2.6-ext/generation", batches: false },
+  { matches: /^gpt-image-1(\.5)?(-official)?$/, docsPage: "gpt-image-1/generation", batches: true },
+  { matches: /^gemini-nano-banana-2\.1$/, docsPage: "gemini-nano-banana-2.1/generation", batches: true },
+  { matches: /^(gemini-3\.1-flash-lite-image(-ext)?|nano-banana-2-lite)$/, docsPage: "gemini-3.1-flash/generation-lite", batches: true },
+  { matches: /^(gemini-3-pro-image-preview(-official)?|nano-banana-pro(-ext)?)$/, docsPage: "gemini-3-pro/generation", batches: false },
+  { matches: /^seedream-4[.-]5$/i, docsPage: "seedream-4.5/generation", batches: false }
 ];
-var unknownModel = {
-  sizes: sizes([["1:1", 1024, 1024]]),
-  maxReferences: 0,
-  maxImages: maxImagesPerJob
-};
 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 +22702,39 @@ 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`, {
+var uploadedSchema = object({ url: string2().min(1) });
+async function uploadReference(reference, target, http, context) {
+  const { body, contentType } = multipartBody([], [{ name: "file", ...reference }]);
+  const init = { method: "POST", headers: { ...headers(target.credential), "content-type": contentType }, body };
+  const failed = (error) => new ProviderError(error instanceof ProviderError ? error.kind : "other", `Could not upload the reference image ${reference.fileName} to APIMart. ${error.message}`);
+  let response;
+  try {
+    response = await sendToProvider(http, target.providerId, `${baseUrlOf(target)}/uploads/images`, init, { context });
+  } catch (error) {
+    throw error instanceof ProviderError ? failed(error) : error;
+  }
+  if (!response.ok)
+    throw failed(await errorOf(response, target.providerId));
+  const parsed = uploadedSchema.safeParse(await response.json().catch(() => {
+    return;
+  }));
+  if (!parsed.success)
+    throw failed(providerError("other", target.providerId, "its answer to the upload had no link."));
+  return parsed.data.url;
+}
+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 +22742,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();
   }
 }
@@ -22192,32 +22797,6 @@ function waitForTasks(taskIds, target, http, context, submissionFailures = []) {
     }
   };
 }
-function capabilitiesFromSchema(schema, modelId) {
-  const properties = object({
-    properties: object({
-      size: object({ enum: array(unknown()) }).optional(),
-      image_urls: object({ maxItems: number2().int().nonnegative().optional() }).optional()
-    })
-  }).safeParse(schema);
-  if (!properties.success)
-    return;
-  const { size, image_urls } = properties.data.properties;
-  const ratios = aspectRatios.filter((ratio) => size?.enum.includes(ratio));
-  if (ratios.length === 0)
-    return;
-  const builtIn = known(modelId)?.capabilities ?? unknownModel;
-  return {
-    sizes: ratios.map((ratio) => builtIn.sizes.find((candidate) => candidate.aspectRatio === ratio) ?? nominalSize(ratio)),
-    maxReferences: image_urls === undefined ? 0 : image_urls.maxItems ?? Math.max(builtIn.maxReferences, 1),
-    maxImages: maxImagesPerJob
-  };
-}
-function nominalSize(aspectRatio) {
-  const [width, height] = aspectRatio.split(":").map(Number);
-  const scale = Math.sqrt(1024 * 1024 / (width * height));
-  const round = (value) => Math.round(value * scale / 16) * 16;
-  return { aspectRatio, width: round(width), height: round(height) };
-}
 var schemaResponse = object({ parameters: object({ input_schema: unknown() }).optional() });
 var modelListSchema = object({
   data: array(object({ id: string2(), category: string2().optional() }))
@@ -22246,7 +22825,6 @@ async function fetchModelIds(target, http) {
   return { ok: true, modelIds: ids.sort() };
 }
 var apimart = {
-  builtInCapabilities: (modelId) => known(modelId)?.capabilities ?? unknownModel,
   async fetchModelInfo(target, http) {
     const response = await http(`${baseUrlOf(target)}/models/${encodeURIComponent(target.modelId)}/schema`, {
       headers: headers(target.credential)
@@ -22258,27 +22836,26 @@ var apimart = {
     const body = await response.json();
     const item = schemaResponse.safeParse(body?.data ?? body);
     const parameterSchema = item.success ? item.data.parameters?.input_schema : undefined;
-    if (parameterSchema === undefined)
-      return;
-    const capabilities = capabilitiesFromSchema(parameterSchema, target.modelId);
-    return { parameterSchema, ...capabilities === undefined ? {} : { capabilities } };
+    return parameterSchema === undefined ? undefined : { parameterSchema };
   },
   docsUrl: (modelId) => {
     const model = known(modelId);
     return model === undefined ? "https://docs.apimart.ai/en" : `${docsBase}/${model.docsPage}`;
   },
-  reservedOptions: ["model", "prompt", "size", "n", "image_urls"],
+  parameterGuide: (modelId, modality) => modality === "image" ? apimartGuide(modelId) : undefined,
+  requestFields: { image: { shape: ["size"], resolution: "resolution" } },
+  reservedOptions: ["model", "prompt", "image_urls"],
   async submit(request, target, http, context) {
     const batches = known(target.modelId)?.batches ?? false;
+    const imageUrls = await Promise.all(request.references.map((reference) => uploadReference(reference, target, http, context)));
     const body = {
       model: target.modelId,
       prompt: request.prompt,
-      size: request.size.aspectRatio,
       n: batches ? request.n : 1,
-      ...request.references.length === 0 ? {} : { image_urls: request.references.map((reference) => `data:${reference.mimeType};base64,${Buffer.from(reference.bytes).toString("base64")}`) },
+      ...imageUrls.length === 0 ? {} : { image_urls: imageUrls },
       ...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)
@@ -22300,15 +22877,105 @@ var apimart = {
   listModelIds: fetchModelIds
 };
 
-// src/protocols/parallel.ts
-async function inParallel(n, providerId, send) {
-  const settled = await Promise.allSettled(Array.from({ length: n }, () => send()));
-  const images = settled.flatMap((outcome) => outcome.status === "fulfilled" ? outcome.value : []);
-  const failures = settled.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-  if (images.length === 0)
-    throw failures[0] ?? providerError("other", providerId, "it returned no images.");
-  if (failures.length === 0)
-    return { images };
+// src/protocols/guides/gemini.ts
+var checked2 = "2026-11-05";
+var sources = [
+  "https://ai.google.dev/gemini-api/docs/image-generation",
+  "https://aistudio.google.com/api-reference/interactions-api/create-interaction",
+  "https://ai.google.dev/gemini-api/docs/pricing"
+];
+var tenRatios = "1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9";
+var fourteenRatios = `${tenRatios}, 1:4, 4:1, 1:8, 8:1`;
+var ratio = (ratios) => ({
+  name: "response_format.aspect_ratio",
+  values: `${ratios}.`,
+  default: "the shape of the input image, else 1:1",
+  price: "no effect: every ratio of a tier costs the same."
+});
+var mimeType = { name: "response_format.mime_type", values: "image/jpeg.", default: "the Provider picks", price: "no effect." };
+var imageSize = (values, price) => ({
+  name: "response_format.image_size",
+  values: `${values} Uppercase K: a lowercase 1k is rejected.`,
+  default: "1K",
+  price
+});
+var shape = ["response_format.aspect_ratio"];
+var nanoBanana21 = {
+  family: "Nano Banana 2.1 (gemini-nano-banana-2.1)",
+  parameters: [
+    ratio(fourteenRatios),
+    imageSize("1K, 2K, 4K (16:9: 1376x768, 2752x1536, 5504x3072).", "about $0.034 at 1K, $0.050 at 2K, $0.113 at 4K ($30 per 1M image tokens)."),
+    mimeType
+  ],
+  sources: [...sources, "https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1"],
+  checked: checked2,
+  notes: ["4K tokens: the image guide says 2520, the pricing page 3780 ($0.113); the price above follows the pricing page."],
+  shapeFields: shape
+};
+var flash31 = {
+  family: "Nano Banana 2 (gemini-3.1-flash-image)",
+  parameters: [
+    ratio(fourteenRatios),
+    imageSize("512, 1K, 2K, 4K (16:9: 688x384, 1376x768, 2752x1536, 5504x3072).", "about $0.045 at 512, $0.067 at 1K, $0.101 at 2K, $0.151 at 4K."),
+    mimeType
+  ],
+  sources: [...sources, "https://ai.google.dev/gemini-api/docs/models/gemini-3.1-flash-image"],
+  checked: checked2,
+  notes: [
+    `The small tier's value is "512" (the guide also calls it 0.5K).`,
+    "The guide prints 21:9 at 512 as 792x168, which is not 21:9; probably 792x336."
+  ],
+  shapeFields: shape
+};
+var flashLite31 = {
+  family: "Nano Banana 2 Lite (gemini-3.1-flash-lite-image)",
+  parameters: [ratio(tenRatios), imageSize("1K only; 2K and 4K are not supported.", "about $0.034 per image."), mimeType],
+  sources: [...sources, "https://ai.google.dev/gemini-api/docs/models/gemini-3.1-flash-lite-image"],
+  checked: checked2,
+  notes: ['The model page speaks of "14 aspect ratios" but lists the 10 above.', "Not optimized for several reference images."],
+  shapeFields: shape
+};
+var pro3 = {
+  family: "Nano Banana Pro (gemini-3-pro-image)",
+  parameters: [
+    ratio(tenRatios),
+    imageSize("1K, 2K, 4K (16:9: 1376x768, 2752x1536, 5504x3072).", "about $0.134 at 1K, the same at 2K, $0.24 at 4K."),
+    mimeType
+  ],
+  sources: [...sources, "https://ai.google.dev/gemini-api/docs/models/gemini-3-pro-image"],
+  checked: checked2,
+  notes: ["Up to 14 reference images, 5 of them with high fidelity."],
+  shapeFields: shape
+};
+var flash25 = {
+  family: "Nano Banana (gemini-2.5-flash-image)",
+  parameters: [
+    { ...ratio(tenRatios), values: `${tenRatios}; one size each (16:9 is 1344x768).` },
+    mimeType
+  ],
+  sources: [...sources, "https://ai.google.dev/gemini-api/docs/models/gemini-2.5-flash-image"],
+  checked: checked2,
+  notes: ["Takes no image_size. Works best with up to 3 reference images.", "Costs $0.039 per image."],
+  shapeFields: shape
+};
+var entries2 = [
+  { matches: /gemini-nano-banana-2\.1/, guide: nanoBanana21 },
+  { matches: /gemini-3\.1-flash-lite-image/, guide: flashLite31 },
+  { matches: /gemini-3\.1-flash-image/, guide: flash31 },
+  { matches: /gemini-3-pro-image/, guide: pro3 },
+  { matches: /gemini-2\.5-flash-image/, guide: flash25 }
+];
+var geminiGuide = (modelId) => guideFor(entries2, modelId);
+
+// src/protocols/parallel.ts
+async function inParallel(n, providerId, send) {
+  const settled = await Promise.allSettled(Array.from({ length: n }, () => send()));
+  const images = settled.flatMap((outcome) => outcome.status === "fulfilled" ? outcome.value : []);
+  const failures = settled.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  if (images.length === 0)
+    throw failures[0] ?? providerError("other", providerId, "it returned no images.");
+  if (failures.length === 0)
+    return { images };
   return {
     images,
     shortfall: `${failures.length} of ${n} requests to ${providerLabel(providerId)} failed: ${failures[0].message}`
@@ -22348,50 +23015,8 @@ var blockedCodes = new Set([
   "image_other",
   "content_blocked"
 ]);
-var sizes2 = (entries) => entries.map(([aspectRatio, width, height]) => ({ aspectRatio, width, height }));
-var gemini3 = {
-  capabilities: {
-    sizes: sizes2([
-      ["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: 4
-  },
-  imageSize: "1K"
-};
-var gemini25 = {
-  capabilities: {
-    sizes: sizes2([
-      ["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: 4
-  }
-};
-var unknownModel2 = { capabilities: { ...gemini3.capabilities, maxReferences: 3 } };
-var gemini3Ids = ["gemini-nano-banana-2.1", "gemini-3.1-flash-image", "gemini-3.1-flash-lite-image", "gemini-3-pro-image"];
-function geminiModel(modelId) {
-  if (modelId.includes("gemini-2.5-flash-image"))
-    return gemini25;
-  if (gemini3Ids.some((id) => modelId.includes(id)))
-    return gemini3;
-  return unknownModel2;
-}
 function interactionBody(request, target) {
   const { response_format: extraFormat, ...options } = request.providerOptions;
-  const { imageSize } = geminiModel(target.modelId);
   return {
     model: target.modelId,
     input: [
@@ -22403,29 +23028,25 @@ function interactionBody(request, target) {
       }))
     ],
     ...options,
-    response_format: {
-      ...imageSize === undefined ? {} : { image_size: imageSize },
-      ...isObject2(extraFormat) ? extraFormat : {},
-      type: "image",
-      aspect_ratio: request.size.aspectRatio
-    }
+    response_format: { ...isObject2(extraFormat) ? extraFormat : {}, type: "image" }
   };
 }
 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 +23056,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) {
@@ -22455,12 +23076,13 @@ async function sendInteraction(request, target, http) {
   const said = content.flatMap((block) => block.text === undefined ? [] : [block.text]).join(" ");
   throw providerError("other", target.providerId, `the Interaction ended "${interaction.status}" with no image.${said === "" ? "" : ` The model wrote: ${said}`}`);
 }
-var gemini = {
-  builtInCapabilities: (modelId) => geminiModel(modelId).capabilities,
-  docsUrl: () => "https://ai.google.dev/api/interactions-api",
-  reservedOptions: ["model", "input"],
-  async submit(request, target, http) {
-    return { wait: () => inParallel(request.n, target.providerId, () => sendInteraction(request, target, http)) };
+var gemini2 = {
+  docsUrl: () => "https://ai.google.dev/gemini-api/docs/image-generation",
+  parameterGuide: (modelId, modality) => modality === "image" ? geminiGuide(modelId) : undefined,
+  requestFields: { image: { shape: ["response_format.aspect_ratio"], resolution: "response_format.image_size" } },
+  reservedOptions: ["model", "input", "response_format.type"],
+  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);
@@ -22511,32 +23133,121 @@ function trimmed(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
 }
 
-// src/protocols/multipart.ts
-import { randomUUID } from "node:crypto";
-function multipartBody(fields, files) {
-  const boundary = `litevision-${randomUUID()}`;
-  const encoder = new TextEncoder;
-  const quote = (value) => value.replace(/["\r\n\\]/g, (char) => encodeURIComponent(char));
-  const parts = [];
-  for (const [name, value] of fields) {
-    parts.push(encoder.encode(`--${boundary}\r
-Content-Disposition: form-data; name="${quote(name)}"\r
-\r
-${value}\r
-`));
-  }
-  for (const file of files) {
-    parts.push(encoder.encode(`--${boundary}\r
-Content-Disposition: form-data; name="${quote(file.name)}"; filename="${quote(file.fileName)}"\r
-Content-Type: ${file.mimeType}\r
-\r
-`), file.bytes, encoder.encode(`\r
-`));
-  }
-  parts.push(encoder.encode(`--${boundary}--\r
-`));
-  return { body: Buffer.concat(parts), contentType: `multipart/form-data; boundary=${boundary}` };
-}
+// src/protocols/guides/openai-images.ts
+var checked3 = "2026-11-05";
+var sources2 = [
+  "https://developers.openai.com/api/reference/resources/images/methods/generate",
+  "https://developers.openai.com/api/reference/resources/images/methods/edit",
+  "https://developers.openai.com/api/docs/guides/image-generation"
+];
+var shared = {
+  background: {
+    name: "background",
+    values: "auto, opaque, transparent (transparent needs output_format png or webp).",
+    default: "auto",
+    price: "no effect."
+  },
+  outputFormat: {
+    name: "output_format",
+    values: "png, jpeg, webp.",
+    default: "png",
+    price: "no effect."
+  },
+  outputCompression: {
+    name: "output_compression",
+    values: "0–100, for jpeg and webp.",
+    default: "100",
+    price: "no effect."
+  },
+  moderation: { name: "moderation", values: "auto, low.", default: "auto", price: "no effect." },
+  n: { name: "n", values: "1–10 images per request; litevision sends `n` here.", default: "1", price: "each image is billed." }
+};
+var arbitrarySize = "auto, or any WIDTHxHEIGHT: both sides multiples of 16, the long side at most 3:1 to the short, at most 3840 a side, 655,360–8,294,400 pixels in all (above 2560x1440 is experimental). Popular: 1024x1024, 1536x1024, 1024x1536, 2048x2048, 2048x1152, 3840x2160, 2160x3840.";
+var sizePrice = "billed by output tokens, which grow with the size and the quality; a larger non-square size can cost fewer tokens than a square.";
+var gptImage252 = {
+  family: "GPT Image 2.5",
+  parameters: [
+    { name: "size", values: arbitrarySize, default: "auto", price: sizePrice },
+    {
+      name: "quality",
+      values: "auto, low, medium, high, xhigh, max.",
+      default: "auto",
+      price: "the main price lever: at 1024x1024 about $0.006 low, $0.013 medium, $0.053 high, up to $0.21 max ($30 per 1M image output tokens)."
+    },
+    shared.background,
+    shared.outputFormat,
+    shared.outputCompression,
+    shared.moderation,
+    shared.n
+  ],
+  sources: [...sources2, "https://developers.openai.com/api/docs/models/gpt-image-2.5-flare"],
+  checked: checked3,
+  shapeFields: ["size"]
+};
+var gptImage26 = {
+  ...gptImage252,
+  family: "GPT Image 2.6",
+  parameters: [
+    ...gptImage252.parameters,
+    { name: "complexity", values: "low, medium, high.", default: "high", price: "no separate fee." }
+  ],
+  sources: [...sources2, "https://developers.openai.com/api/docs/models/gpt-image-2.6-sunburst"],
+  notes: ["The size rule above is GPT Image 2.5's: OpenAI does not say outright that 2.6 still images take arbitrary sizes."]
+};
+var gptImage22 = {
+  family: "GPT Image 2",
+  parameters: [
+    { name: "size", values: arbitrarySize, default: "auto", price: sizePrice },
+    {
+      name: "quality",
+      values: "auto, low, medium, high.",
+      default: "auto",
+      price: "1024x1024 costs $0.006 low, $0.053 medium, $0.211 high; 1536x1024 and 1024x1536 cost $0.005, $0.041, $0.165."
+    },
+    { ...shared.background, values: "auto, opaque, transparent (transparent is a preview on gpt-image-2)." },
+    shared.outputFormat,
+    shared.outputCompression,
+    shared.moderation,
+    shared.n
+  ],
+  sources: [...sources2, "https://developers.openai.com/api/docs/models/gpt-image-2"],
+  checked: checked3,
+  shapeFields: ["size"]
+};
+var gptImage12 = {
+  family: "GPT Image 1.x",
+  parameters: [
+    {
+      name: "size",
+      values: "auto, 1024x1024, 1536x1024, 1024x1536.",
+      default: "auto",
+      price: "gpt-image-1.5: portrait and landscape cost about 1.5 times the square."
+    },
+    {
+      name: "quality",
+      values: "auto, low, medium, high.",
+      default: "auto",
+      price: "gpt-image-1.5 at 1024x1024: $0.009 low, $0.034 medium, $0.133 high; gpt-image-1-mini: $0.005, $0.011, $0.036."
+    },
+    { name: "input_fidelity", values: "high, low (gpt-image-1-mini takes low only).", default: "low", price: "not documented." },
+    shared.background,
+    shared.outputFormat,
+    shared.outputCompression,
+    shared.moderation,
+    shared.n
+  ],
+  sources: [...sources2, "https://developers.openai.com/api/docs/models/gpt-image-1.5"],
+  checked: checked3,
+  notes: ["OpenAI marks gpt-image-1.5 deprecated and shut gpt-image-1 down on 2026-10-23; a relay may still serve them."],
+  shapeFields: ["size"]
+};
+var entries3 = [
+  { matches: /^gpt-image-2\.6(-|$)/, guide: gptImage26 },
+  { matches: /^gpt-image-2\.5(-|$)/, guide: gptImage252 },
+  { matches: /^gpt-image-2(-\d{4}-\d{2}-\d{2})?$/, guide: gptImage22 },
+  { matches: /^(gpt-image-1(\.5|-mini)?|chatgpt-image-latest)$/, guide: gptImage12 }
+];
+var openaiImagesGuide = (modelId) => guideFor(entries3, modelId);
 
 // src/protocols/openai-images.ts
 var successSchema = object({
@@ -22546,32 +23257,10 @@ var errorSchema3 = object({
   error: object({
     message: string2().optional(),
     code: string2().nullish(),
-    type: string2().nullish()
+    type: string2().nullish(),
+    param: string2().nullish()
   })
 });
-var gptImage = {
-  sizes: [
-    { aspectRatio: "1:1", width: 1024, height: 1024 },
-    { aspectRatio: "3:2", width: 1536, height: 1024 },
-    { aspectRatio: "2:3", width: 1024, height: 1536 }
-  ],
-  maxReferences: 16,
-  maxImages: 10
-};
-var dalle3 = {
-  sizes: [
-    { aspectRatio: "1:1", width: 1024, height: 1024 },
-    { aspectRatio: "16:9", width: 1792, height: 1024 },
-    { aspectRatio: "9:16", width: 1024, height: 1792 }
-  ],
-  maxReferences: 0,
-  maxImages: 1
-};
-var dalle2 = {
-  sizes: [{ aspectRatio: "1:1", width: 1024, height: 1024 }],
-  maxReferences: 1,
-  maxImages: 10
-};
 function buildRequest(request, target) {
   const baseUrl = target.baseUrl.replace(/\/+$/, "");
   const headers = { authorization: `Bearer ${target.credential}` };
@@ -22579,7 +23268,6 @@ function buildRequest(request, target) {
     model: target.modelId,
     prompt: request.prompt,
     n: request.n,
-    size: formatSize(request.size),
     ...request.providerOptions
   };
   if (request.references.length === 0) {
@@ -22593,18 +23281,13 @@ function buildRequest(request, target) {
   return { url: `${baseUrl}/images/edits`, init: { method: "POST", headers: { ...headers, "content-type": contentType }, body } };
 }
 var openaiImages = {
-  builtInCapabilities(modelId) {
-    if (modelId.startsWith("dall-e-3"))
-      return dalle3;
-    if (modelId.startsWith("dall-e-2"))
-      return dalle2;
-    return gptImage;
-  },
   docsUrl: () => "https://platform.openai.com/docs/api-reference/images/create",
-  reservedOptions: ["model", "prompt", "n", "size", "image", "image[]"],
-  async submit(request, target, http) {
+  parameterGuide: (modelId, modality) => modality === "image" ? openaiImagesGuide(modelId) : undefined,
+  requestFields: { image: { shape: ["size"] } },
+  reservedOptions: ["model", "prompt", "image", "image[]"],
+  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 +23297,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,106 +23349,557 @@ async function fetchModelIds3(target, http) {
   return { ok: true, modelIds: parsed.data.data.map((model) => model.id).sort() };
 }
 
+// src/protocols/guides/together.ts
+var checked4 = "2026-11-05";
+var imageSources = [
+  "https://docs.together.ai/docs/inference/images/parameters",
+  "https://docs.together.ai/docs/inference/images/reference-images",
+  "https://docs.together.ai/docs/serverless/models"
+];
+var videoSources = [
+  "https://docs.together.ai/docs/inference/videos/parameters",
+  "https://docs.together.ai/docs/inference/videos/reference-and-keyframes",
+  "https://docs.together.ai/docs/serverless/models#video-models"
+];
+var pixels = (range, price) => [
+  { name: "width", values: `${range}, a multiple of 8.`, default: "1024", price },
+  { name: "height", values: `${range}, a multiple of 8.`, default: "1024", price }
+];
+var common = [
+  { name: "n", values: "1–4 images per request; litevision sends `n` here.", default: "1", price: "each image is billed." },
+  { name: "seed", values: "any integer.", default: "random", price: "no effect." },
+  { name: "output_format", values: "jpeg, png.", default: "jpeg", price: "no effect." }
+];
+var imageShape = [{ width: "width", height: "height" }, "aspect_ratio"];
+var flux22 = {
+  family: "FLUX.2 [pro], [flex], [dev]",
+  parameters: [
+    ...pixels("256–1920", "the [pro] and [flex] estimate is $0.03+ per image, [dev] $0.0154+; larger images cost more."),
+    {
+      name: "reference_images",
+      values: "an array of image links; litevision fills it from `references`. Together gives no count; BFL says up to 10.",
+      default: "none",
+      price: "not documented."
+    },
+    { name: "prompt_upsampling", values: "true, false.", default: "true", price: "no effect." },
+    { name: "steps", values: "[dev] and [flex] only.", default: "the Provider picks", price: "not documented." },
+    { name: "guidance", values: "[dev] and [flex] only.", default: "the Provider picks", price: "not documented." },
+    ...common
+  ],
+  sources: [...imageSources, "https://docs.together.ai/docs/quickstart-flux", "https://docs.bfl.ml/flux_2/flux2_overview"],
+  checked: checked4,
+  notes: [
+    "Default size: the quickstart says 1024x768, the API reference 1024x1024.",
+    "Most output: Together's quickstart says up to 9 MP for [pro], BFL says up to 4 MP."
+  ],
+  shapeFields: imageShape
+};
+var flux2Max = {
+  family: "FLUX.2 [max]",
+  parameters: [...pixels("assumed 256–1920 as for the other FLUX.2 models", "$0.07 per megapixel at 50 steps: doubling the pixels doubles the price."), ...common],
+  sources: [...imageSources, "https://docs.together.ai/docs/quickstart-flux"],
+  checked: checked4,
+  notes: ["Together documents neither its size range nor reference images."],
+  shapeFields: imageShape
+};
+var kontext = {
+  family: "FLUX.1 Kontext [pro], [max]",
+  parameters: [
+    {
+      name: "aspect_ratio",
+      values: 'a ratio such as "1:1", "16:9", "9:16", "4:3", "3:2" (examples Together gives).',
+      default: "the Provider picks",
+      price: "[pro] $0.04 and [max] $0.08 per megapixel."
+    },
+    ...pixels("multiples of 8, in place of aspect_ratio", "billed per megapixel."),
+    { name: "image_url", values: "one image link; litevision fills it from the first of `references`.", default: "none", price: "not documented." },
+    { name: "steps", values: "an integer; more than the default costs proportionally more.", default: "28", price: "price × steps ÷ 28 above the default." },
+    ...common
+  ],
+  sources: [...imageSources, "https://docs.together.ai/docs/quickstart-flux"],
+  checked: checked4,
+  notes: ["`aspect_ratio` is in Together's docs but not in its OpenAPI schema."],
+  shapeFields: imageShape
+};
+var flux11 = {
+  family: "FLUX1.1 [pro]",
+  parameters: [...pixels("multiples of 8", "$0.04 per megapixel: doubling the pixels doubles the price."), ...common],
+  sources: imageSources,
+  checked: checked4,
+  notes: ["Takes no reference images."],
+  shapeFields: imageShape
+};
+var gemini3Pro = {
+  family: "Gemini 3 Pro Image on Together",
+  parameters: [
+    {
+      name: "width",
+      values: "with height, one of Together's sizes: 1K 1024x1024, 1264x848, 848x1264, 1200x896, 896x1200, 928x1152, 1152x928, 768x1376, 1376x768, 1584x672; 2K 2048x2048, 2528x1696, 2752x1536 and the like; 4K 4096x4096, 5504x3072 and the like.",
+      default: "1024",
+      price: "$0.134 at 1K or 2K (the same), about $0.24 at 4K."
+    },
+    { name: "height", values: "with width, as above.", default: "1024", price: "as width." },
+    { name: "reference_images", values: "an array of image links; litevision fills it from `references`. Count not documented by Together (Google: up to 14).", default: "none", price: "not documented." },
+    ...common
+  ],
+  sources: imageSources,
+  checked: checked4,
+  notes: ['Together gives some sizes as alternatives ("1548x672 or 1584x672", "5096x3392 or 5056x3392"); Google says 1584x672 and 5056x3392.'],
+  shapeFields: imageShape
+};
+var flash252 = {
+  family: "Gemini 2.5 Flash Image on Together",
+  parameters: [
+    ...pixels("not documented by Together", "estimated at $0.039+ per image."),
+    { name: "reference_images", values: "an array of image links; litevision fills it from `references`. Count not documented.", default: "none", price: "not documented." },
+    ...common
+  ],
+  sources: imageSources,
+  checked: checked4,
+  notes: ["Together documents no sizes for this model; Google's own sizes are about a megapixel at each ratio."],
+  shapeFields: imageShape
+};
+var imageEntries = [
+  { matches: /^black-forest-labs\/FLUX\.2-max$/i, guide: flux2Max },
+  { matches: /^black-forest-labs\/FLUX\.2-(pro|flex|dev)$/i, guide: flux22 },
+  { matches: /^black-forest-labs\/FLUX\.1-kontext-(pro|max)$/i, guide: kontext },
+  { matches: /^black-forest-labs\/FLUX\.1\.1-pro$/i, guide: flux11 },
+  { matches: /^google\/gemini-3-pro-image$/i, guide: gemini3Pro },
+  { matches: /^google\/flash-image-2\.5$/i, guide: flash252 }
+];
+var videoCommon = [
+  { name: "seed", values: "0–2,147,483,647.", default: "random", price: "no effect." },
+  { name: "negative_prompt", values: "text, at most 500 characters.", default: "none", price: "no effect." },
+  {
+    name: "media.frame_images",
+    values: 'litevision fills it from `first_frame` and `last_frame` as { input_image, frame: "first" | "last" }.',
+    default: "none",
+    price: "not documented."
+  }
+];
+var wan = (variant, seconds, media) => ({
+  family: `Wan 2.7 ${variant}`,
+  parameters: [
+    {
+      name: "resolution",
+      values: "720P, 1080P (16:9 is 1280x720 or 1920x1080; 4:3 is 1104x832 or 1648x1248).",
+      default: "1080P",
+      price: "$0.10 per video in Together's catalog, which gives no resolution or length."
+    },
+    { name: "ratio", values: "16:9, 9:16, 1:1, 4:3, 3:4.", default: "16:9", price: "no effect." },
+    { name: "seconds", values: `${seconds}, as a string.`, default: '"5"', price: "not documented." },
+    ...videoCommon
+  ],
+  sources: [...videoSources, "https://docs.together.ai/docs/wan2.7-quickstart"],
+  checked: checked4,
+  notes: [media, "30 fps MP4."],
+  shapeFields: ["ratio"],
+  durationField: "seconds"
+});
+var seedance25 = {
+  family: "Seedance 2.5",
+  parameters: [
+    { name: "resolution", values: "480p, 720p.", default: "720p", price: "480p $0.115 per second; 720p from $0.249 per second." },
+    { name: "seconds", values: "4–30 whole seconds, as a string.", default: '"5"', price: "billed per second of output." },
+    { name: "media.reference_images", values: "up to 30 image links; litevision fills it from `references`.", default: "none", price: "not documented." },
+    ...videoCommon
+  ],
+  sources: [...videoSources, "https://docs.together.ai/docs/seedance2.5-quickstart"],
+  checked: checked4,
+  notes: [
+    "Takes no ratio, width or height: the shape follows the first frame, else the model picks. Audio is always on.",
+    "Frames and references cannot be combined.",
+    'The catalog lists $0.115 under "Price per video"; the quickstart says per second, which is what is given here.'
+  ],
+  shapeFields: [],
+  durationField: "seconds"
+};
+var videoEntries = [
+  { matches: /^Wan-AI\/wan2\.7-t2v$/i, guide: wan("text-to-video", "2–15", "Takes no frames or reference images.") },
+  { matches: /^Wan-AI\/wan2\.7-i2v$/i, guide: wan("image-to-video", "2–15", "Takes a first and/or last frame.") },
+  {
+    matches: /^Wan-AI\/wan2\.7-r2v$/i,
+    guide: wan("reference-to-video", "2–10", "Takes several reference images in media.reference_images; Together gives no count.")
+  },
+  { matches: /^ByteDance\/Seedance-2\.5$/i, guide: seedance25 }
+];
+var togetherGuide = (modelId, modality) => guideFor(modality === "video" ? videoEntries : imageEntries, modelId);
+
+// 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 imageFamilies = [
+  { matches: /^black-forest-labs\/FLUX\.1-kontext-/i, references: "image_url", docsUrl: docs.flux },
+  { matches: /^black-forest-labs\//i, references: "reference_images", docsUrl: docs.flux },
+  { matches: /^google\/(gemini-3-pro-image|flash-image-2\.5)$/i, references: "reference_images", docsUrl: docs.referenceImages }
+];
+var otherImages = { matches: /.*/, references: "reference_images", docsUrl: docs.imageParameters };
+var imageFamily = (modelId) => imageFamilies.find((family) => family.matches.test(modelId)) ?? otherImages;
+var videoFamilies = [
+  { matches: /^Wan-AI\/wan2\.7-/i, docsUrl: docs.wan },
+  { matches: /^ByteDance\/Seedance-2\.5$/i, docsUrl: docs.seedance }
+];
+var videoDocsUrl = (modelId) => videoFamilies.find((family) => family.matches.test(modelId))?.docsUrl ?? docs.videoParameters;
+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 = {
+  parameterGuide: (modelId, modality) => togetherGuide(modelId, modality),
+  docsUrl: (modelId, modality = "image") => modality === "video" ? videoDocsUrl(modelId) : imageFamily(modelId).docsUrl,
+  requestFields: {
+    image: { shape: [{ width: "width", height: "height" }, "aspect_ratio"] },
+    video: { shape: [{ width: "width", height: "height" }, "ratio"], duration: "seconds", resolution: "resolution" }
+  },
+  reservedOptions: ["model", "prompt", "response_format", "reference_images", "image_url"],
+  reservedVideoOptions: ["model", "prompt", "media"],
+  async submit(request, target, http, context) {
+    const family = imageFamily(target.modelId);
+    const { references } = request;
+    const body = {
+      model: target.modelId,
+      prompt: request.prompt,
+      n: request.n,
+      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 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 body = {
+      model: target.modelId,
+      prompt: request.prompt,
+      ...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/guides/venice.ts
+var checked5 = "2026-11-05";
+var generateSources = [
+  "https://docs.venice.ai/api-reference/endpoint/image/generate",
+  "https://docs.venice.ai/models/image",
+  "https://api.venice.ai/api/v1/models?type=image"
+];
+var editSources = [
+  "https://docs.venice.ai/api-reference/endpoint/image/edit",
+  "https://docs.venice.ai/api-reference/endpoint/image/multi-edit",
+  "https://api.venice.ai/api/v1/models?type=inpaint"
+];
+var generateCommon = [
+  { name: "variants", values: "1–4 images per request; litevision sends `n` here.", default: "1", price: "each image is billed." },
+  { name: "format", values: "jpeg, png, webp.", default: "png (litevision's choice; Venice's own is webp)", price: "no effect." },
+  { name: "negative_prompt", values: "text.", default: "none", price: "no effect." },
+  { name: "seed", values: "−999,999,999 to 999,999,999.", default: "random", price: "no effect." },
+  { name: "safe_mode", values: "true, false.", default: "false (litevision's choice; Venice's own is true)", price: "no effect." },
+  { name: "hide_watermark", values: "true, false.", default: "true (litevision's choice)", price: "no effect." }
+];
+var ratioShape = [{ width: "width", height: "height" }, "aspect_ratio"];
+var pixelModels = {
+  family: "Venice pixel-sized models (venice-sd35, wai-Illustrious, lustify, z-image-turbo, chroma)",
+  parameters: [
+    {
+      name: "width",
+      values: "1–1280, divisible by the model's widthHeightDivisor (16 for venice-sd35 and wai-Illustrious, 8 for the rest).",
+      default: "1024",
+      price: "$0.01 per image whatever the size."
+    },
+    { name: "height", values: "as width.", default: "1024", price: "as width." },
+    { name: "cfg_scale", values: "0–20.", default: "the Provider picks", price: "no effect." },
+    { name: "steps", values: "per model (venice-sd35: up to 30).", default: "per model (venice-sd35: 25)", price: "no effect." },
+    ...generateCommon
+  ],
+  sources: generateSources,
+  checked: checked5,
+  shapeFields: ratioShape
+};
+var tierModels = {
+  family: "Venice models sized by aspect ratio and resolution tier",
+  parameters: [
+    {
+      name: "aspect_ratio",
+      values: "per model, most of 1:1, 3:2, 16:9, 21:9, 9:16, 2:3, 3:4, 4:5 (grok-imagine-* lack 21:9 and 4:5 in part; 4:3 only on seedream-v5-*).",
+      default: "1:1",
+      price: "no effect."
+    },
+    {
+      name: "resolution",
+      values: "1K, 2K, and on some models 4K; per model.",
+      default: "1K",
+      price: "per model at 1K / 2K / 4K: gpt-image-2-5-flare and -sunburst $0.07 / $0.15 / $0.23; gpt-image-2 $0.27 / $0.51 / $0.84; nano-banana-2 and -2-1 $0.10 / $0.14 / $0.19; nano-banana-pro $0.18 / $0.23 / $0.35; flux-3-image $0.12 / $0.29 / $0.98; krea-2-turbo $0.04 / $0.06; grok-imagine-image $0.03 / $0.04; seedream-v5-pro $0.06 / $0.11; qwen-image-3-pro $0.05 / $0.09; the same at 1K and 2K on ideogram-v4-5 ($0.26), qwen-image-3 ($0.04), qwen-image-2-1-turbo ($0.02) and qwen-image-2-1-pro ($0.05)."
+    },
+    {
+      name: "quality",
+      values: "low, medium, high on models that list qualities (gpt-image-2*, ideogram-v4-5; grok-imagine-image-2-0 low, medium).",
+      default: "high",
+      price: "gpt-image-2 at 1K: $0.02 low, $0.07 medium, $0.26 high; gpt-image-2.5 at 1K: $0.03, $0.04, $0.07."
+    },
+    ...generateCommon
+  ],
+  sources: generateSources,
+  checked: checked5,
+  notes: ["Venice publishes no pixel sizes for these models.", "gpt-image-2's headline prices are $0.01 above its per-quality high prices; both are in Venice's model list."],
+  shapeFields: ratioShape
+};
+var ratioModels = {
+  family: "Venice models sized by aspect ratio",
+  parameters: [
+    {
+      name: "aspect_ratio",
+      values: "per model, most of 1:1, 3:2, 16:9, 21:9, 9:16, 2:3, 3:4, 4:5 (gpt-image-1-5: 1:1, 3:2, 2:3; flux-2-max also auto).",
+      default: "1:1 (flux-2-max: auto)",
+      price: "no effect; per image: flux-2-pro $0.03, flux-2-max $0.09, gpt-image-1-5 $0.26, hunyuan-image-v3 $0.09, ideogram-v4 $0.06, krea-v2-large $0.07, krea-v2-medium $0.04, luma-uni-1 $0.05, luma-uni-1-max $0.12, muse-image $0.02, nano-banana-2-lite $0.06, recraft-v4 $0.05, recraft-v4-pro $0.29, seedream-v4 $0.05, seedream-v5-lite $0.05, qwen-image $0.03, qwen-image-2 $0.05, qwen-image-2-pro $0.10, wan-2-7-text-to-image $0.0375, wan-2-7-pro-text-to-image $0.094."
+    },
+    ...generateCommon
+  ],
+  sources: generateSources,
+  checked: checked5,
+  notes: ["The Qwen Image models reject width and height with a 400.", "krea-v2-* and luma-uni-1* take up to 3 style_references."],
+  shapeFields: ratioShape
+};
+var editModels = {
+  family: "Venice edit models (`-edit`)",
+  parameters: [
+    {
+      name: "aspect_ratio",
+      values: "auto, 1:1, 3:2, 16:9, 21:9, 9:16, 2:3, 3:4, 4:3, 4:5; a subset per model.",
+      default: "auto",
+      price: "no effect."
+    },
+    {
+      name: "resolution",
+      values: "1K, 2K, and on some models 4K; per model.",
+      default: "1K",
+      price: "per model, e.g. nano-banana-pro-edit $0.18 / $0.23 / $0.35, gpt-image-2-5-flare-edit $0.08 / $0.15 / $0.24."
+    },
+    {
+      name: "quality",
+      values: "low, medium, high; only on /image/multi-edit (several references), where the model lists qualities. /image/edit rejects it.",
+      default: "the model's default tier",
+      price: "per model."
+    },
+    { name: "output_format", values: "jpeg, png, webp.", default: "png (litevision's choice)", price: "no effect." }
+  ],
+  sources: editSources,
+  checked: checked5,
+  notes: [
+    "Reference images per Job: the model list's maxInputImages, else 3, or 1 when combineImages is false. The multi-edit docs name capabilities.maxInputImages, the model list puts it in constraints.",
+    "One reference image goes to /image/edit, several to /image/multi-edit; each image of a Job is its own request."
+  ],
+  shapeFields: ["aspect_ratio"]
+};
+var entries4 = [
+  { matches: /(^|-)edit(-|$)/, guide: editModels },
+  { matches: /^(venice-sd35|wai-Illustrious|lustify-(sdxl|v7|v8)|z-image-turbo|chroma)$/, guide: pixelModels },
+  {
+    matches: /^(gpt-image-2(-5-(flare|sunburst))?|nano-banana-(2|2-1|pro)|flux-3-image|krea-2-turbo|grok-imagine-image(-2-0)?|ideogram-v4-5|seedream-v5-pro|qwen-image-3(-pro)?|qwen-image-2-1-(turbo|pro))$/,
+    guide: tierModels
+  },
+  {
+    matches: /^(flux-2-(pro|max)|gpt-image-1-5|hunyuan-image-v3|ideogram-v4|krea-v2-(large|medium)|luma-uni-1(-max)?|muse-image|nano-banana-2-lite|recraft-v4(-pro)?|seedream-v4|seedream-v5-lite|qwen-image(-2(-pro)?)?|wan-2-7(-pro)?-text-to-image)$/,
+    guide: ratioModels
+  }
+];
+var veniceGuide = (modelId) => guideFor(entries4, modelId);
+
 // 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";
-var maxImages = 4;
-var constraintsSchema = object({
-  aspectRatios: array(string2()).optional(),
-  widthHeightDivisor: number2().positive().optional(),
-  combineImages: boolean2().optional(),
-  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(),
-    model_spec: object({
-      constraints: record(string2(), unknown()).optional(),
-      capabilities: object({ maxInputImages: number2().int().positive().optional() }).passthrough().optional()
-    }).passthrough().optional()
+    model_spec: object({ constraints: record(string2(), unknown()).optional() }).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()),
   content_policy_violation_count: number2().int().nonnegative().optional()
 });
-function sizeFor(aspectRatio, divisor, maxSide = Infinity) {
-  const [w, h] = aspectRatio.split(":").map(Number);
-  const area = 1024 * 1024;
-  let width = Math.sqrt(area * w / h);
-  let height = Math.sqrt(area * h / w);
-  const scale = Math.min(1, maxSide / width, maxSide / height);
-  width *= scale;
-  height *= scale;
-  const snap = (value) => Math.max(divisor, Math.round(value / divisor) * divisor);
-  return { aspectRatio, width: snap(width), height: snap(height) };
-}
-function pixelSizes(divisor) {
-  return aspectRatios.map((ratio) => sizeFor(ratio, divisor, 1280));
-}
-function ratioSizes(ratios) {
-  return aspectRatios.filter((ratio) => ratios.includes(ratio)).map((ratio) => sizeFor(ratio, 16));
-}
 function looksLikeEdit(modelId) {
   return /(^|-)edit(-|$)/.test(modelId);
 }
-var pixelModels = ["venice-sd35", "hidream", "lustify-sdxl", "flux-dev", "flux-dev-uncensored", "pony-realism"];
-function builtInModel(modelId) {
-  if (looksLikeEdit(modelId)) {
-    return { kind: "edit", sizing: "ratio", capabilities: { sizes: ratioSizes(aspectRatios), maxReferences: 3, maxImages } };
-  }
-  if (pixelModels.includes(modelId)) {
-    return { kind: "generate", sizing: "pixels", capabilities: { sizes: pixelSizes(16), maxReferences: 0, maxImages } };
-  }
-  return {
-    kind: "generate",
-    sizing: "ratio",
-    capabilities: { sizes: ratioSizes(["1:1", "16:9", "9:16", "3:2", "2:3"]), maxReferences: 0, maxImages }
-  };
-}
-function describeModel(listed, listType) {
-  const raw = listed.model_spec?.constraints;
-  const parsed = constraintsSchema.safeParse(raw ?? {});
-  const constraints = parsed.success ? parsed.data : {};
-  const nonEmpty = (capabilities) => capabilities.sizes.length === 0 ? undefined : capabilities;
-  if ((listed.type ?? listType) === "inpaint") {
-    const maxReferences = constraints.maxInputImages ?? listed.model_spec?.capabilities?.maxInputImages ?? (constraints.combineImages === false ? 1 : 3);
-    return {
-      kind: "edit",
-      sizing: "ratio",
-      capabilities: nonEmpty({ sizes: ratioSizes(constraints.aspectRatios ?? []), maxReferences, maxImages }),
-      constraints: raw
-    };
-  }
-  if (sizingOf(constraints) === "pixels") {
-    return {
-      kind: "generate",
-      sizing: "pixels",
-      capabilities: { sizes: pixelSizes(constraints.widthHeightDivisor), maxReferences: 0, maxImages },
-      constraints: raw
-    };
-  }
-  return {
-    kind: "generate",
-    sizing: "ratio",
-    capabilities: nonEmpty({ sizes: ratioSizes(constraints.aspectRatios ?? []), maxReferences: 0, maxImages }),
-    constraints: raw
-  };
-}
 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,19 +23909,12 @@ 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.` };
   }
   return { ok: true, models: parsed.data.data };
 }
-function describedModel(described, modelId) {
-  const kind = described.capabilities.maxReferences > 0 ? "edit" : "generate";
-  const constraints = constraintsSchema.safeParse(described.parameterSchema);
-  if (described.parameterSchema === undefined || !constraints.success)
-    return { kind, sizing: builtInModel(modelId).sizing };
-  return { kind, sizing: sizingOf(constraints.data) };
-}
 async function lookUpModel(target, http) {
   const types = looksLikeEdit(target.modelId) ? ["inpaint", "image"] : ["image", "inpaint"];
   for (const type of types) {
@@ -22794,41 +23923,48 @@ async function lookUpModel(target, http) {
       throw new Error(list.message);
     const listed = list.models.find((model) => model.id === target.modelId);
     if (listed !== undefined)
-      return describeModel(listed, type);
+      return listed.model_spec?.constraints === undefined ? {} : { constraints: listed.model_spec.constraints };
   }
   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) {
-  const { size } = request;
-  const sizing = model.sizing === "pixels" ? { width: size.width, height: size.height } : { aspect_ratio: size.aspectRatio };
+async function generate(request, target, http, context) {
   const body = {
     model: target.modelId,
     prompt: request.prompt,
     variants: request.n,
     return_binary: false,
-    ...sizing,
     ...sharedDefaults,
     hide_watermark: true,
     format: "png",
@@ -22836,11 +23972,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,51 +23994,44 @@ 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 = {
     ...inputs,
     prompt: request.prompt,
-    aspect_ratio: request.size.aspectRatio,
     ...sharedDefaults,
     output_format: "png",
     ...request.providerOptions
   };
   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.");
   }
   return [{ bytes: new Uint8Array(await response.arrayBuffer()) }];
 }
 var venice = {
-  builtInCapabilities: (modelId) => builtInModel(modelId).capabilities,
   async fetchModelInfo(target, http) {
     const model = await lookUpModel(target, http);
     if (model === undefined)
       return;
-    return {
-      ...model.capabilities === undefined ? {} : { capabilities: model.capabilities },
-      ...model.constraints === undefined ? {} : { parameterSchema: model.constraints }
-    };
+    return model.constraints === undefined ? {} : { parameterSchema: model.constraints };
   },
   docsUrl: (modelId) => looksLikeEdit(modelId) ? editDocs : generateDocs,
-  reservedOptions: ["model", "modelId", "prompt", "variants", "return_binary", "width", "height", "aspect_ratio", "image", "images"],
-  async submit(request, target, http) {
-    const model = describedModel(request.model, target.modelId);
+  parameterGuide: (modelId, modality) => modality === "image" ? veniceGuide(modelId) : undefined,
+  requestFields: { image: { shape: [{ width: "width", height: "height" }, "aspect_ratio"], resolution: "resolution" } },
+  reservedOptions: ["model", "modelId", "prompt", "return_binary", "image", "images"],
+  async submit(request, target, http, context) {
     if (request.references.length > 0) {
-      return { wait: () => inParallel(request.n, target.providerId, () => edit(request, target, http)) };
-    }
-    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.`);
+      return { wait: () => inParallel(request.n, target.providerId, () => edit(request, target, http, context)) };
     }
-    const images = await generate(request, target, model, http);
+    const images = await generate(request, target, http, context);
     return { wait: async () => images };
   },
   async testConnection(target, http) {
@@ -22924,9 +24053,10 @@ var venice = {
 // src/protocols/index.ts
 var adapters = {
   "openai-images": openaiImages,
-  gemini,
+  gemini: gemini2,
   apimart,
-  venice
+  venice,
+  together
 };
 function supportedProtocols() {
   return Object.keys(adapters);
@@ -22945,6 +24075,7 @@ function adapterFor(model) {
 // src/jobs.ts
 var defaultWaitLimitMs = 120000;
 var defaultPollIntervalMs = 3000;
+var defaultRetryDelayMs = 2000;
 
 class JobFailedError extends Error {
   jobId;
@@ -22961,7 +24092,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 +24101,23 @@ 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,
+      requested: spec.normalised.requested,
+      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 +24127,45 @@ 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,
+      requested: spec.normalised.requested,
+      references: request.references.map((reference) => reference.path),
+      ...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 +24179,10 @@ 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 },
+          ...record.parameters.requested === undefined ? {} : { requested: record.parameters.requested }
         };
       }
       if (record.outcome === "failed") {
@@ -23040,7 +24199,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 +24213,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 +24245,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 +24257,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 +24273,23 @@ 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 },
+        ...base.parameters.requested === undefined ? {} : { requested: base.parameters.requested }
+      };
     } catch (error) {
       if (error instanceof JobAbandoned || this.closed)
         throw new JobAbandoned;
@@ -23135,18 +24313,57 @@ 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) {
+  if (parameters.requested !== undefined) {
+    const parsed = parameters.requested.shape === null ? undefined : parseShape(parameters.requested.shape);
+    return parsed === undefined ? undefined : { ratio: parsed.ratio, asked: parsed.label };
+  }
+  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` };
+  }
+  const { size } = parameters;
+  const ratio = size === undefined ? undefined : parseShape(size.aspectRatio);
+  return size === undefined || ratio === undefined ? undefined : { ratio: ratio.ratio, asked: `${size.aspectRatio} (${size.width}x${size.height})` };
+}
+function mismatchOf(parameters, observed) {
+  const { followsFirstFrame } = parameters;
+  const seconds = parameters.requested !== undefined ? parameters.requested.seconds ?? undefined : parameters.seconds;
+  const expected = expectedShape(parameters);
+  const problems = new Set;
+  for (const facts of observed) {
+    if (facts === null)
+      continue;
+    if (!followsFirstFrame && expected !== undefined && 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 +24373,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,21 +24489,21 @@ function isPlainObject3(value) {
 }
 
 // src/model-info.ts
+function videoModelInfo({ model }) {
+  const adapter = adapterFor(model);
+  if (adapter.submitVideo === undefined) {
+    throw new ConfigError(`Model "${model.alias}" is a video Model, but its Protocol "${model.protocol}" makes no videos in litevision.`);
+  }
+  const guide = adapter.parameterGuide?.(model.modelId, "video");
+  return {
+    docsUrl: adapter.docsUrl(model.modelId, "video"),
+    ...guide === undefined ? {} : { guide }
+  };
+}
 var modelInfoTtlMs = 24 * 60 * 60 * 1000;
 var defaultModelInfoTimeoutMs = 5000;
-var sizeSchema = object({
-  aspectRatio: _enum(aspectRatios),
-  width: number2().int().positive(),
-  height: number2().int().positive()
-});
-var capabilitiesSchema = object({
-  sizes: array(sizeSchema).min(1),
-  maxReferences: number2().int().nonnegative(),
-  maxImages: number2().int().positive()
-});
 var entrySchema = object({
   fetchedAt: string2(),
-  capabilities: capabilitiesSchema.nullable(),
   parameterSchema: unknown().optional()
 });
 var cachePath = (dirs) => join6(dirs.data, "capabilities.json");
@@ -23294,10 +24512,10 @@ function cacheKey({ model, provider }) {
 }
 async function modelInfo(deps, resolved, options = {}) {
   const adapter = adapterFor(resolved.model);
+  const guide = adapter.parameterGuide?.(resolved.model.modelId, "image");
   const builtIn = {
-    capabilities: adapter.builtInCapabilities(resolved.model.modelId),
-    source: "built-in",
-    docsUrl: adapter.docsUrl(resolved.model.modelId)
+    docsUrl: adapter.docsUrl(resolved.model.modelId, "image"),
+    ...guide === undefined ? {} : { guide }
   };
   const fetchModelInfo = adapter.fetchModelInfo;
   if (fetchModelInfo === undefined)
@@ -23322,13 +24540,9 @@ async function modelInfo(deps, resolved, options = {}) {
       entry = cached;
     }
   }
-  if (entry === undefined)
+  if (entry?.parameterSchema === undefined)
     return builtIn;
-  return {
-    ...builtIn,
-    ...entry.capabilities === null ? {} : { capabilities: entry.capabilities, source: "provider" },
-    ...entry.parameterSchema === undefined ? {} : { parameterSchema: entry.parameterSchema }
-  };
+  return { ...builtIn, parameterSchema: entry.parameterSchema };
 }
 async function refreshModelInfo(deps, alias) {
   await refreshMatching(deps, (resolved) => resolved.model.alias === alias);
@@ -23349,12 +24563,7 @@ async function refreshMatching(deps, wanted) {
   } catch {}
 }
 function toEntry(info, now) {
-  const capabilities = capabilitiesSchema.safeParse(info?.capabilities);
-  return {
-    fetchedAt: now.toISOString(),
-    capabilities: capabilities.success ? capabilities.data : null,
-    ...info?.parameterSchema === undefined ? {} : { parameterSchema: info.parameterSchema }
-  };
+  return { fetchedAt: now.toISOString(), ...info?.parameterSchema === undefined ? {} : { parameterSchema: info.parameterSchema } };
 }
 async function readCache(dirs) {
   let value;
@@ -23427,7 +24636,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 +24647,85 @@ 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);
+// src/protocols/requests.ts
+function reservedConflicts(options, reservedFields) {
+  const conflictOf = (field) => {
+    const [parent, child] = field.split(".");
+    if (!Object.hasOwn(options, parent))
+      return;
+    const value = options[parent];
+    if (child === undefined)
+      return `\`${field}\``;
+    if (!isPlainObject3(value))
+      return `\`${parent}\` as anything but an object (litevision sets \`${field}\` in it)`;
+    return Object.hasOwn(value, child) ? `\`${field}\`` : undefined;
+  };
+  const order = Object.keys(options);
+  return [...reservedFields].sort((a, b) => order.indexOf(a.split(".")[0]) - order.indexOf(b.split(".")[0])).map(conflictOf).filter((conflict) => conflict !== undefined);
+}
+function refuseReserved(providerOptions, reservedFields, fromWhat) {
+  const conflicts = reservedConflicts(providerOptions, reservedFields);
+  if (conflicts.length === 0)
+    return;
+  throw new ConfigError(`provider_options, and the Model's Standing Options they are merged over, may not set ${conflicts.join(", ")}: litevision fills ${conflicts.length === 1 ? "that field" : "those fields"} itself, from ${fromWhat}. Use those instead.`);
+}
+async function normaliseImageRequest(parameters, model, adapter, cwd) {
+  refuseReserved(parameters.providerOptions, adapter.reservedOptions, "the prompt, `references` and `model`");
   const references = await readReferences(parameters.references, cwd);
+  return {
+    request: { prompt: parameters.prompt, n: parameters.n, references, providerOptions: parameters.providerOptions },
+    requested: readRequested(fieldsToRead(adapter, model.modelId, "image"), parameters.providerOptions, "image")
+  };
+}
+async function normaliseVideoRequest(parameters, model, adapter, cwd) {
+  refuseReserved(parameters.providerOptions, adapter.reservedVideoOptions ?? [], "the prompt, `first_frame`, `last_frame`, `references` and `model`");
+  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)
+  ]);
   return {
     request: {
       prompt: parameters.prompt,
-      n: parameters.n,
-      size,
+      ...firstFrame === undefined ? {} : { firstFrame },
+      ...lastFrame === undefined ? {} : { lastFrame },
       references,
-      providerOptions: parameters.providerOptions,
-      model: { capabilities, ...described.parameterSchema === undefined ? {} : { parameterSchema: described.parameterSchema } }
+      providerOptions: parameters.providerOptions
     },
-    requestedAspectRatio: parameters.aspectRatio,
-    aspectRatioAdjusted: adjusted
+    requested: readRequested(fieldsToRead(adapter, model.modelId, "video"), parameters.providerOptions, "video")
   };
 }
 
+// src/standing-options.ts
+function mergeOptions(standing, agent) {
+  const merged = { ...standing };
+  for (const [key, value] of Object.entries(agent)) {
+    if (value === null)
+      delete merged[key];
+    else if (isPlainObject3(value))
+      merged[key] = mergeOptions(isPlainObject3(merged[key]) ? merged[key] : {}, value);
+    else
+      merged[key] = value;
+  }
+  return merged;
+}
+function reservedFields(protocol, modality) {
+  const adapter = adapterForProtocol(protocol);
+  if (adapter === undefined)
+    return [];
+  return modality === "video" ? adapter.reservedVideoOptions ?? [] : adapter.reservedOptions;
+}
+function standingOptionsProblem(value, protocol, modality) {
+  if (!isPlainObject3(value)) {
+    return 'Standing Options must be a JSON object of request fields, such as { "quality": "high" }.';
+  }
+  const conflicts = reservedConflicts(value, reservedFields(protocol, modality));
+  if (conflicts.length === 0)
+    return;
+  return `Standing Options may not set ${conflicts.join(", ")}: litevision fills ${conflicts.length === 1 ? "that field" : "those fields"} itself for Protocol "${protocol}".`;
+}
+
 // src/settings/browser.ts
 import { spawn } from "node:child_process";
 var openInBrowser = (url) => {
@@ -23522,7 +24756,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 +24867,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 +24879,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 +24910,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 +24987,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 +25014,19 @@ 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(", ")}.` }),
-  notes: notes.optional()
+  modality: _enum(modalities, { error: () => "Choose whether the Model makes images or videos." }).default("image"),
+  notes: notes.optional(),
+  standingOptions: unknown().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,11 +25039,19 @@ 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() };
     }
+    if (input.standingOptions !== undefined)
+      setStandingOptions(stored, input.standingOptions);
     config.models = [...models, stored];
   });
   return getModel(dirs, input.alias);
@@ -23769,8 +25065,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);
@@ -23782,6 +25084,8 @@ async function updateModel(dirs, wanted, input, at) {
       model.protocol = input.protocol;
     if (input.notes !== undefined)
       replaceNotes(model, input.notes, "User", at);
+    if (input.standingOptions !== undefined)
+      setStandingOptions(model, input.standingOptions);
   });
   return getModel(dirs, input.alias ?? wanted);
 }
@@ -23801,22 +25105,38 @@ 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 setStandingOptions(model, value) {
+  if (value === null || isPlainObject3(value) && Object.keys(value).length === 0) {
+    delete model.standingOptions;
+    return;
+  }
+  const problem = standingOptionsProblem(value, model.protocol, modalityOf(model));
+  if (problem !== undefined)
+    throw new SettingsError(400, problem);
+  model.standingOptions = value;
 }
 function requireFreeAlias(models, wanted) {
   if (models.some((model) => model.alias === wanted)) {
@@ -23837,15 +25157,21 @@ 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
+    ...model.standingOptions && { standingOptions: model.standingOptions },
+    default: model.alias === (modality === "video" ? defaults.defaultVideoModel : defaults.defaultImageModel)
   };
 }
 function notFound2(wanted) {
@@ -23910,7 +25236,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 +25283,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 +25306,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 +25461,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 +25517,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 +25534,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>
@@ -24390,25 +25742,52 @@ function notesHistoryRow(model, path) {
   return [el("div", { className: "note" }, ...parts)];
 }
 
+/** A JSON textarea for a Model's Standing Options: request fields every Job on it sends unless the Agent overrides them. */
+function standingOptionsField(value) {
+  const textarea = el("textarea", {
+    value: value ? JSON.stringify(value, null, 2) : "",
+    spellcheck: false,
+    placeholder: '{ "quality": "high" }',
+  });
+  const wrapper = field("Standing Options", textarea);
+  wrapper.classList.add("wide");
+  wrapper.append(el("div", { className: "note", textContent: "A JSON object of the Provider's own request fields, sent with every Job on this Model. Your Agent's provider_options override them for a Job. Leave empty for none." }));
+  /** The value to save: null when empty; throws when the text is not a JSON object. */
+  const read = () => {
+    const text = textarea.value.trim();
+    if (text === "") return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new Error('Standing Options must be a JSON object, such as { "quality": "high" }. This is not valid JSON: ' + text.slice(0, 40));
+    }
+    return parsed;
+  };
+  return { wrapper, read };
+}
+
 function modelCard(model) {
   const alias = el("input", { value: model.alias, spellcheck: false });
   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 standing = standingOptionsField(model.standingOptions);
   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, standingOptions: standing.read() });
     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,16 +25802,23 @@ 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, standing.wrapper),
     el("div", { className: "actions" }, save, el("span", { className: "spacer" }), remove),
   );
 }
 
+// The saved Models, so the fetched model list can say which model ids are already added.
+let savedModels = [];
+// Redraws the fetched model list; set by setUpAddModelForm.
+let showModelIds = () => {};
+
 async function loadModels() {
   const list = document.getElementById("model-list");
   const { models } = await api("GET", "/api/models");
+  savedModels = models;
+  showModelIds();
   list.replaceChildren(...(models.length === 0
     ? [emptyState(providerIds.length === 0 ? "Add a Provider first, then add its Models below." : "No Models yet. Add one below.")]
     : models.map(modelCard)));
@@ -24447,27 +25833,57 @@ 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");
+  // The model ids the last fetch found, and what each one makes when the Provider says.
+  let fetchedIds = [];
+  let knownModalities = {};
   protocol.replaceChildren(...options(protocols));
 
+  const forgetModelIds = () => {
+    fetchedIds = [];
+    knownModalities = {};
+    showModelIds();
+  };
+
+  // Lists the fetched model ids that make what Makes says (and those the Provider says nothing about),
+  // marking the ones already added as a Model on this Provider.
+  showModelIds = () => {
+    const shown = fetchedIds.filter((id) => (knownModalities[id] ?? modality.value) === modality.value);
+    ids.replaceChildren(...shown.map((id) => {
+      const aliases = savedModels.filter((m) => m.provider === provider.value && m.modelId === id).map((m) => m.alias);
+      return el("option", aliases.length === 0 ? { value: id } : { value: id, label: "Already added as " + aliases.join(", ") });
+    }));
+    if (fetchedIds.length === 0) return;
+    const hidden = fetchedIds.length - shown.length;
+    const other = modality.value === "image" ? "video" : "image";
+    fetchResult.textContent = shown.length + (hidden === 0 ? "" : " " + modality.value) + " model id(s) found"
+      + (hidden === 0 ? "" : ", and " + hidden + " " + other + " model id(s) hidden until Makes says " + (other === "image" ? "Images" : "Videos"))
+      + ". Pick one in the Model id field, or type your own.";
+  };
+
   // Suggest the Protocol a preset Provider's Models usually speak; the User can still change it.
   provider.onchange = () => {
     const suggested = presets.find((p) => p.id === provider.value);
     if (suggested && protocols.includes(suggested.protocol)) protocol.value = suggested.protocol;
-    ids.replaceChildren();
+    forgetModelIds();
     fetchResult.textContent = "";
   };
-  protocol.onchange = () => ids.replaceChildren();
+  protocol.onchange = forgetModelIds;
+  modality.onchange = () => showModelIds();
 
   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 })));
-      fetchResult.textContent = outcome.modelIds.length + " model id(s) found. Pick one in the Model id field, or type your own.";
+      fetchedIds = outcome.modelIds;
+      knownModalities = outcome.modalities || {};
       fetchResult.className = "result success";
+      showModelIds();
+      if (fetchedIds.length === 0) fetchResult.textContent = "No model ids found. Type the model id.";
       modelId.focus();
     } else {
+      forgetModelIds();
       fetchResult.textContent = outcome.message;
       fetchResult.className = "result " + outcome.result;
     }
@@ -24477,13 +25893,18 @@ function setUpAddModelForm() {
   let aliasEdited = false;
   alias.oninput = () => (aliasEdited = alias.value !== "");
   modelId.oninput = () => {
+    const known = knownModalities[modelId.value.trim()];
+    if (known && known !== modality.value) {
+      modality.value = known;
+      showModelIds();
+    }
     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 +25945,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 +26161,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,91 +26254,298 @@ function settingsOpener(options) {
   };
 }
 // package.json
-var version2 = "0.1.1";
+var version2 = "0.3.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\`.
+- litevision passes \`provider_options\` to the Provider as they are and translates nothing: write each Model's own fields, such as the size, resolution or length, from its Parameter Guide (\`list_models\` with \`model\`). Without them the Provider's defaults apply. Reuse Known-good Options; for anything else, or an option marked suspect, read the Parameter Guide and docs first.
+- 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 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."),
+  standing_options: record(string2(), unknown()).describe("Standing Options the User set: request fields every Job on this Model sends. Your `provider_options` are merged over them: your values win, objects merge key by key, and `null` removes a key for that Job."),
   docs_url: string2().nullable().describe("Where to read which `provider_options` this Model accepts."),
+  parameters: string2().optional().describe("In brief, what litevision knows about the Model's request parameters: its Parameter Guide, the Provider's own description, or that it knows neither."),
+  parameter_guide: object({
+    family: string2(),
+    checked: string2().describe("When the sources were last checked; read the docs first when this is old."),
+    sources: array(string2()),
+    parameters: array(object({
+      name: string2().describe("The Provider's own field name for `provider_options`, dotted for nested fields."),
+      values: string2(),
+      default: string2(),
+      price: string2().describe("How the value changes the price.")
+    })),
+    notes: array(string2())
+  }).nullable().optional().describe("Only with `model`: the built-in Parameter Guide for the Model's family. Null when litevision has none, or when the Provider describes the Model itself (see `parameter_schema`)."),
+  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 ?? ""
+    notes: model.notes ?? "",
+    standing_options: model.standingOptions ?? {}
   };
-  const heading = `${model.alias}${isDefault ? " (default)" : ""}: ${model.modelId} on ${model.provider} via ${model.protocol}.`;
-  const notes = model.notes ? ` Notes: ${model.notes}` : "";
-  let info;
+  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}` : ""}${model.standingOptions ? ` Standing Options: ${JSON.stringify(model.standingOptions)}.` : ""}`;
+  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 = {
+        docsUrl: info.docsUrl,
+        ...info.guide === undefined ? {} : { guide: info.guide }
+      };
+    } else {
+      const info = await modelInfo(deps, { model, provider });
+      described = {
+        docsUrl: info.docsUrl,
+        ...info.parameterSchema === undefined ? {} : { parameterSchema: info.parameterSchema },
+        ...info.guide === undefined ? {} : { guide: info.guide }
+      };
+    }
   } catch (error) {
     if (!(error instanceof ConfigError))
       throw error;
     return {
-      output: { ...base, capabilities: null, docs_url: null, problem: error.message },
+      output: { ...base, docs_url: null, problem: error.message },
       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
+    docs_url: described.docsUrl,
+    parameters: parametersSummary(described, model.provider),
+    known_good_options: record2.knownGood,
+    suspect_options: suspectOutput(record2)
   };
-  let text = `${heading} Supports ${describeCapabilities(capabilities)}${notes} provider_options: ${info.docsUrl}`;
+  let text = `${heading}${notes} provider_options docs: ${described.docsUrl}`;
+  if (!detailed)
+    text += ` ${output.parameters}`;
+  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 += `
-Parameter schema from the Provider: ${JSON.stringify(info.parameterSchema)}`;
-    }
+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 += `
+- ${describeRecentPick(picked)}`;
+    output.parameter_guide = described.parameterSchema === undefined && described.guide !== undefined ? guideOutput(described.guide) : null;
+    if (described.parameterSchema !== undefined)
+      output.parameter_schema = described.parameterSchema;
+    text += `
+${parameterHelp(described, model.provider)}`;
+  } else {
+    if (goodKeys.length > 0)
+      text += ` Known-good Options: ${goodKeys.join(", ")}.`;
+    if (suspectKeys.length > 0)
+      text += ` Suspect options: ${suspectKeys.join(", ")}.`;
   }
   return { output, text };
 }
+function parametersSummary(known, providerId) {
+  if (known.parameterSchema !== undefined) {
+    return `Provider "${providerId}" describes this Model's parameters itself; \`list_models\` with \`model\` shows its description.`;
+  }
+  if (known.guide !== undefined)
+    return guideSummary(known.guide);
+  return noGuide(known.docsUrl);
+}
+function parameterHelp(known, providerId) {
+  if (known.parameterSchema !== undefined) {
+    return `Parameter schema from Provider "${providerId}", which wins over litevision's own Parameter Guide: ${JSON.stringify(known.parameterSchema)}`;
+  }
+  if (known.guide !== undefined)
+    return guideText(known.guide);
+  return noGuide(known.docsUrl);
+}
+function noGuide(docsUrl) {
+  return `litevision has no Parameter Guide for this model id; read ${docsUrl} before setting provider_options.`;
+}
+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 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(deps, jobId) {
+  const job = await readJob(deps.dirs, jobId);
+  const adapter = job === undefined ? undefined : adapterForProtocol(job.protocol);
+  if (job === undefined || adapter === undefined)
+    return;
+  const modality = job.modality ?? "image";
+  const guide = adapter.parameterGuide?.(job.modelId, modality);
+  let known = { docsUrl: adapter.docsUrl(job.modelId, modality), ...guide === undefined ? {} : { guide } };
+  const provider = modality === "image" ? (await loadConfig(deps.dirs).catch(() => {
+    return;
+  }))?.providers.find((candidate) => candidate.id === job.provider) : undefined;
+  if (provider !== undefined) {
+    const model = { alias: job.model, provider: job.provider, modelId: job.modelId, protocol: job.protocol, modality };
+    known = await modelInfo(deps, { model, provider });
+  }
+  return { known, provider: job.provider, options: optionsRecord(await readRatedJobs(deps.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 failureHint(known, providerId, record2, kind) {
+  const help = kind === "rejected_option" || kind === "unsupported" ? `
+${parameterHelp(known, providerId)}` : "";
+  return `${optionsHint(known.docsUrl, record2)}${help}`;
+}
+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 requestedShapeSchema = string2().nullable().describe("The shape the request sent asks for, as litevision read it from the Model's own fields, e.g. 16:9 or 3840x2160; null when it asks for none litevision can read, so the result's shape is not checked. Compare it with `observed`.");
+var requestedResolutionSchema = string2().nullable().describe("The resolution tier the request sent asks for, as written in its Protocol's tier field, e.g. 4K or 1080P; null when it sets none. Not checked against the result.");
+var requestedDurationSchema = number2().nullable().describe("Video Jobs: the length in seconds the request sent asks for, as litevision read it; null when unreadable, so the length is not checked.");
+function requestedOutput(requested) {
+  return {
+    requested_shape: requested.shape,
+    requested_resolution: requested.resolution,
+    ...requested.seconds === undefined ? {} : { requested_duration: requested.seconds }
+  };
+}
+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 requestedText({ shape, resolution, seconds }) {
+  const size = shape === null ? resolution : resolution === null ? shape : `${shape} at ${resolution}`;
+  const read = [size, typeof seconds === "number" ? `${seconds} s` : null].filter((part) => part !== null);
+  const unread = [shape === null ? "shape" : null, seconds === null ? "length" : null].filter((part) => part !== null);
+  const asked = read.length === 0 ? "" : `The request asks for ${read.join(", ")}.`;
+  const unchecked = unread.length === 0 ? "" : `The request asks for no ${unread.join(" or ")} litevision can read, so the result's ${unread.join(" and ")} ${unread.length === 1 ? "was" : "were"} not checked.`;
+  return [asked, unchecked].filter(Boolean).join(" ");
+}
+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 +26553,10 @@ 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 } : {},
+    ...job.status === "completed" && job.requested !== undefined ? requestedOutput(job.requested) : {}
   };
 }
 function jobText(job) {
@@ -24848,111 +26565,265 @@ 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(error.kind) : ""}`;
+  }
+  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."),
+  requested_shape: requestedShapeSchema,
+  requested_resolution: requestedResolutionSchema,
+  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."),
+  requested_shape: requestedShapeSchema,
+  requested_duration: requestedDurationSchema,
+  requested_resolution: requestedResolutionSchema,
+  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,
+      references: args.references,
+      providerOptions: mergeOptions(model.standingOptions ?? {}, args.provider_options)
+    }, model, adapter, 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 (kind) => failureHint(info, model.provider, await modelOptions(deps, model), kind),
+      report: (job) => {
+        const output = { ...jobOutput(job), ...requestedOutput(normalised.requested) };
+        const asked = requestedText(normalised.requested);
+        const text = job.status === "running" ? `${jobText(job)} ${asked}` : `Saved ${job.files.length} image(s) from ${model.alias}, Job ${job.id}. ${asked}${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.first_frame === undefined ? {} : { firstFrame: args.first_frame },
+      ...args.last_frame === undefined ? {} : { lastFrame: args.last_frame },
+      references: args.references,
+      providerOptions: mergeOptions(model.standingOptions ?? {}, args.provider_options)
+    }, model, adapter, 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 (kind) => failureHint(info, model.provider, await modelOptions(deps, model), kind),
+      report: (job) => {
+        const output = { ...jobOutput(job), ...requestedOutput(normalised.requested) };
+        const asked = requestedText(normalised.requested);
+        const text = job.status === "running" ? `${jobText(job)} ${asked}` : `Saved a video from ${model.alias}, Job ${job.id}. ${asked}${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: {
+    inputSchema: strictObject({
       prompt: string2().min(1).describe("Sent to the Model verbatim."),
       model: string2().optional().describe("Alias of the Model to use. Omit to use the default image Model."),
-      n: number2().int().positive().default(1).describe("How many images to generate in this Job, up to the Model's maximum."),
-      aspect_ratio: _enum(aspectRatios).default("1:1").describe("Wanted aspect ratio. If the Model does not support it, the closest supported one is used and reported."),
+      n: number2().int().positive().default(1).describe("How many images this Job brings back: sent as the Model's own count field, or as that many requests where it has none."),
       references: array(string2().min(1)).default([]).describe("Local paths of reference images to edit or draw on. Relative paths resolve against litevision's working directory."),
       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.')
-    },
+      provider_options: record(string2(), unknown()).default({}).describe(`The Model's own request fields, passed through untouched, e.g. { "size": "2048x1152", "quality": "high" } for OpenAI: see its Parameter Guide in \`list_models\`. Merged over the Model's Standing Options. Only the model id, prompt, reference image fields and response format are litevision's.`)
+    }),
+    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: strictObject({
+      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."),
+      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(`The Model's own request fields, passed through untouched, e.g. { "resolution": "1080P", "ratio": "9:16", "seconds": "10" } for Wan 2.7: see its Parameter Guide in \`list_models\`. Merged over the Model's Standing Options. Only the model id, prompt and media fields are litevision's.`)
+    }),
+    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: strictObject({
+      variants: array(strictObject({
+        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. Defaults to 1."),
+        provider_options: record(string2(), unknown()).default({}).describe("This variant's own request fields, in its Model's own names (see its Parameter Guide), merged over its Standing Options.")
+      })).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."),
+      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.")
+    }),
     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, references, output_path }) => {
+    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 === "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: variant.provider_options, ...output_path === undefined ? {} : { output_path } };
+        return modality === "video" ? prepareVideo(resolved, shared) : prepareImage(resolved, { ...shared, n: variant.n ?? 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."),
+      requested_shape: requestedShapeSchema.optional(),
+      requested_duration: requestedDurationSchema.optional(),
+      requested_resolution: requestedResolutionSchema.optional(),
+      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(infoDeps, job_id))?.known.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 (kind) => {
+        const docs = await jobDocs(infoDeps, job_id);
+        return docs === undefined ? "" : failureHint(docs.known, docs.provider, docs.options, kind);
+      });
     }
   });
   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 +26831,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, Model Notes, Standing Options, a summary of each Model's Parameter Guide, the Known-good Options for `provider_options` and a docs link, and which Models are the defaults. Use it to choose a Model by what it accepts and costs. Pass `model` for one Model in detail: its full Parameter Guide (or the Provider's own parameter schema, which wins), the values of its Known-good and suspect options, its five most recent Ratings, and the Picks of up to five Comparisons it took part in (most recently picked first).",
     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 +26882,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)