@opencode/ai 0.0.0-dev-20453 → 0.0.0-dev-20456

package/README.md

@@ -1223,7 +1223,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/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";

package/dist/protocols/cohere-chat.js

@@ -0,0 +1,292 @@
+import { Effect, Schema } from "effect";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Framing } from "../route/framing.js";
+import { Protocol } from "../route/protocol.js";
+import { LLMEvent, Usage } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { Lifecycle } from "./utils/lifecycle.js";
+import { ToolStream } from "./utils/tool-stream.js";
+const ADAPTER = "cohere-chat";
+export const DEFAULT_BASE_URL = "https://api.cohere.com/v2";
+const Options = Schema.Struct({
+    thinking: Schema.optional(Schema.Struct({
+        type: Schema.optional(Schema.Literals(["enabled", "disabled"])),
+        tokenBudget: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
+    })),
+});
+const Content = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("thinking"), thinking: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("image_url"), image_url: Schema.Struct({ url: Schema.String }) }),
+]);
+const ToolCall = Schema.Struct({
+    id: Schema.String,
+    type: Schema.Literal("function"),
+    function: Schema.Struct({ name: Schema.String, arguments: Schema.String }),
+});
+const Message = Schema.Struct({
+    role: Schema.Literals(["system", "user", "assistant", "tool"]),
+    content: Schema.optional(Schema.Union([Schema.String, Schema.Array(Content)])),
+    tool_calls: Schema.optional(Schema.Array(ToolCall)),
+    tool_call_id: Schema.optional(Schema.String),
+    tool_plan: Schema.optional(Schema.String),
+});
+const Body = Schema.Struct({
+    model: Schema.String,
+    messages: Schema.Array(Message),
+    stream: Schema.Literal(true),
+    tools: Schema.optional(Schema.Array(Schema.Struct({
+        type: Schema.Literal("function"),
+        function: Schema.Struct({
+            name: Schema.String,
+            description: Schema.optional(Schema.String),
+            parameters: Schema.Unknown,
+        }),
+    }))),
+    tool_choice: Schema.optional(Schema.Literals(["NONE", "REQUIRED"])),
+    thinking: Schema.optional(Schema.Struct({ type: Schema.String, token_budget: Schema.optional(Schema.Number) })),
+    max_tokens: Schema.optional(Schema.Number),
+    temperature: Schema.optional(Schema.Number),
+    p: Schema.optional(Schema.Number),
+    k: Schema.optional(Schema.Number),
+    seed: Schema.optional(Schema.Number),
+    stop_sequences: Schema.optional(Schema.Array(Schema.String)),
+    frequency_penalty: Schema.optional(Schema.Number),
+    presence_penalty: Schema.optional(Schema.Number),
+});
+const TokenCounts = Schema.Struct({
+    input_tokens: Schema.optional(Schema.Number),
+    output_tokens: Schema.optional(Schema.Number),
+    reasoning_tokens: Schema.optional(Schema.Number),
+});
+const NativeUsage = Schema.Struct({
+    tokens: Schema.optional(TokenCounts),
+    billed_units: Schema.optional(TokenCounts),
+    cached_tokens: Schema.optional(Schema.Number),
+});
+const Event = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("message-start") }),
+    Schema.Struct({
+        type: Schema.Literals(["content-start", "content-delta"]),
+        index: Schema.Number,
+        delta: Schema.Struct({
+            message: Schema.Struct({
+                content: Schema.Struct({ text: Schema.optional(Schema.String), thinking: Schema.optional(Schema.String) }),
+            }),
+        }),
+    }),
+    Schema.Struct({ type: Schema.Literal("content-end"), index: Schema.Number }),
+    Schema.Struct({
+        type: Schema.Literal("tool-plan-delta"),
+        delta: Schema.Struct({ message: Schema.Struct({ tool_plan: Schema.String }) }),
+    }),
+    Schema.Struct({
+        type: Schema.Literals(["tool-call-start", "tool-call-delta"]),
+        index: Schema.Number,
+        delta: Schema.Struct({
+            message: Schema.Struct({
+                tool_calls: Schema.Struct({
+                    id: Schema.optional(Schema.String),
+                    function: Schema.Struct({ name: Schema.optional(Schema.String), arguments: Schema.optional(Schema.String) }),
+                }),
+            }),
+        }),
+    }),
+    Schema.Struct({ type: Schema.Literal("tool-call-end"), index: Schema.Number }),
+    Schema.Struct({
+        type: Schema.Literal("message-end"),
+        delta: Schema.Struct({ finish_reason: Schema.String, usage: Schema.optional(NativeUsage) }),
+    }),
+    // Citation output is outside this basic chat surface.
+    Schema.Struct({ type: Schema.Literals(["citation-start", "citation-end"]) }),
+]);
+const TOOL_CHOICE = { auto: undefined, none: "NONE", required: "REQUIRED", tool: "REQUIRED" };
+const fromRequest = Effect.fn("CohereChat.fromRequest")(function* (request) {
+    const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {});
+    const flattened = ProviderShared.flattenToolRequest(request);
+    const messages = request.system.length
+        ? [{ role: "system", content: ProviderShared.joinText(request.system) }]
+        : [];
+    for (const message of flattened.request.messages) {
+        if (message.role === "system") {
+            messages.push({ role: "user", content: (yield* ProviderShared.wrappedSystemUpdate("Cohere Chat", message)).text });
+            continue;
+        }
+        if (message.role === "tool") {
+            for (const part of message.content) {
+                if (part.type !== "tool-result")
+                    return yield* ProviderShared.unsupportedContent("Cohere Chat", "tool", ["tool-result"]);
+                if (part.result.type === "content" && part.result.value.some((item) => item.type === "file"))
+                    return yield* ProviderShared.invalidRequest("Cohere Chat does not support file content in tool results");
+                messages.push({ role: "tool", tool_call_id: part.id, content: ProviderShared.toolResultText(part) });
+            }
+            continue;
+        }
+        const content = [];
+        const calls = [];
+        const plans = [];
+        for (const part of message.content) {
+            if (part.type === "text") {
+                content.push({ type: "text", text: part.text });
+                continue;
+            }
+            if (message.role === "assistant" && part.type === "reasoning") {
+                if (part.providerMetadata?.cohere?.toolPlan === true)
+                    plans.push(part.text);
+                else
+                    content.push({ type: "thinking", thinking: part.text });
+                continue;
+            }
+            if (message.role === "assistant" && part.type === "tool-call") {
+                const args = ProviderShared.encodeJson(part.input);
+                calls.push({ id: part.id, type: "function", function: { name: part.name, arguments: args } });
+                continue;
+            }
+            if (message.role === "user" && part.type === "media" && part.media.mediaType.startsWith("image/")) {
+                const url = ProviderShared.mediaUrl(part.media) ??
+                    (yield* ProviderShared.requireInlineMedia("Cohere Chat", part.media)).dataUrl;
+                content.push({ type: "image_url", image_url: { url } });
+                continue;
+            }
+            return yield* ProviderShared.unsupportedContent("Cohere Chat", message.role, message.role === "user" ? ["text", "media"] : ["text", "reasoning", "tool-call"]);
+        }
+        messages.push({
+            role: message.role,
+            content: content.length ? content : undefined,
+            tool_calls: calls.length ? calls : undefined,
+            tool_plan: plans.length ? plans.join("") : undefined,
+        });
+    }
+    const selected = request.toolChoice?.type === "tool" ? request.toolChoice.name : undefined;
+    const tools = selected === undefined ? flattened.tools : flattened.tools.filter((tool) => tool.name === selected);
+    if (selected !== undefined && tools.length === 0)
+        return yield* ProviderShared.invalidRequest("Cohere Chat tool choice must name an available tool");
+    if (tools.some((tool) => tool.native !== undefined))
+        return yield* ProviderShared.invalidRequest("Cohere Chat does not support provider-defined tools");
+    return {
+        model: request.model.id,
+        messages,
+        stream: true,
+        tools: tools.length
+            ? tools.map((tool) => ({
+                type: "function",
+                function: { name: tool.name, description: tool.description, parameters: tool.inputSchema },
+            }))
+            : undefined,
+        tool_choice: TOOL_CHOICE[request.toolChoice?.type ?? "auto"],
+        thinking: options.thinking && {
+            type: options.thinking.type ?? "enabled",
+            // Cohere rejects budgets above max_tokens; fitting also leaves room for the answer.
+            token_budget: options.thinking.tokenBudget === undefined
+                ? undefined
+                : ProviderShared.fitThinkingBudget(options.thinking.tokenBudget, request.generation?.maxTokens),
+        },
+        max_tokens: request.generation?.maxTokens,
+        temperature: request.generation?.temperature,
+        p: request.generation?.topP,
+        k: request.generation?.topK,
+        seed: request.generation?.seed,
+        stop_sequences: request.generation?.stop,
+        frequency_penalty: request.generation?.frequencyPenalty,
+        presence_penalty: request.generation?.presencePenalty,
+    };
+});
+const finishReason = (raw) => {
+    switch (raw) {
+        case "COMPLETE":
+        case "STOP_SEQUENCE":
+            return { normalized: "stop", raw };
+        case "MAX_TOKENS":
+            return { normalized: "length", raw };
+        case "TOOL_CALL":
+            return { normalized: "tool-calls", raw };
+        case "ERROR":
+        case "TIMEOUT":
+            return { normalized: "error", raw };
+        default:
+            return { normalized: "unknown", raw };
+    }
+};
+const mapUsage = (usage) => new Usage({
+    inputTokens: usage.tokens?.input_tokens,
+    outputTokens: usage.tokens?.output_tokens,
+    nonCachedInputTokens: ProviderShared.subtractTokens(usage.tokens?.input_tokens, usage.cached_tokens),
+    cacheReadInputTokens: usage.cached_tokens,
+    reasoningTokens: usage.tokens?.reasoning_tokens,
+    totalTokens: ProviderShared.totalTokens(usage.tokens?.input_tokens, usage.tokens?.output_tokens, undefined),
+    providerMetadata: { cohere: usage },
+});
+// Lifecycle deltas open blocks on demand and ends are no-ops for closed blocks, so content-start needs no handling.
+const step = Effect.fn("CohereChat.step")(function* (state, event) {
+    const events = [];
+    switch (event.type) {
+        case "message-start":
+            return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, events];
+        case "content-delta": {
+            const id = String(event.index);
+            const content = event.delta.message.content;
+            const lifecycle = content.thinking !== undefined
+                ? Lifecycle.reasoningDelta(state.lifecycle, events, id, content.thinking)
+                : Lifecycle.textDelta(state.lifecycle, events, id, content.text ?? "");
+            return [{ ...state, lifecycle }, events];
+        }
+        case "content-end": {
+            const id = String(event.index);
+            const lifecycle = Lifecycle.textEnd(Lifecycle.reasoningEnd(state.lifecycle, events, id), events, id);
+            return [{ ...state, lifecycle }, events];
+        }
+        case "tool-plan-delta": {
+            const plan = event.delta.message.tool_plan;
+            const lifecycle = Lifecycle.reasoningDelta(state.lifecycle, events, "tool-plan", plan, {
+                cohere: { toolPlan: true },
+            });
+            return [{ ...state, lifecycle }, events];
+        }
+        case "tool-call-start":
+        case "tool-call-delta": {
+            const call = event.delta.message.tool_calls;
+            const result = ToolStream.appendOrStart(ADAPTER, state.tools, event.index, { id: call.id, name: call.function.name, text: call.function.arguments ?? "" }, "Cohere tool call is missing id or name");
+            if (ToolStream.isError(result))
+                return yield* result;
+            return [{ ...state, tools: result.tools }, result.events];
+        }
+        case "tool-call-end": {
+            const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index);
+            return [{ ...state, tools: result.tools }, result.events ?? []];
+        }
+        case "message-end": {
+            const pending = yield* ToolStream.finishAll(ADAPTER, state.tools);
+            events.push(...pending.events);
+            const lifecycle = Lifecycle.finish(state.lifecycle, events, {
+                reason: finishReason(event.delta.finish_reason),
+                usage: event.delta.usage && mapUsage(event.delta.usage),
+            });
+            return [{ tools: pending.tools, lifecycle, finished: true }, events];
+        }
+        default:
+            return [state, events];
+    }
+});
+export const protocol = Protocol.make({
+    id: ADAPTER,
+    body: { schema: Body, from: fromRequest },
+    stream: {
+        event: Protocol.jsonEvent(Event),
+        initial: () => ({ lifecycle: Lifecycle.initial(), tools: ToolStream.empty(), finished: false }),
+        step,
+        terminal: (event) => event.type === "message-end",
+        onHalt: (state) => state.finished
+            ? Effect.succeed([])
+            : Effect.fail(ProviderShared.eventError(ADAPTER, "Cohere stream ended without message-end")),
+    },
+});
+export const route = Route.make({
+    id: ADAPTER,
+    provider: "cohere",
+    providerMetadataKey: "cohere",
+    protocol,
+    endpoint: Endpoint.path("/chat", { baseURL: DEFAULT_BASE_URL }),
+    framing: Framing.sse,
+});
+export * as CohereChat from "./cohere-chat.js";

