@opencode-ai/ai 0.0.0-next-16671 → 0.0.0-next-16680

package/dist/route/client.js

@@ -8,14 +8,14 @@ import { HttpTransport } from "./transport";
 import { WebSocketExecutor } from "./transport";
 import { applyCachePolicy } from "../cache-policy";
 import * as ProviderShared from "../protocols/shared";
-import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMError as LLMErrorClass, LLMEvent, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema";
-const makeRouteModel = (route, mapped) => {
+import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LanguageModelLimits, LLMEvent, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema";
+const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
     if (!provider)
         throw new Error(`Route.model(${route.id}) requires a provider`);
     if (!endpointBaseURL(route.endpoint))
         throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`);
-    return Model.make({
+    return LanguageModel.make({
         ...mapped,
         provider,
         route,
@@ -27,7 +27,7 @@ const mergeRouteDefaults = (base, patch) => {
         ...base,
         ...patch,
         headers,
-        limits: patch.limits === undefined ? base?.limits : ModelLimits.make(patch.limits),
+        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 })),
@@ -60,7 +60,7 @@ const resolveRequestOptions = (request) => {
 };
 const streamError = (route, message, cause) => {
     const failed = cause.reasons.find(Cause.isFailReason)?.error;
-    if (failed instanceof LLMErrorClass)
+    if (failed instanceof AIError)
         return failed;
     return ProviderShared.eventError(route, message, Cause.pretty(cause));
 };
@@ -104,7 +104,7 @@ function makeFromTransport(input) {
                     defaults: mergeRouteDefaults(route.defaults, defaults),
                 });
             },
-            model: (input) => makeRouteModel(route, input),
+            model: (input) => makeRouteLanguageModel(route, input),
             prepareTransport: (body, request, options) => routeInput.transport.prepare({
                 body,
                 request,

package/dist/route/executor.d.ts

@@ -1,10 +1,10 @@
 import { Context, Effect, Layer } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { LLMError } from "../schema";
+import { AIError } from "../schema";
 export interface Interface {
-    readonly execute: (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, LLMError>;
+    readonly execute: (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/LLM/RequestExecutor", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;

package/dist/route/executor.js

@@ -1,8 +1,8 @@
 import { Cause, Context, Effect, Layer } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
-import { HttpContext, HttpRateLimitDetails, HttpRequestDetails, HttpResponseDetails, LLMError, TransportReason, } from "../schema";
+import { HttpContext, HttpRateLimitDetails, HttpRequestDetails, HttpResponseDetails, AIError, TransportReason, } from "../schema";
 import { classifyProviderFailure } from "../provider-error";
-export class Service extends Context.Service()("@opencode/LLM/RequestExecutor") {
+export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
 }
 const BODY_LIMIT = 16_384;
 const REDACTED = "<redacted>";
@@ -163,7 +163,7 @@ const statusError = (request, redactedNames) => (response) => Effect.gen(functio
     const retryAfter = retryAfterMs(headers);
     const rateLimit = rateLimitDetails(headers, retryAfter);
     const details = responseBody(body, request);
-    return yield* new LLMError({
+    return yield* new AIError({
         module: "RequestExecutor",
         method: "execute",
         reason: classifyProviderFailure({
@@ -183,7 +183,7 @@ const statusError = (request, redactedNames) => (response) => Effect.gen(functio
     });
 });
 const toHttpError = (redactedNames) => (error) => {
-    const transportError = (input) => new LLMError({
+    const transportError = (input) => new AIError({
         module: "RequestExecutor",
         method: "execute",
         reason: new TransportReason({

package/dist/route/framing.d.ts

@@ -1,5 +1,5 @@
 import type { Stream } from "effect";
-import type { LLMError } from "../schema";
+import type { AIError } from "../schema";
 /**
  * Decode a streaming HTTP response body into provider-protocol frames.
  *
@@ -16,7 +16,7 @@ import type { LLMError } from "../schema";
  */
 export interface Definition<Frame> {
     readonly id: string;
-    readonly frame: (bytes: Stream.Stream<Uint8Array, LLMError>) => Stream.Stream<Frame, LLMError>;
+    readonly frame: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<Frame, AIError>;
 }
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export declare const sse: Definition<string>;

package/dist/route/index.d.ts

@@ -1,5 +1,5 @@
 export { Route, LLMClient } from "./client";
-export type { Route as RouteShape, RouteModelInput, RouteRoutedModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, StreamOptions, } from "./client";
+export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, StreamOptions, } from "./client";
 export * from "./executor";
 export { Auth } from "./auth";
 export { AuthOptions } from "./auth-options";

package/dist/route/protocol.d.ts

@@ -1,5 +1,5 @@
 import { Schema, type Effect } from "effect";
-import type { LLMError, LLMEvent, LLMRequest, ProtocolID } from "../schema";
+import type { AIError, LLMEvent, LLMRequest, ProtocolID } from "../schema";
 /**
  * The semantic API contract of one model server family.
  *
@@ -45,7 +45,7 @@ export interface ProtocolBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */
     readonly schema: Schema.Codec<Body, unknown>;
     /** Build the provider-native body from a common `LLMRequest`. */
-    readonly from: (request: LLMRequest) => Effect.Effect<Body, LLMError>;
+    readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>;
 }
 export interface ProtocolStream<Frame, Event, State> {
     /** Schema for one decoded streaming event, decoded from a transport frame. */
@@ -53,7 +53,7 @@ export interface ProtocolStream<Frame, Event, State> {
     /** Initial parser state. Called once per response with the resolved request. */
     readonly initial: (request: LLMRequest) => State;
     /** Translate one event into emitted `LLMEvent`s plus the next state. */
-    readonly step: (state: State, event: Event) => Effect.Effect<readonly [State, ReadonlyArray<LLMEvent>], LLMError>;
+    readonly step: (state: State, event: Event) => Effect.Effect<readonly [State, ReadonlyArray<LLMEvent>], AIError>;
     /** Optional request-completion signal for transports that do not end naturally. */
     readonly terminal?: (event: Event) => boolean;
     /** Optional flush emitted when the framed stream ends. */

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

@@ -18,7 +18,7 @@ export declare const jsonRequestParts: <Body>(input: JsonRequestInput<Body>) =>
     jsonBody: Record<string, unknown> | Body;
     bodyText: string;
     headers: Headers.Headers;
-}, import("../..").LLMError, never>;
+}, import("../..").AIError, never>;
 export interface HttpJsonInput<_Body, Frame> {
     readonly framing: Framing.Definition<Frame>;
 }

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

@@ -3,7 +3,7 @@ import { Endpoint } from "../endpoint";
 import { Auth } from "../auth";
 import type { Interface as RequestExecutorInterface } from "../executor";
 import type { Interface as WebSocketExecutorInterface } from "./websocket";
-import type { LLMError, LLMRequest } from "../../schema";
+import type { AIError, LLMRequest } from "../../schema";
 export interface TransportRuntime {
     readonly http: RequestExecutorInterface;
     readonly webSocket?: WebSocketExecutorInterface;
@@ -17,8 +17,8 @@ export interface HttpRequest {
 export type HttpRequestTransform = (request: HttpRequest) => Effect.Effect<void>;
 export interface Transport<Body, Prepared, Frame> {
     readonly id: string;
-    readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, LLMError>;
-    readonly frames: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<Frame, LLMError>;
+    readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, AIError>;
+    readonly frames: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<Frame, AIError>;
 }
 export interface TransportPrepareInput<Body> {
     readonly body: Body;

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

@@ -1,25 +1,25 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { Headers } from "effect/unstable/http";
-import { LLMError } from "../../schema";
+import { AIError } from "../../schema";
 import type { Transport } from "./index";
 export interface WebSocketRequest {
     readonly url: string;
     readonly headers: Headers.Headers;
 }
 export interface WebSocketConnection {
-    readonly sendText: (message: string) => Effect.Effect<void, LLMError>;
-    readonly messages: Stream.Stream<string | Uint8Array, LLMError>;
+    readonly sendText: (message: string) => Effect.Effect<void, AIError>;
+    readonly messages: Stream.Stream<string | Uint8Array, AIError>;
     readonly close: Effect.Effect<void, never>;
 }
 export interface Interface {
-    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, LLMError>;
+    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/LLM/WebSocketExecutor", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/WebSocketExecutor", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, LLMError, never>;
+export declare const open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, never>;
 export declare const layer: Layer.Layer<Service>;
-export declare const fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, LLMError>;
+export declare const fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
 export declare const messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
 export interface JsonPrepared {
     readonly url: string;
@@ -27,7 +27,7 @@ export interface JsonPrepared {
     readonly message: string;
 }
 export interface JsonInput<Body, Message> {
-    readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, LLMError>;
+    readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, AIError>;
     readonly encodeMessage: (message: Message) => string;
 }
 export type JsonPatch<Body, Message> = Partial<JsonInput<Body, Message>>;
@@ -42,8 +42,8 @@ export declare const jsonTransport: {
 export declare const WebSocketExecutor: {
     readonly Service: typeof Service;
     readonly layer: Layer.Layer<Service, never, never>;
-    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, LLMError, never>;
-    readonly fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, LLMError>;
+    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, never>;
+    readonly fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
     readonly messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
 };
 export declare const WebSocketTransport: {

package/dist/route/transport/websocket.js

@@ -1,10 +1,10 @@
 import { Cause, Context, Effect, Layer, Queue, Stream } from "effect";
 import { Headers } from "effect/unstable/http";
-import { LLMError, TransportReason } from "../../schema";
+import { AIError, TransportReason } from "../../schema";
 import * as HttpTransport from "./http";
-export class Service extends Context.Service()("@opencode/LLM/WebSocketExecutor") {
+export class Service extends Context.Service()("@opencode/AI/WebSocketExecutor") {
 }
-const transportError = (method, message, input = {}) => new LLMError({
+const transportError = (method, message, input = {}) => new AIError({
     module: "WebSocketExecutor",
     method,
     reason: new TransportReason({ message, url: input.url, kind: input.kind }),

package/dist/schema/errors.d.ts

@@ -46,8 +46,8 @@ export declare class InvalidRequestReason extends InvalidRequestReason_base {
 declare const NoRouteReason_base: Schema.Class<NoRouteReason, Schema.Struct<{
     readonly _tag: Schema.tag<"NoRoute">;
     readonly route: Schema.String;
-    readonly provider: Schema.brand<Schema.String, "LLM.ProviderID">;
-    readonly model: Schema.brand<Schema.String, "LLM.ModelID">;
+    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+    readonly model: Schema.brand<Schema.String, "AI.ModelID">;
 }>, {}>;
 export declare class NoRouteReason extends NoRouteReason_base {
     get message(): string;
@@ -124,14 +124,14 @@ declare const UnknownProviderReason_base: Schema.Class<UnknownProviderReason, Sc
 }>, {}>;
 export declare class UnknownProviderReason extends UnknownProviderReason_base {
 }
-export declare const LLMErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
-export type LLMErrorReason = Schema.Schema.Type<typeof LLMErrorReason>;
-declare const LLMError_base: Schema.Class<LLMError, Schema.TaggedStruct<"LLM.Error", {
+export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
+export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>;
+declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error", {
     readonly module: Schema.String;
     readonly method: Schema.String;
     readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
 }>, import("effect/Cause").YieldableError>;
-export declare class LLMError extends LLMError_base {
+export declare class AIError extends AIError_base {
     readonly cause: InvalidRequestReason | NoRouteReason | AuthenticationReason | RateLimitReason | QuotaExceededReason | ContentPolicyReason | ProviderInternalReason | TransportReason | InvalidProviderOutputReason | UnknownProviderReason;
     get message(): string;
 }

package/dist/schema/errors.js

@@ -2,25 +2,25 @@ import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids";
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"]);
-export class HttpRequestDetails extends Schema.Class("LLM.HttpRequestDetails")({
+export class HttpRequestDetails extends Schema.Class("AI.HttpRequestDetails")({
     method: Schema.String,
     url: Schema.String,
     headers: Schema.Record(Schema.String, Schema.String),
 }) {
 }
-export class HttpResponseDetails extends Schema.Class("LLM.HttpResponseDetails")({
+export class HttpResponseDetails extends Schema.Class("AI.HttpResponseDetails")({
     status: Schema.Number,
     headers: Schema.Record(Schema.String, Schema.String),
 }) {
 }
-export class HttpRateLimitDetails extends Schema.Class("LLM.HttpRateLimitDetails")({
+export class HttpRateLimitDetails extends Schema.Class("AI.HttpRateLimitDetails")({
     retryAfterMs: Schema.optional(Schema.Number),
     limit: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     remaining: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {
 }
-export class HttpContext extends Schema.Class("LLM.HttpContext")({
+export class HttpContext extends Schema.Class("AI.HttpContext")({
     request: HttpRequestDetails,
     response: Schema.optional(HttpResponseDetails),
     body: Schema.optional(Schema.String),
@@ -29,7 +29,7 @@ export class HttpContext extends Schema.Class("LLM.HttpContext")({
     rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {
 }
-export class InvalidRequestReason extends Schema.Class("LLM.Error.InvalidRequest")({
+export class InvalidRequestReason extends Schema.Class("AI.Error.InvalidRequest")({
     _tag: Schema.tag("InvalidRequest"),
     message: Schema.String,
     parameter: Schema.optional(Schema.String),
@@ -38,17 +38,17 @@ export class InvalidRequestReason extends Schema.Class("LLM.Error.InvalidRequest
     http: Schema.optional(HttpContext),
 }) {
 }
-export class NoRouteReason extends Schema.Class("LLM.Error.NoRoute")({
+export class NoRouteReason extends Schema.Class("AI.Error.NoRoute")({
     _tag: Schema.tag("NoRoute"),
     route: RouteID,
     provider: ProviderID,
     model: ModelID,
 }) {
     get message() {
-        return `No LLM route for ${this.provider}/${this.model} using ${this.route}`;
+        return `No AI route for ${this.provider}/${this.model} using ${this.route}`;
     }
 }
-export class AuthenticationReason extends Schema.Class("LLM.Error.Authentication")({
+export class AuthenticationReason extends Schema.Class("AI.Error.Authentication")({
     _tag: Schema.tag("Authentication"),
     message: Schema.String,
     kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
@@ -56,7 +56,7 @@ export class AuthenticationReason extends Schema.Class("LLM.Error.Authentication
     http: Schema.optional(HttpContext),
 }) {
 }
-export class RateLimitReason extends Schema.Class("LLM.Error.RateLimit")({
+export class RateLimitReason extends Schema.Class("AI.Error.RateLimit")({
     _tag: Schema.tag("RateLimit"),
     message: Schema.String,
     retryAfterMs: Schema.optional(Schema.Number),
@@ -65,21 +65,21 @@ export class RateLimitReason extends Schema.Class("LLM.Error.RateLimit")({
     http: Schema.optional(HttpContext),
 }) {
 }
-export class QuotaExceededReason extends Schema.Class("LLM.Error.QuotaExceeded")({
+export class QuotaExceededReason extends Schema.Class("AI.Error.QuotaExceeded")({
     _tag: Schema.tag("QuotaExceeded"),
     message: Schema.String,
     providerMetadata: Schema.optional(ProviderMetadata),
     http: Schema.optional(HttpContext),
 }) {
 }
-export class ContentPolicyReason extends Schema.Class("LLM.Error.ContentPolicy")({
+export class ContentPolicyReason extends Schema.Class("AI.Error.ContentPolicy")({
     _tag: Schema.tag("ContentPolicy"),
     message: Schema.String,
     providerMetadata: Schema.optional(ProviderMetadata),
     http: Schema.optional(HttpContext),
 }) {
 }
-export class ProviderInternalReason extends Schema.Class("LLM.Error.ProviderInternal")({
+export class ProviderInternalReason extends Schema.Class("AI.Error.ProviderInternal")({
     _tag: Schema.tag("ProviderInternal"),
     message: Schema.String,
     status: Schema.optional(Schema.Number),
@@ -88,7 +88,7 @@ export class ProviderInternalReason extends Schema.Class("LLM.Error.ProviderInte
     http: Schema.optional(HttpContext),
 }) {
 }
-export class TransportReason extends Schema.Class("LLM.Error.Transport")({
+export class TransportReason extends Schema.Class("AI.Error.Transport")({
     _tag: Schema.tag("Transport"),
     message: Schema.String,
     kind: Schema.optional(Schema.String),
@@ -96,7 +96,7 @@ export class TransportReason extends Schema.Class("LLM.Error.Transport")({
     http: Schema.optional(HttpContext),
 }) {
 }
-export class InvalidProviderOutputReason extends Schema.Class("LLM.Error.InvalidProviderOutput")({
+export class InvalidProviderOutputReason extends Schema.Class("AI.Error.InvalidProviderOutput")({
     _tag: Schema.tag("InvalidProviderOutput"),
     message: Schema.String,
     route: Schema.optional(Schema.String),
@@ -104,7 +104,7 @@ export class InvalidProviderOutputReason extends Schema.Class("LLM.Error.Invalid
     providerMetadata: Schema.optional(ProviderMetadata),
 }) {
 }
-export class UnknownProviderReason extends Schema.Class("LLM.Error.UnknownProvider")({
+export class UnknownProviderReason extends Schema.Class("AI.Error.UnknownProvider")({
     _tag: Schema.tag("UnknownProvider"),
     message: Schema.String,
     status: Schema.optional(Schema.Number),
@@ -112,7 +112,7 @@ export class UnknownProviderReason extends Schema.Class("LLM.Error.UnknownProvid
     http: Schema.optional(HttpContext),
 }) {
 }
-export const LLMErrorReason = Schema.Union([
+export const AIErrorReason = Schema.Union([
     InvalidRequestReason,
     NoRouteReason,
     AuthenticationReason,
@@ -124,10 +124,10 @@ export const LLMErrorReason = Schema.Union([
     InvalidProviderOutputReason,
     UnknownProviderReason,
 ]).pipe(Schema.toTaggedUnion("_tag"));
-export class LLMError extends Schema.TaggedErrorClass()("LLM.Error", {
+export class AIError extends Schema.TaggedErrorClass()("AI.Error", {
     module: Schema.String,
     method: Schema.String,
-    reason: LLMErrorReason,
+    reason: AIErrorReason,
 }) {
     cause = this.reason;
     get message() {

package/dist/schema/events.js

@@ -47,7 +47,7 @@ import { ProviderFailureClassification } from "./errors";
  * — for fields we don't normalize and for billing-level audit trails.
  * Matches the same escape-hatch field on `LLMEvent`.
  */
-export class Usage extends Schema.Class("LLM.Usage")({
+export class Usage extends Schema.Class("AI.Usage")({
     inputTokens: Schema.optional(Schema.Number),
     outputTokens: Schema.optional(Schema.Number),
     nonCachedInputTokens: Schema.optional(Schema.Number),

package/dist/schema/ids.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { ProviderMetadata } from "@opencode-ai/schema/llm";
+import { ProviderMetadata } from "@opencode-ai/schema/ai";
 export { ProviderMetadata };
 /** Stable string identifier for a protocol implementation. */
 export declare const ProtocolID: Schema.String;
@@ -7,9 +7,9 @@ export type ProtocolID = Schema.Schema.Type<typeof ProtocolID>;
 /** Stable string identifier for the runnable route. */
 export declare const RouteID: Schema.String;
 export type RouteID = Schema.Schema.Type<typeof RouteID>;
-export declare const ModelID: Schema.brand<Schema.String, "LLM.ModelID">;
+export declare const ModelID: Schema.brand<Schema.String, "AI.ModelID">;
 export type ModelID = typeof ModelID.Type;
-export declare const ProviderID: Schema.brand<Schema.String, "LLM.ProviderID">;
+export declare const ProviderID: Schema.brand<Schema.String, "AI.ProviderID">;
 export type ProviderID = typeof ProviderID.Type;
 export declare const ResponseID: Schema.String;
 export type ResponseID = Schema.Schema.Type<typeof ResponseID>;

package/dist/schema/ids.js

@@ -1,12 +1,13 @@
 import { Schema } from "effect";
-import { LLM, ProviderMetadata } from "@opencode-ai/schema/llm";
+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. */
 export const RouteID = Schema.String;
-export const ModelID = Schema.String.pipe(Schema.brand("LLM.ModelID"));
-export const ProviderID = Schema.String.pipe(Schema.brand("LLM.ProviderID"));
+export const ModelID = Schema.String.pipe(Schema.brand("AI.ModelID"));
+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;

package/dist/schema/messages.d.ts

@@ -336,11 +336,11 @@ 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").Model<{
+    readonly model: Schema.declare<import("./options").LanguageModel<{
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
-    }>, import("./options").Model<{
+    }>, import("./options").LanguageModel<{
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };

package/dist/schema/messages.js

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { JsonSchema, MessageRole, ProviderMetadata } from "./ids";
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, ModelSchema, ProviderOptions } from "./options";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, LanguageModelSchema, ProviderOptions } from "./options";
 import { isRecord } from "../utils/record";
 const systemPartSchema = Schema.Struct({
     type: Schema.Literal("text"),
@@ -202,7 +202,7 @@ export class ToolChoice extends Schema.Class("LLM.ToolChoice")({
 })(ToolChoice || (ToolChoice = {}));
 export class LLMRequest extends Schema.Class("LLM.Request")({
     id: Schema.optional(Schema.String),
-    model: ModelSchema,
+    model: LanguageModelSchema,
     system: Schema.Array(SystemPart),
     messages: Schema.Array(Message),
     tools: Schema.Array(ToolDefinition),

package/dist/schema/options.d.ts

@@ -47,86 +47,86 @@ export type GenerationOptionsFields = {
 };
 export type GenerationOptionsInput = GenerationOptions | GenerationOptionsFields;
 export declare const mergeGenerationOptions: (...items: ReadonlyArray<GenerationOptionsInput | undefined>) => GenerationOptions | undefined;
-declare const ModelLimits_base: Schema.Class<ModelLimits, Schema.Struct<{
+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 ModelLimits extends ModelLimits_base {
+export declare class LanguageModelLimits extends LanguageModelLimits_base {
 }
-export declare namespace ModelLimits {
-    type Input = ModelLimits | ConstructorParameters<typeof ModelLimits>[0];
-    /** Normalize model limit input into the canonical `ModelLimits` class. */
-    const make: (input: Input | undefined) => ModelLimits;
+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 ModelDefaults_base: Schema.Class<ModelDefaults, Schema.Struct<{
-    readonly limits: Schema.optional<typeof ModelLimits>;
+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 http: Schema.optional<typeof HttpOptions>;
 }>, {}>;
-export declare class ModelDefaults extends ModelDefaults_base {
+export declare class LanguageModelDefaults extends LanguageModelDefaults_base {
 }
-export declare namespace ModelDefaults {
-    type Input = ModelDefaults | {
-        readonly limits?: ModelLimits.Input;
+export declare namespace LanguageModelDefaults {
+    type Input = LanguageModelDefaults | {
+        readonly limits?: LanguageModelLimits.Input;
         readonly generation?: GenerationOptions.Input;
         readonly providerOptions?: ProviderOptions;
         readonly http?: HttpOptions.Input;
     };
     /** Normalize selected-model request defaults without applying precedence. */
-    const make: (input: Input) => ModelDefaults;
+    const make: (input: Input) => LanguageModelDefaults;
 }
-export declare const ModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
-export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSchemaCompatibility>;
-export declare const ModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
-export type ModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof ModelMaxTokensFieldCompatibility>;
-declare const ModelCompatibility_base: Schema.Class<ModelCompatibility, Schema.Struct<{
+export declare const LanguageModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
+export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>;
+export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
+export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
+declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
     readonly toolSchema: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot"]>>;
     readonly reasoningField: Schema.optional<Schema.String>;
     readonly maxTokensField: Schema.optional<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>;
 }>, {}>;
-export declare class ModelCompatibility extends ModelCompatibility_base {
+export declare class LanguageModelCompatibility extends LanguageModelCompatibility_base {
 }
-export declare namespace ModelCompatibility {
-    type Input = ModelCompatibility | ConstructorParameters<typeof ModelCompatibility>[0];
+export declare namespace LanguageModelCompatibility {
+    type Input = LanguageModelCompatibility | ConstructorParameters<typeof LanguageModelCompatibility>[0];
     /** Normalize model/upstream compatibility metadata without projecting requests. */
-    const make: (input: Input) => ModelCompatibility;
+    const make: (input: Input) => LanguageModelCompatibility;
 }
-export declare class Model<Options extends ProviderOptions = ProviderOptions> {
+export declare class LanguageModel<Options extends ProviderOptions = ProviderOptions> {
     protected readonly _ProviderOptions: Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
     readonly route: AnyRoute;
-    readonly defaults?: ModelDefaults;
-    readonly compatibility?: ModelCompatibility;
-    constructor(input: Model.ConstructorInput);
-    static make<Options extends ProviderOptions = ProviderOptions>(input: Model.Input): Model<Options>;
-    static input<Options extends ProviderOptions>(model: Model<Options>): Model.ConstructorInput;
-    static update<Options extends ProviderOptions>(model: Model<Options>, patch: Partial<Model.Input>): Model<Options>;
+    readonly defaults?: LanguageModelDefaults;
+    readonly compatibility?: LanguageModelCompatibility;
+    constructor(input: LanguageModel.ConstructorInput);
+    static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input): LanguageModel<Options>;
+    static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput;
+    static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>): LanguageModel<Options>;
 }
-export declare namespace Model {
+export declare namespace LanguageModel {
     type ConstructorInput = {
         readonly id: ModelID;
         readonly provider: ProviderID;
         readonly route: AnyRoute;
-        readonly defaults?: ModelDefaults;
-        readonly compatibility?: ModelCompatibility;
+        readonly defaults?: LanguageModelDefaults;
+        readonly compatibility?: LanguageModelCompatibility;
     };
     type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
         readonly id: string | ModelID;
         readonly provider: string | ProviderID;
-        readonly defaults?: ModelDefaults.Input;
-        readonly compatibility?: ModelCompatibility.Input;
+        readonly defaults?: LanguageModelDefaults.Input;
+        readonly compatibility?: LanguageModelCompatibility.Input;
     };
 }
-export type ModelInput = Model.Input;
-export type ModelProviderOptions<SelectedModel> = SelectedModel extends Model<infer Options> ? Options : never;
-export declare const ModelSchema: Schema.declare<Model<{
+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;
     };
-}>, Model<{
+}>, LanguageModel<{
     readonly [x: string]: {
         readonly [x: string]: unknown;
     };