@opencode/ai 2.0.21 → 2.0.23

package/dist/protocols/utils/cache.js

@@ -1,5 +1,13 @@
-// Shared counter and TTL mapping for provider cache-marker lowering.
 export const newBreakpoints = (cap) => ({ remaining: cap, dropped: 0 });
 // Requests of at least one hour use the explicit `"1h"` bucket; shorter
 // requests omit the wire TTL and use the provider default.
 export const ttlBucket = (ttlSeconds) => ttlSeconds !== undefined && ttlSeconds >= 3600 ? "1h" : undefined;
+export const cacheControl = () => {
+    const breakpoints = newBreakpoints(4);
+    return (cache) => {
+        if (cache === undefined || breakpoints.remaining === 0)
+            return undefined;
+        breakpoints.remaining -= 1;
+        return { type: "ephemeral", ttl: ttlBucket(cache.ttlSeconds) };
+    };
+};

package/dist/protocols/utils/responses-checkpoint.js

@@ -4,7 +4,7 @@ import { Protocol } from "../../route/protocol.js";
 import { CompactionCheckpointResponse, LLMEvent, LLMRequest } from "../../schema/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { ProviderShared } from "../shared.js";
-const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (state, input) {
+const onOutputItem = Effect.fnUntraced(function* (state, input) {
     const event = OpenResponses.normalize(state.parser, input);
     const item = event.item;
     if (!item)
@@ -49,7 +49,7 @@ export const make = (body) => Effect.fn("ResponsesCheckpoint.execute")(function*
                 checkpoints: {},
             }),
             terminal: OpenResponses.terminal,
-            step: Effect.fn("ResponsesCheckpoint.step")(function* (state, event) {
+            step: Effect.fnUntraced(function* (state, event) {
                 if (event.response?.id && state.responseID && event.response.id !== state.responseID)
                     return yield* ProviderShared.eventError(source.id, "Compaction response ID changed during execution");
                 if (event.type === "response.created")

package/dist/protocols/utils/responses-hosted-tools.js

@@ -3,7 +3,7 @@ import { LLMEvent } from "../../schema/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { Lifecycle } from "./lifecycle.js";
 export const isItem = (item, tools) => item.type in tools;
-export const onDone = Effect.fn("ResponsesHostedTools.onDone")(function* (state, item, tools) {
+export const onDone = Effect.fnUntraced(function* (state, item, tools) {
     const tool = tools[item.type];
     if (!tool)
         return [state, []];

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

@@ -258,6 +258,8 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly index: number;
         readonly providerMetadata?: {
@@ -271,6 +273,8 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -481,6 +485,8 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly index: number;
         readonly providerMetadata?: {
@@ -494,6 +500,8 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -701,6 +709,8 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly index: number;
         readonly providerMetadata?: {
@@ -714,6 +724,8 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly providerMetadata?: {
             readonly [x: string]: {

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";