@opencode/ai 2.0.31 → 2.1.0

package/dist/protocols/openai-responses.js

@@ -252,7 +252,7 @@ export const protocol = Protocol.make({
 const endpoint = Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL });
 const auth = Auth.none;
 export const httpTransport = HttpTransport.sseJson.with();
-export const channelTransport = (OpenResponsesChannel.transport);
+export const channelTransport = OpenResponsesChannel.transport;
 export const transport = channelTransport({
     id: ADAPTER,
     name: NAME,

package/dist/protocols/openai-speech.d.ts

@@ -16,12 +16,12 @@ interface State extends SpeechStream.Audio {
     readonly usage?: MediaUsage;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly id: string;
     readonly type: "generation-queued";
+    readonly id: string;
     readonly position?: number | undefined;
 } | {
-    readonly id: string;
     readonly type: "generation-progress";
+    readonly id: string;
     readonly progress?: number | undefined;
 } | {
     readonly type: "audio-delta";
@@ -36,11 +36,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 } | {
     readonly type: "finish";
     readonly audio: import("../media.js").Asset;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
     readonly usage?: {
         readonly type: "tokens";
         readonly input?: number | undefined;
@@ -63,7 +58,7 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         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]: {
@@ -71,16 +66,21 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
             };
         } | undefined;
     }[] | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 }, string | Uint8Array<ArrayBufferLike>, State>;
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<OpenAISpeechOptions>;
 export declare const OpenAISpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly id: string;
         readonly type: "generation-queued";
+        readonly id: string;
         readonly position?: number | undefined;
     } | {
-        readonly id: string;
         readonly type: "generation-progress";
+        readonly id: string;
         readonly progress?: number | undefined;
     } | {
         readonly type: "audio-delta";
@@ -95,11 +95,6 @@ export declare const OpenAISpeech: {
     } | {
         readonly type: "finish";
         readonly audio: import("../media.js").Asset;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -122,7 +117,7 @@ export declare const OpenAISpeech: {
             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]: {
@@ -130,7 +125,12 @@ export declare const OpenAISpeech: {
                 };
             } | undefined;
         }[] | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
     }, string | Uint8Array<ArrayBufferLike>, State>;
-    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<OpenAISpeechOptions>;
+    readonly model: typeof model;
 };
 export {};

package/dist/protocols/openai-transcription.d.ts

@@ -59,12 +59,12 @@ interface State {
     readonly transcript?: Transcript;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly id: string;
     readonly type: "generation-queued";
+    readonly id: string;
     readonly position?: number | undefined;
 } | {
-    readonly id: string;
     readonly type: "generation-progress";
+    readonly id: string;
     readonly progress?: number | undefined;
 } | {
     readonly type: "text-delta";
@@ -78,14 +78,22 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly speaker?: string | undefined;
     };
 } | {
-    readonly type: "finish";
     readonly text: string;
+    readonly segments?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+    }[] | undefined;
+    readonly words?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+        readonly confidence?: number | undefined;
+    }[] | undefined;
+    readonly language?: string | undefined;
     readonly durationSeconds?: number | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
     readonly usage?: {
         readonly type: "tokens";
         readonly input?: number | undefined;
@@ -108,7 +116,7 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         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]: {
@@ -116,30 +124,22 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
             };
         } | undefined;
     }[] | undefined;
-    readonly language?: string | undefined;
-    readonly segments?: readonly {
-        readonly text: string;
-        readonly startSeconds: number;
-        readonly endSeconds: number;
-        readonly speaker?: string | undefined;
-    }[] | undefined;
-    readonly words?: readonly {
-        readonly text: string;
-        readonly startSeconds: number;
-        readonly endSeconds: number;
-        readonly speaker?: string | undefined;
-        readonly confidence?: number | undefined;
-    }[] | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly type: "finish";
 }, Frame, State>;
 export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<OpenAITranscriptionOptions>;
 export declare const OpenAITranscription: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly id: string;
         readonly type: "generation-queued";
+        readonly id: string;
         readonly position?: number | undefined;
     } | {
-        readonly id: string;
         readonly type: "generation-progress";
+        readonly id: string;
         readonly progress?: number | undefined;
     } | {
         readonly type: "text-delta";
@@ -153,14 +153,22 @@ export declare const OpenAITranscription: {
             readonly speaker?: string | undefined;
         };
     } | {
-        readonly type: "finish";
         readonly text: string;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+        readonly language?: string | undefined;
         readonly durationSeconds?: number | undefined;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -183,7 +191,7 @@ export declare const OpenAITranscription: {
             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]: {
@@ -191,21 +199,13 @@ export declare const OpenAITranscription: {
                 };
             } | undefined;
         }[] | undefined;
