@opencode/ai 2.0.32 → 2.1.1

package/dist/utils/sanitize.d.ts

@@ -1 +1,5 @@
+/**
+ * Replace lone UTF-16 surrogates in every string, key and nested value. Unchanged
+ * subtrees are returned by reference so requests with large histories are not copied.
+ */
 export declare const sanitizeSurrogates: <T>(value: T) => T;

package/dist/utils/sanitize.js

@@ -1,14 +1,31 @@
+import { Schema } from "effect";
 import { Media } from "../media.js";
 import { isRecord } from "./record.js";
+/**
+ * Replace lone UTF-16 surrogates in every string, key and nested value. Unchanged
+ * subtrees are returned by reference so requests with large histories are not copied.
+ */
 export const sanitizeSurrogates = (value) => {
     if (typeof value === "string")
-        return value.toWellFormed();
-    if (Array.isArray(value))
-        return value.map(sanitizeSurrogates);
+        return (value.isWellFormed() ? value : value.toWellFormed());
+    if (Array.isArray(value)) {
+        const items = value.map(sanitizeSurrogates);
+        return (Object.getPrototypeOf(value) === Array.prototype && items.every((item, index) => item === value[index])
+            ? value
+            : items);
+    }
     // Media assets carry binary or base64 payloads and a lazy byte cache; flattening them into a record would drop both.
     if (value instanceof Uint8Array || value instanceof Error || value instanceof Media.Asset)
         return value;
-    if (isRecord(value))
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key.toWellFormed(), sanitizeSurrogates(entry)]));
-    return value;
+    if (!isRecord(value))
+        return value;
+    const entries = Object.entries(value);
+    const sanitized = entries.map(([key, entry]) => [sanitizeSurrogates(key), sanitizeSurrogates(entry)]);
+    // Changed nodes and other objects (such as Date) are copied into plain records as before. Unchanged plain
+    // records and Schema class instances are kept: a copy would hold the same fields, and Schema constructors
+    // decode such a copy back into an equal instance.
+    if (sanitized.every(([key, entry], index) => key === entries[index][0] && entry === entries[index][1]) &&
+        (Object.getPrototypeOf(value) === Object.prototype || Schema.isSchema(value.constructor)))
+        return value;
+    return Object.fromEntries(sanitized);
 };

package/dist/video-client.d.ts

@@ -10,17 +10,12 @@ export type Service = VideoClientService;
 export declare const VideoClient: {
     readonly layer: import("effect/Layer").Layer<VideoClientService, never, import("./route/executor-service.js").RequestExecutorService>;
     readonly generate: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<VideoResponse, import("./index.js").AIError, VideoClientService>;
-    readonly stream: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+    readonly stream: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<{
         readonly type: "video";
         readonly index: number;
         readonly video: import("./media.js").Asset;
     } | {
         readonly type: "finish";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -43,7 +38,7 @@ export declare const VideoClient: {
             readonly seconds: number;
         } | undefined;
         readonly notices?: readonly {
-            readonly type: "other" | "moderated" | "filtered";
+            readonly type: "filtered" | "moderated" | "other";
             readonly message: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -51,7 +46,12 @@ export declare const VideoClient: {
                 };
             } | undefined;
         }[] | undefined;
-    }, import("./index.js").AIError, VideoClientService>;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | import("./generation.js").Observation, import("./index.js").AIError, VideoClientService>;
     readonly start: (request: VideoRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
     readonly resume: (model: import("./video.js").VideoModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
     readonly Service: typeof VideoClientService;