@opencode-ai/ai 0.0.0-beta-17639 → 0.0.0-beta-17728

package/dist/providers/xai.d.ts

@@ -1,12 +1,10 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
-import { type ModelID, type ProviderOptions } from "../schema/index.js";
+import { type ModelID } from "../schema/index.js";
 import type { OpenAIOptionsInput } from "./openai-options.js";
 import type { ProviderPackage } from "../provider-package.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-export type XAIProviderOptionsInput = ProviderOptions & {
-    readonly xai?: OpenAIOptionsInput;
-};
+export type XAIProviderOptionsInput = OpenAIOptionsInput;
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: XAIProviderOptionsInput;
@@ -79,7 +77,6 @@ export declare const routes: (Route<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -96,9 +93,10 @@ export declare const routes: (Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -110,7 +108,7 @@ export declare const routes: (Route<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>> | Route<{
@@ -146,17 +144,20 @@ export declare const routes: (Route<{
             readonly text: string;
         })[];
     } | {
+        readonly type: "message";
         readonly content: readonly {
             readonly type: "output_text";
             readonly text: string;
         }[];
         readonly role: "assistant";
+        readonly id?: string | undefined;
         readonly phase?: "commentary" | "final_answer" | undefined;
     } | {
         readonly type: "function_call";
-        readonly call_id: string;
         readonly name: string;
         readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
     } | {
         readonly type: "function_call_output";
         readonly call_id: string;
@@ -173,19 +174,24 @@ export declare const routes: (Route<{
             readonly text: string;
         })[];
     } | {
+        readonly type: "message";
         readonly content: readonly {
             readonly type: "output_text";
             readonly text: string;
         }[];
         readonly role: "assistant";
+        readonly id?: string | undefined;
         readonly phase?: "commentary" | "final_answer" | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: string | undefined;
+        readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";
@@ -200,54 +206,70 @@ export declare const routes: (Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
     })[] | undefined;
     readonly text?: {
-        readonly verbosity?: "low" | "medium" | "high" | undefined;
+        readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
     } | {
         readonly type: "image_generation";
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly include?: readonly ("file_search_call.results" | "web_search_call.results" | "web_search_call.action.sources" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "code_interpreter_call.outputs" | "reasoning.encrypted_content" | "message.output_text.logprobs")[] | undefined;
     readonly store?: boolean | undefined;
+    readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
     readonly prompt_cache_key?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
     readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
     readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>)[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
     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<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"];
-export declare const responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
-export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput>;
+export declare const responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
+export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;

package/dist/providers/xai.js

@@ -15,7 +15,7 @@ const responsesRoute = Route.make({
     protocol: OpenAIResponses.protocol,
     endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
     transport: OpenAIResponses.httpTransport,
-    defaults: { providerOptions: { xai: { store: false } } },
+    defaults: { providerOptions: { store: false } },
 });
 const chatRoute = Route.make({
     id: "openai-compatible-chat",
@@ -71,7 +71,6 @@ export const model = (modelID, settings) => configure({
     baseURL: settings.baseURL,
     headers: settings.headers,
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    limits: settings.limits,
     providerOptions: settings.providerOptions,
 }).model(modelID);
 export const responses = provider.responses;

package/dist/route/client.d.ts

@@ -7,7 +7,7 @@ import { HttpTransport } from "./transport/index.js";
 import type { HttpMiddleware, Transport, TransportRuntime, WebSocketChannelExecutor } from "./transport/index.js";
 import type { Protocol } from "./protocol.js";
 import type { ProtocolID, ProviderOptions } from "../schema/index.js";
-import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LanguageModelLimits, LLMEvent, ProviderID } from "../schema/index.js";
+import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, ProviderID } from "../schema/index.js";
 export interface RouteBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */
     readonly schema: Schema.Codec<Body, unknown>;
@@ -36,14 +36,12 @@ export type RouteLanguageModelInput = Omit<LanguageModel.Input, "provider" | "ro
 export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">;
 export interface RouteDefaults {
     readonly headers?: Record<string, string>;
-    readonly limits?: LanguageModelLimits;
     readonly generation?: GenerationOptions;
     readonly providerOptions?: ProviderOptions;
     readonly http?: HttpOptions;
 }
 export interface RouteDefaultsInput {
     readonly headers?: Record<string, string>;
-    readonly limits?: LanguageModelLimits.Input;
     readonly generation?: GenerationOptions.Input;
     readonly providerOptions?: ProviderOptions;
     readonly http?: HttpOptions.Input;
@@ -142,9 +140,7 @@ export declare const compileRequest: (request: LLMRequest) => Effect.Effect<{
     route: string;
     protocol: string;
     model: LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>;
     body: any;
     metadata: {

package/dist/route/client.js

@@ -6,7 +6,7 @@ import { Framing } from "./framing.js";
 import { HttpTransport } from "./transport/index.js";
 import { applyCachePolicy } from "../cache-policy.js";
 import * as ProviderShared from "../protocols/shared.js";
-import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LanguageModelLimits, LLMEvent, InvalidProviderOutputReason, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
+import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputReason, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
     if (!provider)
@@ -25,7 +25,6 @@ const mergeRouteDefaults = (base, patch) => {
         ...base,
         ...patch,
         headers,
-        limits: patch.limits === undefined ? base?.limits : LanguageModelLimits.make(patch.limits),
         generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
         providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
         http: mergeHttpOptions(base?.http, httpOptions(patch.http), headers === undefined ? undefined : new HttpOptions({ headers })),

package/dist/route/framing.d.ts

@@ -11,8 +11,8 @@ import type { AIError } from "../schema/index.js";
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
- * The frame type is opaque to this layer; the protocol's `decode` step turns
- * a frame into a typed chunk.
+ * The frame type is opaque to this layer; the protocol's event schema decodes
+ * each frame before its state machine handles it.
  */
 export interface Definition<Frame> {
     readonly id: string;

package/dist/route/protocol.d.ts

@@ -69,8 +69,7 @@ export interface ProtocolStream<Frame, Event, State> {
  *
  * Provider implementations should usually call `Protocol.make({ ... })`
  * without explicit type arguments; the schemas and parser functions are the
- * source of truth. The constructor remains as the public seam for future
- * cross-cutting concerns such as tracing or instrumentation.
+ * source of truth.
  */
 export declare const make: <Body, Frame, Event, State>(input: Protocol<Body, Frame, Event, State>) => Protocol<Body, Frame, Event, State>;
 export declare const jsonEvent: <const S extends Schema.Top>(schema: S) => Schema.fromJsonString<S>;

package/dist/route/protocol.js

@@ -9,8 +9,7 @@ import { Schema } from "effect";
  *
  * Provider implementations should usually call `Protocol.make({ ... })`
  * without explicit type arguments; the schemas and parser functions are the
- * source of truth. The constructor remains as the public seam for future
- * cross-cutting concerns such as tracing or instrumentation.
+ * source of truth.
  */
 export const make = (input) => input;
 export const jsonEvent = (schema) => Schema.fromJsonString(schema);

package/dist/schema/errors.js

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
-import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids.js";
+import { ModelID, ProviderID, RouteID } from "./ids.js";
+import { ProviderMetadata } from "./messages.js";
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"]);
 export class HttpRequestDetails extends Schema.Class("AI.HttpRequestDetails")({
     method: Schema.String,

package/dist/schema/events.d.ts

@@ -1,6 +1,9 @@
 import { Schema } from "effect";
-import { ContentBlockID, ProviderMetadata, ToolCallID } from "./ids.js";
-import { Message, ToolOutput, ToolResultValue } from "./messages.js";
+import { ContentBlockID, ToolCallID } from "./ids.js";
+import { Message, ProviderMetadata, ToolOutput, ToolResultValue } from "./messages.js";
+export declare const FinishReason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+export type FinishReason = Schema.Schema.Type<typeof FinishReason>;
+export { ProviderMetadata } from "./messages.js";
 declare const Usage_base: Schema.Class<Usage, Schema.Struct<{
     readonly inputTokens: Schema.optional<Schema.Number>;
     readonly outputTokens: Schema.optional<Schema.Number>;
@@ -4584,4 +4587,3 @@ export declare namespace LLMResponse {
     /** Concatenate reasoning text from a response or collected event list. */
     const reasoning: (response: Output) => string;
 }
-export {};

package/dist/schema/events.js

@@ -1,7 +1,10 @@
 import { Schema } from "effect";
-import { ContentBlockID, FinishReason, ProviderMetadata, ToolCallID } from "./ids.js";
-import { Message, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue } from "./messages.js";
+import { LLM } from "@opencode-ai/schema/llm";
+import { ContentBlockID, ToolCallID } from "./ids.js";
+import { Message, ProviderMetadata, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue, } from "./messages.js";
 import { ProviderFailureClassification } from "./errors.js";
+export const FinishReason = LLM.FinishReason;
+export { ProviderMetadata } from "./messages.js";
 /**
  * Token usage reported by an LLM provider.
  *

package/dist/schema/ids.d.ts

@@ -1,6 +1,4 @@
 import { Schema } from "effect";
-import { ProviderMetadata } from "@opencode-ai/schema/ai";
-export { ProviderMetadata };
 /** Stable string identifier for a protocol implementation. */
 export declare const ProtocolID: Schema.String;
 export type ProtocolID = Schema.Schema.Type<typeof ProtocolID>;
@@ -17,14 +15,3 @@ export declare const ContentBlockID: Schema.String;
 export type ContentBlockID = Schema.Schema.Type<typeof ContentBlockID>;
 export declare const ToolCallID: Schema.String;
 export type ToolCallID = Schema.Schema.Type<typeof ToolCallID>;
-export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
-export declare const ReasoningEffort: Schema.String;
-export type ReasoningEffort = Schema.Schema.Type<typeof ReasoningEffort>;
-export declare const TextVerbosity: Schema.Literals<readonly ["low", "medium", "high"]>;
-export type TextVerbosity = Schema.Schema.Type<typeof TextVerbosity>;
-export declare const MessageRole: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
-export type MessageRole = Schema.Schema.Type<typeof MessageRole>;
-export declare const FinishReason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
-export type FinishReason = Schema.Schema.Type<typeof FinishReason>;
-export declare const JsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
-export type JsonSchema = Schema.Schema.Type<typeof JsonSchema>;

package/dist/schema/ids.js

@@ -1,7 +1,4 @@
 import { Schema } from "effect";
-import { ProviderMetadata } from "@opencode-ai/schema/ai";
-import { LLM } from "@opencode-ai/schema/llm";
-export { ProviderMetadata };
 /** Stable string identifier for a protocol implementation. */
 export const ProtocolID = Schema.String;
 /** Stable string identifier for the runnable route. */
@@ -11,9 +8,3 @@ export const ProviderID = Schema.String.pipe(Schema.brand("AI.ProviderID"));
 export const ResponseID = Schema.String;
 export const ContentBlockID = Schema.String;
 export const ToolCallID = Schema.String;
-export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
-export const ReasoningEffort = Schema.String;
-export const TextVerbosity = Schema.Literals(["low", "medium", "high"]);
-export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
-export const FinishReason = LLM.FinishReason;
-export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown);

package/dist/schema/messages.d.ts

@@ -1,6 +1,10 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { CacheHint, GenerationOptions, HttpOptions } from "./options.js";
+export declare const MessageRole: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
+export type MessageRole = Schema.Schema.Type<typeof MessageRole>;
+export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
 declare const systemPartSchema: Schema.Struct<{
     readonly type: Schema.Literal<"text">;
     readonly text: Schema.String;
@@ -358,13 +362,9 @@ export declare namespace ToolChoice {
 declare const LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
     readonly id: Schema.optional<Schema.String>;
     readonly model: Schema.declare<import("./options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>, import("./options.js").LanguageModel<{
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
+        readonly [x: string]: unknown;
     }>>;
     readonly system: Schema.$Array<Schema.Struct<{
         readonly type: Schema.Literal<"text">;
@@ -379,7 +379,7 @@ declare const LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
     readonly tools: Schema.$Array<typeof ToolDefinition>;
     readonly toolChoice: Schema.optional<typeof ToolChoice>;
     readonly generation: Schema.optional<typeof GenerationOptions>;
-    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly http: Schema.optional<typeof HttpOptions>;
     readonly cache: Schema.optional<Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<"none">, Schema.Struct<{
         readonly tools: Schema.optional<Schema.Boolean>;

package/dist/schema/messages.js

@@ -1,8 +1,11 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
-import { JsonSchema, MessageRole, ProviderMetadata } from "./ids.js";
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, LanguageModelSchema, ProviderOptions, } from "./options.js";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderOptions, } from "./options.js";
 import { isRecord } from "../utils/record.js";
+export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
+export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
+    identifier: "LLM.ProviderMetadata",
+});
 const systemPartSchema = Schema.Struct({
     type: Schema.Literal("text"),
     text: Schema.String,

package/dist/schema/options.d.ts

@@ -1,8 +1,10 @@
 import { Schema } from "effect";
 import { ModelID, ProviderID } from "./ids.js";
 import type { AnyRoute } from "../route/client.js";
+export declare const JsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+export type JsonSchema = Schema.Schema.Type<typeof JsonSchema>;
 export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
-export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.Unknown>;
 export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
 export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
@@ -47,29 +49,15 @@ export type GenerationOptionsFields = {
 };
 export type GenerationOptionsInput = GenerationOptions | GenerationOptionsFields;
 export declare const mergeGenerationOptions: (...items: ReadonlyArray<GenerationOptionsInput | undefined>) => GenerationOptions | undefined;
-declare const LanguageModelLimits_base: Schema.Class<LanguageModelLimits, Schema.Struct<{
-    readonly context: Schema.optional<Schema.Number>;
-    readonly input: Schema.optional<Schema.Number>;
-    readonly output: Schema.optional<Schema.Number>;
-}>, {}>;
-export declare class LanguageModelLimits extends LanguageModelLimits_base {
-}
-export declare namespace LanguageModelLimits {
-    type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0];
-    /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
-    const make: (input: Input | undefined) => LanguageModelLimits;
-}
 declare const LanguageModelDefaults_base: Schema.Class<LanguageModelDefaults, Schema.Struct<{
-    readonly limits: Schema.optional<typeof LanguageModelLimits>;
     readonly generation: Schema.optional<typeof GenerationOptions>;
-    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly http: Schema.optional<typeof HttpOptions>;
 }>, {}>;
 export declare class LanguageModelDefaults extends LanguageModelDefaults_base {
 }
 export declare namespace LanguageModelDefaults {
     type Input = LanguageModelDefaults | {
-        readonly limits?: LanguageModelLimits.Input;
         readonly generation?: GenerationOptions.Input;
         readonly providerOptions?: ProviderOptions;
         readonly http?: HttpOptions.Input;
@@ -124,13 +112,9 @@ export declare namespace LanguageModel {
 export type LanguageModelInput = LanguageModel.Input;
 export type LanguageModelProviderOptions<SelectedModel> = SelectedModel extends LanguageModel<infer Options> ? Options : never;
 export declare const LanguageModelSchema: Schema.declare<LanguageModel<{
-    readonly [x: string]: {
-        readonly [x: string]: unknown;
-    };
+    readonly [x: string]: unknown;
 }>, LanguageModel<{
-    readonly [x: string]: {
-        readonly [x: string]: unknown;
-    };
+    readonly [x: string]: unknown;
 }>>;
 declare const CacheHint_base: Schema.Class<CacheHint, Schema.Struct<{
     readonly type: Schema.Literals<readonly ["ephemeral", "persistent"]>;

package/dist/schema/options.js

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
-import { JsonSchema, ModelID, ProviderID } from "./ids.js";
+import { ModelID, ProviderID } from "./ids.js";
 import { isRecord } from "../utils/record.js";
+export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown);
 export const mergeJsonRecords = (...items) => {
     const defined = items.filter((item) => item !== undefined);
     if (defined.length === 0)
@@ -26,20 +27,8 @@ const mergeStringRecords = (...items) => {
     const result = Object.fromEntries(defined.flatMap((item) => Object.entries(item).filter((entry) => entry[1] !== undefined)));
     return Object.keys(result).length === 0 ? undefined : result;
 };
-export const ProviderOptions = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown));
-export const mergeProviderOptions = (...items) => {
-    const result = {};
-    for (const item of items) {
-        if (!item)
-            continue;
-        for (const [provider, options] of Object.entries(item)) {
-            const merged = mergeJsonRecords(result[provider], options);
-            if (merged)
-                result[provider] = merged;
-        }
-    }
-    return Object.keys(result).length === 0 ? undefined : result;
-};
+export const ProviderOptions = Schema.Record(Schema.String, Schema.Unknown);
+export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -87,18 +76,7 @@ export const mergeGenerationOptions = (...items) => {
     });
     return Object.values(result).some((value) => value !== undefined) ? result : undefined;
 };
-export class LanguageModelLimits extends Schema.Class("LLM.LanguageModelLimits")({
-    context: Schema.optional(Schema.Number),
-    input: Schema.optional(Schema.Number),
-    output: Schema.optional(Schema.Number),
-}) {
-}
-(function (LanguageModelLimits) {
-    /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
-    LanguageModelLimits.make = (input) => input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {});
-})(LanguageModelLimits || (LanguageModelLimits = {}));
 export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaults")({
-    limits: Schema.optional(LanguageModelLimits),
     generation: Schema.optional(GenerationOptions),
     providerOptions: Schema.optional(ProviderOptions),
     http: Schema.optional(HttpOptions),
@@ -110,7 +88,6 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
         if (input instanceof LanguageModelDefaults)
             return input;
         return new LanguageModelDefaults({
-            limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
             generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
             providerOptions: input.providerOptions,
             http: input.http === undefined ? undefined : HttpOptions.make(input.http),
@@ -181,10 +158,9 @@ export class CacheHint extends Schema.Class("LLM.CacheHint")({
 // Auto-placement policy for prompt caching. The protocol-neutral lowering step
 // reads this and injects `CacheHint`s at the configured boundaries; the
 // per-protocol body builders then translate those hints into wire markers as
-// usual. `"auto"` is the recommended default for agent loops — it places
+// usual. `"auto"` is the default for agent loops — it places
 // breakpoints at the last tool definition, the first and last distinct system
-// parts, and the conversation tail. The rolling message breakpoint keeps a
-// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
+// parts, and the conversation tail so recent prefixes remain reusable during
 // tool loops.
 //
 // Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-17639",
+  "version": "0.0.0-beta-17728",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,8 @@
   },
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "4.0.0-beta.107",
-    "@opencode-ai/http-recorder": "0.0.0-beta-17639",
+    "@effect/platform-node": "4.0.0-rc.110",
+    "@opencode-ai/http-recorder": "0.0.0-beta-17728",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,9 +39,9 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-beta-17639",
+    "@opencode-ai/schema": "0.0.0-beta-17728",
     "aws4fetch": "1.0.20",
-    "effect": "4.0.0-beta.107",
+    "effect": "4.0.0-rc.110",
     "google-auth-library": "10.5.0"
   }
 }