@opencode/ai 2.0.14 → 2.0.16

package/dist/video.js

@@ -0,0 +1,119 @@
+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 make(input) {
+        return new VideoModel(input);
+    }
+    /** Compose a queued video protocol with its canonical start path into a model for one deployment. */
+    static fromRoute(route, input) {
+        return new VideoModel({
+            id: input.id,
+            provider: route.provider,
+            http: input.http,
+            route: composeRoute(MediaRoute.queued, route, input),
+        });
+    }
+}
+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,
+    },
+});
+/** A completed response expanded into the streaming event shape. */
+export const responseEvents = (response) => [
+    ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
+    VideoFinishEvent.make({
+        usage: response.usage,
+        notices: response.notices,
+        providerMetadata: response.providerMetadata,
+    }),
+];
+export function request(input) {
+    if (input instanceof VideoRequest)
+        return input;
+    return new VideoRequest({
+        ...input,
+        http: input.http === undefined ? undefined : 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.14",
+  "version": "2.0.16",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./promise": {
+      "import": "./dist/promise.js",
+      "types": "./dist/promise.d.ts"
+    },
     "./testing": {
       "import": "./dist/testing.js",
       "types": "./dist/testing.d.ts"
@@ -30,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.14",
+    "@opencode/http-recorder": "2.0.16",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,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.14",
+    "@opencode/schema": "2.0.16",
     "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/image-input.d.ts

@@ -1,21 +0,0 @@
-import { Effect } from "effect";
-import type { ImageInput } from "../../image.js";
-import { AIError } from "../../schema/index.js";
-export declare const dataUrl: (input: Extract<ImageInput, {
-    readonly type: "bytes";
-}>) => string;
-export declare const decodeDataUrl: (url: string) => Effect.Effect<{
-    readonly mediaType: string;
-    readonly data: Uint8Array;
-} | undefined, AIError>;
-export declare const invalidImageInput: (message: string, cause?: unknown) => AIError;
-export declare const ImageInputs: {
-    readonly dataUrl: (input: Extract<ImageInput, {
-        readonly type: "bytes";
-    }>) => string;
-    readonly decodeDataUrl: (url: string) => Effect.Effect<{
-        readonly mediaType: string;
-        readonly data: Uint8Array;
-    } | undefined, AIError>;
-    readonly invalid: (message: string, cause?: unknown) => AIError;
-};

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

@@ -1,20 +0,0 @@
-import { Effect, Encoding } from "effect";
-import { InvalidRequestError, AIError } from "../../schema/index.js";
-const invalid = (message, cause) => new AIError({
-    reason: new InvalidRequestError({ message, cause }),
-});
-export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
-export const decodeDataUrl = (url) => {
-    if (!url.startsWith("data:"))
-        return Effect.undefined;
-    const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
-    if (!match)
-        return Effect.fail(invalid("Image data URLs must contain a MIME type and base64 data"));
-    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError((cause) => invalid("Image data URL contains invalid base64 data", cause)), Effect.map((data) => ({ mediaType: match[1], data })));
-};
-export const invalidImageInput = invalid;
-export const ImageInputs = {
-    dataUrl,
-    decodeDataUrl,
-    invalid: invalidImageInput,
-};