@opencode/ai 2.1.3 → 2.1.4

package/dist/protocols/openai-responses.js

@@ -170,7 +170,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
         tools: request.tools.length === 0 ? undefined : yield* lowerTools(request),
         tool_choice: request.tools.length === 0
             ? undefined
-            : (OpenResponses.allowedToolChoice(request) ??
+            : (OpenResponses.allowedToolChoice(request, options) ??
                 (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined)),
     };
 });

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

@@ -16,14 +16,6 @@ interface State extends SpeechStream.Audio {
     readonly usage?: MediaUsage;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number | undefined;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number | undefined;
-} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -33,18 +25,18 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly startSeconds: number;
         readonly endSeconds: number;
     }[];
+} | {
+    readonly type: "generation-queued";
+    readonly id: string;
+    readonly position?: number | undefined;
+} | {
+    readonly type: "generation-progress";
+    readonly id: string;
+    readonly progress?: number | undefined;
 } | {
     readonly type: "finish";
     readonly audio: import("../media.js").Asset;
     readonly usage?: {
-        readonly type: "tokens";
-        readonly input?: number | undefined;
-        readonly output?: number | undefined;
-        readonly total?: number | undefined;
-        readonly details?: {
-            readonly [x: string]: unknown;
-        } | undefined;
-    } | {
         readonly type: "seconds";
         readonly seconds: number;
     } | {
@@ -56,6 +48,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     } | {
         readonly type: "compute";
         readonly seconds: number;
+    } | {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     } | undefined;
     readonly notices?: readonly {
         readonly type: "filtered" | "moderated" | "other";
@@ -75,14 +75,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<OpenAISpeechOptions>;
 export declare const OpenAISpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly type: "generation-queued";
-        readonly id: string;
-        readonly position?: number | undefined;
-    } | {
-        readonly type: "generation-progress";
-        readonly id: string;
-        readonly progress?: number | undefined;
-    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {
@@ -92,18 +84,18 @@ export declare const OpenAISpeech: {
             readonly startSeconds: number;
             readonly endSeconds: number;
         }[];
+    } | {
+        readonly type: "generation-queued";
+        readonly id: string;
+        readonly position?: number | undefined;
+    } | {
+        readonly type: "generation-progress";
+        readonly id: string;
+        readonly progress?: number | undefined;
     } | {
         readonly type: "finish";
         readonly audio: import("../media.js").Asset;
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -115,6 +107,14 @@ export declare const OpenAISpeech: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";

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

@@ -59,14 +59,6 @@ interface State {
     readonly transcript?: Transcript;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number | undefined;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number | undefined;
-} | {
     readonly type: "text-delta";
     readonly delta: string;
 } | {
@@ -77,6 +69,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly endSeconds: number;
         readonly speaker?: string | undefined;
     };
+} | {
+    readonly type: "generation-queued";
+    readonly id: string;
+    readonly position?: number | undefined;
+} | {
+    readonly type: "generation-progress";
+    readonly id: string;
+    readonly progress?: number | undefined;
 } | {
     readonly text: string;
     readonly segments?: readonly {
@@ -95,14 +95,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     readonly language?: string | undefined;
     readonly durationSeconds?: number | undefined;
     readonly usage?: {
-        readonly type: "tokens";
-        readonly input?: number | undefined;
-        readonly output?: number | undefined;
-        readonly total?: number | undefined;
-        readonly details?: {
-            readonly [x: string]: unknown;
-        } | undefined;
-    } | {
         readonly type: "seconds";
         readonly seconds: number;
     } | {
@@ -114,6 +106,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     } | {
         readonly type: "compute";
         readonly seconds: number;
+    } | {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     } | undefined;
     readonly notices?: readonly {
         readonly type: "filtered" | "moderated" | "other";
@@ -134,14 +134,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<OpenAITranscriptionOptions>;
 export declare const OpenAITranscription: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly type: "generation-queued";
-        readonly id: string;
-        readonly position?: number | undefined;
-    } | {
-        readonly type: "generation-progress";
-        readonly id: string;
-        readonly progress?: number | undefined;
-    } | {
         readonly type: "text-delta";
         readonly delta: string;
     } | {
@@ -152,6 +144,14 @@ export declare const OpenAITranscription: {
             readonly endSeconds: number;
             readonly speaker?: string | undefined;
         };
+    } | {
+        readonly type: "generation-queued";
+        readonly id: string;
+        readonly position?: number | undefined;
+    } | {
+        readonly type: "generation-progress";
+        readonly id: string;
+        readonly progress?: number | undefined;
     } | {
         readonly text: string;
         readonly segments?: readonly {
@@ -170,14 +170,6 @@ export declare const OpenAITranscription: {
         readonly language?: string | undefined;
         readonly durationSeconds?: number | undefined;
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -189,6 +181,14 @@ export declare const OpenAITranscription: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";

package/dist/protocols/openai-transcription.js

@@ -1,4 +1,4 @@
-import { Effect, Schema, Stream } from "effect";
+import { Effect, Schema, SchemaGetter, Stream } from "effect";
 import { classifyProviderFailure } from "../provider-error.js";
 import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
@@ -39,8 +39,14 @@ const transcriptFields = {
     words: Schema.optional(Schema.Array(Schema.Struct({ word: Schema.String, start: Schema.Number, end: Schema.Number }))),
     usage: Schema.optional(Usage),
 };
-/** OpenAI may add stream event types; frames outside `EVENT_TYPES` are ignored. */
-const EventType = Schema.Struct({ type: Schema.String });
+const EVENT_TYPES = new Set(["transcript.text.delta", "transcript.text.segment", "transcript.text.done", "error"]);
+/** OpenAI may add stream event types; frames outside `EVENT_TYPES` are ignored, while a malformed known type still fails decoding. */
+const UnknownEvent = Schema.Struct({
+    type: Schema.String.check(Schema.makeFilter((type) => !EVENT_TYPES.has(type))),
+}).pipe(Schema.decodeTo(Schema.Struct({ type: Schema.Literal("unknown"), rawType: Schema.String }), {
+    decode: SchemaGetter.transform((event) => ({ type: "unknown", rawType: event.type })),
+    encode: SchemaGetter.forbidden(() => "Unknown OpenAI Transcription stream events are decode-only"),
+}));
 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 }),
@@ -50,10 +56,9 @@ const Event = Schema.Union([
         message: Schema.optional(Schema.String),
         error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
     }),
+    UnknownEvent,
 ]);
-const EVENT_TYPES = new Set(["transcript.text.delta", "transcript.text.segment", "transcript.text.done", "error"]);
 const Transcript = Schema.Struct(transcriptFields);
-const decodeEventType = route.decodeFrame(EventType);
 const decodeEvent = route.decodeFrame(Event);
 const decodeTranscript = route.decodeFrame(Transcript);
 const TRANSCRIBE = { stream: true, timestamps: [], diarize: false, languageField: "language" };
@@ -132,9 +137,9 @@ const segment = (value) => ({
     speaker: value.speaker,
 });
 const onEvent = Effect.fnUntraced(function* (state, frame) {
-    if (!EVENT_TYPES.has((yield* decodeEventType(frame)).type))
-        return [state, []];
     const event = yield* decodeEvent(frame);
+    if (event.type === "unknown")
+        return [state, []];
     if (event.type === "error")
         return yield* new AIError({
             reason: classifyProviderFailure({

package/dist/protocols/utils/partial-json-options.d.ts

@@ -59,4 +59,3 @@ export declare const Allow: {
     COLLECTION: number;
     ALL: number;
 };
-export default Allow;

package/dist/protocols/utils/partial-json-options.js

@@ -49,4 +49,3 @@ export const ALL = ATOM | COLLECTION;
  * The default is to allow all types to be partially parsed, which in most cases is the best option.
  */
 export const Allow = { STR, NUM, ARR, OBJ, NULL, BOOL, NAN, INFINITY, _INFINITY, INF, SPECIAL, ATOM, COLLECTION, ALL };
-export default Allow;

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

@@ -299,8 +299,8 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
  * arguments on `response.output_item.done`; the final value wins.
  */
 export declare const finishWithInput: <K extends StreamKey>(route: string, tools: State<K>, key: K, input: string) => Effect.Effect<{
-    events?: undefined;
     tools: Partial<Record<K, PendingTool>>;
+    events?: undefined;
 } | {
     tools: Partial<Record<K, PendingTool>>;
     events: readonly ({

package/dist/protocols/venice-chat.d.ts

@@ -1,44 +1,43 @@
 import { Schema } from "effect";
 import { Protocol } from "../route/protocol.js";
 import { OpenAIChat } from "./openai-chat.js";
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | (string & {});
-declare const Parameters: Schema.Struct<{
-    readonly enableWebSearch: Schema.optional<Schema.String>;
-    readonly enableWebScraping: Schema.optional<Schema.Boolean>;
-    readonly enableWebCitations: Schema.optional<Schema.Boolean>;
-    readonly enableXSearch: Schema.optional<Schema.Boolean>;
-    readonly stripThinkingResponse: Schema.optional<Schema.Boolean>;
-    readonly disableThinking: Schema.optional<Schema.Boolean>;
-    readonly includeVeniceSystemPrompt: Schema.optional<Schema.Boolean>;
-    readonly characterSlug: Schema.optional<Schema.String>;
-    readonly includeSearchResultsInStream: Schema.optional<Schema.Boolean>;
-    readonly returnSearchResultsAsDocuments: Schema.optional<Schema.Boolean>;
+import { OpenResponsesOptions } from "./utils/open-responses-options.js";
+export type ReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+declare const Options: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
+    readonly reasoning: Schema.optional<Schema.Struct<{
+        readonly effort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
+        readonly enabled: Schema.optional<Schema.Boolean>;
+        readonly summary: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "concise" | "detailed">, import("../schema/options.js").OpenString<"auto" | "concise" | "detailed">>>;
+    }>>;
+    readonly veniceParameters: Schema.optional<Schema.Struct<{
+        readonly enableWebSearch: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "off" | "on">, import("../schema/options.js").OpenString<"auto" | "off" | "on">>>;
+        readonly enableWebScraping: Schema.optional<Schema.Boolean>;
+        readonly enableWebCitations: Schema.optional<Schema.Boolean>;
+        readonly enableXSearch: Schema.optional<Schema.Boolean>;
+        readonly stripThinkingResponse: Schema.optional<Schema.Boolean>;
+        readonly disableThinking: Schema.optional<Schema.Boolean>;
+        readonly includeVeniceSystemPrompt: Schema.optional<Schema.Boolean>;
+        readonly characterSlug: Schema.optional<Schema.String>;
+        readonly includeSearchResultsInStream: Schema.optional<Schema.Boolean>;
+        readonly returnSearchResultsAsDocuments: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly promptCacheKey: Schema.optional<Schema.String>;
+    readonly promptCacheRetention: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"24h" | "default" | "extended">, import("../schema/options.js").OpenString<"24h" | "default" | "extended">>>;
+    readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
+    readonly maxCompletionTokens: Schema.optional<Schema.Number>;
+    readonly maxTokens: Schema.optional<Schema.Number>;
+    readonly minP: Schema.optional<Schema.Number>;
+    readonly repetitionPenalty: Schema.optional<Schema.Number>;
+    readonly stopTokenIds: Schema.optional<Schema.$Array<Schema.Number>>;
+    readonly logprobs: Schema.optional<Schema.Boolean>;
+    readonly topLogprobs: Schema.optional<Schema.Number>;
+    readonly maxTemp: Schema.optional<Schema.Number>;
+    readonly minTemp: Schema.optional<Schema.Number>;
+    readonly responseFormat: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly user: Schema.optional<Schema.String>;
 }>;
-export type OptionsInput = {
-    readonly reasoningEffort?: ReasoningEffort;
-    readonly reasoning?: {
-        readonly effort?: ReasoningEffort;
-        readonly enabled?: boolean;
-        readonly summary?: "auto" | "concise" | "detailed" | (string & {});
-    };
-    readonly veniceParameters?: Omit<typeof Parameters.Type, "enableWebSearch"> & {
-        readonly enableWebSearch?: "off" | "on" | "auto" | (string & {});
-    };
-    readonly promptCacheKey?: string;
-    readonly promptCacheRetention?: "default" | "extended" | "24h" | (string & {});
-    readonly parallelToolCalls?: boolean;
-    readonly maxCompletionTokens?: number;
-    readonly maxTokens?: number;
-    readonly minP?: number;
-    readonly repetitionPenalty?: number;
-    readonly stopTokenIds?: readonly number[];
-    readonly logprobs?: boolean;
-    readonly topLogprobs?: number;
-    readonly maxTemp?: number;
-    readonly minTemp?: number;
-    readonly responseFormat?: Readonly<Record<string, unknown>>;
-    readonly user?: string;
-};
+export type OptionsInput = typeof Options.Type;
 interface State {
     readonly shared: OpenAIChat.ParserState;
     readonly pending: string;
@@ -80,7 +79,7 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    readonly reasoning_effort?: OpenResponsesOptions.ReasoningEffort | undefined;
     readonly tool_stream?: boolean | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
@@ -93,13 +92,6 @@ export declare const protocol: Protocol<{
     readonly messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
-            readonly type: "text";
-            readonly text: string;
-            readonly cache_control?: {
-                readonly type: "ephemeral";
-                readonly ttl?: string | undefined;
-            } | undefined;
-        } | {
             readonly type: "image_url";
             readonly image_url: {
                 readonly url: string;
@@ -110,17 +102,17 @@ export declare const protocol: Protocol<{
                 readonly filename: string;
                 readonly file_data: string;
             };
-        })[];
-    } | {
-        readonly role: "user";
-        readonly content: string | readonly ({
+        } | {
             readonly type: "text";
             readonly text: string;
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: string | undefined;
             } | undefined;
-        } | {
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
             readonly type: "image_url";
             readonly image_url: {
                 readonly url: string;
@@ -131,6 +123,13 @@ export declare const protocol: Protocol<{
                 readonly filename: string;
                 readonly file_data: string;
             };
+        } | {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
         })[];
     } | {
         readonly role: "tool";
@@ -175,14 +174,14 @@ export declare const protocol: Protocol<{
         readonly thought_signature?: string | undefined;
     })[];
     readonly reasoning?: {
-        readonly effort?: string | undefined;
+        readonly effort?: OpenResponsesOptions.ReasoningEffort | undefined;
         readonly enabled?: boolean | undefined;
-        readonly summary?: string | undefined;
+        readonly summary?: import("../schema/options.js").OpenString<"auto" | "concise" | "detailed"> | undefined;
     } | undefined;
     readonly venice_parameters: {
         readonly [x: string]: string | boolean;
     };
-    readonly prompt_cache_retention?: string | undefined;
+    readonly prompt_cache_retention?: import("../schema/options.js").OpenString<"24h" | "default" | "extended"> | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
     readonly min_p?: number | undefined;
     readonly top_k?: number | undefined;

package/dist/protocols/venice-chat.js

@@ -5,8 +5,9 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { OpenAIChat } from "./openai-chat.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { cacheControl } from "./utils/cache.js";
+import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 const Parameters = Schema.Struct({
-    enableWebSearch: Schema.optional(Schema.String),
+    enableWebSearch: Schema.optional(ProviderShared.knownString()),
     enableWebScraping: Schema.optional(Schema.Boolean),
     enableWebCitations: Schema.optional(Schema.Boolean),
     enableXSearch: Schema.optional(Schema.Boolean),
@@ -18,16 +19,16 @@ const Parameters = Schema.Struct({
     returnSearchResultsAsDocuments: Schema.optional(Schema.Boolean),
 });
 const Reasoning = Schema.Struct({
-    effort: Schema.optional(Schema.String),
+    effort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
     enabled: Schema.optional(Schema.Boolean),
-    summary: Schema.optional(Schema.String),
+    summary: Schema.optional(ProviderShared.knownString()),
 });
 const Options = Schema.Struct({
-    reasoningEffort: Schema.optional(Schema.String),
+    reasoningEffort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
     reasoning: Schema.optional(Reasoning),
     veniceParameters: Schema.optional(Parameters),
     promptCacheKey: Schema.optional(Schema.String),
-    promptCacheRetention: Schema.optional(Schema.String),
+    promptCacheRetention: Schema.optional(ProviderShared.knownString()),
     parallelToolCalls: Schema.optional(Schema.Boolean),
     maxCompletionTokens: Schema.optional(Schema.Number),
     maxTokens: Schema.optional(Schema.Number),