ottoport 1.7.1 → 1.9.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ottoport",
   "description": "One API for every model. Call chat, image, video, speech and music models through the OttoPort gateway — as MCP tools, slash commands, or the bundled CLI.",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "author": {
     "name": "LITBOX LLC",
     "email": "support@ottoport.ai"

package/cli/ottoport.mjs

@@ -5,6 +5,7 @@
 //
 //   ottoport models [--modality chat|image|video]
 //   ottoport chat   "prompt" [--model claude-sonnet-5] [--system "..."] [--no-stream]
+//                   [--video <url|file>]   ask about a video (defaults to video-understanding)
 //   ottoport image  "prompt" [--model gpt-image-2] [--resolution 2k] [--ref a.png,b.png] [--out img.png]
 //   ottoport video  "prompt" [--model kling-3.0] [--duration 5] [--out clip.mp4]
 //   ottoport speech "text" [--model gpt-4o-mini-tts] [--voice alloy] [--out speech.mp3]
@@ -17,7 +18,7 @@
 //   The public CLI always targets https://ottoport.ai unless --url is passed
 //   explicitly for local development or a self-hosted gateway.
 
-import { writeFile } from "node:fs/promises";
+import { readFile, stat, writeFile } from "node:fs/promises";
 
 const BASE = "https://ottoport.ai";
 
@@ -152,11 +153,13 @@ async function cmdChat(prompt, flags) {
   const { baseUrl, apiKey } = config(flags);
   const messages = [];
   if (flags.system) messages.push({ role: "system", content: flags.system });
-  messages.push({ role: "user", content: prompt });
+  const videos = await videoParts(flags);
+  messages.push({ role: "user", content: videos.length ? [{ type: "text", text: prompt }, ...videos] : prompt });
 
   const stream = flags.stream !== false;
   const body = {
-    model: last(flags.model) || "claude-sonnet-5",
+    // A video question goes to the model built for it unless one is named.
+    model: last(flags.model) || (videos.length ? "video-understanding" : "claude-sonnet-5"),
     messages,
     stream,
     ...(flags.temperature ? { temperature: Number(last(flags.temperature)) } : {}),
@@ -202,6 +205,39 @@ async function cmdChat(prompt, flags) {
   process.stdout.write("\n");
 }
 
+const VIDEO_TYPES = { ".mp4": "video/mp4", ".m4v": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm", ".mpeg": "video/mpeg", ".mpg": "video/mpeg" };
+
+/**
+ * `--video`, once or several times (or comma-separated), as chat content parts.
+ *
+ * A URL is sent as-is: the gateway's transport fetches it, so it must be
+ * publicly reachable. A local file is inlined as a base64 data URL, which is
+ * convenient for trying a clip but costs a third more than the file on the
+ * wire — for anything large, host it and pass the URL.
+ */
+async function videoParts(flags) {
+  const list = (Array.isArray(flags.video) ? flags.video : [flags.video])
+    .filter((value) => typeof value === "string")
+    .flatMap((value) => value.split(",").map((one) => one.trim()))
+    .filter(Boolean);
+  const parts = [];
+  for (const source of list) {
+    if (/^(https?:|data:)/i.test(source)) {
+      parts.push({ type: "video_url", video_url: { url: source } });
+      continue;
+    }
+    const info = await stat(source).catch(() => null);
+    if (!info?.isFile()) die(`--video ${source}: not a URL and no such file`);
+    const ext = source.slice(source.lastIndexOf(".")).toLowerCase();
+    const type = VIDEO_TYPES[ext];
+    if (!type) die(`--video ${source}: unsupported type ${ext || "(none)"}; use ${Object.keys(VIDEO_TYPES).join(", ")}`);
+    const mb = info.size / 1e6;
+    if (mb > 20) console.error(`ottoport: ${source} is ${mb.toFixed(0)}MB; inlined it will be ~${(mb * 4 / 3).toFixed(0)}MB and may be refused — host it and pass the URL instead`);
+    parts.push({ type: "video_url", video_url: { url: `data:${type};base64,${(await readFile(source)).toString("base64")}` } });
+  }
+  return parts;
+}
+
 async function download(url, out) {
   const res = await fetch(url);
   if (!res.ok) die(`could not download ${url}: ${res.status}`);
@@ -377,6 +413,7 @@ Usage:
   ottoport models [--modality chat|image|video|tts|music] [--json]
   ottoport models <model-id> [--json]     what that one model accepts
   ottoport chat  "<prompt>" [--model claude-sonnet-5] [--system "..."] [--no-stream]
+                            [--video <url|file>[,<url|file>…]]   ask about a video
                             [--temperature 0.7] [--max-tokens 512]
   ottoport image "<prompt>" [--model gpt-image-2] [--size 1024x1024 | --resolution 2k] [--quality high]
                             [--aspect-ratio 16:9] [--n 1] [--seed 7]
@@ -409,6 +446,7 @@ Examples:
   ottoport models --modality image      # prints what each one accepts
   ottoport models veo-3.1               # its modes, tiers, and every parameter
   ottoport chat "explain MCP in one line" --model claude-haiku-4.5
+  ottoport chat "break this clip down shot by shot" --video https://example.com/clip.mp4
   ottoport image "isometric city at dusk" --model gpt-image-2 --out city.png
   ottoport video "cinematic product reveal" --model seedance-2.0-fast --resolution 1080p
   ottoport video "the logo unfolds" --image start.png --last-frame end.png

package/mcp/server.mjs

@@ -151,6 +151,34 @@ async function chat({ prompt, model, system, temperature, max_tokens }) {
   return json?.choices?.[0]?.message?.content ?? "";
 }
 
+/**
+ * Poll a job until it finishes, or until `timeoutMs` runs out.
+ *
+ * `statusPath` is the job's status route with `{id}` for the id — the same
+ * template the gateway's quote reports as `job_path` — and it is always read
+ * from BASE: every request this server makes goes to OTTOPORT_BASE_URL, which
+ * is what lets a reseller put its own gateway in front without a code change.
+ *
+ * Returns the finished job, or the last one seen with `timedOut` set so the
+ * caller can say where to pick it up. A failed job throws.
+ */
+async function waitForJob(statusPath, job, { timeoutMs, label }) {
+  const path = statusPath.replace("{id}", encodeURIComponent(job.id));
+  const deadline = Date.now() + timeoutMs;
+  while (job.status === "queued" || job.status === "processing") {
+    if (Date.now() >= deadline) return { job, timedOut: true, path };
+    await new Promise((resolve) => setTimeout(resolve, 3_000));
+    const status = await fetch(`${BASE}${path}`, { headers: headers(false) });
+    if (!status.ok) throw new Error(await gwError(status));
+    job = await status.json();
+  }
+  if (job.status === "failed") throw new Error(job.error || `${label} generation failed`);
+  return { job, timedOut: false, path };
+}
+
+const IMAGE_JOB_PATH = "/api/v1/images/generations/{id}";
+const VIDEO_JOB_PATH = "/api/v1/videos/generations/{id}";
+
 async function generateImage({ prompt, model, ...rest }) {
   // A layer-decomposition model splits `image_url` and takes the prompt as an
   // optional caption; every other image model needs the prompt. The gateway
@@ -165,10 +193,21 @@ async function generateImage({ prompt, model, ...rest }) {
     // live on the gateway and unreachable from any MCP client, silently. The
     // gateway validates against the model's capabilities and says what it
     // does not accept; this layer has no business having an opinion.
-    body: JSON.stringify({ model: model || "gpt-image-2", ...(prompt ? { prompt } : {}), ...rest }),
+    //
+    // Queued as a job and polled: a 4K or layered image can take longer than
+    // a proxy in front of the gateway holds a request open, and the hold is
+    // then settled on what actually came back.
+    body: JSON.stringify({ model: model || "gpt-image-2", ...(prompt ? { prompt } : {}), ...rest, async: true }),
   });
   if (!res.ok) throw new Error(await gwError(res));
-  const json = await res.json();
+  let json = await res.json();
+  // A 202 is a job. A 200 with `data` is the image itself — the dev key, or a
+  // gateway that predates image jobs — and is read exactly as before.
+  if (res.status === 202) {
+    const { job, timedOut, path } = await waitForJob(IMAGE_JOB_PATH, json, { timeoutMs: 5 * 60_000, label: "image" });
+    if (timedOut) return `Image job ${job.id} is still processing. Poll ${path} for its result.`;
+    json = job;
+  }
   // A layer stack prints one line per layer with what the model called it, so
   // the agent can pick "headline" out of eight URLs without opening them.
   const lines = (json.data ?? []).filter((d) => d.url).map((d) =>
@@ -191,30 +230,23 @@ async function generateVideo({ prompt, model, webhook_url, webhook_secret, ...re
     body: JSON.stringify({ model: model || "kling-3.0", ...(prompt ? { prompt } : {}), ...rest, ...(webhook_url ? { webhook_url, webhook_secret: secret } : {}) }),
   });
   if (!res.ok) throw new Error(await gwError(res));
-  let job = await res.json();
-  if (job.status === "failed") throw new Error(job.error || "video generation failed");
+  const submitted = await res.json();
+  if (submitted.status === "failed") throw new Error(submitted.error || "video generation failed");
   // With a webhook the caller has said where the result should go; holding the
   // tool call open for minutes as well would only block the agent.
-  if (webhook_url) return `Video job ${job.id} is ${job.status}. ${webhook_url} will receive video.completed or video.failed when it finishes; check deliveries with ottoport_video_webhook.`;
+  if (webhook_url) return `Video job ${submitted.id} is ${submitted.status}. ${webhook_url} will receive video.completed or video.failed when it finishes; check deliveries with ottoport_video_webhook.`;
   // The public video endpoint is deliberately asynchronous. MCP tools should
   // still fulfil their promise of returning usable output, so wait for the
   // job rather than returning a queued-job JSON blob to the agent.
-  const deadline = Date.now() + 10 * 60_000;
-  while (job.status === "queued" || job.status === "processing") {
-    if (Date.now() >= deadline) return `Video job ${job.id} is still processing. Poll /api/v1/videos/generations/${job.id} for its result.`;
-    await new Promise((resolve) => setTimeout(resolve, 3_000));
-    const status = await fetch(`${BASE}/api/v1/videos/generations/${encodeURIComponent(job.id)}`, { headers: headers(false) });
-    if (!status.ok) throw new Error(await gwError(status));
-    job = await status.json();
-  }
-  if (job.status === "failed") throw new Error(job.error || "video generation failed");
+  const { job, timedOut, path } = await waitForJob(VIDEO_JOB_PATH, submitted, { timeoutMs: 10 * 60_000, label: "video" });
+  if (timedOut) return `Video job ${job.id} is still processing. Poll ${path} for its result.`;
   const url = job.data?.[0]?.url;
   return url || JSON.stringify(job);
 }
 
 async function videoWebhook({ job_id, action = "status" }) {
   if (!job_id) throw new Error("`job_id` is required");
-  const path = `${BASE}/api/v1/videos/generations/${encodeURIComponent(job_id)}`;
+  const path = `${BASE}${VIDEO_JOB_PATH.replace("{id}", encodeURIComponent(job_id))}`;
   const res = action === "retry"
     ? await fetch(`${path}/webhook`, { method: "POST", headers: headers(false) })
     : await fetch(path, { headers: headers(false) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ottoport",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Claude Code plugin, CLI and MCP server for OttoPort — one OpenAI-compatible API for every LLM, image, video, and speech model.",
   "homepage": "https://ottoport.ai",
   "repository": {