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

package/dist/protocols/shared.js

@@ -3,7 +3,7 @@ import { Tool } from "@opencode-ai/schema/tool";
 import { Effect, Schema, Stream } from "effect";
 import * as Sse from "effect/unstable/encoding/Sse";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { InvalidProviderOutputReason, InvalidRequestReason, LLMError, } from "../schema";
+import { InvalidProviderOutputReason, InvalidRequestReason, AIError, } from "../schema";
 import { isRecord } from "../utils/record";
 export { isRecord };
 export const Json = Schema.fromJsonString(Schema.Unknown);
@@ -19,7 +19,7 @@ export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
  * 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
@@ -63,7 +63,7 @@ export const sumTokens = (...values) => {
         return undefined;
     return values.reduce((acc, value) => acc + (value ?? 0), 0);
 };
-export const eventError = (route, message, raw) => new LLMError({
+export const eventError = (route, message, raw) => new AIError({
     module: "ProviderShared",
     method: "stream",
     reason: new InvalidProviderOutputReason({ route, message, raw }),
@@ -185,7 +185,7 @@ export const errorText = (error) => {
  * `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 const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipeThroughChannel(Sse.decode()), Stream.catchTag("Retry", () => Stream.empty), Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"), Stream.map((event) => event.data));
 /**
@@ -195,7 +195,7 @@ export const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipe
  * `InvalidRequestReason` with route context or trace metadata, the change
  * lands here.
  */
-export const invalidRequest = (message) => new LLMError({
+export const invalidRequest = (message) => new AIError({
     module: "ProviderShared",
     method: "request",
     reason: new InvalidRequestReason({ message }),
@@ -224,7 +224,7 @@ export const unsupportedContent = (route, role, types) => invalidRequest(`${rout
  * 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 const validateWith = (decode) => (payload) => decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)));
 /**

package/dist/protocols/utils/bedrock-media.d.ts

@@ -45,5 +45,5 @@ export declare const lower: (part: {
             bytes: string;
         };
     };
-}, import("../..").LLMError, never>;
+}, import("../..").AIError, never>;
 export * as BedrockMedia from "./bedrock-media";

package/dist/protocols/utils/image-input.d.ts

@@ -1,14 +1,14 @@
 import { Effect } from "effect";
 import type { ImageInput } from "../../image";
-import { LLMError } from "../../schema";
+import { AIError } from "../../schema";
 export declare const dataUrl: (input: Extract<ImageInput, {
     readonly type: "bytes";
 }>) => string;
 export declare const decodeDataUrl: (url: string, module: string) => Effect.Effect<{
     readonly mediaType: string;
     readonly data: Uint8Array;
-} | undefined, LLMError>;
-export declare const invalidImageInput: (module: string, message: string) => LLMError;
+} | undefined, AIError>;
+export declare const invalidImageInput: (module: string, message: string) => AIError;
 export declare const ImageInputs: {
     readonly dataUrl: (input: Extract<ImageInput, {
         readonly type: "bytes";
@@ -16,6 +16,6 @@ export declare const ImageInputs: {
     readonly decodeDataUrl: (url: string, module: string) => Effect.Effect<{
         readonly mediaType: string;
         readonly data: Uint8Array;
-    } | undefined, LLMError>;
-    readonly invalid: (module: string, message: string) => LLMError;
+    } | undefined, AIError>;
+    readonly invalid: (module: string, message: string) => AIError;
 };

package/dist/protocols/utils/image-input.js

@@ -1,6 +1,6 @@
 import { Effect, Encoding } from "effect";
-import { InvalidRequestReason, LLMError } from "../../schema";
-const invalid = (module, message) => new LLMError({
+import { InvalidRequestReason, AIError } from "../../schema";
+const invalid = (module, message) => new AIError({
     module,
     method: "generate",
     reason: new InvalidRequestReason({ message }),

package/dist/protocols/utils/tool-schema.d.ts

@@ -1,7 +1,7 @@
-import type { JsonSchema, ModelToolSchemaCompatibility } from "../../schema";
+import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema";
 export declare const ToolSchemaProjection: {
     readonly gemini: (schema: JsonSchema) => JsonSchema;
-    readonly modelCompatibility: (schema: JsonSchema, compatibility: ModelToolSchemaCompatibility | undefined) => JsonSchema;
+    readonly modelCompatibility: (schema: JsonSchema, compatibility: LanguageModelToolSchemaCompatibility | undefined) => JsonSchema;
     readonly moonshot: (schema: JsonSchema) => JsonSchema;
     readonly openAI: (schema: JsonSchema) => JsonSchema;
     readonly responses: (schema: JsonSchema) => JsonSchema;

package/dist/protocols/utils/tool-stream.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { LLMError, LLMEvent, type ProviderMetadata } from "../../schema";
+import { AIError, LLMEvent, type ProviderMetadata } from "../../schema";
 import { type ToolAccumulator } from "../shared";
 type StreamKey = string | number;
 /**
@@ -33,7 +33,7 @@ export interface AppendOutcome<K extends StreamKey> {
 }
 /** Create empty accumulator state for one provider stream. */
 export declare const empty: <K extends StreamKey>() => State<K>;
-export declare const isError: <K extends StreamKey>(result: AppendOutcome<K> | LLMError) => result is LLMError;
+export declare const isError: <K extends StreamKey>(result: AppendOutcome<K> | AIError) => result is AIError;
 /**
  * Register a tool call whose start event arrived before any argument deltas.
  * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and
@@ -52,13 +52,13 @@ export declare const appendOrStart: <K extends StreamKey>(route: string, tools:
     readonly id?: string;
     readonly name?: string;
     readonly text: string;
-}, missingToolMessage: string) => AppendOutcome<K> | LLMError;
+}, missingToolMessage: string) => AppendOutcome<K> | AIError;
 /**
  * Append argument text to a tool that must already have been started. This keeps
  * protocols honest when their stream grammar promises a start event before any
  * argument delta.
  */
-export declare const appendExisting: <K extends StreamKey>(route: string, tools: State<K>, key: K, text: string, missingToolMessage: string) => AppendOutcome<K> | LLMError;
+export declare const appendExisting: <K extends StreamKey>(route: string, tools: State<K>, key: K, text: string, missingToolMessage: string) => AppendOutcome<K> | AIError;
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
  * from state, and return either a call or a non-executable local input error.
@@ -252,7 +252,7 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
         } | undefined;
         readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
-}, LLMError, never>;
+}, AIError, never>;
 /**
  * Finalize one pending tool call with an authoritative final input string.
  * OpenAI Responses can send accumulated deltas and then repeat the completed
@@ -445,7 +445,7 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
         } | undefined;
         readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
-}, LLMError, never>;
+}, AIError, never>;
 /**
  * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
  * not emit per-tool stop events, so all accumulated calls finish independently
@@ -635,5 +635,5 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
         } | undefined;
         readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
-}, LLMError, never>;
+}, AIError, never>;
 export * as ToolStream from "./tool-stream";

package/dist/protocols/utils/tool-stream.js

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { LLMError, LLMEvent } from "../../schema";
+import { AIError, LLMEvent } from "../../schema";
 import { eventError, parseToolInput } from "../shared";
 /** Create empty accumulator state for one provider stream. */
 export const empty = () => ({});
