@opencode/ai 2.0.22 → 2.0.23

package/README.md

@@ -27,6 +27,31 @@ Run `LLM.stream(...)` instead of `generate` when you want incremental `LLMEvent`
 `LLM.request(...)`. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
 Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+### Google Interactions
+
+`Google.configure({ apiKey }).interactions(modelID)` selects the Interactions API; `.model(modelID)` still selects
+GenerateContent. The package entrypoint is `@opencode/ai/providers/google/interactions`.
+
+```ts
+const model = Google.configure({ apiKey }).interactions("gemini-3.8-flash")
+const response = yield* LLM.generate({
+  model,
+  prompt: "Say hello.",
+  providerOptions: { thinkingLevel: "low", thinkingSummaries: "auto", store: true },
+})
+```
+
+Interactions supports text output, streamed function calls, native tool results, thought signatures, and multimodal
+input. Full-history replay is the default (`store: false`); implicit caching works without retained interactions.
+For server-side continuation, set `store: true` on the predecessor, read `interactionId` from the final event's
+`providerMetadata.google`, and pass `previousInteractionId` on the next request with **only new messages**. Repeat
+the system instructions and tool declarations on each request. Set `store: true` on each response you intend to
+continue from. The package does not automatically select or persist continuation IDs.
+
+Raw usage is preserved in `usage.providerMetadata.google`. `inputTokens` follows Google's top-level accounting;
+`contextTokens` uses its full `raw_prompt_token` count when supplied. These can differ substantially with server-side
+continuation. Explicit caches, hosted tools, and generated media are not supported by this initial protocol.
+
 The same configured facade names image, video, speech, and transcription models. `Image.generate` resolves the
 provider's image route from the model and returns `Media.Asset`s with lazily decoded bytes:
 