package/dist/protocols/gemini.d.ts

@@ -158,7 +158,7 @@ export declare const protocol: Protocol<{
     readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
-            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly mode: "NONE" | "AUTO" | "ANY";
             readonly allowedFunctionNames?: readonly string[] | undefined;
         };
     } | undefined;
@@ -272,7 +272,7 @@ export declare const route: Route<{
     readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
-            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly mode: "NONE" | "AUTO" | "ANY";
             readonly allowedFunctionNames?: readonly string[] | undefined;
         };
     } | undefined;

package/dist/protocols/index.d.ts

@@ -1,5 +1,6 @@
 export * as AnthropicMessages from "./anthropic-messages.js";
 export * as BedrockConverse from "./bedrock-converse.js";
+export * as CohereChat from "./cohere-chat.js";
 export * as Gemini from "./gemini.js";
 export * as MistralChat from "./mistral-chat.js";
 export * as OpenAIChat from "./openai-chat.js";

package/dist/protocols/index.js

@@ -1,5 +1,6 @@
 export * as AnthropicMessages from "./anthropic-messages.js";
 export * as BedrockConverse from "./bedrock-converse.js";
+export * as CohereChat from "./cohere-chat.js";
 export * as Gemini from "./gemini.js";
 export * as MistralChat from "./mistral-chat.js";
 export * as OpenAIChat from "./openai-chat.js";

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