@@ -54,7 +54,7 @@ const appendTool = (tools, key, tool, text) => {
         events,
     };
 };
-export const isError = (result) => result instanceof LLMError;
+export const isError = (result) => result instanceof AIError;
 /**
  * Register a tool call whose start event arrived before any argument deltas.
  * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and

package/dist/protocols/xai-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, optionalNull } from "./shared";
 import { ImageInputs } from "./utils/image-input";
 const ADAPTER = "xai-images";
@@ -28,7 +28,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/zai-images.js

@@ -2,7 +2,7 @@ import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { GeneratedImage, ImageModel, ImageResponse } from "../image";
 import { Auth } from "../route/auth";
-import { InvalidProviderOutputReason, LLMError, mergeHttpOptions, mergeJsonRecords } from "../schema";
+import { InvalidProviderOutputReason, AIError, mergeHttpOptions, mergeJsonRecords } from "../schema";
 import { ProviderShared } from "./shared";
 import { ImageInputs } from "./utils/image-input";
 const ADAPTER = "zai-images";
@@ -27,7 +27,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/provider-error.d.ts

@@ -1,4 +1,4 @@
-import { LLMError, type HttpContext, type HttpRateLimitDetails, type ProviderMetadata } from "./schema";
+import { AIError, type HttpContext, type HttpRateLimitDetails, type ProviderMetadata } from "./schema";
 export declare const isContextOverflow: (message: string) => boolean;
 export declare const isPayloadTooLarge: (message: string) => boolean;
 export declare const isContextOverflowFailure: (failure: unknown) => boolean;
@@ -11,4 +11,4 @@ export interface ProviderFailure {
     readonly http?: HttpContext | undefined;
     readonly providerMetadata?: ProviderMetadata | undefined;
 }
-export declare function classifyProviderFailure(input: ProviderFailure): LLMError["reason"];
+export declare function classifyProviderFailure(input: ProviderFailure): AIError["reason"];

package/dist/provider-error.js

@@ -1,5 +1,5 @@
 import { Option, Schema } from "effect";
-import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, LLMError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema";
+import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, AIError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema";
 const patterns = [
     /prompt is too long/i,
     /input is too long for requested model/i,
@@ -32,7 +32,7 @@ const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i,
 export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
     (patterns.some((pattern) => pattern.test(message)) || /^400\s*(status code)?\s*\(no body\)/i.test(message));
 export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) => pattern.test(message));
-export const isContextOverflowFailure = (failure) => failure instanceof LLMError
+export const isContextOverflowFailure = (failure) => failure instanceof AIError
     ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
 const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);

package/dist/provider-package.d.ts

@@ -1,4 +1,4 @@
-import type { Model, ProviderOptions } from "./schema";
+import type { LanguageModel, ProviderOptions } from "./schema";
 export interface Settings extends Readonly<Record<string, unknown>> {
     readonly baseURL?: string;
     readonly headers?: Readonly<Record<string, string>>;
@@ -10,6 +10,6 @@ export interface Settings extends Readonly<Record<string, unknown>> {
     };
 }
 export interface Definition<ProviderSettings extends Settings = Settings, Options extends ProviderOptions = ProviderOptions> {
-    readonly model: (modelID: string, settings: ProviderSettings) => Model<Options>;
+    readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>;
 }
 export * as ProviderPackage from "./provider-package";

package/dist/provider.d.ts

@@ -1,22 +1,22 @@
-import type { Model, ModelID, ProviderID } from "./schema";
-export type ModelOptions = Pick<Model.Input, "defaults" | "compatibility">;
+import type { LanguageModel, ModelID, ProviderID } from "./schema";
+export type LanguageModelOptions = Pick<LanguageModel.Input, "defaults" | "compatibility">;
 /**
  * Advanced structural provider definition helper. Built-in providers should
  * prefer explicit `configure(options).model(id)` facades so deployment config is
  * chosen before model selection. The optional `apis` map remains for external
  * structural providers that expose multiple route selectors behind one provider.
  */