@@ -81,6 +106,41 @@ for await (const event of ai.llm.stream(ai.llm.request(input))) {
 await ai.dispose()
 ```
 
+## Venice AI
+
+`Venice` provides native Chat Completions with streaming tools and reasoning. `model` and `chat`
+select the same API; credentials default to `VENICE_API_KEY`.
+
+```ts
+import { LLM } from "@opencode/ai"
+import { Venice } from "@opencode/ai/providers"
+import { Effect } from "effect"
+
+const program = Effect.gen(function* () {
+  const response = yield* LLM.generate({
+    model: Venice.configure({ apiKey: process.env.VENICE_API_KEY }).chat("qwen3-6-27b"),
+    prompt: "Explain this design.",
+    providerOptions: {
+      reasoningEffort: "high",
+      veniceParameters: { includeVeniceSystemPrompt: false },
+    },
+  })
+  console.log(response.text)
+})
+```
+
+Effort lowers to `reasoning.effort`; `reasoning.enabled` and `reasoning.summary` are also available.
+Supported effort levels and toggles depend on the selected model. Omitted controls preserve its defaults.
+Venice's added system prompt is disabled by default, matching the previous OpenCode Venice SDK behavior.
+
+Replay complete `response.message` values to retain signed/encrypted reasoning and Gemini thought
+signatures, including per-tool signatures. Venice's encrypted scalar trailers are excluded from visible
+reasoning but retained in provider metadata for replay. Cache affinity uses `promptCacheKey`, and cache-write
+usage reads Venice's `cache_creation_input_tokens` field.
+
+The native package entrypoint is `@opencode/ai/providers/venice`. Image generation, embeddings, Responses, and
+client-side E2EE are not implemented by this provider.
+
 ## Experimental evaluation
 
 Evaluation models compare shared state with typed choice, score, and boolean questions. The API is
@@ -1223,7 +1283,7 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
+Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cohere, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
 
 Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
 

package/dist/cache-policy.js

@@ -40,6 +40,7 @@ const RESPECTS_INLINE_HINTS = new Set([
     "alibaba-messages",
     "anthropic-messages",
     "anthropic-compatible-messages",
+    "bedrock-mantle-messages",
     "cloudflare-ai-gateway-messages",
     "google-vertex-messages",
     "meta-messages",

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

@@ -152,10 +152,10 @@ export declare const protocol: Protocol<{
     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?: OpenResponsesOptions.ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
@@ -188,9 +188,9 @@ export declare const protocol: Protocol<{
         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 total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
@@ -229,9 +229,9 @@ export declare const protocol: Protocol<{
             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 total_tokens?: number | null | undefined;
             readonly prompt_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly cached_tokens?: number | null | undefined;

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

@@ -48,6 +48,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: OpenResponsesOptions.ReasoningEffort;
+        };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -124,12 +133,6 @@ export declare const protocol: Protocol<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_extractor_call";
-        readonly urls?: readonly string[] | undefined;
-        readonly goal?: string | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -142,6 +145,9 @@ export declare const protocol: Protocol<{
         readonly effort?: OpenResponsesOptions.ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
+        readonly [x: string]: unknown;
+        readonly type: string;
+    } | {
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -149,8 +155,6 @@ export declare const protocol: Protocol<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    } | {
-        readonly type: "web_search" | "code_interpreter" | "web_extractor";
     })[] | undefined;
     readonly text?: {
         readonly verbosity?: OpenResponsesOptions.TextVerbosity | undefined;
@@ -171,9 +175,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 OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -181,7 +186,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;
     readonly previous_response_id?: string | undefined;
     readonly conversation?: string | undefined;
@@ -204,8 +208,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?: {
@@ -232,8 +236,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;

package/dist/protocols/alibaba-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { Protocol } from "../route/protocol.js";
 import { OpenResponses } from "./open-responses.js";
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
+import { JsonObject, ProviderShared } from "./shared.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 const Options = Schema.Struct({
@@ -20,8 +20,6 @@ const WebExtractorItem = Schema.StructWithRest(Schema.Struct({
 }), [JsonObject]);
 const Body = Schema.Struct({
     ...OpenResponses.coreFields,
-    input: Schema.Array(Schema.Union([OpenResponses.InputItem, WebExtractorItem])),
-    tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
     enable_thinking: Options.fields.enableThinking,
     previous_response_id: Options.fields.previousResponseId,
     conversation: Options.fields.conversation,
@@ -45,7 +43,7 @@ export const protocol = Protocol.make({
             const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
             const body = yield* OpenResponses.fromRequestWithAdapter(req, adapter);
             const choice = body.tool_choice;
-            return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+            return {
                 ...body,
                 enable_thinking: opts.enableThinking,
                 previous_response_id: opts.previousResponseId,
@@ -54,7 +52,7 @@ export const protocol = Protocol.make({
                 tool_choice: typeof choice === "object" && choice.type === "function"
                     ? { type: "allowed_tools", mode: "required", tools: [choice] }
                     : choice,
-            });
+            };
         }),
     },
     stream: {

package/dist/protocols/anthropic-messages.js

@@ -462,7 +462,7 @@ const serverToolResultType = (name) => {
         return "web_fetch_tool_result";
     return undefined;
 };
-const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (part, providerMetadataKey) {
+const lowerServerToolResult = Effect.fnUntraced(function* (part, providerMetadataKey) {
     const wireType = serverToolResultType(part.name);
     if (!wireType)
         return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`);
@@ -538,7 +538,7 @@ const citationsFromMetadata = (metadata) => {
     return undefined;
 };
 const isHttpUrl = (value) => /^https?:\/\//i.test(value.trim());
