@opencode/ai 2.0.22 → 2.0.23

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

@@ -20,13 +20,21 @@ const inputStart = (tool) => LLMEvent.toolInputStart({
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
 });
-const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
-    id: tool.id,
-    name: tool.name,
-    namespace: tool.namespace,
-    text,
-    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
-});
+const inputDelta = (tool, text) => {
+    const raw = tool.input;
+    let parsed;
+    return {
+        ...LLMEvent.toolInputDelta({
+            id: tool.id,
+            name: tool.name,
+            namespace: tool.namespace,
+            text,
+        }),
+        get input() {
+            return (parsed ??= Option.getOrElse(parsePartialInput(raw), () => ({})));
+        },
+    };
+};
 const toolCall = (route, tool, inputOverride) => {
     const raw = inputOverride ?? tool.input;
     return parseToolInput(route, tool.name, raw).pipe(Effect.catch((error) => tool.providerExecuted

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

@@ -0,0 +1,280 @@
+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>;
+}>;
+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;
+};
+interface State {
+    readonly shared: OpenAIChat.ParserState;
+    readonly pending: string;
+    readonly reasoning: string;
+    readonly encrypted: boolean;
+    readonly signature?: string;
+    readonly tools: Readonly<Record<string, string>>;
+}
+export declare const compatibility: {
+    maxTokensField: "max_completion_tokens";
+    supportsStore: false;
+    supportsPromptCacheKey: true;
+};
+export declare const protocol: Protocol<{
+    readonly model: string;
+    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;
+            };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                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 type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
+        })[];
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly tool_calls?: readonly {
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+            readonly id: string;
+            readonly type: "function";
+            readonly thought_signature?: string | undefined;
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
+        }[] | undefined;
+        readonly thought_signature?: string | undefined;
+        readonly reasoning_details?: unknown;
+    })[];
+    readonly stream: true;
+    readonly venice_parameters: {
+        readonly [x: string]: string | boolean;
+    };
+    readonly reasoning?: {
+        readonly enabled?: boolean | undefined;
+        readonly summary?: string | undefined;
+        readonly effort?: string | undefined;
+    } | undefined;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly user?: string | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly top_k?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly prompt_cache_retention?: string | undefined;
+    readonly repetition_penalty?: number | undefined;
+    readonly response_format?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly logprobs?: boolean | undefined;
+    readonly min_p?: number | undefined;
+    readonly stop_token_ids?: readonly number[] | undefined;
+    readonly max_temp?: number | undefined;
+    readonly min_temp?: number | undefined;
+}, string, "[DONE]" | {
+    readonly [x: string]: unknown;
+    readonly error?: string | {
+        readonly [x: string]: unknown;
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly [x: string]: unknown;
+        readonly cache_read_input_tokens?: number | null | undefined;
+        readonly cached_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly prompt_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly cache_creation_input_tokens?: number | null | undefined;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
+        } | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly cache_created_input_tokens?: number | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly reasoning_tokens?: number | null | undefined;
+            readonly accepted_prediction_tokens?: number | null | undefined;
+            readonly rejected_prediction_tokens?: number | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
+        readonly [x: string]: unknown;
+        readonly delta?: {
+            readonly [x: string]: unknown;
+            readonly reasoning?: string | null | undefined;
+            readonly reasoning_content?: string | null | undefined;
+            readonly reasoning_text?: string | null | undefined;
+            readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
+            readonly tool_calls?: readonly {
+                readonly function?: {
+                    readonly name?: string | null | undefined;
+                    readonly arguments?: string | null | undefined;
+                } | null | undefined;
+                readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
+                readonly thought_signature?: string | null | undefined;
+                readonly extra_content?: unknown;
+            }[] | null | undefined;
+            readonly thought_signature?: string | null | undefined;
+            readonly reasoning_details?: unknown;
+        } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly cache_read_input_tokens?: number | null | undefined;
+            readonly cached_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly cache_created_input_tokens?: number | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
+    readonly issues?: readonly {
+        readonly message: string;
+        readonly path?: readonly (string | number)[] | undefined;
+    }[] | undefined;
+}, State>;
+export * as VeniceChat from "./venice-chat.js";

package/dist/protocols/venice-chat.js