-export type ModelFactory<Options extends ModelOptions = ModelOptions> = (id: string | ModelID, options?: Options) => Model;
-type AnyModelFactory = (...args: never[]) => Model;
-export interface Definition<Factory extends AnyModelFactory = ModelFactory> {
+export type LanguageModelFactory<Options extends LanguageModelOptions = LanguageModelOptions> = (id: string | ModelID, options?: Options) => LanguageModel;
+type AnyLanguageModelFactory = (...args: never[]) => LanguageModel;
+export interface Definition<Factory extends AnyLanguageModelFactory = LanguageModelFactory> {
     readonly id: ProviderID;
     readonly model: Factory;
-    readonly apis?: Record<string, AnyModelFactory>;
+    readonly apis?: Record<string, AnyLanguageModelFactory>;
 }
 type DefinitionShape = {
     readonly id: ProviderID;
-    readonly model: (...args: never[]) => Model;
-    readonly apis?: Record<string, (...args: never[]) => Model>;
+    readonly model: (...args: never[]) => LanguageModel;
+    readonly apis?: Record<string, (...args: never[]) => LanguageModel>;
 };
 type NoExtraFields<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
 export declare const make: <DefinitionType extends DefinitionShape>(definition: NoExtraFields<DefinitionType, DefinitionShape>) => NoExtraFields<DefinitionType, DefinitionShape>;

package/dist/providers/amazon-bedrock.d.ts

@@ -2,7 +2,7 @@ import type { RouteDefaultsInput } from "../route/client";
 import type { ProviderPackage } from "../provider-package";
 import { type ModelID } from "../schema";
 import type { BedrockCredentials } from "../protocols/bedrock-converse";
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & {
     readonly apiKey?: string;
     readonly headers?: Record<string, string>;
@@ -144,8 +144,8 @@ export declare const routes: import("../route").Route<{
     } | undefined;
 }, import("../route/transport/http").HttpPrepared<object>>[];
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<{
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<{
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
@@ -153,15 +153,15 @@ export declare const configure: (input?: Config) => {
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<{
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<{
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     }>;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<{
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<{
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };

package/dist/providers/anthropic-compatible.d.ts

@@ -6,7 +6,7 @@ import { type ModelID } from "../schema";
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
 export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly provider?: string;
     readonly baseURL: string;
@@ -202,15 +202,15 @@ export declare const routes: import("../route").Route<{
     } | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/anthropic.d.ts

@@ -6,7 +6,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages";
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
 export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export declare const routes: import("../route").Route<{
     readonly model: string;
     readonly messages: readonly ({
@@ -200,16 +200,16 @@ export type Settings = ProviderPackage.Settings & ({
     readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/azure.d.ts

@@ -3,18 +3,18 @@ import type { Route as RouteDef, RouteDefaultsInput } from "../route/client";
 import type { ProviderPackage } from "../provider-package";
 import { type ModelID } from "../schema";
 import { type OpenAIProviderOptionsInput } from "./openai-options";
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 type AzureURL = AtLeastOne<{
     readonly resourceName: string;
     readonly baseURL: string;
 }>;
-export type ModelOptions = AzureURL & RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+export type LanguageModelOptions = AzureURL & RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly apiVersion?: string;
     readonly queryParams?: Record<string, string>;
     readonly useCompletionUrls?: boolean;
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
-export type Config = ModelOptions;
+export type Config = LanguageModelOptions;
 export type Settings = ProviderPackage.Settings & AzureURL & {
     readonly apiKey?: string;
     readonly apiVersion?: string;
@@ -224,23 +224,23 @@ export declare const routes: (RouteDef<{
     readonly max_output_tokens?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>)[];
 export declare const configure: (input: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
     configure: (input: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const model: (modelID: string, settings: Settings) => import("..").Model<OpenAIProviderOptionsInput>;
+export declare const model: (modelID: string, settings: Settings) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
 export {};

package/dist/providers/cloudflare.d.ts

@@ -3,8 +3,8 @@ import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
 import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
 import type { OpenAIProviderOptionsInput } from "./openai-options";
-export declare const aiGatewayID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-export declare const workersAIID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const aiGatewayID: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export declare const workersAIID: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export declare const aiGatewayAuthEnvVars: readonly ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"];
 export declare const workersAIAuthEnvVars: readonly ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"];
 type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>;
@@ -317,18 +317,18 @@ export declare const routes: import("../route").Route<{
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const CloudflareAIGateway: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (options: AIGatewayOptions) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
 export declare const CloudflareWorkersAI: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (options: WorkersAIOptions) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/github-copilot.d.ts

@@ -2,13 +2,13 @@ import { type ProviderAuthOption } from "../route/auth-options";
 import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
 import { type OpenAIProviderOptionsInput } from "./openai-options";
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL: string;
     readonly endpoint?: "chat" | "responses";
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
-export declare const shouldUseResponsesApi: (modelID: string | ModelID, endpoint?: ModelOptions["endpoint"]) => boolean;
+export declare const shouldUseResponsesApi: (modelID: string | ModelID, endpoint?: LanguageModelOptions["endpoint"]) => boolean;
 export declare const routes: (import("../route").Route<{
     readonly model: string;
     readonly messages: readonly ({
@@ -211,20 +211,20 @@ export declare const routes: (import("../route").Route<{
     readonly prompt_cache_key?: string | undefined;
     readonly max_output_tokens?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>)[];
-export declare const configure: (options: ModelOptions) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    configure: (options: ModelOptions) => /*elided*/ any;
+export declare const configure: (options: LanguageModelOptions) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    configure: (options: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    configure: (options: ModelOptions) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    configure: (options: LanguageModelOptions) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-chat.d.ts

@@ -3,7 +3,7 @@ import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
 import { GoogleVertexShared } from "./google-vertex-shared";
 import type { OpenAIProviderOptionsInput } from "./openai-options";
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
     readonly baseURL?: string;
     readonly location?: string;
@@ -115,15 +115,15 @@ export declare const routes: import("../route").Route<{
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google-vertex-messages.d.ts

@@ -6,7 +6,7 @@ import { GoogleVertexShared } from "./google-vertex-shared";
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
 export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
     readonly baseURL?: string;
     readonly location?: string;
@@ -200,15 +200,15 @@ export declare const routes: Route<{
     } | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<AnthropicMessages.ProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };