@opencode/ai 0.0.0-beta-19296 → 0.0.0-beta-19378

package/dist/protocols/alibaba-responses.js

@@ -0,0 +1,80 @@
+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 { OpenResponsesOptions } from "./utils/open-responses-options.js";
+import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
+const Options = Schema.Struct({
+    reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
+    enableThinking: Schema.optional(Schema.Boolean),
+    store: OpenResponsesOptions.Options.fields.store,
+    previousResponseId: Schema.optional(Schema.String),
+    conversation: Schema.optional(Schema.String),
+});
+const NativeTool = Schema.Struct({ type: Schema.Literals(["web_search", "web_extractor", "code_interpreter"]) });
+const WebExtractorItem = Schema.StructWithRest(Schema.Struct({
+    type: Schema.Literal("web_extractor_call"),
+    id: Schema.String,
+    urls: Schema.optional(Schema.Array(Schema.String)),
+    goal: Schema.optional(Schema.String),
+}), [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,
+    stream: Schema.Literal(true),
+});
+const adapter = {
+    id: "alibaba-responses",
+    name: "Alibaba Responses",
+    nativeTool: (native) => ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(native.alibaba),
+    restoreHostedToolItem: (item) => (Schema.is(WebExtractorItem)(item) ? item : undefined),
+};
+const tools = {
+    web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+    code_interpreter_call: { name: "code_interpreter", input: (item) => ({ code: item.code }) },
+};
+export const protocol = Protocol.make({
+    id: adapter.id,
+    body: {
+        schema: Body,
+        from: Effect.fn("AlibabaResponses.fromRequest")(function* (req) {
+            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))({
+                ...body,
+                enable_thinking: opts.enableThinking,
+                previous_response_id: opts.previousResponseId,
+                conversation: opts.conversation,
+                // Model Studio expresses named selection through allowed_tools.
+                tool_choice: typeof choice === "object" && choice.type === "function"
+                    ? { type: "allowed_tools", mode: "required", tools: [choice] }
+                    : choice,
+            });
+        }),
+    },
+    stream: {
+        event: OpenResponses.protocol.stream.event,
+        initial: (req) => OpenResponses.initial(req, adapter),
+        step: (state, input) => Effect.gen(function* () {
+            const event = OpenResponses.normalize(state, input);
+            if (event.type !== "response.output_item.done" || !event.item)
+                return yield* OpenResponses.step(state, event);
+            if (event.item.type === "web_extractor_call") {
+                const item = yield* Schema.decodeUnknownEffect(WebExtractorItem)(event.item).pipe(Effect.mapError((cause) => ProviderShared.eventError(adapter.id, "Alibaba returned an invalid web extraction item", ProviderShared.encodeJson(event), cause)));
+                return yield* ResponsesHostedTools.onDone(state, item, {
+                    web_extractor_call: { name: "web_extractor", input: () => ({ urls: item.urls, goal: item.goal }) },
+                });
+            }
+            if (ResponsesHostedTools.isItem(event.item, tools))
+                return yield* ResponsesHostedTools.onDone(state, event.item, tools);
+            return yield* OpenResponses.step(state, event);
+        }),
+        terminal: OpenResponses.terminal,
+    },
+});
+export * as AlibabaResponses from "./alibaba-responses.js";

package/dist/protocols/anthropic-messages.d.ts

@@ -10,14 +10,19 @@ export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export declare const PATH = "/messages";
 export declare const DEFAULT_MAX_TOKENS = 32000;
 export declare const framing: Framing.Definition<string>;
+export type ThinkingBlockBinding = {
+    readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {});
+};
 export type ThinkingInput = {
     readonly type: "adaptive";
     readonly display?: "summarized" | "omitted";
+    readonly block_binding?: ThinkingBlockBinding;
 } | {
     readonly type: "disabled";
 } | ({
     readonly type: "enabled";
     readonly display?: "summarized" | "omitted";
+    readonly block_binding?: ThinkingBlockBinding;
 } & ({
     readonly budgetTokens: number;
     readonly budget_tokens?: number;
@@ -309,9 +314,15 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"adaptive">;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"disabled">;
     }>]>>;
@@ -556,9 +567,15 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
@@ -684,7 +701,7 @@ export declare const protocol: Protocol<{
     reasoningSignatures: {};
     lifecycle: Lifecycle.State;
 }>;
-export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
+export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">>() => {
     prepare: (input: Parameters<(input: import("../route/transport/index.js").TransportPrepareInput<Body>) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>>[0]) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>;
     with: (patch: Partial<HttpTransport.HttpJsonInput<Body, string>>) => HttpTransport.HttpJsonTransport<Body, string>;
     id: string;
@@ -904,9 +921,15 @@ export declare const route: Route<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

package/dist/protocols/anthropic-messages.js

@@ -202,15 +202,20 @@ const AnthropicToolChoice = Schema.Union([
         disable_parallel_tool_use: Schema.optional(Schema.Boolean),
     }),
 ]);
