@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
164 lines (145 loc) • 5.9 kB
text/typescript
import { pathToFileURL } from "node:url";
import type { VideoBridgePlan, VideoCallResult } from "./types";
import { submitVideoJob, pollVideoJob } from "./xai-video-client";
import { downloadVideoToArtifact, createVideoBudget, type VideoBudget } from "./artifacts";
/** Parsed arguments from the model's video_gen tool call. */
export interface ParsedVideoArgs {
ok: true;
prompt: string;
duration?: number;
resolution?: string;
aspectRatio?: string;
}
const INITIAL_POLL_INTERVAL_MS = 5_000;
const MAX_POLL_INTERVAL_MS = 15_000;
const POLL_BACKOFF = 1.5;
const DEFAULT_VIDEO_TIMEOUT_MS = 300_000; // 5 min
export type SleepFn = (ms: number, signal?: AbortSignal) => Promise<void>;
export type PollVideoJobFn = (
requestId: string,
auth: { baseUrl: string; token: string },
signal?: AbortSignal,
) => ReturnType<typeof pollVideoJob>;
export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
if (signal?.aborted) return Promise.reject(new Error("aborted"));
return new Promise((resolve, reject) => {
const onAbort = (): void => { clearTimeout(timer); reject(new Error("aborted")); };
const timer = setTimeout(() => { signal?.removeEventListener("abort", onAbort); resolve(); }, ms);
signal?.addEventListener("abort", onAbort, { once: true });
});
}
/**
* Parse the JSON arguments string from a video_gen tool call. Mirrors fulfillImageCall's
* defensive parsing: invalid JSON or missing prompt returns an error result.
*/
export function parseVideoCallArgs(raw: string):
| ParsedVideoArgs
| { ok: false; error: string } {
let args: unknown;
try {
args = JSON.parse(raw || "{}");
} catch {
return { ok: false, error: "invalid arguments JSON" };
}
if (typeof args !== "object" || args === null) {
return { ok: false, error: "invalid arguments JSON" };
}
const obj = args as Record<string, unknown>;
const prompt =
typeof obj.prompt === "string" ? obj.prompt : typeof obj.input === "string" ? obj.input : "";
if (!prompt) {
return { ok: false, error: "missing prompt" };
}
const result: ParsedVideoArgs = { ok: true, prompt };
// duration: clamp to 1-15
if (typeof obj.duration === "number") {
result.duration = Math.max(1, Math.min(15, Math.floor(obj.duration)));
}
if (typeof obj.resolution === "string" && (obj.resolution === "480p" || obj.resolution === "720p")) {
result.resolution = obj.resolution;
}
if (typeof obj.aspect_ratio === "string") {
const VALID_RATIOS = ["16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3"];
if (VALID_RATIOS.includes(obj.aspect_ratio)) result.aspectRatio = obj.aspect_ratio;
}
return result;
}
/**
* Poll a video generation job, yielding heartbeats with elapsed-time messages so the
* caller can forward them to the SSE stream. Returns the final result when the job
* completes or fails/times out.
*/
export async function* pollVideoWithHeartbeats(
requestId: string,
auth: { baseUrl: string; token: string },
signal: AbortSignal,
timeoutMs: number = DEFAULT_VIDEO_TIMEOUT_MS,
/** Test seams — avoid mock.module / global setTimeout (both poison parallel Bun CI). */
sleepFn: SleepFn = sleep,
pollFn: PollVideoJobFn = pollVideoJob,
): AsyncGenerator<
{ type: "heartbeat"; message: string },
{ ok: true; videoUrl: string } | { ok: false; error: string }
> {
const start = Date.now();
let interval = INITIAL_POLL_INTERVAL_MS;
const timeoutStr = `video generation timed out after ${Math.floor(timeoutMs / 1000)}s`;
for (;;) {
if (Date.now() - start >= timeoutMs) {
return { ok: false, error: timeoutStr };
}
try {
const poll = await pollFn(requestId, auth, signal);
if (poll.status === "done") {
if (poll.videoUrl) {
return { ok: true, videoUrl: poll.videoUrl };
}
return { ok: false, error: "video generation completed but no video URL was returned" };
}
if (poll.status === "failed") {
return { ok: false, error: "video generation failed" };
}
if (poll.status === "expired") {
return { ok: false, error: "video generation expired" };
}
// still processing — continue with backoff
} catch (e) {
// Distinguish deadline-expiry from client-cancel.
// AbortSignal.timeout sets signal.reason to a TimeoutError.
const isDeadline = signal.aborted && e instanceof Error && e.name === "TimeoutError";
if (isDeadline) return { ok: false, error: timeoutStr };
if (signal.aborted) return { ok: false, error: "client closed request during video generation" };
const status = (e as Error & { status?: number }).status;
if (status && status >= 400 && status < 500 && status !== 429) {
return { ok: false, error: `video poll failed permanently: HTTP ${status}` };
}
console.warn(`[videos] poll error (will retry): ${e instanceof Error ? e.message : String(e)}`);
}
const elapsed = Math.floor((Date.now() - start) / 1000);
yield { type: "heartbeat", message: `Generating video... ${elapsed}s` };
try {
await sleepFn(interval, signal);
} catch {
const isDeadline = signal.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError";
if (isDeadline) return { ok: false, error: timeoutStr };
return { ok: false, error: "client closed request during video generation" };
}
interval = Math.min(MAX_POLL_INTERVAL_MS, Math.floor(interval * POLL_BACKOFF));
}
}
/**
* Build a success VideoCallResult after the video has been downloaded to disk.
*/
export function buildVideoResult(path: string, prompt: string, model: string): VideoCallResult {
return {
ok: true,
model,
prompt,
path,
files: [path],
count: 1,
markdown: `[video](${pathToFileURL(path).href})`,
};
}
export type { VideoBudget };
export { createVideoBudget };