@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/openai-transcription.js

@@ -0,0 +1,190 @@
+import { Effect, Schema, Stream } from "effect";
+import { Framing } from "../route/framing.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
+import { mediaTypeExtension } from "../utils/media-type.js";
+import { ProviderShared } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "openai-transcription";
+const NAME = "OpenAI Transcription";
+const PROVIDER = ProviderID.make("openai");
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/audio/transcriptions";
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const Segment = Schema.Struct({
+    text: Schema.String,
+    start: Schema.Number,
+    end: Schema.Number,
+    speaker: Schema.optional(Schema.String),
+});
+const Usage = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("tokens"),
+        input_tokens: Schema.optional(Schema.Number),
+        output_tokens: Schema.optional(Schema.Number),
+        total_tokens: Schema.optional(Schema.Number),
+    }),
+    Schema.Struct({ type: Schema.Literal("duration"), seconds: Schema.Number }),
+]);
+const transcriptFields = {
+    text: Schema.String,
+    language: Schema.optional(Schema.String),
+    languages: Schema.optional(Schema.Array(Schema.Struct({ code: Schema.String }))),
+    duration: Schema.optional(Schema.Number),
+    segments: Schema.optional(Schema.Array(Segment)),
+    words: Schema.optional(Schema.Array(Schema.Struct({ word: Schema.String, start: Schema.Number, end: Schema.Number }))),
+    usage: Schema.optional(Usage),
+};
+const Event = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("transcript.text.delta"), delta: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("transcript.text.segment"), ...Segment.fields }),
+    Schema.Struct({ type: Schema.Literal("transcript.text.done"), ...transcriptFields }),
+]);
+const Transcript = Schema.Struct(transcriptFields);
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, Event);
+const decodeTranscript = MediaProtocol.decodeFrame(ADAPTER, NAME, Transcript);
+const TRANSCRIBE = { stream: true, timestamps: [], diarize: false, languageField: "language" };
+const capabilities = (model) => {
+    if (model.startsWith("whisper"))
+        return { ...TRANSCRIBE, stream: false, timestamps: ["segment", "word"] };
+    if (model.includes("diarize"))
+        return { ...TRANSCRIBE, timestamps: ["segment"], diarize: true };
+    // `gpt-transcribe` replaces `language` with `languages[]` and rejects both together.
+    if (model.startsWith("gpt-transcribe"))
+        return { ...TRANSCRIBE, languageField: "languages" };
+    return TRANSCRIBE;
+};
+const unsupported = (operation, message) => Effect.fail(ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route: ADAPTER, message }));
+const validate = (request, model) => {
+    const id = request.model.id;
+    if (request.mode === "stream" && !model.stream)
+        return unsupported("media.stream", `${id} does not stream; use Transcription.generate`);
+    if (request.diarize === true && !model.diarize)
+        return unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`);
+    if (request.prompt !== undefined && model.diarize)
+        return unsupported("media.prompt", `${id} does not accept a prompt`);
+    if (request.timestamps === undefined ||
+        request.timestamps === "none" ||
+        model.timestamps.includes(request.timestamps))
+        return Effect.void;
+    return unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`);
+};
+const RESERVED_FORM_FIELDS = new Set([
+    "file",
+    "model",
+    "prompt",
+    "language",
+    "response_format",
+    "timestamp_granularities",
+    "stream",
+]);
+const appendField = (form, key, value) => {
+    if (Array.isArray(value))
+        return value.forEach((item) => form.append(`${key}[]`, String(item)));
+    form.append(key, typeof value === "object" && value !== null ? ProviderShared.encodeJson(value) : String(value));
+};
+const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (request) {
+    const model = capabilities(request.model.id);
+    yield* validate(request, model);
+    // The API detects the audio format from the upload's filename extension.
+    const extension = mediaTypeExtension(request.audio.mediaType);
+    if (extension === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
+    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    const responseFormat = model.diarize
+        ? "diarized_json"
+        : request.timestamps === undefined || request.timestamps === "none"
+            ? undefined
+            : "verbose_json";
+    const native = Object.entries(mergeJsonRecords(request.providerOptions, request.http?.body) ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
+    const fields = mergeJsonRecords({
+        model: request.model.id,
+        language: model.languageField === "language" ? request.language : undefined,
+        languages: model.languageField === "languages" && request.language !== undefined ? [request.language] : undefined,
+        prompt: request.prompt,
+        response_format: responseFormat,
+        timestamp_granularities: responseFormat === "verbose_json" ? [request.timestamps] : undefined,
+        // Diarizing audio longer than 30 seconds requires a chunking strategy.
+        chunking_strategy: model.diarize ? "auto" : undefined,
+        stream: request.mode === "stream" ? true : undefined,
+    }, Object.fromEntries(native));
+    const form = new FormData();
+    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
+    Object.entries(fields ?? {}).forEach(([key, value]) => appendField(form, key, value));
+    return MediaProtocol.multipart(form);
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const segment = (value) => ({
+    text: value.text.trim(),
+    startSeconds: value.start,
+    endSeconds: value.end,
+    speaker: value.speaker,
+});
+const onEvent = Effect.fn("OpenAITranscription.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "transcript.text.done")
+        return [{ ...state, transcript: event }, []];
+    if (event.type === "transcript.text.delta")
+        return [state, event.delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta: event.delta })]];
+    const next = segment(event);
+    state.segments.push(next);
+    return [state, [TranscriptionSegmentEvent.make({ segment: next })]];
+});
+const step = (state, frame) => typeof frame === "string"
+    ? onEvent(state, frame)
+    : decodeTranscript(frame.document).pipe(Effect.map((transcript) => [{ ...state, transcript }, []]));
+const usage = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value.type === "duration")
+        return { type: "seconds", seconds: value.seconds };
+    return {
+        type: "tokens",
+        input: value.input_tokens,
+        output: value.output_tokens,
+        total: value.total_tokens,
+        details: { openai: value },
+    };
+};
+const finish = (state) => {
+    const transcript = state.transcript;
+    if (transcript === undefined)
+        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+    const segments = transcript.segments?.map(segment) ?? state.segments;
+    return Effect.succeed([
+        TranscriptionFinishEvent.make({
+            text: transcript.text,
+            segments: segments.length === 0 ? undefined : segments,
+            words: transcript.words?.map((word) => ({ text: word.word, startSeconds: word.start, endSeconds: word.end })),
+            language: (transcript.language ?? transcript.languages?.[0]?.code)?.toLowerCase(),
+            durationSeconds: transcript.duration,
+            usage: usage(transcript.usage),
+        }),
+    ]);
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["speakers"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => context.request.mode === "stream"
+        ? Framing.sse.frame(bytes)
+        : Framing.document.frame(bytes).pipe(Stream.map((document) => ({ document }))),
+    initial: () => ({ segments: [] }),
+    step,
+    finish,
+});
+export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const OpenAITranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/replicate-images.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export declare const DEFAULT_BASE_URL = "https://api.replicate.com";
+/** Model-defined `input` fields under the model's own names; `Media.Asset` values lower to URLs or data URLs. */
+export type ReplicateImageOptions = Record<string, unknown>;
+export type Request = ImageRequestFor<ReplicateImageOptions>;
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly getURL: Schema.String;
+    readonly cancelURL: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly getURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<ReplicateImageOptions>;
+export declare const ReplicateImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly id: string;
+        readonly getURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<ReplicateImageOptions>;
+};