+const AnthropicThinkingBlockBinding = Schema.Struct({
+    prefix_mismatch_behavior: Schema.optional(Schema.String),
+});
 const AnthropicThinking = Schema.Union([
     Schema.Struct({
         type: Schema.tag("enabled"),
         budget_tokens: Schema.Number,
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("adaptive"),
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("disabled"),
@@ -843,8 +848,9 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
             ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
             ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
         };
+    const thinking = yield* resolveThinking(input?.thinking);
     return {
-        thinking: yield* resolveThinking(input?.thinking),
+        thinking: applyThinkingBindingDefault(request.model, thinking),
         effort: outputConfigEffort,
         output_config,
         service_tier,
@@ -854,18 +860,44 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
         cache_control,
     };
 });
+const supportsThinkingBlockBinding = (model) => {
+    const override = model.compatibility?.supportsThinkingBlockBinding;
+    if (override !== undefined)
+        return override;
+    // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+    const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups;
+    if (!version)
+        return false;
+    const major = Number(version.major);
+    const minor = Number(version.minor ?? 0);
+    return major > 5 || (major === 5 && minor >= 1);
+};
+const applyThinkingBindingDefault = (model, thinking) => {
+    if (thinking?.type === "disabled")
+        return thinking;
+    if (!supportsThinkingBlockBinding(model))
+        return thinking;
+    return {
+        ...(thinking ?? { type: "adaptive" }),
+        block_binding: {
+            prefix_mismatch_behavior: "drop_block",
+            ...thinking?.block_binding,
+        },
+    };
+};
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
     if (!ProviderShared.isRecord(input))
         return undefined;
+    if (input.type === "disabled")
+        return { type: "disabled" };
+    if (input.type !== "adaptive" && input.type !== "enabled")
+        return undefined;
+    const block_binding = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)))(input.block_binding);
     const display = input.display === "summarized" || input.display === "omitted"
         ? input.display
         : undefined;
     if (input.type === "adaptive")
-        return { type: "adaptive", ...(display === undefined ? {} : { display }) };
-    if (input.type === "disabled")
-        return { type: "disabled" };
-    if (input.type !== "enabled")
-        return undefined;
+        return { type: "adaptive", display, block_binding };
     const budget = typeof input.budgetTokens === "number"
         ? input.budgetTokens
         : typeof input.budget_tokens === "number"
@@ -873,7 +905,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
             : undefined;
     if (budget === undefined)
         return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget, ...(display === undefined ? {} : { display }) };
+    return { type: "enabled", budget_tokens: budget, display, block_binding };
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
@@ -1378,15 +1410,15 @@ export const transport = () => {
     return {
         ...http,
         prepare: (input) => {
-            if (!input.body.context_management?.edits.length &&
-                !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction")))
+            const requiredBetas = requiredBetaHeaders(input.body);
+            if (requiredBetas.length === 0)
                 return http.prepare(input);
             const headers = Headers.fromInput(input.request.http?.headers);
-            const betas = new Set((headers["anthropic-beta"] ?? "")
+            const existingBetas = (headers["anthropic-beta"] ?? "")
                 .split(",")
                 .map((item) => item.trim())
-                .filter(Boolean));
-            betas.add("compact-2026-01-12");
+                .filter(Boolean);
+            const betas = new Set([...existingBetas, ...requiredBetas]);
             return http.prepare({
                 ...input,
                 request: LLMRequest.update(input.request, {
@@ -1399,6 +1431,17 @@ export const transport = () => {
         },
     };
 };
+function requiredBetaHeaders(body) {
+    const betas = [];
+    const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0;
+    const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
+    if (requestsCompaction || replaysCompaction)
+        betas.push("compact-2026-01-12");
+    const thinking = body.thinking;
+    if (thinking && thinking.type !== "disabled" && thinking.block_binding)
+        betas.push("thinking-binding-controls-2026-08-01");
+    return betas;
+}
 export const route = Route.make({
     id: ADAPTER,
     provider: "anthropic",

package/dist/protocols/meta-messages.d.ts

@@ -219,9 +219,15 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
+        readonly block_binding?: {
+            readonly prefix_mismatch_behavior?: string | undefined;
+        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

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

@@ -656,6 +656,9 @@ export type NormalizedEvent = Event & {
 export interface ProviderAdapter {
     readonly id: string;
     readonly name: string;
+    readonly nativeTool?: (native: NonNullable<ToolDefinition["native"]>) => Effect.Effect<{
+        readonly type: string;
+    }, AIError>;
     readonly lowerMedia?: (input: {
         readonly part: MediaPart;
         readonly media: ProviderShared.NormalizedMedia;
@@ -750,13 +753,7 @@ export declare const fromRequestWithAdapter: (request: LLMRequest<import("../sch
     readonly [x: string]: unknown;
 }, import("../route.js").CompactionOperations | undefined>>, adapter: ProviderAdapter) => Effect.Effect<{
     tools: {
-        type: "function";
-        name: string;
-        description: string;
-        parameters: {
-            readonly [x: string]: unknown;
-        };
-        strict: boolean;
+        readonly type: string;
     }[] | undefined;
     tool_choice: "required" | "auto" | "none" | {
         type: "allowed_tools";

package/dist/protocols/open-responses.js

@@ -597,7 +597,9 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
         ...lowerGeneration(request),
         tools: projected.tools.length === 0
             ? undefined
-            : yield* Effect.forEach(projected.tools, (tool) => lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
+            : yield* Effect.forEach(projected.tools, (tool) => tool.native !== undefined && adapter.nativeTool
+                ? adapter.nativeTool(tool.native)
+                : lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

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

@@ -0,0 +1 @@
+export { model, type Settings } from "../alibaba.js";

package/dist/providers/alibaba/chat.js

@@ -0,0 +1 @@
+export { model } from "../alibaba.js";

package/dist/providers/alibaba/messages.d.ts

@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js";
+export { messagesModel as model } from "../alibaba.js";
+export type Settings = Alibaba.Settings<Alibaba.MessagesOptionsInput>;

package/dist/providers/alibaba/messages.js

@@ -0,0 +1 @@
+export { messagesModel as model } from "../alibaba.js";

package/dist/providers/alibaba/responses.d.ts

@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js";
+export { responsesModel as model } from "../alibaba.js";
+export type Settings = Alibaba.Settings<Alibaba.ResponsesOptionsInput>;

package/dist/providers/alibaba/responses.js

@@ -0,0 +1 @@
+export { responsesModel as model } from "../alibaba.js";