-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, breakpoints) {
+const lowerMedia = Effect.fnUntraced(function* (part, breakpoints) {
     const mime = part.media.mediaType.toLowerCase();
     const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined;
     const fileId = fileIdFromMetadata(part.metadata);
@@ -675,9 +675,6 @@ const requireThinkingSignature = (request) => {
         return false;
     return true;
 };
-// Mid-conversation system messages became available with Opus 4.8 and version
-// 5 of the other supported Claude families. Treat later family versions as
-// compatible without assuming that every Anthropic Messages model is Claude.
 // Opus 4.8 and every Claude 5 model accept mid-conversation system messages; later versions inherit support.
 const supportsNativeSystemUpdates = (request) => {
     const version = claudeVersion(String(request.model.id));
@@ -687,23 +684,8 @@ const supportsNativeSystemUpdates = (request) => {
         return version.minor >= 8;
     return version.major >= 5;
 };
-const endsInServerToolUse = (message) => {
-    const last = message.content.at(-1);
-    return message.role === "assistant" && last?.type === "tool-call" && last.providerExecuted === true;
-};
-const canUseNativeSystemUpdate = (request, index) => {
-    const previous = request.messages[index - 1];
-    const next = request.messages[index + 1];
-    // Vertex currently rejects/404s for a system message after local tool results,
-    // so fold it into the user tool-result turn across continuations and history.
-    if (request.model.route.id === "google-vertex-messages" && previous?.role === "tool")
-        return false;
-    return (previous !== undefined &&
-        previous.role !== "system" &&
-        (previous.role === "user" || previous.role === "tool" || endsInServerToolUse(previous)) &&
-        next?.role !== "system" &&
-        (next === undefined || next.role === "assistant"));
-};
+// Native system messages must follow a user turn (tool results count) or a paused server-tool turn.
+const acceptsNativeSystemAfter = (message) => message?.role === "user" || (message?.role === "assistant" && message.content.at(-1)?.type === "server_tool_use");
 const splitsLocalToolResults = (messages, index) => {
     const pending = new Set();
     for (const message of messages.slice(0, index)) {
@@ -716,7 +698,7 @@ const splitsLocalToolResults = (messages, index) => {
     }
     return pending.size > 0;
 };
-const lowerNativeSystemUpdate = Effect.fn("AnthropicMessages.lowerNativeSystemUpdate")(function* (message, breakpoints) {
+const lowerNativeSystemUpdate = Effect.fnUntraced(function* (message, breakpoints) {
     const content = yield* ProviderShared.systemUpdateText("Anthropic Messages", message);
     return {
         role: "system",
@@ -727,9 +709,33 @@ const lowerNativeSystemUpdate = Effect.fn("AnthropicMessages.lowerNativeSystemUp
         })),
     };
 });
-const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (request, breakpoints) {
+const lowerWrappedSystemUpdate = Effect.fnUntraced(function* (message, breakpoints) {
+    const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", message);
+    return { type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) };
+});
+const appendToUserTurn = (messages, block) => {
+    const last = messages.at(-1);
+    if (last?.role === "user")
+        messages[messages.length - 1] = { role: "user", content: [...last.content, block] };
+    else
+        messages.push({ role: "user", content: [block] });
+};
+const lowerMessages = Effect.fnUntraced(function* (request, breakpoints) {
     const messages = [];
     const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
+    // Text updates stay where they are unless a user turn follows them; then they move after the latest
+    // user turn, the nearest spot where Anthropic accepts a native system message.
+    const holdUpdates = supportsNativeSystemUpdates(request);
+    const held = [];
+    const releaseHeld = Effect.fnUntraced(function* () {
+        const native = acceptsNativeSystemAfter(messages.findLast((message) => message.role !== "system"));
+        for (const update of held.splice(0)) {
+            if (native)
+                messages.push(yield* lowerNativeSystemUpdate(update, breakpoints));
+            else
+                appendToUserTurn(messages, yield* lowerWrappedSystemUpdate(update, breakpoints));
+        }
+    });
     for (const [index, message] of request.messages.entries()) {
         if (message.role === "system") {
             const update = effortUpdate(message);
@@ -740,17 +746,10 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
             }
             if (splitsLocalToolResults(request.messages, index))
                 return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result");
-            if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request, index)) {
-                messages.push(yield* lowerNativeSystemUpdate(message, breakpoints));
-                continue;
-            }
-            const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", message);
-            const block = { type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) };
-            const previous = messages.at(-1);
-            if (previous?.role === "user")
-                messages[messages.length - 1] = { role: "user", content: [...previous.content, block] };
+            if (holdUpdates)
+                held.push(message);
             else
-                messages.push({ role: "user", content: [block] });
+                appendToUserTurn(messages, yield* lowerWrappedSystemUpdate(message, breakpoints));
             continue;
         }
         if (message.role === "user") {
@@ -826,8 +825,10 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                 }
                 return yield* invalid(`Anthropic Messages assistant messages only support text, reasoning, and tool-call content for now`);
             }
-            if (content.length > 0)
-                messages.push({ role: "assistant", content });
+            if (content.length === 0)
+                continue;
+            yield* releaseHeld();
+            messages.push({ role: "assistant", content });
             continue;
         }
         const content = [];
@@ -848,8 +849,12 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
         else
             messages.push({ role: "user", content });
     }
+    yield* releaseHeld();
     return messages;
 });