-        readonly language?: string | undefined;
-        readonly segments?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-        }[] | undefined;
-        readonly words?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-            readonly confidence?: number | undefined;
-        }[] | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly type: "finish";
     }, Frame, State>;
-    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<OpenAITranscriptionOptions>;
+    readonly model: typeof model;
 };
 export {};

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

@@ -24,5 +24,5 @@ export declare const ReplicateImages: {
         readonly getURL: string;
         readonly cancelURL: string;
     }>;
-    readonly model: (input: MediaRoute.ModelInput) => ImageModel<ReplicateImageOptions>;
+    readonly model: typeof model;
 };

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

@@ -34,5 +34,5 @@ export declare const RunwayVideo: {
     readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
         readonly taskID: string;
     }>;
-    readonly model: (input: MediaRoute.ModelInput) => VideoModel<RunwayVideoOptions>;
+    readonly model: typeof model;
 };

package/dist/protocols/shared.d.ts

@@ -9,8 +9,19 @@ export { Json, decodeJson, encodeJson, isRecord };
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
+/** Optional provider field where an explicit `null` means absent, so decoding never yields `null`. */
+export declare const optionalNullish: <const S extends Schema.Top>(schema: S) => Schema.decodeTo<Schema.optional<Schema.toType<S>>, Schema.optional<Schema.NullOr<S>>, never, never>;
 /** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
 export declare const lenient: <const S extends Schema.Top>(schema: S) => Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<S>, S["DecodingServices"]>>;
+/**
+ * Accepts stream frames that carry no `type`, alongside the typed event schema. Gateways inject such frames as
+ * keep-alives, so they decode as an ignored event; one with an `error` still decodes as an error event.
+ */
+export declare const withUntypedFrames: <const S extends Schema.Codec<{
+    readonly type: string;
+}, {
+    readonly type: string;
+}>>(event: S) => Schema.Union<readonly [S, Schema.decodeTo<S, Schema.$Record<Schema.String, Schema.Unknown>, never, never>]>;
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
 export declare const knownString: <Known extends string>() => Schema.declare<OpenString<Known>, OpenString<Known>>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