@@ -0,0 +1,283 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { AIError, LLMEvent } from "../schema/index.js";
+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";
+const Parameters = Schema.Struct({
+    enableWebSearch: Schema.optional(Schema.String),
+    enableWebScraping: Schema.optional(Schema.Boolean),
+    enableWebCitations: Schema.optional(Schema.Boolean),
+    enableXSearch: Schema.optional(Schema.Boolean),
+    stripThinkingResponse: Schema.optional(Schema.Boolean),
+    disableThinking: Schema.optional(Schema.Boolean),
+    includeVeniceSystemPrompt: Schema.optional(Schema.Boolean),
+    characterSlug: Schema.optional(Schema.String),
+    includeSearchResultsInStream: Schema.optional(Schema.Boolean),
+    returnSearchResultsAsDocuments: Schema.optional(Schema.Boolean),
+});
+const Reasoning = Schema.Struct({
+    effort: Schema.optional(Schema.String),
+    enabled: Schema.optional(Schema.Boolean),
+    summary: Schema.optional(Schema.String),
+});
+const Options = Schema.Struct({
+    reasoningEffort: Schema.optional(Schema.String),
+    reasoning: Schema.optional(Reasoning),
+    veniceParameters: Schema.optional(Parameters),
+    promptCacheKey: Schema.optional(Schema.String),
+    promptCacheRetention: Schema.optional(Schema.String),
+    parallelToolCalls: Schema.optional(Schema.Boolean),
+    maxCompletionTokens: Schema.optional(Schema.Number),
+    maxTokens: Schema.optional(Schema.Number),
+    minP: Schema.optional(Schema.Number),
+    repetitionPenalty: Schema.optional(Schema.Number),
+    stopTokenIds: Schema.optional(Schema.Array(Schema.Number)),
+    logprobs: Schema.optional(Schema.Boolean),
+    topLogprobs: Schema.optional(Schema.Number),
+    maxTemp: Schema.optional(Schema.Number),
+    minTemp: Schema.optional(Schema.Number),
+    responseFormat: Schema.optional(JsonObject),
+    user: Schema.optional(Schema.String),
+});
+const ToolCall = Schema.Struct({
+    ...OpenAIChat.OpenAIChatAssistantToolCall.fields,
+    thought_signature: Schema.optional(Schema.String),
+});
+const Assistant = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatMessage.cases.assistant.schema.fields,
+    tool_calls: optionalArray(ToolCall),
+    thought_signature: Schema.optional(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Messages = Schema.Array(Schema.Union([
+    OpenAIChat.OpenAIChatMessage.cases.system,
+    OpenAIChat.OpenAIChatMessage.cases.user,
+    Assistant,
+    OpenAIChat.OpenAIChatMessage.cases.tool,
+]));
+const Body = Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    messages: Messages,
+    reasoning: Schema.optional(Reasoning),
+    venice_parameters: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Boolean])),
+    prompt_cache_retention: Options.fields.promptCacheRetention,
+    parallel_tool_calls: Options.fields.parallelToolCalls,
+    min_p: Options.fields.minP,
+    top_k: Schema.optional(Schema.Number),
+    repetition_penalty: Options.fields.repetitionPenalty,
+    stop_token_ids: Options.fields.stopTokenIds,
+    logprobs: Options.fields.logprobs,
+    top_logprobs: Options.fields.topLogprobs,
+    max_temp: Options.fields.maxTemp,
+    min_temp: Options.fields.minTemp,
+    response_format: Options.fields.responseFormat,
+    user: Options.fields.user,
+});
+// ---------------------------------------------------------------------------
+// Streaming schemas and state
+// ---------------------------------------------------------------------------
+const ToolDelta = Schema.Struct({
+    ...OpenAIChat.OpenAIChatToolCallDelta.fields,
+    thought_signature: optionalNull(Schema.String),
+});
+const Delta = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatDelta.schema.fields,
+    tool_calls: optionalNull(Schema.Array(ToolDelta)),
+    thought_signature: optionalNull(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Choice = Schema.StructWithRest(Schema.Struct({ ...OpenAIChat.OpenAIChatChoice.schema.fields, delta: optionalNull(Delta) }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Usage = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatUsage.schema.fields,
+    prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
+        cached_tokens: optionalNull(Schema.Number),
+        cache_write_tokens: optionalNull(Schema.Number),
+        cache_creation_input_tokens: optionalNull(Schema.Number),
+    }), [Schema.Record(Schema.String, Schema.Unknown)])),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Event = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.OpenAIChatEvent.schema.fields,
+    choices: optionalNull(Schema.Array(Choice)),
+    usage: optionalNull(Usage),
+    error: optionalNull(Schema.Union([Schema.String, OpenAIChat.OpenAIChatEvent.schema.fields.error.schema])),
+    issues: optionalArray(Schema.Struct({
+        message: Schema.String,
+        path: Schema.optional(Schema.Array(Schema.Union([Schema.String, Schema.Number]))),
+    })),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const MARKER = "__ENCRYPTED_REASONING__";
+// ---------------------------------------------------------------------------
+// Request lowering
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("VeniceChat.fromRequest")(function* (request) {
+    const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {});
+    const body = yield* OpenAIChat.fromRequest(request, {
+        cacheControl: cacheControl(),
+        assistant: (source, message) => {
+            if (message.role !== "assistant")
+                return message;
+            const parts = source.content.filter((part) => part.type === "text" || part.type === "reasoning" || part.type === "tool-call");
+            const calls = source.content.filter((part) => part.type === "tool-call");
+            const signature = parts
+                .map((part) => part.providerMetadata?.venice?.messageThoughtSignature)
+                .find((value) => typeof value === "string");
+            const raw = parts
+                .map((part) => part.providerMetadata?.venice?.encryptedReasoningContent)
+                .find((value) => typeof value === "string");
+            return {
+                ...message,
+                ...(signature === undefined ? {} : { thought_signature: signature }),
+                ...(raw === undefined ? {} : { reasoning_content: raw }),
+                tool_calls: message.tool_calls?.map((call, index) => {
+                    const signature = calls[index]?.providerMetadata?.venice?.thoughtSignature;
+                    return { ...call, ...(typeof signature === "string" ? { thought_signature: signature } : {}) };
+                }),
+            };
+        },
+    });
+    return {
+        ...body,
+        max_completion_tokens: options.maxCompletionTokens ?? options.maxTokens ?? request.generation?.maxTokens,
+        reasoning_effort: undefined,
+        reasoning: options.reasoningEffort === undefined
+            ? options.reasoning
+            : { ...options.reasoning, effort: options.reasoningEffort },
+        // Match the previous Venice SDK default, not the gateway's added prompt.
+        venice_parameters: Object.fromEntries(Object.entries({
+            ...options.veniceParameters,
+            includeVeniceSystemPrompt: options.veniceParameters?.includeVeniceSystemPrompt ?? false,
+        })
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`), value])),
+        prompt_cache_retention: options.promptCacheRetention,
+        parallel_tool_calls: options.parallelToolCalls,
+        min_p: options.minP,
+        top_k: request.generation?.topK,
+        repetition_penalty: options.repetitionPenalty,
+        stop_token_ids: options.stopTokenIds,
+        logprobs: options.logprobs,
+        top_logprobs: options.topLogprobs,
+        max_temp: options.maxTemp,
+        min_temp: options.minTemp,
+        response_format: options.responseFormat,
+        user: options.user,
+    };
+});
+// ---------------------------------------------------------------------------
+// Venice normalization around the shared Chat state machine
+// ---------------------------------------------------------------------------
+const step = Effect.fn("VeniceChat.step")(function* (state, event) {
+    if (typeof event.error === "string")
+        return yield* new AIError({
+            reason: classifyProviderFailure({
+                message: [
+                    event.error,
+                    ...(event.issues ?? []).map((issue) => `${issue.path?.length ? `${issue.path.join(".")}: ` : ""}${issue.message}`),
+                ].join("; "),
+                rawBody: ProviderShared.encodeJson(event),
+            }),
+        });
+    const delta = event.choices?.[0]?.delta;
+    const scalar = delta?.reasoning_content ?? "";
+    const text = state.pending + scalar;
+    const marker = text.indexOf(MARKER);
+    const pending = marker >= 0 || state.encrypted
+        ? 0
+        : (Array.from({ length: Math.min(text.length, MARKER.length - 1) }, (_, index) => index + 1)
+            .filter((length) => text.endsWith(MARKER.slice(0, length)))
+            .at(-1) ?? 0);
+    const visible = state.encrypted ? "" : marker >= 0 ? text.slice(0, marker) : text.slice(0, text.length - pending);
+    const result = yield* OpenAIChat.protocol.stream.step(state.shared, {
+        ...event,
+        error: event.error,
+        usage: event.usage
+            ? {
+                ...event.usage,
+                prompt_tokens_details: event.usage.prompt_tokens_details
+                    ? {
+                        ...event.usage.prompt_tokens_details,
+                        cache_write_tokens: event.usage.prompt_tokens_details.cache_write_tokens ??
+                            event.usage.prompt_tokens_details.cache_creation_input_tokens,
+                    }
+                    : event.usage.prompt_tokens_details,
+            }
+            : event.usage,
+        choices: event.choices?.map((choice, index) => index === 0 && choice.delta
+            ? {
+                ...choice,
+                delta: {
+                    ...choice.delta,
+                    reasoning_content: visible || undefined,
+                    // Opaque-only scalar reasoning still needs a canonical part for replay.
+                    reasoning_details: choice.delta.reasoning_details ?? (marker >= 0 ? [] : undefined),
+                },
+            }
+            : choice),
+    });
+    const tools = { ...state.tools };
+    for (const call of delta?.tool_calls ?? []) {
+        if (!call.thought_signature)
+            continue;
+        const index = call.index ?? result[0].latestToolIndex;
+        const id = call.id ?? (index === undefined ? undefined : (result[0].tools[index]?.id ?? result[0].pendingTools[index]?.id));
+        if (id)
+            tools[id] = call.thought_signature;
+    }
+    return [
+        {
+            shared: result[0],
+            pending: pending ? text.slice(-pending) : "",
+            reasoning: state.reasoning + scalar,
+            encrypted: state.encrypted || marker >= 0,
+            signature: delta?.thought_signature ?? state.signature,
+            tools,
+        },
+        result[1],
+    ];
+});
+const onHalt = Effect.fn("VeniceChat.onHalt")(function* (state) {
+    const events = yield* OpenAIChat.finishEvents(state.shared);
+    return events.flatMap((event) => {
+        if (event.type !== "reasoning-end" &&
+            event.type !== "text-end" &&
+            event.type !== "tool-call" &&
+            event.type !== "tool-input-end")
+            return [event];
+        const signature = event.type === "tool-call" || event.type === "tool-input-end" ? state.tools[event.id] : undefined;
+        const providerMetadata = {
+            ...event.providerMetadata,
+            venice: {
+                ...event.providerMetadata?.venice,
+                ...(state.signature ? { messageThoughtSignature: state.signature } : {}),
+                ...(signature ? { thoughtSignature: signature } : {}),
+                ...(event.type === "reasoning-end" && state.encrypted ? { encryptedReasoningContent: state.reasoning } : {}),
+            },
+        };
+        if (event.type === "reasoning-end" && state.pending)
+            return [LLMEvent.reasoningDelta({ id: event.id, text: state.pending }), { ...event, providerMetadata }];
+        return [{ ...event, providerMetadata }];
+    });
+});
+export const compatibility = {
+    maxTokensField: "max_completion_tokens",
+    supportsStore: false,
+    supportsPromptCacheKey: true,
+};
+export const protocol = Protocol.make({
+    id: "venice-chat",
+    body: { schema: Body, from: fromRequest },
+    stream: {
+        event: Schema.Union([Schema.Literal("[DONE]"), Protocol.jsonEvent(Event)]),
+        initial: (request) => ({
+            shared: OpenAIChat.protocol.stream.initial(request),
+            pending: "",
+            reasoning: "",
+            encrypted: false,
+            tools: {},
+        }),
+        step: (state, event) => (event === "[DONE]" ? Effect.succeed([state, []]) : step(state, event)),
+        terminal: (event) => event === "[DONE]",
+        onHalt,
+    },
+});
+export * as VeniceChat from "./venice-chat.js";

package/dist/protocols/xai-responses.d.ts

@@ -38,6 +38,15 @@ export declare const protocol: Protocol<{
         readonly error?: unknown;
         readonly arguments?: string | undefined;
         readonly server_label?: string | undefined;
+    } | {
+        readonly type: "configuration_update";
+        readonly reasoning: {
+            readonly effort: import("../schema/options.js").ReasoningEffort;
+        };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -114,21 +123,6 @@ export declare const protocol: Protocol<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "x_search_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly error?: unknown;
-        readonly result?: unknown;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -140,7 +134,10 @@ export declare const protocol: Protocol<{
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
+        readonly [x: string]: unknown;
+        readonly type: string;
+    } | {
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -148,7 +145,7 @@ export declare const protocol: Protocol<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    }[] | undefined;
+    })[] | undefined;
     readonly text?: {
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
@@ -168,9 +165,10 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -178,7 +176,6 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, string, {
     readonly [x: string]: unknown;
@@ -198,8 +195,8 @@ export declare const protocol: Protocol<{
             readonly name?: string | undefined;
             readonly namespace?: string | undefined;
             readonly arguments?: string | undefined;
-            readonly encrypted_content?: string | null | undefined;
             readonly call_id?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
@@ -226,8 +223,8 @@ export declare const protocol: Protocol<{
         readonly name?: string | undefined;
         readonly namespace?: string | undefined;
         readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
     } | null | undefined;
     readonly delta?: string | undefined;
     readonly arguments?: string | undefined;