@@ -310,9 +310,9 @@ export declare const protocol: Protocol<{
         };
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly random_seed?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly random_seed?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly safe_prompt?: boolean | undefined;
     readonly document_image_limit?: number | undefined;
@@ -444,9 +444,9 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         };
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly random_seed?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly random_seed?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly safe_prompt?: boolean | undefined;
     readonly document_image_limit?: number | undefined;
@@ -532,9 +532,9 @@ export declare const route: Route<{
         };
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly random_seed?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly random_seed?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly safe_prompt?: boolean | undefined;
     readonly document_image_limit?: number | undefined;

package/dist/provider-error.js

@@ -40,7 +40,13 @@ const patterns = [
     /request_too_large/i,
 ];
 const payloadPatterns = [/request entity too large/i, /payload too large/i, /request too large/i];
-const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i];
+const exclusions = [
+    /^(throttling error|service unavailable):/i,
+    /rate limit/i,
+    /too many requests/i,
+    // Cohere reports an output limit above the model maximum as "too many tokens"; compaction cannot fix it.
+    /max[_ ]tokens must be less than/i,
+];
 export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
     (patterns.some((pattern) => pattern.test(message)) || /^4(?:00|13)\s*(status code)?\s*\(no body\)/i.test(message));
 export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) => pattern.test(message));

