@opencode/ai 2.0.26 → 2.0.28

package/dist/providers/moonshot/messages.js

@@ -3,6 +3,6 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).messages(modelID);

package/dist/providers/moonshot/responses.js

@@ -3,6 +3,6 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).responses(modelID);

package/dist/providers/moonshot.js

@@ -85,7 +85,7 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);
 export * as Moonshot from "./moonshot.js";

package/dist/providers/openai-compatible-responses.js

@@ -25,8 +25,8 @@ export const provider = {
 export const model = (modelID, { apiKey, baseURL, body, headers, provider, ...providerOptions }) => configure({
     apiKey,
     baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
+    headers,
+    http: body === undefined ? undefined : { body },
     provider,
     providerOptions,
 }).model(modelID);

package/dist/providers/openai-compatible.js

@@ -25,8 +25,8 @@ export const provider = {
 export const model = (modelID, { apiKey, baseURL, body, headers, provider, ...providerOptions }) => configure({
     apiKey,
     baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
+    headers,
+    http: body === undefined ? undefined : { body },
     provider,
     providerOptions,
 }).model(modelID);

package/dist/providers/openai.d.ts

@@ -275,7 +275,7 @@ export declare const routes: (Route<{
     } | {
         readonly type: "image_generation";
         readonly size?: string | undefined;
-        readonly action?: "generate" | "auto" | "edit" | undefined;
+        readonly action?: "auto" | "generate" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;

package/dist/providers/openai.js

@@ -77,9 +77,9 @@ const config = ({ apiKey, baseURL, body, headers: given, organization, project,
         apiKey,
         baseURL,
         headers: Object.keys(headers).length === 0 ? undefined : headers,
-        http: body === undefined ? undefined : { body: { ...body } },
+        http: body === undefined ? undefined : { body },
         providerOptions,
-        queryParams: queryParams === undefined ? undefined : { ...queryParams },
+        queryParams,
     };
 };
 export const model = (modelID, settings) => {

package/dist/providers/{opencode-zen.d.ts → opencode.d.ts}

@@ -29,4 +29,4 @@ export declare const provider: {
 export declare const experimental: {
     evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
 };
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";

package/dist/providers/{opencode-zen.js → opencode.js}

@@ -2,7 +2,7 @@ import { HttpOptions, ProviderID } from "../schema/index.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { SystemOne } from "../experimental/system-one.js";
 export const id = ProviderID.make("opencode");
-const baseURL = "https://opencode.ai/zen/v1";
+const baseURL = "https://opencode.ai/inference/v1";
 export const configure = (input = {}) => {
     const evaluation = (modelID) => SystemOne.model({
         id: modelID,
@@ -17,4 +17,4 @@ export const configure = (input = {}) => {
 };
 export const provider = configure();
 export const experimental = provider.experimental;
-export * as OpenCodeZen from "./opencode-zen.js";
+export * as OpenCode from "./opencode.js";

package/dist/providers/openrouter.js

@@ -114,6 +114,6 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);

package/dist/providers/togetherai.js

@@ -34,7 +34,7 @@ export const provider = configure();
 export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
     apiKey,
     baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
+    headers,
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);

package/dist/providers/venice.js

@@ -32,7 +32,7 @@ export const model = (modelID, { apiKey, baseURL, queryParams, body, headers, ..
     baseURL,
     queryParams,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);
 export * as Venice from "./venice.js";

package/dist/providers/vercel-ai-gateway.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/http";
 import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion, EvaluationResponse, EvaluationRounding, } from "../experimental/evaluation.js";
 import { AnthropicMessages } from "../protocols/anthropic-messages.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
@@ -218,7 +218,7 @@ function fromSettings({ apiKey, baseURL, headers, body, ...providerOptions }) {
         apiKey,
         baseURL,
         headers,
-        http: body === undefined ? undefined : { body: { ...body } },
+        http: body === undefined ? undefined : { body },
         providerOptions,
     });
 }

package/dist/providers/xai.js

@@ -77,7 +77,7 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);
 export const responses = provider.responses;

package/dist/providers/zai-coding-plan/messages.js

@@ -3,6 +3,6 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).messages(modelID);

package/dist/providers/zai-coding-plan/responses.js

@@ -3,6 +3,6 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).responses(modelID);

package/dist/providers/zai-coding-plan.js

@@ -57,7 +57,7 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);
 export * as ZAICodingPlan from "./zai-coding-plan.js";

package/dist/providers/zai.js

@@ -43,7 +43,7 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     apiKey,
     baseURL,
     headers,
-    http: body === undefined ? undefined : { body: { ...body } },
+    http: body === undefined ? undefined : { body },
     providerOptions,
 }).model(modelID);
 export * as ZAI from "./zai.js";

