@opencode/ai 2.0.15 → 2.0.17

package/dist/video.js

@@ -0,0 +1,118 @@
+import { Effect, Schema, Stream } from "effect";
+import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
+import { Media } from "./media.js";
+import { MediaModel, composeRoute, tryRequest } from "./media-model.js";
+import { MediaRoute } from "./route/media.js";
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
+import { VideoClient, Service } from "./video-client.js";
+export class VideoModel extends MediaModel {
+    static fromRoute(route, input) {
+        return new VideoModel({
+            id: input.id,
+            provider: route.protocol.provider,
+            http: input.http,
+            route: composeRoute(route, input, collectResponse),
+        });
+    }
+}
+export const VideoModelSchema = Schema.declare((value) => value instanceof VideoModel, {
+    expected: "Video.Model",
+});
+export const VideoAspectRatio = Media.AspectRatio;
+/** Pinned frames. Routes that accept only a first frame fail typed when `last` is present. */
+export const VideoFrames = Schema.Struct({
+    first: Schema.optional(Media.AssetSchema),
+    last: Schema.optional(Media.AssetSchema),
+}).annotate({ identifier: "Video.Frames" });
+export class VideoRequest extends Schema.Class("Video.Request")({
+    model: VideoModelSchema,
+    prompt: Schema.String,
+    frames: Schema.optional(VideoFrames),
+    /** Style or subject references that guide the output without pinning a frame. */
+    references: Schema.optional(Schema.Array(Media.AssetSchema)),
+    /** Source video for edit or extension routes. */
+    video: Schema.optional(Media.AssetSchema),
+    durationSeconds: Schema.optional(Schema.Number),
+    aspectRatio: Schema.optional(VideoAspectRatio),
+    resolution: Schema.optional(Schema.String),
+    /** Whether to generate an audio track; routes whose audio is always on fail typed on `false`. */
+    audio: Schema.optional(Schema.Boolean),
+    n: Schema.optional(Schema.Int),
+    seed: Schema.optional(Schema.Number),
+    negativePrompt: Schema.optional(Schema.String),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+// ---------------------------------------------------------------------------
+// Response and events
+// ---------------------------------------------------------------------------
+export class VideoResponse extends Schema.Class("Video.Response")({
+    videos: Schema.Array(Media.AssetSchema),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+    get video() {
+        return this.videos[0];
+    }
+}
+export const VideoOutputEvent = Schema.Struct({
+    type: Schema.tag("video"),
+    index: Schema.Number,
+    video: Media.AssetSchema,
+}).annotate({ identifier: "Video.Event.Video" });
+export const VideoFinishEvent = Schema.Struct({
+    type: Schema.tag("finish"),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Video.Event.Finish" });
+const videoEventTagged = Schema.Union([QueuedEvent, ProgressEvent, VideoOutputEvent, VideoFinishEvent]).pipe(Schema.toTaggedUnion("type"));
+export const VideoEvent = Object.assign(videoEventTagged, {
+    is: {
+        generationQueued: videoEventTagged.guards["generation-queued"],
+        generationProgress: videoEventTagged.guards["generation-progress"],
+        video: videoEventTagged.guards.video,
+        finish: videoEventTagged.guards.finish,
+    },
+});
+const collectResponse = (events) => {
+    const finish = events.find(VideoEvent.is.finish);
+    // A streaming video protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
+    if (finish === undefined)
+        return Effect.die(new Error("The video stream completed without a finish event"));
+    return Effect.succeed(new VideoResponse({
+        videos: events.filter(VideoEvent.is.video).map((event) => event.video),
+        usage: finish.usage,
+        notices: finish.notices,
+        providerMetadata: finish.providerMetadata,
+    }));
+};
+export function request(input) {
+    if (input instanceof VideoRequest)
+        return input;
+    return new VideoRequest({
+        ...input,
+        http: HttpOptions.make(input.http),
+    });
+}
+const requestEffect = (input) => tryRequest(() => request(input));
+export function start(input) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => VideoClient.start(request)));
+}
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => VideoClient.generate(request, options)));
+}
+/** Rebuild a generation handle from a persisted `Generation.token`, refreshing its status once. */
+export const resume = (model, token) => VideoClient.resume(model, token);
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => VideoClient.stream(request, options))));
+}
+export const Video = {
+    request,
+    start,
+    generate,
+    resume,
+    stream,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.15",
+  "version": "2.0.17",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.15",
+    "@opencode/http-recorder": "2.0.17",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.15",
+    "@opencode/schema": "2.0.17",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"

package/dist/protocols/utils/gemini-tool-schema.d.ts

@@ -1,2 +0,0 @@
-export declare const convert: (schema: unknown) => Record<string, unknown> | undefined;
-export * as GeminiToolSchema from "./gemini-tool-schema.js";

package/dist/protocols/utils/gemini-tool-schema.js

@@ -1,103 +0,0 @@
-import { isRecord } from "../../utils/record.js";
-// Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
-// handful of common JSON Schema shapes. Keep this projection isolated so the
-// Gemini protocol file still reads like the other protocol modules.
-const SCHEMA_INTENT_KEYS = [
-    "type",
-    "properties",
-    "items",
-    "prefixItems",
-    "enum",
-    "const",
-    "$ref",
-    "additionalProperties",
-    "patternProperties",
-    "required",
-    "not",
-    "if",
-    "then",
-    "else",
-];
-const hasCombiner = (schema) => isRecord(schema) && (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf));
-const hasSchemaIntent = (schema) => isRecord(schema) && (hasCombiner(schema) || SCHEMA_INTENT_KEYS.some((key) => key in schema));
-const sanitizeNode = (schema) => {
-    if (!isRecord(schema))
-        return Array.isArray(schema) ? schema.map(sanitizeNode) : schema;
-    const result = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
-        key,
-        key === "enum" && Array.isArray(value) ? value.map(String) : sanitizeNode(value),
-    ]));
-    if (Array.isArray(result.enum) && (result.type === "integer" || result.type === "number"))
-        result.type = "string";
-    const properties = result.properties;
-    if (result.type === "object" && isRecord(properties) && Array.isArray(result.required)) {
-        result.required = result.required.filter((field) => typeof field === "string" && field in properties);
-    }
-    if (result.type === "array" && !hasCombiner(result)) {
-        result.items = result.items ?? {};
-        if (isRecord(result.items) && !hasSchemaIntent(result.items))
-            result.items = { ...result.items, type: "string" };
-    }
-    if (typeof result.type === "string" && result.type !== "object" && !hasCombiner(result)) {
-        delete result.properties;
-        delete result.required;
-    }
-    return result;
-};
-const emptyObjectSchema = (schema) => schema.type === "object" &&
-    (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
-    !schema.additionalProperties;
-const projectNode = (schema, nested = false) => {
-    if (!isRecord(schema))
-        return undefined;
-    if (!nested && emptyObjectSchema(schema))
-        return undefined;
-    const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined;
-    const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined;
-    const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false;
-    const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf;
-    const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined;
-    const result = Object.fromEntries([
-        ["description", schema.description],
-        ["required", schema.required],
-        ["format", schema.format],
-        ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
-        [
-            "nullable",
-            (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
-                ? true
-                : undefined,
-        ],
-        ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
-        [
-            "properties",
-            isRecord(schema.properties)
-                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
-                : undefined,
-        ],
-        [
-            "items",
-            Array.isArray(schema.items)
-                ? schema.items.map((item) => projectNode(item, true))
-                : schema.items === undefined
-                    ? undefined
-                    : projectNode(schema.items, true),
-        ],
-        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
-        [
-            "anyOf",
-            anyOfTypes
-                ? hasNullAnyOf && anyOfTypes.length === 1
-                    ? undefined
-                    : anyOfTypes.map((item) => projectNode(item, true))
-                : types && types.length > 0
-                    ? types.map((type) => ({ type }))
-                    : undefined,
-        ],
-        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
-        ["minLength", schema.minLength],
-    ].filter((entry) => entry[1] !== undefined));
-    return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result;
-};
-export const convert = (schema) => projectNode(sanitizeNode(schema));
-export * as GeminiToolSchema from "./gemini-tool-schema.js";

package/dist/protocols/utils/meta-image.d.ts

@@ -1,2 +0,0 @@
-export declare const mediaType: (data: Uint8Array, format?: string) => string;
-export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/meta-image.js

@@ -1,13 +0,0 @@
-// Responses image items can omit output_format, including when PNG/JPEG was requested.
-export const mediaType = (data, format) => {
-    if (format !== undefined)
-        return `image/${format}`;
-    if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71)
-        return "image/png";
-    if (data[0] === 255 && data[1] === 216 && data[2] === 255)
-        return "image/jpeg";
-    if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
-        return "image/webp";
-    return "application/octet-stream";
-};
-export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/openai-image.d.ts

@@ -1,5 +0,0 @@
-import { Schema } from "effect";
-export declare const Size: Schema.String;
-export declare const OpenAIImage: {
-    readonly Size: Schema.String;
-};

package/dist/protocols/utils/openai-image.js

@@ -1,18 +0,0 @@
-import { Schema } from "effect";
-const dimensions = (value) => {
-    const match = /^(\d+)x(\d+)$/.exec(value);
-    if (!match)
-        return undefined;
-    return { width: Number(match[1]), height: Number(match[2]) };
-};
-export const Size = Schema.String.check(Schema.makeFilter((value) => {
-    if (value === "auto")
-        return undefined;
-    const parsed = dimensions(value);
-    if (!parsed)
-        return "image size must be `auto` or `{width}x{height}`";
-    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers";
-}));
-export const OpenAIImage = {
-    Size,
-};