package/dist/protocols/replicate-images.js

@@ -0,0 +1,133 @@
+import { Duration, Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+const ADAPTER = "replicate-images";
+const NAME = "Replicate";
+const PROVIDER = ProviderID.make("replicate");
+export const DEFAULT_BASE_URL = "https://api.replicate.com";
+const OUTPUT_RETENTION = Duration.hours(1);
+const MAX_DATA_URL_BYTES = 256 * 1024;
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ id: Schema.String, getURL: Schema.String, cancelURL: Schema.String });
+const Prediction = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    output: optionalNull(Schema.Unknown),
+    error: optionalNull(Schema.Unknown),
+    data_removed: optionalNull(Schema.Boolean),
+    completed_at: optionalNull(Schema.String),
+    metrics: optionalNull(Schema.Struct({ predict_time: optionalNull(Schema.Number) })),
+    urls: Schema.Struct({ get: Schema.String, cancel: Schema.String }),
+});
+const Output = Schema.Union([Schema.String, Schema.Array(Schema.String)]);
+const isOutput = Schema.is(Output);
+const STATUS = {
+    starting: "queued",
+    processing: "running",
+    succeeded: "completed",
+    failed: "failed",
+    canceled: "cancelled",
+    // The prediction hit its `Cancel-After` deadline before it started running.
+    aborted: "expired",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Official models run by `owner/name`; anything else (`owner/name:version` or a bare version id) is a pinned version.
+const isOfficial = (model) => /^[^/:]+\/[^/:]+$/.test(model);
+const inlineSize = (source) => {
+    if (source.type === "bytes")
+        return source.data.byteLength;
+    if (source.type === "base64")
+        return source.data.length * 0.75;
+    return 0;
+};
+const fileInput = (asset) => {
+    if (inlineSize(asset.source) > MAX_DATA_URL_BYTES)
+        return Effect.fail(ProviderShared.invalidRequest(`${NAME} data URL inputs are limited to 256 KB; pass a larger file by https URL`));
+    return ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((reference) => reference.value));
+};
+const inputValue = (value) => {
+    if (value instanceof Media.Asset)
+        return fileInput(value);
+    if (Array.isArray(value) && value.some((item) => item instanceof Media.Asset))
+        return Effect.forEach(value, (item) => (item instanceof Media.Asset ? fileInput(item) : Effect.succeed(item)));
+    return Effect.succeed(value);
+};
+const fromRequest = Effect.fn("ReplicateImages.fromRequest")(function* (request) {
+    const native = yield* Effect.forEach(Object.entries(request.providerOptions ?? {}), ([key, value]) => inputValue(value).pipe(Effect.map((lowered) => [key, lowered])));
+    const input = mergeJsonRecords({ prompt: request.prompt }, Object.fromEntries(native));
+    const model = request.model.id;
+    return MediaProtocol.json(mergeJsonRecords(isOfficial(model) ? { input } : { version: model, input }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodePrediction = MediaProtocol.decodeJson(ADAPTER, NAME, Prediction);
+const decodeStart = Effect.fn("ReplicateImages.decodeStart")(function* (response) {
+    const output = yield* decodePrediction(response);
+    const prediction = output.value;
+    return {
+        token: { id: prediction.id, getURL: prediction.urls.get, cancelURL: prediction.urls.cancel },
+        // `Prefer: wait` can return an already-finished prediction, so `await` skips straight to the result.
+        snapshot: { id: prediction.id, status: yield* MediaProtocol.status(STATUS, prediction.status, output) },
+    };
+});
+const decodeStatus = Effect.fn("ReplicateImages.decodeStatus")(function* (response, context) {
+    const output = yield* decodePrediction(response);
+    return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
+});
+const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (response, context) {
+    const output = yield* decodePrediction(response);
+    const prediction = output.value;
+    const status = yield* MediaProtocol.status(STATUS, prediction.status, output);
+    if (status === "failed" || status === "cancelled" || status === "expired")
+        return yield* output.ended(status, `${NAME} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} has not finished`);
+    if (prediction.data_removed === true)
+        return yield* output.ended("expired", `${NAME} removed the output of prediction ${context.token.id}`);
+    if (!isOutput(prediction.output))
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned output that is not image URLs`);
+    const urls = typeof prediction.output === "string" ? [prediction.output] : prediction.output;
+    if (urls.length === 0)
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned no images`);
+    const predictTime = prediction.metrics?.predict_time ?? undefined;
+    const completedAt = prediction.completed_at ?? undefined;
+    const expiresAt = completedAt === undefined ? undefined : Date.parse(completedAt) + Duration.toMillis(OUTPUT_RETENTION);
+    return new ImageResponse({
+        images: urls.map((url) => Media.url(url, { expiresAt })),
+        usage: predictTime === undefined ? undefined : { type: "compute", seconds: predictTime },
+        providerMetadata: { replicate: { predictionId: prediction.id } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["images", "mask", "n", "size", "aspectRatio", "seed", "format"],
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: (token) => token.getURL, decode: decodeStatus },
+    result: { path: (token) => token.getURL, decode: decodeResult },
+    cancel: { method: "POST", path: (token) => token.cancelURL },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => isOfficial(request.model.id) ? `/v1/models/${request.model.id}/predictions` : "/v1/predictions",
+}, input);
+export const ReplicateImages = {
+    protocol,
+    model,
+};

package/dist/protocols/runway-video.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export declare const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
+/** Every Runway request must pin the API version. */
+export declare const API_VERSION = "2024-11-06";
+export declare const TEXT_TO_VIDEO_PATH = "/text_to_video";
+export declare const IMAGE_TO_VIDEO_PATH = "/image_to_video";
+export declare const VIDEO_TO_VIDEO_PATH = "/video_to_video";
+export declare const TASKS_PATH = "/tasks";
+export type RunwayVideoString<Known extends string> = Known | (string & {});
+/**
+ * Provider-native options. Common fields lower to Runway's names: `aspectRatio` → `ratio` (Runway expects pixel
+ * ratios such as `1280:720` for most models), `durationSeconds` → `duration`, `audio`, `negativePrompt`,
+ * `resolution`, `references`, and `frames` → `promptImage`.
+ */
+export type RunwayVideoOptions = {
+    readonly contentModeration?: {
+        readonly publicFigureThreshold?: RunwayVideoString<"auto" | "low">;
+    };
+    readonly outputFormat?: RunwayVideoString<"mp4" | "prores" | "png_sequence">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<RunwayVideoOptions>;
+export declare const Token: Schema.Struct<{
+    readonly taskID: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly taskID: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<RunwayVideoOptions>;
+export declare const RunwayVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly taskID: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<RunwayVideoOptions>;
+};

package/dist/protocols/runway-video.js

@@ -0,0 +1,146 @@
+import { Duration, Effect, Schema } from "effect";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { VideoModel, VideoResponse } from "../video.js";
+import { ProviderShared, optionalArray, optionalNull } from "./shared.js";
+const ADAPTER = "runway-video";
+const NAME = "Runway";
+const PROVIDER = ProviderID.make("runway");
+export const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
+/** Every Runway request must pin the API version. */
+export const API_VERSION = "2024-11-06";
+export const TEXT_TO_VIDEO_PATH = "/text_to_video";
+export const IMAGE_TO_VIDEO_PATH = "/image_to_video";
+export const VIDEO_TO_VIDEO_PATH = "/video_to_video";
+export const TASKS_PATH = "/tasks";
+/** Output URLs are valid for 24–48 hours; the asset carries the conservative bound. */
+const OUTPUT_RETENTION = Duration.hours(24);
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ taskID: Schema.String });
+const Cost = Schema.Struct({ credits: Schema.Number });
+const StartResponse = Schema.Struct({ id: Schema.String });
+const Task = Schema.Struct({
+    status: Schema.String,
+    progress: optionalNull(Schema.Number),
+    output: optionalArray(Schema.String),
+    failure: optionalNull(Schema.String),
+    failureCode: optionalNull(Schema.String),
+    cost: Schema.optional(Cost),
+    estimatedCost: Schema.optional(Cost),
+});
+const STATUS = {
+    PENDING: "queued",
+    THROTTLED: "queued",
+    RUNNING: "running",
+    SUCCEEDED: "completed",
+    FAILED: "failed",
+    CANCELLED: "cancelled",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Runway accepts HTTPS URLs, `runway://` upload URIs, and data URIs, all as one string.
+const mediaUri = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => reference.value));
+const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
+    const first = request.frames?.first === undefined ? undefined : yield* mediaUri(request.frames.first);
+    const last = request.frames?.last === undefined ? undefined : yield* mediaUri(request.frames.last);
+    const promptImage = [
+        ...(first === undefined ? [] : [{ uri: first, position: "first" }]),
+        ...(last === undefined ? [] : [{ uri: last, position: "last" }]),
+    ];
+    const videoUri = request.video === undefined ? undefined : yield* mediaUri(request.video);
+    const references = yield* Effect.forEach(request.references ?? [], (asset) => mediaUri(asset).pipe(Effect.map((uri) => ({ uri }))));
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        promptText: request.prompt,
+        promptImage: promptImage.length === 0 ? undefined : promptImage,
+        videoUri,
+        references: references.length === 0 ? undefined : references,
+        ratio: request.aspectRatio,
+        duration: request.durationSeconds,
+        resolution: request.resolution,
+        audio: request.audio,
+        negativePrompt: request.negativePrompt,
+        seed: request.seed,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { taskID: value.id },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeTask = MediaProtocol.decodeJson(ADAPTER, NAME, Task);
+const decodeStatus = Effect.fn("RunwayVideo.decodeStatus")(function* (response, context) {
+    const output = yield* decodeTask(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { id: context.token.taskID, status, progress: output.value.progress ?? undefined };
+});
+const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeTask(response);
+    const task = output.value;
+    const status = yield* MediaProtocol.status(STATUS, task.status, output);
+    if (status === "failed") {
+        const code = task.failureCode ?? undefined;
+        const message = `${NAME} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
+        // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
+        if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code))
+            return yield* output.contentPolicy(message);
+        return yield* output.ended("failed", message);
+    }
+    if (status === "cancelled")
+        return yield* output.ended("cancelled", `${NAME} task ${context.token.taskID} was cancelled`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} task ${context.token.taskID} has not finished`);
+    const urls = task.output ?? [];
+    if (urls.length === 0)
+        return yield* output.invalid(`${NAME} task succeeded without any output`);
+    return new VideoResponse({
+        videos: yield* Effect.forEach(urls, (url) => MediaProtocol.expiringUrl(url, OUTPUT_RETENTION, { mediaType: "video/mp4" })),
+        usage: task.cost === undefined ? undefined : { type: "credits", credits: task.cost.credits },
+        providerMetadata: {
+            runway: {
+                taskId: context.token.taskID,
+                estimatedCredits: task.estimatedCost?.credits,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const taskPath = (token) => `${TASKS_PATH}/${token.taskID}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["n"],
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: taskPath, decode: decodeStatus },
+    result: { path: taskPath, decode: decodeResult },
+    cancel: { method: "DELETE", path: taskPath },
+});
+const startPath = (request) => {
+    if (request.video !== undefined)
+        return VIDEO_TO_VIDEO_PATH;
+    if (request.frames?.first !== undefined || request.frames?.last !== undefined)
+        return IMAGE_TO_VIDEO_PATH;
+    return TEXT_TO_VIDEO_PATH;
+};
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: { "X-Runway-Version": API_VERSION },
+    path: ({ request }) => startPath(request),
+}, input);
+export const RunwayVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/shared.d.ts

@@ -1,6 +1,7 @@
 import { Tool } from "@opencode/schema/tool";
 import { Effect, Schema, Stream } from "effect";
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Media } from "../media.js";
 import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
@@ -110,23 +111,36 @@ export declare const wrappedSystemUpdate: (route: string, message: Message) => E
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, AIError, never>;
-export interface NormalizedMedia {
-    readonly mime: string;
-    readonly base64: string;
-    readonly dataUrl: string;
-}
-export declare const normalizeMedia: (part: MediaPart) => NormalizedMedia;
-export declare const normalizeToolFile: (part: Tool.FileContent) => NormalizedMedia;
+/** Inline view or a typed `InvalidRequest` for routes that cannot fetch URLs or dereference provider refs. */
+export declare const requireInlineMedia: (route: string, asset: Media.Asset) => Effect.Effect<Media.Inline, AIError>;
+export declare const inlineRequired: (route: string, asset: Media.Asset) => AIError;
+/** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
+export declare const mediaUrl: (asset: Media.Asset) => string | undefined;
+export type MediaReference = {
+    readonly type: "dataUrl" | "url" | "ref";
+    readonly value: string;
+};
+/**
+ * The one string a provider can address an asset by: inline payloads as a data URL, `url` sources as their URL, and
+ * this provider's own `ref` as its id. Other providers' refs are never forwarded and fail typed; omit `provider` for
+ * APIs with no file handles at all.
+ */
+export declare const mediaReference: (asset: Media.Asset, provider: ProviderID | undefined, label: string) => Effect.Effect<MediaReference, AIError>;
+/**
+ * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
+ * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.
+ */
+export declare const toolFileMedia: (item: Tool.FileContent) => MediaPart;
 export declare const trimBaseUrl: (value: string) => string;
 export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty events. `[DONE]`
- * is dropped by default or retained for protocols that use it as their stream
- * boundary. Retry control events are ignored without interrupting the stream.
- * Decoder failures become provider output errors so the public error channel
- * stays `AIError`.
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
  */
 export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>, includeDone?: boolean) => Stream.Stream<string, AIError>;
 /**
@@ -158,10 +172,6 @@ export declare const flattenToolRequest: (request: LLMRequest) => {
         readonly [x: string]: unknown;
     }, import("../route.js").CompactionOperations | undefined>>;
 };
-export declare const imageResponse: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
-    body: string;
-    invalid: (message: string, cause?: unknown) => AIError;
-}, AIError, never>;
 export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {
     readonly auto: () => Auto;
     readonly none: () => None;