+// TODO: Move per-model capability heuristics (`supportsEffortUpdates`, `supportsNativeSystemUpdates`,
+// `supportsThinkingBlockBinding`) into explicit model/provider `compatibility` metadata so the protocol
+// only reads `request.model.compatibility`.
 // Per-turn effort started with Claude Opus 5 and every Claude 5.1 model; later versions of any family inherit it.
 const supportsEffortUpdates = (model) => {
     const override = model.compatibility?.supportsEffortUpdates;
@@ -1132,7 +1137,7 @@ const onContentBlockStart = (state, event) => {
     const events = [];
     return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, [...events, result]];
 };
-const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(function* (state, event) {
+const onContentBlockDelta = Effect.fnUntraced(function* (state, event) {
     const delta = event.delta;
     if (delta.type === "compaction_delta") {
         if (event.index === undefined || !(event.index in state.compactions) || delta.content === undefined)
@@ -1190,7 +1195,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     }
     return [state, NO_EVENTS];
 });
-const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(function* (state, event) {
+const onContentBlockStop = Effect.fnUntraced(function* (state, event) {
     if (event.index === undefined)
         return [state, NO_EVENTS];
     if (event.index in state.compactions) {
@@ -1246,7 +1251,7 @@ const onMessageDelta = (state, event) => {
         NO_EVENTS,
     ];
 };
-const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (state) {
+const onMessageStop = Effect.fnUntraced(function* (state) {
     if (Object.keys(state.compactions).length)
         return yield* ProviderShared.eventError(ADAPTER, "Response ended with an incomplete compaction block");
     const result = yield* ToolStream.finishAll(ADAPTER, state.tools);

package/dist/protocols/bedrock-converse.js

@@ -211,7 +211,7 @@ const lowerToolCall = (part, normalizeID) => ({
         input: removeEmptyToolInputKeys(part.input),
     },
 });
-const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part, documentNames) {
+const lowerToolResultContent = Effect.fnUntraced(function* (part, documentNames) {
     if (part.result.type === "text" || part.result.type === "error")
         return [{ text: ProviderShared.toolResultText(part) }];
     if (part.result.type === "json")
@@ -227,7 +227,7 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
     }
     return content;
 });
-const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part, documentNames, normalizeID) {
+const lowerToolResult = Effect.fnUntraced(function* (part, documentNames, normalizeID) {
     return {
         toolResult: {
             toolUseId: normalizeID(part.id),
@@ -238,7 +238,7 @@ const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (
 });
 // Keep Claude and Nova tool-result images inline; put other models' images beside the result.
 const keepToolImagesInline = (id) => id.includes("anthropic.claude-") || id.includes("amazon.nova-");
-const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (request, breakpoints) {
+const lowerMessages = Effect.fnUntraced(function* (request, breakpoints) {
     const messages = [];
     const documentNames = new Set();
     // Mistral can reject replay IDs even when they satisfy Converse's broader ID syntax.

package/dist/protocols/cartesia-speech.js

@@ -38,7 +38,7 @@ const decodeEvent = route.decodeFrame(SseEvent);
 /** Timestamps exist only on the SSE endpoint, so a `generate` that asks for them collects an SSE stream. */
 const usesSse = (request) => request.mode === "stream" || request.timestamps === true;
 const CONTAINERS = { pcm: "raw", wav: "wav", mp3: "mp3" };
-const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request) {
+const outputFormat = Effect.fnUntraced(function* (request) {
     const sse = usesSse(request);
     const format = request.format ?? (sse ? "pcm" : "mp3");
     const container = CONTAINERS[format];
@@ -69,7 +69,7 @@ const fromRequest = Effect.fn("CartesiaSpeech.fromRequest")(function* (request)
 // ---------------------------------------------------------------------------
 // 6. Stream parsing
 // ---------------------------------------------------------------------------
-const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
+const onEvent = Effect.fnUntraced(function* (state, frame) {
     const event = yield* decodeEvent(frame);
     if (event.type === "chunk" && event.data !== undefined)
         return SpeechStream.delta(state, event.data);
@@ -89,7 +89,7 @@ const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
         });
     return [state, []];
 });
-const finish = Effect.fn("CartesiaSpeech.finish")(function* (state, context) {
+const finish = Effect.fnUntraced(function* (state, context) {
     if (usesSse(context.request) && !state.done)
         return yield* route.incomplete();
     const format = yield* outputFormat(context.request);

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

@@ -0,0 +1,178 @@
+import { Schema } from "effect";
+import { Route } from "../route/client.js";
+import { Protocol } from "../route/protocol.js";
+import { Lifecycle } from "./utils/lifecycle.js";
+import { ToolStream } from "./utils/tool-stream.js";
+export declare const DEFAULT_BASE_URL = "https://api.cohere.com/v2";
+declare const Options: Schema.Struct<{
+    readonly thinking: Schema.optional<Schema.Struct<{
+        readonly type: Schema.optional<Schema.Literals<readonly ["enabled", "disabled"]>>;
+        readonly tokenBudget: Schema.optional<Schema.Int>;
+    }>>;
+}>;
+export type ProviderOptionsInput = Schema.Schema.Type<typeof Options>;
+export declare const protocol: Protocol<{
+    readonly model: string;
+    readonly messages: readonly {
+        readonly role: "tool" | "system" | "user" | "assistant";
+        readonly content?: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "thinking";
+            readonly thinking: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[] | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly tool_call_id?: string | undefined;
+        readonly tool_plan?: string | undefined;
+    }[];
+    readonly stream: true;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly parameters: unknown;
+            readonly description?: string | undefined;
+        };
+    }[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly thinking?: {
+        readonly type: string;
+        readonly token_budget?: number | undefined;
+    } | undefined;
+    readonly tool_choice?: "NONE" | "REQUIRED" | undefined;
+    readonly stop_sequences?: readonly string[] | undefined;
+    readonly p?: number | undefined;
+    readonly k?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+}, string, {
+    readonly type: "message-start";
+} | {
+    readonly type: "content-start" | "content-delta";
+    readonly index: number;
+    readonly delta: {
+        readonly message: {
+            readonly content: {
+                readonly text?: string | undefined;
+                readonly thinking?: string | undefined;
+            };
+        };
+    };
+} | {
+    readonly type: "content-end";
+    readonly index: number;
+} | {
+    readonly type: "tool-plan-delta";
+    readonly delta: {
+        readonly message: {
+            readonly tool_plan: string;
+        };
+    };
+} | {
+    readonly type: "tool-call-start" | "tool-call-delta";
+    readonly index: number;
+    readonly delta: {
+        readonly message: {
+            readonly tool_calls: {
+                readonly function: {
+                    readonly name?: string | undefined;
+                    readonly arguments?: string | undefined;
+                };
+                readonly id?: string | undefined;
+            };
+        };
+    };
+} | {
+    readonly type: "tool-call-end";
+    readonly index: number;
+} | {
+    readonly type: "message-end";
+    readonly delta: {
+        readonly finish_reason: string;
+        readonly usage?: {
+            readonly tokens?: {
+                readonly input_tokens?: number | undefined;
+                readonly output_tokens?: number | undefined;
+                readonly reasoning_tokens?: number | undefined;
+            } | undefined;
+            readonly billed_units?: {
+                readonly input_tokens?: number | undefined;
+                readonly output_tokens?: number | undefined;
+                readonly reasoning_tokens?: number | undefined;
+            } | undefined;
+            readonly cached_tokens?: number | undefined;
+        } | undefined;
+    };
+} | {
+    readonly type: "citation-start" | "citation-end";
+}, {
+    readonly tools: Partial<Record<number, ToolStream.PendingTool>>;
+    readonly lifecycle: Lifecycle.State;
+    readonly finished: boolean;
+}>;
+export declare const route: Route<{
+    readonly model: string;
+    readonly messages: readonly {
+        readonly role: "tool" | "system" | "user" | "assistant";
+        readonly content?: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "thinking";
+            readonly thinking: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[] | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly tool_call_id?: string | undefined;
+        readonly tool_plan?: string | undefined;
+    }[];
+    readonly stream: true;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly parameters: unknown;
+            readonly description?: string | undefined;
+        };
+    }[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly thinking?: {
+        readonly type: string;
+        readonly token_budget?: number | undefined;
+    } | undefined;
+    readonly tool_choice?: "NONE" | "REQUIRED" | undefined;
+    readonly stop_sequences?: readonly string[] | undefined;
+    readonly p?: number | undefined;
+    readonly k?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
+export * as CohereChat from "./cohere-chat.js";