package/dist/providers/cohere/chat.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderPackage } from "../../provider-package.js";
+import { Cohere } from "../cohere.js";
+export type Settings = Cohere.Settings<Cohere.ChatOptionsInput>;
+export declare const model: ProviderPackage.Definition<Settings, Cohere.ChatOptionsInput>["model"];

package/dist/providers/cohere/chat.js

@@ -0,0 +1,8 @@
+import { Cohere } from "../cohere.js";
+export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => Cohere.configure({
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+}).chat(modelID);

package/dist/providers/cohere.d.ts

@@ -0,0 +1,395 @@
+import { CohereChat } from "../protocols/cohere-chat.js";
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { type ModelID, type OpenString } from "../schema/index.js";
+import type { ProviderPackage } from "../provider-package.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type ChatOptionsInput = {
+    readonly reasoningEffort?: OpenString<"none" | "high">;
+};
+export type ProviderOptions = CohereChat.ProviderOptionsInput & ChatOptionsInput;
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly providerOptions?: ProviderOptions;
+};
+export type Settings<Options = CohereChat.ProviderOptionsInput> = ProviderPackage.Settings & Options & {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+};
+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 declare const chatRoute: Route<{
+    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 [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 extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        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 stream: true;
+    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 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 frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
+export declare const routes: (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> | Route<{
+    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 [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 extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        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 stream: true;
+    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 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 frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>)[];
+export declare const configure: (input?: LanguageModelOptions) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
+        readonly thinking?: {
+            readonly type?: "enabled" | "disabled" | undefined;
+            readonly tokenBudget?: number | undefined;
+        } | undefined;
+    }, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ChatOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: LanguageModelOptions) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
+        readonly thinking?: {
+            readonly type?: "enabled" | "disabled" | undefined;
+            readonly tokenBudget?: number | undefined;
+        } | undefined;
+    }, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ChatOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: LanguageModelOptions) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
+            readonly thinking?: {
+                readonly type?: "enabled" | "disabled" | undefined;
+                readonly tokenBudget?: number | undefined;
+            } | undefined;
+        }, import("../route/client.js").CompactionOperations | undefined>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ChatOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, CohereChat.ProviderOptionsInput>["model"];
+export * as Cohere from "./cohere.js";

