@opencode/ai 2.1.2 → 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/open-responses-options.d.ts

@@ -3,17 +3,17 @@ import { ReasoningEffort, ReasoningEfforts, type LLMRequest } from "../../schema
 export { ReasoningEffort, ReasoningEfforts };
 export declare const TextVerbosities: readonly ["low", "medium", "high"];
 export type TextVerbosity = (typeof TextVerbosities)[number] | (string & {});
-export declare const TextVerbosity: Schema.declare<TextVerbosity, TextVerbosity>;
+export declare const TextVerbosity: Schema.declare<import("../../schema/options.js").OpenString<"high" | "low" | "medium">, import("../../schema/options.js").OpenString<"high" | "low" | "medium">>;
 export declare const ResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
 export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {});
 export declare const ServiceTiers: readonly ["auto", "default", "flex", "priority"];
 export type ServiceTier = (typeof ServiceTiers)[number] | (string & {});
-export declare const ServiceTier: Schema.declare<ServiceTier, ServiceTier>;
+export declare const ServiceTier: Schema.declare<import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">, import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">>;
 export declare const Truncations: readonly ["auto", "disabled"];
 export type Truncation = (typeof Truncations)[number];
-export declare const TextVerbositySchema: Schema.declare<TextVerbosity, TextVerbosity>;
-export declare const ResponseIncludableSchema: Schema.declare<ResponseIncludable, ResponseIncludable>;
-export declare const ServiceTierSchema: Schema.declare<ServiceTier, ServiceTier>;
+export declare const TextVerbositySchema: Schema.declare<import("../../schema/options.js").OpenString<"high" | "low" | "medium">, import("../../schema/options.js").OpenString<"high" | "low" | "medium">>;
+export declare const ResponseIncludableSchema: Schema.declare<import("../../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">, import("../../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">>;
+export declare const ServiceTierSchema: Schema.declare<import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">, import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">>;
 export declare const TruncationSchema: Schema.Literals<readonly ["auto", "disabled"]>;
 export declare const AllowedTools: Schema.Struct<{
     readonly toolNames: Schema.$Array<Schema.String>;
@@ -33,9 +33,9 @@ export declare const Options: Schema.Struct<{
     readonly topLogprobs: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Int>, never>>;
     readonly reasoningEffort: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<ReasoningEffort, ReasoningEffort>>, never>>;
     readonly reasoningSummary: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Literals<readonly ["auto", "concise", "detailed"]>>, never>>;
-    readonly include: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.declare<ResponseIncludable, ResponseIncludable>>>, never>>;
-    readonly textVerbosity: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<TextVerbosity, TextVerbosity>>, never>>;
-    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<ServiceTier, ServiceTier>>, never>>;
+    readonly include: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.declare<import("../../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">, import("../../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">>>>, never>>;
+    readonly textVerbosity: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../../schema/options.js").OpenString<"high" | "low" | "medium">, import("../../schema/options.js").OpenString<"high" | "low" | "medium">>>, never>>;
+    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">, import("../../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority">>>, never>>;
     readonly truncation: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Literals<readonly ["auto", "disabled"]>>, never>>;
     readonly allowedTools: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Struct<{
         readonly toolNames: Schema.$Array<Schema.String>;

package/dist/protocols/utils/open-responses-options.js

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
 import { ReasoningEffort, ReasoningEfforts } from "../../schema/index.js";
-import { lenient } from "../shared.js";
+import { lenient, ProviderShared } from "../shared.js";
 export { ReasoningEffort, ReasoningEfforts };
 export const TextVerbosities = ["low", "medium", "high"];
-export const TextVerbosity = Schema.declare((value) => typeof value === "string", { title: "TextVerbosity" });
+export const TextVerbosity = ProviderShared.knownString();
 export const ResponseIncludables = [
     "file_search_call.results",
     "web_search_call.results",
@@ -15,12 +15,10 @@ export const ResponseIncludables = [
     "message.output_text.logprobs",
 ];
 export const ServiceTiers = ["auto", "default", "flex", "priority"];
-export const ServiceTier = Schema.declare((value) => typeof value === "string", {
-    title: "ServiceTier",
-});
+export const ServiceTier = ProviderShared.knownString();
 export const Truncations = ["auto", "disabled"];
 export const TextVerbositySchema = TextVerbosity;
-export const ResponseIncludableSchema = Schema.declare((value) => typeof value === "string", { title: "ResponseIncludable" });
+export const ResponseIncludableSchema = ProviderShared.knownString();
 export const ServiceTierSchema = ServiceTier;
 export const TruncationSchema = Schema.Literals(Truncations);
 export const AllowedTools = Schema.Struct({

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/partial-json.js

@@ -25,13 +25,14 @@
  * SOFTWARE.
  */
 import { Schema } from "effect";
+import { decodeJson } from "../../utils/json.js";
 import { Allow } from "./partial-json-options.js";
 export * from "./partial-json-options.js";
 export class PartialJSON extends Error {
 }
 export class MalformedJSON extends Error {
 }
-const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+const decodeJsonString = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.String));
 /** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
 export function parseJSON(jsonString, allowPartial = Allow.ALL) {
     if (typeof jsonString !== "string")
@@ -159,7 +160,7 @@ const _parseJSON = (jsonString, allow) => {
         }
         if (jsonString.charAt(index) === '"') {
             try {
-                return decodeJson(jsonString.substring(start, ++index - Number(escape)));
+                return decodeJsonString(jsonString.substring(start, ++index - Number(escape)));
             }
             catch (error) {
                 throwMalformedError(String(error));
@@ -167,10 +168,10 @@ const _parseJSON = (jsonString, allow) => {
         }
         if (Allow.STR & allow) {
             try {
-                return decodeJson(`${jsonString.substring(start, index - Number(escape))}"`);
+                return decodeJsonString(`${jsonString.substring(start, index - Number(escape))}"`);
             }
             catch {
-                return decodeJson(`${jsonString.substring(start, jsonString.lastIndexOf("\\"))}"`);
+                return decodeJsonString(`${jsonString.substring(start, jsonString.lastIndexOf("\\"))}"`);
             }
         }
         return markPartialJSON("Unterminated string literal");

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

@@ -1,13 +1,10 @@
 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: typeof GeminiJsonSchema.normalize;
     readonly moonshot: typeof moonshot;
-    readonly openAI: typeof openAI;
-    readonly responses: typeof openAI;
     readonly tools: typeof tools;
 };
 export {};

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

@@ -48,8 +48,6 @@ const moonshot = (schema) => {
     const projected = moonshotNode(schema);
     return isRecord(projected) ? projected : {};
 };
-const openAI = (schema) => schema;
-const responses = openAI;
 const gemini = GeminiJsonSchema.normalize;
 const MODEL_NAMES = [
     [/gemini/i, "gemini"],
@@ -97,7 +95,5 @@ const tools = (entries, model) => entries.map((tool) => tool.type === "tool"
 export const ToolSchemaProjection = {
     gemini,
     moonshot,
-    openAI,
-    responses,
     tools,
 };

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),