@@ -93,10 +104,10 @@ export declare const wrapSystemUpdate: (parts: ReadonlyArray<{
 export declare const systemUpdateText: (route: string, message: Message) => Effect.Effect<{
     readonly type: "text";
     readonly text: string;
+    readonly cache?: import("../schema/options.js").CacheHint | undefined;
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cache?: import("../schema/options.js").CacheHint | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;

package/dist/protocols/shared.js

@@ -1,5 +1,5 @@
 import { Tool } from "@opencode/schema/tool";
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Predicate, Schema, SchemaGetter, SchemaTransformation } from "effect";
 import { Headers, HttpClientRequest } from "effect/http";
 import { Media } from "../media.js";
 import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
@@ -10,8 +10,24 @@ const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
 export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
+/** Optional provider field where an explicit `null` means absent, so decoding never yields `null`. */
+export const optionalNullish = (schema) => Schema.optional(Schema.NullOr(schema)).pipe(Schema.decodeTo(Schema.optional(Schema.toType(schema)), SchemaTransformation.transformOptional({
+    decode: Option.filter(Predicate.isNotNullish),
+    encode: (value) => value,
+})));
 /** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
 export const lenient = (schema) => Schema.optionalKey(Schema.UndefinedOr(schema).pipe(Schema.catchDecoding(() => Effect.succeed(Option.some(undefined)))));
+/**
+ * Accepts stream frames that carry no `type`, alongside the typed event schema. Gateways inject such frames as
+ * keep-alives, so they decode as an ignored event; one with an `error` still decodes as an error event.
+ */
+export const withUntypedFrames = (event) => Schema.Union([
+    event,
+    JsonObject.check(Schema.makeFilter((frame) => !("type" in frame))).pipe(Schema.decodeTo(event, {
+        decode: SchemaGetter.transform((frame) => ({ ...frame, type: frame.error != null ? "error" : "ignored" })),
+        encode: SchemaGetter.forbidden(() => "Untyped stream frames are decode-only"),
+    })),
+]);
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
 export const knownString = () => Schema.declare((value) => typeof value === "string", {
     expected: "string",

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

@@ -34,6 +34,6 @@ export declare const StabilityImages: {
     readonly upscaleProtocol: MediaProtocol.Queued<UpscaleRequest, ImageResponse, {
         readonly id: string;
     }>;
-    readonly model: (input: MediaRoute.ModelInput) => ImageModel<StabilityImageOptions>;
-    readonly upscaleModel: (input: Omit<MediaRoute.ModelInput, "id">) => ImageModel<StabilityUpscaleOptions>;
+    readonly model: typeof model;
+    readonly upscaleModel: typeof upscaleModel;
 };

package/dist/protocols/utils/bedrock-cache.d.ts

@@ -9,10 +9,10 @@ export declare const CachePointBlock: Schema.Struct<{
 export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>;
 export declare const BEDROCK_BREAKPOINT_CAP = 4;
 export declare const breakpoints: (model: LLMRequest["model"]) => {
-    supported: boolean;
-    ttl1h: boolean;
     remaining: number;
     dropped: number;
+    supported: boolean;
+    ttl1h: boolean;
 };
 export type Breakpoints = ReturnType<typeof breakpoints>;
 export declare const block: (breakpoints: Breakpoints, cache: CacheHint | undefined) => CachePointBlock | undefined;

package/dist/protocols/utils/bedrock-media.d.ts

@@ -25,26 +25,26 @@ export type DocumentBlock = Schema.Schema.Type<typeof DocumentBlock>;
 export declare const lower: (part: {
     readonly type: "media";
     readonly media: import("../../media.js").Asset;
+    readonly filename?: string | undefined;
+    readonly cache?: import("../../schema/options.js").CacheHint | undefined;
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cache?: import("../../schema/options.js").CacheHint | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly filename?: string | undefined;
 }, documentNames: Set<string>) => Effect.Effect<{
     image: {
-        format: "png" | "jpeg" | "gif" | "webp";
+        format: "gif" | "jpeg" | "png" | "webp";
         source: {
             bytes: string;
         };
     };
 }[] | ({
     readonly document: {
-        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
+        readonly format: "csv" | "doc" | "docx" | "html" | "md" | "pdf" | "txt" | "xls" | "xlsx";
         readonly name: string;
         readonly source: {
             readonly bytes: string;

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

@@ -12,5 +12,5 @@ export declare const OpenAITextVerbosity: import("effect/Schema").declare<OpenRe
 export declare const OpenAIResponseIncludable: import("effect/Schema").declare<OpenResponsesOptions.ResponseIncludable, OpenResponsesOptions.ResponseIncludable>;
 export declare const OpenAIServiceTier: import("effect/Schema").declare<OpenResponsesOptions.ServiceTier, OpenResponsesOptions.ServiceTier>;
 export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
-export declare const resolve: (request: import("../../index.js").LLMRequest) => OpenResponsesOptions.Resolved;
+export declare const resolve: typeof OpenResponsesOptions.resolve;
 export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/speech-stream.d.ts

@@ -31,7 +31,7 @@ export declare const pcm: (encoding: PcmEncoding, sampleRate: number | undefined
     mediaType: string;
     info: {
         format: string;
-        encoding: "pcm_s16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw";
+        encoding: "pcm_alaw" | "pcm_f32le" | "pcm_mulaw" | "pcm_s16le";
         sampleRate: number | undefined;
         channels: number;
     };

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

@@ -1,8 +1,13 @@
 import { type JsonSchema, type LanguageModel, type LLMRequest } from "../../schema/index.js";
+import { GeminiJsonSchema } from "./gemini-json-schema.js";
+declare const moonshot: (schema: JsonSchema) => JsonSchema;
+declare const openAI: (schema: JsonSchema) => JsonSchema;
+declare const tools: (entries: LLMRequest["tools"], model: LanguageModel) => LLMRequest["tools"];
 export declare const ToolSchemaProjection: {
-    readonly gemini: (schema: JsonSchema) => JsonSchema;
-    readonly moonshot: (schema: JsonSchema) => JsonSchema;
-    readonly openAI: (schema: JsonSchema) => JsonSchema;
-    readonly responses: (schema: JsonSchema) => JsonSchema;
-    readonly tools: (entries: LLMRequest["tools"], model: LanguageModel) => LLMRequest["tools"];
+    readonly gemini: typeof GeminiJsonSchema.normalize;
+    readonly moonshot: typeof moonshot;
+    readonly openAI: typeof openAI;
+    readonly responses: typeof openAI;
+    readonly tools: typeof tools;
 };
+export {};