package/dist/providers/cohere.js

@@ -0,0 +1,48 @@
+import { CohereChat } from "../protocols/cohere-chat.js";
+import { OpenAIChat } from "../protocols/openai-chat.js";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { ProviderID } from "../schema/index.js";
+export const id = ProviderID.make("cohere");
+const COMPATIBILITY_BASE_URL = "https://api.cohere.ai/compatibility/v1";
+export const route = CohereChat.route;
+export const chatRoute = Route.make({
+    id: "cohere-chat-completions",
+    provider: id,
+    providerMetadataKey: "cohere",
+    protocol: OpenAIChat.protocol,
+    endpoint: Endpoint.path("/chat/completions", { baseURL: COMPATIBILITY_BASE_URL }),
+    framing: OpenAIChat.framing,
+});
+export const routes = [route, chatRoute];
+export const configure = (input = {}) => {
+    const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input;
+    const auth = AuthOptions.bearer(input, "COHERE_API_KEY");
+    const native = route.with({ ...defaults, auth, endpoint: { baseURL: baseURL ?? CohereChat.DEFAULT_BASE_URL } });
+    const chat = chatRoute.with({ ...defaults, auth, endpoint: { baseURL: baseURL ?? COMPATIBILITY_BASE_URL } });
+    return {
+        id,
+        model: (modelID) => native.model({ id: modelID }),
+        chat: (modelID) => chat.model({
+            id: modelID,
+            compatibility: {
+                maxTokensField: "max_tokens",
+                supportsStore: false,
+                supportsUsageInStreaming: true,
+                reasoningField: "reasoning_content",
+                supportsStrictMode: false,
+            },
+        }),
+        configure,
+    };
+};
+export const provider = configure();
+export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+}).model(modelID);
+export * as Cohere from "./cohere.js";

package/dist/providers/google-vertex.d.ts

@@ -77,7 +77,7 @@ export declare const routes: Route<{
     readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
-            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly mode: "NONE" | "AUTO" | "ANY";
             readonly allowedFunctionNames?: readonly string[] | undefined;
         };
     } | undefined;

package/dist/providers/google.d.ts

@@ -62,7 +62,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
-            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly mode: "NONE" | "AUTO" | "ANY";
             readonly allowedFunctionNames?: readonly string[] | undefined;
         };
     } | undefined;

package/dist/providers/index.d.ts

@@ -9,6 +9,7 @@ export * as Baseten from "./baseten.js";
 export * as BlackForestLabs from "./black-forest-labs.js";
 export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
+export * as Cohere from "./cohere.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";

package/dist/providers/index.js

@@ -9,6 +9,7 @@ export * as Baseten from "./baseten.js";
 export * as BlackForestLabs from "./black-forest-labs.js";
 export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
+export * as Cohere from "./cohere.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";

package/dist/providers/mistral.d.ts

@@ -90,9 +90,9 @@ export declare const route: import("../route/client.js").Route<{
         };
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly random_seed?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly random_seed?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly safe_prompt?: boolean | undefined;
     readonly document_image_limit?: number | undefined;
@@ -178,9 +178,9 @@ export declare const routes: import("../route/client.js").Route<{
         };
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly random_seed?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly random_seed?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly safe_prompt?: boolean | undefined;
     readonly document_image_limit?: number | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20453",
+  "version": "0.0.0-dev-20456",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20453",
+    "@opencode/http-recorder": "0.0.0-dev-20456",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20453",
+    "@opencode/schema": "0.0.0-dev-20456",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"