package/dist/route/auth.d.ts

@@ -1,5 +1,5 @@
 import { Config, Effect, Redacted } from "effect";
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 import { AIError, type HttpOptions } from "../schema/index.js";
 export declare class MissingCredentialError extends Error {
     readonly source: string;

package/dist/route/auth.js

@@ -1,5 +1,5 @@
 import { Config, Effect, Option, Redacted } from "effect";
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 import { AuthenticationError, AIError } from "../schema/index.js";
 export class MissingCredentialError extends Error {
     source;
@@ -48,7 +48,7 @@ export const optional = (secret, source = "optional value") => secret === undefi
     ? credential(Effect.fail(new MissingCredentialError(source)))
     : credentialFromSecret(secret, source);
 export const config = (name) => credential(Effect.gen(function* () {
-    const secret = yield* Config.option(Config.redacted(name));
+    const secret = yield* Config.option(Config.Redacted(name));
     if (Option.isSome(secret) && Redacted.value(secret.value) !== "")
         return secret.value;
     return yield* Effect.fail(new MissingCredentialError(name, `${name} is not set`));

package/dist/route/executor-service.d.ts

@@ -1,5 +1,5 @@
 import { Context, type Effect } from "effect";
-import type { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import type { HttpClientRequest, HttpClientResponse } from "effect/http";
 import type { AIError } from "../schema/errors.js";
 export interface Interface {
     readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;

package/dist/route/executor.d.ts

@@ -1,5 +1,5 @@
 import { Layer, Stream } from "effect";
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
 import { HttpContext, AIError } from "../schema/index.js";
 import { Service, type HttpMiddleware, type Interface } from "./executor-service.js";
 export { Service } from "./executor-service.js";

package/dist/route/executor.js

@@ -1,5 +1,5 @@
 import { Cause, Effect, Layer, Option, Schema, Stream } from "effect";
-import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
+import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/http";
 import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
 import { classifyProviderFailure, providerErrorMessage } from "../provider-error.js";
 import { Service } from "./executor-service.js";

package/dist/route/framing.js

@@ -1,5 +1,5 @@
 import { Effect, Stream } from "effect";
-import { makeParser } from "effect/unstable/encoding/Sse";
+import { makeParser } from "effect/encoding/Sse";
 import { AIError, InvalidProviderOutputError } from "../schema/index.js";
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel

package/dist/route/media-protocol.d.ts

@@ -1,5 +1,5 @@
 import { Duration, Effect, Schema, type Stream } from "effect";
-import { HttpClientResponse } from "effect/unstable/http";
+import { HttpClientResponse } from "effect/http";
 import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";

package/dist/route/media-protocol.js

@@ -1,5 +1,5 @@
 import { Clock, Duration, Effect, Schema } from "effect";
-import { HttpClientResponse } from "effect/unstable/http";
+import { HttpClientResponse } from "effect/http";
 import { Media } from "../media.js";
 import { AIError, AuthenticationError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError, UnsupportedOperationError, } from "../schema/index.js";
 export const json = (value, query) => ({

package/dist/route/media.js

@@ -1,5 +1,5 @@
 import { Duration, Effect, Schedule, Schema, Stream } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
 import { RequestExecutorService } from "./executor-service.js";

package/dist/route/transport/http.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/http";
 import { Framing } from "../framing.js";
 import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index.js";
 import { AIError } from "../../schema/index.js";

package/dist/route/transport/http.js

@@ -1,10 +1,10 @@
 import { Clock, Duration, Effect, Stream } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/http";
 import { Auth } from "../auth.js";
 import { render as renderEndpoint } from "../endpoint.js";
 import { Framing } from "../framing.js";
 import * as ProviderShared from "../../protocols/shared.js";
-import { AIError, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
+import { AIError, DEFAULT_CHUNK_TIMEOUT_MS, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
 import { RequestExecutor } from "../executor.js";
 const applyQuery = (url, query) => {
     if (!query)
@@ -46,6 +46,7 @@ export const httpJson = (input) => ({
             url: parts.url,
             body: parts.bodyText,
             headers: parts.headers,
+            encoding: prepareInput.request.http?.encoding,
         });
         return {
             request,
@@ -75,7 +76,7 @@ export const httpJson = (input) => ({
         const remaining = Duration.subtract(total, Duration.millis((yield* Clock.currentTimeMillis) - started));
         return {
             frames: prepared.framing.frame(RequestExecutor.responseStream(response).pipe(Stream.timeoutOrElse({
-                duration: timeoutDuration(request.http?.chunkTimeout),
+                duration: timeoutDuration(request.http?.chunkTimeout, DEFAULT_CHUNK_TIMEOUT_MS),
                 orElse: () => Stream.fail(timeout("read", "Timed out waiting for response data", http)),
             }), Stream.interruptWhen(Effect.sleep(remaining).pipe(Effect.andThen(Effect.fail(timeout("read", "Timed out waiting for the response to complete", http))))))),
             http,
@@ -83,7 +84,7 @@ export const httpJson = (input) => ({
         };
     }),
 });
-const timeoutDuration = (value) => value === false ? Duration.infinity : Duration.millis(value ?? DEFAULT_HTTP_TIMEOUT_MS);
+const timeoutDuration = (value, fallback = DEFAULT_HTTP_TIMEOUT_MS) => value === false ? Duration.infinity : Duration.millis(value ?? fallback);
 export const sseJson = {
     id: "http-json/sse",
     with: () => httpJson({ framing: Framing.sse }),

package/dist/route/transport/websocket-channel.d.ts

@@ -1,5 +1,5 @@
 import type { Effect, Scope, Stream } from "effect";
-import type { Headers } from "effect/unstable/http";
+import type { Headers } from "effect/http";
 import type { AIError, HttpContext } from "../../schema/index.js";
 export interface WebSocketChannelExecutor {
     readonly execute: (exchange: WebSocketChannelExchange) => Effect.Effect<WebSocketChannelExecution, AIError, Scope.Scope>;

package/dist/route/transport/websocket.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Stream } from "effect";
-import { Headers } from "effect/unstable/http";
-import { Socket } from "effect/unstable/socket";
+import { Headers } from "effect/http";
+import { Socket } from "effect/socket";
 import { AIError, type HttpContext } from "../../schema/index.js";
 import type { Transport } from "./index.js";
 import type { WebSocketChannelExecutor } from "./websocket-channel.js";
@@ -19,7 +19,7 @@ export interface WebSocketConnector {
 }
 export declare const toWebSocketUrl: (value: string) => Effect.Effect<string, AIError, never>;
 export declare const open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, Socket.WebSocketConstructor>;
-export declare const fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
+export declare const fromWebSocket: (ws: Socket.WebSocketLike, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
 export declare const messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
 export declare const makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
 export declare const direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
@@ -50,7 +50,7 @@ export declare const WebSocketTransport: {
     readonly direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
     readonly makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
     readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, Socket.WebSocketConstructor>;
-    readonly fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
+    readonly fromWebSocket: (ws: Socket.WebSocketLike, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
     readonly messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
     readonly toWebSocketUrl: (value: string) => Effect.Effect<string, AIError, never>;
 };

package/dist/route/transport/websocket.js

@@ -1,6 +1,6 @@
 import { Cause, Effect, Queue, Stream } from "effect";
-import { Headers } from "effect/unstable/http";
-import { Socket } from "effect/unstable/socket";
+import { Headers } from "effect/http";
+import { Socket } from "effect/socket";
 import { AIError, AIErrorReason, TransportError, } from "../../schema/index.js";
 import * as HttpTransport from "./http.js";
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
@@ -31,7 +31,7 @@ const annotateTransportError = (error, input) => error.reason._tag === "Transpor
 const eventMessage = (event) => {
     if ("message" in event && typeof event.message === "string")
         return event.message;
-    return event.type;
+    return event.type ?? "error";
 };
 const binaryMessage = (data) => {
     if (data instanceof Uint8Array)
@@ -127,12 +127,7 @@ export const toWebSocketUrl = (value) => Effect.try({
 export const open = (input) => Effect.gen(function* () {
     const constructor = yield* Socket.WebSocketConstructor;
     const ws = yield* Effect.try({
-        try: () => 
-        // Platform implementations may extend Effect's browser-compatible constructor with handshake options.
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        constructor(input.url, {
-            headers: input.headers,
-        }),
+        try: () => constructor(input.url, { headers: input.headers }),
         catch: (error) => transportError(error instanceof Error ? error.message : "Failed to construct WebSocket", {
             cause: error,
             url: input.url,

package/dist/schema/messages.js

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { withStatics } from "@opencode/schema/schema";
 import { Tool } from "@opencode/schema/tool";
 import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderMetadata, ProviderOptions, ReasoningEffort, } from "./options.js";
 import { ProviderID } from "./ids.js";
@@ -11,7 +12,7 @@ const systemPartSchema = Schema.Struct({
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }).annotate({ identifier: "LLM.SystemPart" });
 const makeSystemPart = (text) => ({ type: "text", text });
-export const SystemPart = Object.assign(systemPartSchema, {
+export const SystemPart = withStatics(systemPartSchema, {
     make: makeSystemPart,
     content: (input) => {
         if (input === undefined)
@@ -53,7 +54,7 @@ const toolResultValueSchema = Schema.Union([
     }),
 ]).annotate({ identifier: "LLM.ToolResult" });
 const isToolResultValue = Schema.is(toolResultValueSchema);
-export const ToolResultValue = Object.assign(toolResultValueSchema, {
+export const ToolResultValue = withStatics(toolResultValueSchema, {
     is: isToolResultValue,
     make: (value, type = "json") => {
         if (isToolResultValue(value))
@@ -63,7 +64,7 @@ export const ToolResultValue = Object.assign(toolResultValueSchema, {
         return { type, value };
     },
 });
-export const ToolOutput = Object.assign(Schema.Struct({
+export const ToolOutput = withStatics(Schema.Struct({
     structured: Schema.Unknown,
     content: Schema.Array(Tool.Content),
 }).annotate({ identifier: "LLM.ToolOutput" }), {
@@ -98,7 +99,7 @@ const toolResultText = (value) => {
         return String(value);
     }
 };
-export const ToolCallPart = Object.assign(Schema.Struct({
+export const ToolCallPart = withStatics(Schema.Struct({
     type: Schema.Literal("tool-call"),
     id: Schema.String,
     name: Schema.String,
@@ -111,7 +112,7 @@ export const ToolCallPart = Object.assign(Schema.Struct({
 }).annotate({ identifier: "LLM.Content.ToolCall" }), {
     make: (input) => ({ type: "tool-call", ...input }),
 });
-export const ToolResultPart = Object.assign(Schema.Struct({
+export const ToolResultPart = withStatics(Schema.Struct({
     type: Schema.Literal("tool-result"),
     id: Schema.String,
     name: Schema.String,
@@ -152,7 +153,7 @@ const compactionPartSchema = Schema.Struct({
 })
     .pipe(Schema.refine((part) => (part.encrypted !== undefined) !== (part.text !== undefined), { message: "Compaction requires either encrypted content or a summary" }))
     .annotate({ identifier: "LLM.Content.Compaction" });
-export const CompactionPart = Object.assign(compactionPartSchema, {
+export const CompactionPart = withStatics(compactionPartSchema, {
     make: (input) => Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
 });
 /** Reasoning effort changed here, from `previous` to `effort`; `undefined` is the model default. */
@@ -225,7 +226,7 @@ export class ToolDefinition extends Schema.Class("LLM.ToolDefinition")({
     /** Normalize tool definition input into the canonical `ToolDefinition` class. */
     ToolDefinition.make = (input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input));
 })(ToolDefinition || (ToolDefinition = {}));
-export const ToolNamespace = Object.assign(Schema.Struct({
+export const ToolNamespace = withStatics(Schema.Struct({
     type: Schema.Literal("namespace"),
     name: Schema.String,
     description: Schema.optional(Schema.UndefinedOr(Schema.String)),
@@ -237,7 +238,7 @@ export const ToolNamespace = Object.assign(Schema.Struct({
         tools: input.tools.map(ToolEntry.make),
     }),
 });
-export const ToolEntry = Object.assign(Schema.Union([ToolDefinition, ToolNamespace]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "LLM.ToolEntry" })), {
+export const ToolEntry = withStatics(Schema.Union([ToolDefinition, ToolNamespace]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "LLM.ToolEntry" })), {
     make: (input) => "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
 });
 export class ToolChoice extends Schema.Class("LLM.ToolChoice")({

package/dist/schema/options.d.ts

@@ -12,8 +12,16 @@ export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOpti
 /** Milliseconds for an HTTP timeout, or `false` to disable it. */
 export declare const HttpTimeout: Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>;
 export type HttpTimeout = Schema.Schema.Type<typeof HttpTimeout>;
-/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+/** Applied to `headerTimeout` when a request leaves it unset. */
 export declare const DEFAULT_HTTP_TIMEOUT_MS = 300000;
+/**
+ * Applied to `chunkTimeout` when a request leaves it unset. Some providers, such as DeepSeek, have specifically asked
+ * clients to allow at least 15 minutes, because their models can stream nothing for minutes while they reason.
+ */
+export declare const DEFAULT_CHUNK_TIMEOUT_MS = 900000;
+/** `Content-Encoding` for JSON request bodies; `none` sends plain JSON. */
+export declare const RequestEncoding: Schema.Literals<readonly ["zstd", "gzip", "none"]>;
+export type RequestEncoding = Schema.Schema.Type<typeof RequestEncoding>;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -24,6 +32,8 @@ declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly headerTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
     /** Time allowed between streamed response chunks once headers have arrived. */
     readonly chunkTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
+    /** Compression for JSON request bodies. Only set it for endpoints known to decode it. */
+    readonly encoding: Schema.optional<Schema.Literals<readonly ["zstd", "gzip", "none"]>>;
 }>, {}>;
 export declare class HttpOptions extends HttpOptions_base {
 }
@@ -89,6 +99,8 @@ export declare const LanguageModelSanitizerCompatibility: Schema.Literals<readon
 export type LanguageModelSanitizerCompatibility = Schema.Schema.Type<typeof LanguageModelSanitizerCompatibility>;
 export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
 export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
+export declare const LanguageModelCacheFormatCompatibility: Schema.Literals<readonly ["anthropic", "alibaba"]>;
+export type LanguageModelCacheFormatCompatibility = Schema.Schema.Type<typeof LanguageModelCacheFormatCompatibility>;
 declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
     readonly sanitizer: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot", "none"]>>;
     readonly reasoningField: Schema.optional<Schema.String>;
@@ -101,6 +113,8 @@ declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompati
     readonly supportsUsageInStreaming: Schema.optional<Schema.Boolean>;
     readonly supportsStrictMode: Schema.optional<Schema.Boolean>;
     readonly supportsPromptCacheKey: Schema.optional<Schema.Boolean>;
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    readonly cacheFormat: Schema.optional<Schema.Literals<readonly ["anthropic", "alibaba"]>>;
     readonly zaiToolStream: Schema.optional<Schema.Boolean>;
     readonly requireSignature: Schema.optional<Schema.Boolean>;
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */

package/dist/schema/options.js

@@ -34,8 +34,15 @@ export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schem
 export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
 /** Milliseconds for an HTTP timeout, or `false` to disable it. */
 export const HttpTimeout = Schema.Union([Schema.Number.check(Schema.isGreaterThan(0)), Schema.Literal(false)]);
-/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+/** Applied to `headerTimeout` when a request leaves it unset. */
 export const DEFAULT_HTTP_TIMEOUT_MS = 300_000;
+/**
+ * Applied to `chunkTimeout` when a request leaves it unset. Some providers, such as DeepSeek, have specifically asked
+ * clients to allow at least 15 minutes, because their models can stream nothing for minutes while they reason.
+ */
+export const DEFAULT_CHUNK_TIMEOUT_MS = 900_000;
+/** `Content-Encoding` for JSON request bodies; `none` sends plain JSON. */
+export const RequestEncoding = Schema.Literals(["zstd", "gzip", "none"]);
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -46,6 +53,8 @@ export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     headerTimeout: Schema.optional(HttpTimeout),
     /** Time allowed between streamed response chunks once headers have arrived. */
     chunkTimeout: Schema.optional(HttpTimeout),
+    /** Compression for JSON request bodies. Only set it for endpoints known to decode it. */
+    encoding: Schema.optional(RequestEncoding),
 }) {
 }
 (function (HttpOptions) {
@@ -63,9 +72,16 @@ export const mergeHttpOptions = (...items) => {
     const timeout = items.findLast((item) => item?.timeout !== undefined)?.timeout;
     const headerTimeout = items.findLast((item) => item?.headerTimeout !== undefined)?.headerTimeout;
     const chunkTimeout = items.findLast((item) => item?.chunkTimeout !== undefined)?.chunkTimeout;
-    if (!body && !headers && !query && timeout === undefined && headerTimeout === undefined && chunkTimeout === undefined)
+    const encoding = items.findLast((item) => item?.encoding !== undefined)?.encoding;
+    if (!body &&
+        !headers &&
+        !query &&
+        timeout === undefined &&
+        headerTimeout === undefined &&
+        chunkTimeout === undefined &&
+        encoding === undefined)
         return undefined;
-    return new HttpOptions({ body, headers, query, timeout, headerTimeout, chunkTimeout });
+    return new HttpOptions({ body, headers, query, timeout, headerTimeout, chunkTimeout, encoding });
 };
 export class GenerationOptions extends Schema.Class("LLM.GenerationOptions")({
     maxTokens: Schema.optional(Schema.Number),
@@ -119,6 +135,7 @@ export const ReasoningEffort = Schema.declare((value) => typeof value === "strin
 /** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
 export const LanguageModelSanitizerCompatibility = Schema.Literals(["gemini", "moonshot", "none"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
+export const LanguageModelCacheFormatCompatibility = Schema.Literals(["anthropic", "alibaba"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
     sanitizer: Schema.optional(LanguageModelSanitizerCompatibility),
     reasoningField: Schema.optional(Schema.String),
@@ -130,9 +147,12 @@ export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelC
     supportsStore: Schema.optional(Schema.Boolean),
     supportsUsageInStreaming: Schema.optional(Schema.Boolean),
     supportsStrictMode: Schema.optional(Schema.Boolean),
-    // Accepts `prompt_cache_key` in the Chat Completions body. Chat omits the
-    // key unless this is set; session-affinity headers still flow regardless.
+    // Accepts `prompt_cache_key` in the request body. Chat omits the key unless
+    // this is true; other protocols omit it only when this is false.
+    // Session-affinity headers still flow regardless.
     supportsPromptCacheKey: Schema.optional(Schema.Boolean),
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    cacheFormat: Schema.optional(LanguageModelCacheFormatCompatibility),
     zaiToolStream: Schema.optional(Schema.Boolean),
     requireSignature: Schema.optional(Schema.Boolean),
     /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */

package/dist/tool.d.ts

@@ -132,5 +132,15 @@ export type Tools = Record<string, AnyTool>;
  * is reused.
  */
 export declare const toDefinitions: (tools: Tools) => ReadonlyArray<ToolDefinitionClass>;
+/**
+ * Describes a no-argument Effect tool input as an empty object, or returns
+ * `undefined` when the input takes arguments.
+ *
+ * Effect emits `{ not: { type: "null" } }` only for an encoded struct with no
+ * properties or index signatures, but providers require tool parameters to
+ * describe an object. Annotations are kept; any other keyword, such as a
+ * check's `minProperties`, leaves the schema as Effect emitted it.
+ */
+export declare const emptyInputJsonSchema: (schema: Schema.Top) => JsonSchema.JsonSchema | undefined;
 export { ToolFailure };
 export * as Tool from "./tool.js";