@opencode-ai/ai 0.0.0-next-16670 → 0.0.0-next-16676

package/README.md

@@ -195,7 +195,7 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
 - **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
-- **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
+- **`LanguageModel.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
 - **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.

package/dist/image-client.d.ts

@@ -1,19 +1,19 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor";
 import type { ImageOptions, ImageRequestFor, ImageResponse } from "./image";
-import type { LLMError } from "./schema";
+import type { AIError } from "./schema";
 export type Execute = RequestExecutor.Interface["execute"];
 export interface Interface {
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, LLMError>;
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/ImageClient", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, LLMError>;
+export declare const generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const ImageClient: {
     readonly Service: typeof Service;
     readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, LLMError>;
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;
 };
 export {};

package/dist/image.d.ts

@@ -1,9 +1,9 @@
 import { Effect, Schema } from "effect";
-import { HttpOptions, LLMError, ModelID, ProviderID, Usage } from "./schema";
+import { HttpOptions, AIError, ModelID, ProviderID, Usage } from "./schema";
 import { Service, type Execute as ImageExecute } from "./image-client";
 export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
     readonly id: string;
-    readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>;
+    readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, AIError>;
 }
 export type ImageOptions = Record<string, unknown>;
 export declare class ImageModel<Options extends ImageOptions = ImageOptions> {
@@ -101,8 +101,8 @@ export declare class ImageResponse extends ImageResponse_base {
 }
 export declare function request<const Model extends object>(input: ImageRequestInput<Model>): ImageRequestFor<ImageModelOptions<Model>>;
 export declare function request(input: ImageRequest): ImageRequest;
-export declare function generate<const Model extends object>(input: ImageRequestInput<Model>): Effect.Effect<ImageResponse, LLMError, Service>;
-export declare function generate(input: ImageRequest): Effect.Effect<ImageResponse, LLMError, Service>;
+export declare function generate<const Model extends object>(input: ImageRequestInput<Model>): Effect.Effect<ImageResponse, AIError, Service>;
+export declare function generate(input: ImageRequest): Effect.Effect<ImageResponse, AIError, Service>;
 export declare const Image: {
     readonly request: typeof request;
     readonly generate: typeof generate;

package/dist/image.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema";
+import { HttpOptions, InvalidRequestReason, AIError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema";
 import { ImageClient, Service } from "./image-client";
 export class ImageModel {
     id;
@@ -89,7 +89,7 @@ export function request(input) {
 export function generate(input) {
     return Effect.try({
         try: () => (input instanceof ImageRequest ? input : request(input)),
-        catch: (error) => new LLMError({
+        catch: (error) => new AIError({
             module: "Image",
             method: "generate",
             reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { Auth } from "./route/auth";
 export { Provider } from "./provider";
 export { ProviderPackage } from "./provider-package";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error";
-export type { RouteModelInput, RouteRoutedModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client";
+export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client";
 export * from "./schema";
 export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image";
 export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image";
@@ -14,5 +14,5 @@ export { ToolRuntime } from "./tool-runtime";
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime";
 export type { AnyExecutableTool, AnyTool, ExecutableTool, ExecutableTools, Definition as ToolShape, ToolExecute, ToolExecuteContext, ToolModelOutputInput, Tools, ToolSchema, ToolToModelOutput, } from "./tool";
 export * as LLM from "./llm";
-export type { Definition as ProviderDefinition, ModelFactory as ProviderModelFactory, ModelOptions as ProviderModelOptions, } from "./provider";
+export type { Definition as ProviderDefinition, LanguageModelFactory as ProviderLanguageModelFactory, LanguageModelOptions as ProviderLanguageModelOptions, } from "./provider";
 export type { Definition as ProviderPackageDefinition, Settings as ProviderPackageSettings } from "./provider-package";

package/dist/llm.d.ts

@@ -1,22 +1,22 @@
 import { Effect, JsonSchema, Schema } from "effect";
-import { GenerationOptions, HttpOptions, LLMError, LLMRequest, LLMResponse, Message, Model, SystemPart, ToolChoice, ToolDefinition, type ContentPart, type ModelProviderOptions } from "./schema";
+import { GenerationOptions, HttpOptions, AIError, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, type ContentPart, type LanguageModelProviderOptions } from "./schema";
 import { type ToolSchema } from "./tool";
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
-export type RequestInput<SelectedModel extends Model = Model> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
-    readonly model: SelectedModel;
+export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
+    readonly model: SelectedLanguageModel;
     readonly system?: string | SystemPart | ReadonlyArray<SystemPart>;
     readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>;
     readonly messages?: ReadonlyArray<Message | Message.Input>;
     readonly tools?: ReadonlyArray<ToolDefinition.Input>;
     readonly toolChoice?: ToolChoice.Input;
     readonly generation?: GenerationOptions.Input;
-    readonly providerOptions?: NoInfer<ModelProviderOptions<SelectedModel>>;
+    readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
     readonly http?: HttpOptions.Input;
 };
 export declare const generate: typeof import("./route/client").generate;
 export declare const stream: typeof import("./route/client").stream;
-export declare const request: <const SelectedModel extends Model>(input: RequestInput<SelectedModel>) => LLMRequest;
-type GenerateObjectBase<SelectedModel extends Model = Model> = Omit<RequestInput<SelectedModel>, "tools" | "toolChoice">;
+export declare const request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest;
+type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<RequestInput<SelectedLanguageModel>, "tools" | "toolChoice">;
 export declare class GenerateObjectResponse<T> {
     readonly object: T;
     readonly response: LLMResponse;
@@ -205,10 +205,10 @@ export declare class GenerateObjectResponse<T> {
     })[];
     get usage(): import("./schema").Usage | undefined;
 }
-export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedModel extends Model = Model> extends GenerateObjectBase<SelectedModel> {
+export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
     readonly schema: S;
 }
-export interface GenerateObjectDynamicOptions<SelectedModel extends Model = Model> extends GenerateObjectBase<SelectedModel> {
+export interface GenerateObjectDynamicOptions<SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
     /** Raw JSON Schema object describing the expected output shape. */
     readonly jsonSchema: JsonSchema.JsonSchema;
 }
@@ -220,10 +220,10 @@ export interface GenerateObjectDynamicOptions<SelectedModel extends Model = Mode
  * Two input modes:
  *
  * 1. `schema: EffectSchema<T>` — `.object` is decoded and typed as `T`.
- *    Decode failures surface as `LLMError`.
+ *    Decode failures surface as `AIError`.
  * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
  *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
  */
-export declare function generateObject<const SelectedModel extends Model, S extends ToolSchema<any>>(options: GenerateObjectOptions<S, SelectedModel>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, LLMError>;
-export declare function generateObject<const SelectedModel extends Model>(options: GenerateObjectDynamicOptions<SelectedModel>): Effect.Effect<GenerateObjectResponse<unknown>, LLMError>;
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(options: GenerateObjectOptions<S, SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError>;
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel>(options: GenerateObjectDynamicOptions<SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<unknown>, AIError>;
 export {};

package/dist/llm.js

@@ -1,6 +1,6 @@
 import { Effect, JsonSchema, Schema } from "effect";
 import { LLMClient } from "./route/client";
-import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, LLMError, LLMEvent, LLMRequest, LLMResponse, Message, Model, SystemPart, ToolChoice, ToolDefinition, } from "./schema";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema";
 import { make as makeTool, toDefinitions } from "./tool";
 export const generate = LLMClient.generate;
 export const stream = LLMClient.stream;
@@ -42,14 +42,14 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, to
     const response = yield* LLMClient.generate(generateRequest);
     const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
     if (!call || !LLMEvent.is.toolCall(call))
-        return yield* new LLMError({
+        return yield* new AIError({
             module: "LLM",
             method: "generateObject",
             reason: new InvalidProviderOutputReason({
                 message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
             }),
         });
-    const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new LLMError({
+    const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new AIError({
         module: "LLM",
         method: "generateObject",
         reason: new InvalidProviderOutputReason({

package/dist/protocols/anthropic-messages.js

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth";
 import { Endpoint } from "../route/endpoint";
 import { Framing } from "../route/framing";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, mergeJsonRecords, Usage, } from "../schema";
+import { AIError, LLMEvent, mergeJsonRecords, Usage, } from "../schema";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
 import { classifyProviderFailure } from "../provider-error";
 import * as Cache from "./utils/cache";
@@ -167,8 +167,12 @@ const AnthropicUsage = Schema.StructWithRest(Schema.Struct({
     output_tokens: Schema.optional(Schema.Number),
     cache_creation_input_tokens: optionalNull(Schema.Number),
     cache_read_input_tokens: optionalNull(Schema.Number),
-    server_tool_use: optionalNull(Schema.StructWithRest(Schema.Struct({ web_search_requests: Schema.optional(Schema.Number) }), [Schema.Record(Schema.String, Schema.Unknown)])),
-    output_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({ thinking_tokens: Schema.optional(Schema.Number) }), [Schema.Record(Schema.String, Schema.Unknown)])),
+    server_tool_use: optionalNull(Schema.StructWithRest(Schema.Struct({ web_search_requests: Schema.optional(Schema.Number) }), [
+        Schema.Record(Schema.String, Schema.Unknown),
+    ])),
+    output_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({ thinking_tokens: Schema.optional(Schema.Number) }), [
+        Schema.Record(Schema.String, Schema.Unknown),
+    ])),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const AnthropicStreamBlock = Schema.Struct({
     type: Schema.String,
@@ -793,7 +797,7 @@ const providerErrorMessage = (event) => {
         return `${type}: ${message}`;
     return message || type || "Anthropic Messages stream error";
 };
-const onError = (event) => new LLMError({
+const onError = (event) => new AIError({
     module: ADAPTER,
     method: "stream",
     reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),

package/dist/protocols/bedrock-converse.js

@@ -2,7 +2,7 @@ import { Effect, Schema } from "effect";
 import { Route } from "../route/client";
 import { Endpoint } from "../route/endpoint";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, } from "../schema";
+import { AIError, LLMEvent, Usage, } from "../schema";
 import { BedrockEventStream } from "./bedrock-event-stream";
 import { classifyProviderFailure } from "../provider-error";
 import { JsonObject, optionalArray, ProviderShared } from "./shared";
@@ -193,9 +193,7 @@ const reasoningSignature = (part) => {
 };
 const reasoningRedactedData = (part) => {
     const bedrock = part.providerMetadata?.bedrock;
-    return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string"
-        ? bedrock.redactedData
-        : undefined;
+    return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string" ? bedrock.redactedData : undefined;
 };
 const lowerToolCall = (part) => ({
     toolUse: {
@@ -509,7 +507,7 @@ const step = (state, event) => Effect.gen(function* () {
         ["validationException", event.validationException],
     ].find((entry) => entry[1] !== undefined);
     if (exception) {
-        return yield* new LLMError({
+        return yield* new AIError({
             module: ADAPTER,
             method: "stream",
             reason: classifyProviderFailure({

package/dist/protocols/google-images.js

@@ -2,7 +2,7 @@ import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { GeneratedImage, ImageModel, ImageResponse, } from "../image";
 import { Auth } from "../route/auth";
-import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
+import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
 import { ProviderShared } from "./shared";
 import { ImageInputs } from "./utils/image-input";
 const ADAPTER = "google-images";
@@ -58,7 +58,7 @@ const nativeOptions = (options) => {
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-const invalidOutput = (message, providerMetadata) => new LLMError({
+const invalidOutput = (message, providerMetadata) => new AIError({
     module: ADAPTER,
     method: "generate",
     reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),

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

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, type LLMRequest, type MediaPart, type ProviderMetadata, type ToolDefinition } from "../schema";
+import { AIError, LLMEvent, Usage, type LLMRequest, type MediaPart, type ProviderMetadata, type ToolDefinition } from "../schema";
 import { ProviderShared } from "./shared";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolStream } from "./utils/tool-stream";
@@ -361,11 +361,11 @@ export declare const lowerTool: (protocolName: string, tool: ToolDefinition, inp
         readonly [x: string]: unknown;
     };
     strict: boolean;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const lowerToolChoice: (protocolName: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>) => Effect.Effect<"required" | "none" | "auto" | {
     type: "function";
     name: string;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const fromRequestWithExtension: (request: LLMRequest, extension: Extension) => Effect.Effect<{
     service_tier?: "auto" | "default" | "flex" | "priority" | undefined;
     text?: {
@@ -379,7 +379,7 @@ export declare const fromRequestWithExtension: (request: LLMRequest, extension:
     prompt_cache_key?: string | undefined;
     store?: boolean | undefined;
     instructions?: string | undefined;
-    model: string & import("effect/Brand").Brand<"LLM.ModelID">;
+    model: string & import("effect/Brand").Brand<"AI.ModelID">;
     input: LoweredInputItem[];
     tools: {
         type: "function";
@@ -398,7 +398,7 @@ export declare const fromRequestWithExtension: (request: LLMRequest, extension:
     max_output_tokens: number | undefined;
     temperature: number | undefined;
     top_p: number | undefined;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
     readonly input: readonly ({
         readonly type: "reasoning";
@@ -486,13 +486,13 @@ export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
     readonly service_tier?: "auto" | "default" | "flex" | "priority" | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly max_output_tokens?: number | undefined;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const providerMetadata: (state: ParserState, metadata: Record<string, unknown>) => ProviderMetadata;
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>];
 export declare const terminal: (event: Event) => boolean;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, _event: Event) => StepResult;
-export declare const step: (state: ParserState, event: Event) => LLMError | Effect.Effect<StepResult, never, never> | Effect.Effect<[ParserState, readonly ({
+export declare const step: (state: ParserState, event: Event) => AIError | Effect.Effect<StepResult, never, never> | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;
 } | {
@@ -673,7 +673,7 @@ export declare const step: (state: ParserState, event: Event) => LLMError | Effe
         };
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-})[]], LLMError, never>;
+})[]], AIError, never>;
 /**
  * The provider-neutral Open Responses protocol. Provider-specific Responses
  * implementations compose this baseline with their own tools and event variants.

package/dist/protocols/open-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, } from "../schema";
+import { AIError, LLMEvent, Usage, } from "../schema";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
 import { classifyProviderFailure } from "../provider-error";
 import { OpenResponsesOptions } from "./utils/open-responses-options";
@@ -290,9 +290,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     return;
                 const groups = content.reduce((groups, part) => {
                     const metadata = part.providerMetadata?.[providerMetadataKey];
-                    const phase = ProviderShared.isRecord(metadata)
-                        ? messagePhase(metadata.phase, extension)
-                        : undefined;
+                    const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined;
                     const group = groups.at(-1);
                     if (group && group.phase === phase)
                         group.parts.push(part);
@@ -481,10 +479,7 @@ const onOutputTextDelta = (state, event, id) => {
     const phase = state.messagePhases[id];
     const metadata = phase === undefined ? undefined : providerMetadata(state, { phase });
     const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata);
-    return [
-        { ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) },
-        events,
-    ];
+    return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events];
 };
 const onOutputTextDone = (state, event, id) => {
     if (state.messageItems.has(id)) {
@@ -754,7 +749,7 @@ const providerErrorMessage = (event, fallback) => {
 const providerError = (state, event, fallback) => {
     const code = event.code || event.error?.code || event.response?.error?.code || undefined;
     const message = providerErrorMessage(event, fallback);
-    return new LLMError({
+    return new AIError({
         module: state.id,
         method: "stream",
         reason: classifyProviderFailure({ message, code }),

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

@@ -2,7 +2,7 @@ import { Effect, Schema } from "effect";
 import { Route } from "../route/client";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, type FinishReasonDetails, type CacheHint, type LLMRequest } from "../schema";
+import { AIError, LLMEvent, Usage, type FinishReasonDetails, type CacheHint, type LLMRequest } from "../schema";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolStream } from "./utils/tool-stream";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
@@ -266,7 +266,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
     seed: number | undefined;
     stop: readonly string[] | undefined;
     max_completion_tokens: number | undefined;
-    model: string & import("effect/Brand").Brand<"LLM.ModelID">;
+    model: string & import("effect/Brand").Brand<"AI.ModelID">;
     messages: ({
         readonly role: "system";
         readonly content: string | readonly ({
@@ -360,7 +360,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
     seed: number | undefined;
     stop: readonly string[] | undefined;
     max_tokens: number | undefined;
-    model: string & import("effect/Brand").Brand<"LLM.ModelID">;
+    model: string & import("effect/Brand").Brand<"AI.ModelID">;
     messages: ({
         readonly role: "system";
         readonly content: string | readonly ({
@@ -444,7 +444,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
     stream_options: {
         include_usage: boolean;
     };
-}, LLMError, never>;
+}, AIError, never>;
 /**
  * The OpenAI Chat protocol — request body construction, body schema, and the
  * streaming-event state machine. Reused by every route that speaks OpenAI Chat

package/dist/protocols/openai-chat.js

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth";
 import { Endpoint } from "../route/endpoint";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, } from "../schema";
+import { AIError, LLMEvent, Usage, } from "../schema";
 import { classifyProviderFailure } from "../provider-error";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
 import { OpenAIOptions } from "./utils/openai-options";
@@ -444,7 +444,7 @@ const mapFinishReason = (reason) => {
 // OpenAI Chat reports `prompt_tokens` (inclusive total) with a
 // cached-read and cache-write subsets, and `completion_tokens` (inclusive
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
-// through and derive the non-cached breakdown so the `LLM.Usage` contract is
+// through and derive the non-cached breakdown so the `AI.Usage` contract is
 // satisfied on both sides.
 const mapUsage = (usage) => {
     if (!usage)
@@ -524,7 +524,7 @@ const reasoningMetadata = (field, details) => ({
 });
 const step = (state, event) => Effect.gen(function* () {
     if (event.error)
-        return yield* new LLMError({
+        return yield* new AIError({
             module: ADAPTER,
             method: "stream",
             reason: classifyProviderFailure({

package/dist/protocols/openai-compatible-chat.d.ts

@@ -1,5 +1,5 @@
-import { Route, type RouteRoutedModelInput } from "../route/client";
-export type OpenAICompatibleChatModelInput = RouteRoutedModelInput;
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client";
+export type OpenAICompatibleChatLanguageModelInput = RouteRoutedLanguageModelInput;
 /**
  * Route for non-OpenAI providers that expose an OpenAI Chat-compatible
  * `/chat/completions` endpoint. Reuses `OpenAIChat.protocol` end-to-end and

package/dist/protocols/openai-compatible-responses.d.ts

@@ -1,5 +1,5 @@
-import { Route, type RouteRoutedModelInput } from "../route/client";
-export type OpenAICompatibleResponsesModelInput = RouteRoutedModelInput;
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client";
+export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageModelInput;
 /**
  * Deployment adapter for providers that expose an Open Responses-compatible
  * `/responses` endpoint. Provider helpers configure identity, endpoint, and

package/dist/protocols/openai-images.js

@@ -2,7 +2,7 @@ import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { ImageModel, GeneratedImage, ImageResponse, } from "../image";
 import { Auth } from "../route/auth";
-import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
+import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
 import { ProviderShared } from "./shared";
 import { ImageInputs } from "./utils/image-input";
 import { OpenAIImage } from "./utils/openai-image";
@@ -35,7 +35,7 @@ const nativeOptions = (options) => {
         ...native,
     };
 };
-const invalidOutput = (message) => new LLMError({
+const invalidOutput = (message) => new AIError({
     module: ADAPTER,
     method: "generate",
     reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),

package/dist/protocols/shared.d.ts

@@ -2,7 +2,7 @@ import { Buffer } from "node:buffer";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Effect, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { LLMError, type ContentPart, type LLMRequest, type ToolResultPart } from "../schema";
+import { AIError, type ContentPart, type LLMRequest, type ToolResultPart } from "../schema";
 import { isRecord } from "../utils/record";
 export { isRecord };
 export declare const Json: Schema.fromJsonString<Schema.Unknown>;
@@ -27,7 +27,7 @@ export interface ToolAccumulator {
  * when at least one is defined. Returns `undefined` when neither input nor
  * output is known so routes don't publish a misleading `0`.
  *
- * Under the additive `LLM.Usage` contract, `inputTokens` and `outputTokens`
+ * Under the additive `AI.Usage` contract, `inputTokens` and `outputTokens`
  * are the non-cached input and visible output only. The provider-supplied
  * `total` is the source of truth when present; the computed fallback
  * under-counts cache and reasoning by design and exists mainly so
@@ -55,8 +55,8 @@ export declare const subtractTokens: (total: number | undefined, subtrahend: num
  * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
  */
 export declare const sumTokens: (...values: ReadonlyArray<number | undefined>) => number | undefined;
-export declare const eventError: (route: string, message: string, raw?: string) => LLMError;
-export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, LLMError, never>;
+export declare const eventError: (route: string, message: string, raw?: string) => AIError;
+export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, AIError, never>;
 /**
  * Join the `text` field of a list of parts with newlines. Used by routes
  * that flatten system / message content arrays into a single provider string
@@ -92,20 +92,20 @@ export declare const systemUpdateText: (route: string, message: import("..").Mes
             readonly [x: string]: unknown;
         };
     } | undefined;
-}[], LLMError, never>;
+}[], AIError, never>;
 /** Lower an unsupported privileged update into visible, in-order user text. */
 export declare const wrappedSystemUpdate: (route: string, message: import("..").Message) => Effect.Effect<{
     type: "text";
     text: string;
     cache: import("..").CacheHint | undefined;
-}, LLMError, never>;
+}, AIError, never>;
 /**
  * Parse the streamed JSON input of a tool call. Treats an empty string as
  * `"{}"` — providers occasionally finish a tool call without ever emitting
  * input deltas (e.g. zero-arg tools). The error message is uniform across
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
-export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, LLMError, never>;
+export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, AIError, never>;
 export declare const IMAGE_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
 export declare const VIDEO_MIMES: readonly ["video/mp4", "video/webm", "video/quicktime"];
 export declare const AUDIO_MIMES: readonly ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
@@ -132,13 +132,13 @@ export declare const validateMedia: (route: string, part: {
     base64: string;
     dataUrl: string;
     bytes: Buffer<ArrayBuffer>;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const validateToolFile: (route: string, part: Tool.FileContent, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
     mime: string;
     base64: string;
     dataUrl: string;
     bytes: Buffer<ArrayBuffer>;
-}, LLMError, never>;
+}, AIError, never>;
 export declare const trimBaseUrl: (value: string) => string;
 export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
@@ -148,9 +148,9 @@ export declare const errorText: (error: unknown) => string;
  * `decodeChunk` sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
  * implement client-driven retries) so the public error channel stays
- * `LLMError`.
+ * `AIError`.
  */
-export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, LLMError>) => Stream.Stream<string, LLMError>;
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<string, AIError>;
 /**
  * Canonical invalid-request constructor. Lift one-line `const invalid =
  * (message) => invalidRequest(message)` aliases out of every
@@ -158,27 +158,27 @@ export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, LLMError>) =>
  * `InvalidRequestReason` with route context or trace metadata, the change
  * lands here.
  */
-export declare const invalidRequest: (message: string) => LLMError;
+export declare const invalidRequest: (message: string) => AIError;
 export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {
     readonly auto: () => Auto;
     readonly none: () => None;
     readonly required: () => Required;
     readonly tool: (name: string) => Tool;
-}) => Effect.Effect<Auto | None | Required | Tool, LLMError, never>;
+}) => Effect.Effect<Auto | None | Required | Tool, AIError, never>;
 type ContentType = ContentPart["type"];
 export declare const supportsContent: <const Type extends ContentType>(part: ContentPart, types: ReadonlyArray<Type>) => part is Extract<ContentPart, {
     readonly type: Type;
 }>;
-export declare const unsupportedContent: (route: string, role: LLMRequest["messages"][number]["role"], types: ReadonlyArray<ContentType>) => LLMError;
+export declare const unsupportedContent: (route: string, role: LLMRequest["messages"][number]["role"], types: ReadonlyArray<ContentType>) => AIError;
 /**
  * Build a `validate` step from a Schema decoder. Replaces the per-route
  * lambda body `(payload) => decode(payload).pipe(Effect.mapError((e) =>
  * invalid(e.message)))`. Any decode error is translated into
- * `LLMError` carrying the original parse-error message.
+ * `AIError` carrying the original parse-error message.
  */
 export declare const validateWith: <A, I, E extends {
     readonly message: string;
-}>(decode: (input: I) => Effect.Effect<A, E>) => (payload: I) => Effect.Effect<A, LLMError, never>;
+}>(decode: (input: I) => Effect.Effect<A, E>) => (payload: I) => Effect.Effect<A, AIError, never>;
 /**
  * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
  * automatically after caller-supplied headers so routes cannot accidentally