@opencode/ai 2.0.22 → 2.0.24

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,299 @@
+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: request.system.length === 1
+                    ? request.system[0].text
+                    : request.system.map((part) => ({ type: "text", text: part.text })),
+            },
+        ]
+        : [];
+    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.fnUntraced(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/elevenlabs-speech.js

@@ -32,7 +32,7 @@ const OUTPUT_FORMATS = {
     opus: "opus_48000_64",
 };
 /** WAV is served only by the non-streaming endpoints. */
-const outputFormat = Effect.fn("ElevenLabsSpeech.outputFormat")(function* (request) {
+const outputFormat = Effect.fnUntraced(function* (request) {
     const format = request.providerOptions?.outputFormat ?? OUTPUT_FORMATS[request.format ?? "mp3"];
     if (format === undefined)
         return yield* route.unsupported("media.format", `${route.name} has no default output format for "${request.format}"; pass providerOptions.outputFormat`);
@@ -55,7 +55,7 @@ const path = (request) => `${PATH}/${encodeURIComponent(SpeechStream.voiceID(req
 // ---------------------------------------------------------------------------
 // 6. Stream parsing
 // ---------------------------------------------------------------------------
-const onRecord = Effect.fn("ElevenLabsSpeech.onRecord")(function* (state, frame) {
+const onRecord = Effect.fnUntraced(function* (state, frame) {
     const record = yield* decodeRecord(frame);
     const [next, events] = SpeechStream.delta(state, record.audio_base64);
     const alignment = record.alignment;
@@ -80,7 +80,7 @@ const describeOutput = (format) => {
     const encoding = PCM_CODECS[codec];
     return encoding === undefined ? SpeechStream.container(codec, sampleRate) : SpeechStream.pcm(encoding, sampleRate);
 };
-const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (state, context) {
+const finish = Effect.fnUntraced(function* (state, context) {
     const requestID = context.http.headers["request-id"];
     return yield* SpeechStream.finish(route, state, {
         ...describeOutput(yield* outputFormat(context.request)),

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/gemini.js

@@ -201,7 +201,7 @@ const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini",
     required: () => ({ functionCallingConfig: { mode: "ANY" } }),
     tool: (name) => ({ functionCallingConfig: { mode: "ANY", allowedFunctionNames: [name] } }),
 });
-const lowerContentPart = Effect.fn("Gemini.lowerContentPart")(function* (part) {
+const lowerContentPart = Effect.fnUntraced(function* (part) {
     if (part.type === "text")
         return { text: part.text };
     return yield* GeminiGenerateContent.mediaPart("Gemini", part.media);
@@ -217,7 +217,7 @@ const lowerToolCall = (part, omitIds, metadataKey) => ({
     functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
     thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
 });
-const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
+const lowerMessages = Effect.fnUntraced(function* (request) {
     const contents = [];
     const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     const omitCallIds = omitsFunctionCallIds(request.model.id);
@@ -382,7 +382,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
         contents: yield* lowerMessages(flattened.request),
         safetySettings: options.safetySettings,
         serviceTier: options.serviceTier,
-        systemInstruction: request.system.length === 0 ? undefined : { parts: [{ text: ProviderShared.joinText(request.system) }] },
+        systemInstruction: request.system.length === 0 ? undefined : { parts: request.system.map((part) => ({ text: part.text })) },
         tools: hasTools
             ? [
                 {