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

package/dist/providers/google-vertex-responses.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 { OpenResponsesProviderOptionsInput } from "./open-responses-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;
@@ -107,15 +107,15 @@ export declare const routes: import("../route").Route<{
     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<OpenResponsesProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenResponsesProviderOptionsInput>;
     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<OpenResponsesProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenResponsesProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

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

@@ -5,7 +5,7 @@ import { type ModelID } from "../schema";
 import { GoogleVertexShared } from "./google-vertex-shared";
 export type GeminiOptionsInput = Gemini.OptionsInput;
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
-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.ApiKeyOptions & {
     readonly baseURL?: string;
     readonly location?: string;
@@ -97,15 +97,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<Gemini.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<Gemini.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<Gemini.ProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<Gemini.ProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/google.d.ts

@@ -6,7 +6,7 @@ import { Gemini } from "../protocols/gemini";
 export type { GoogleImageOptions } from "../protocols/google-images";
 export type GeminiOptionsInput = Gemini.OptionsInput;
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
-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 contents: readonly {
         readonly role: "user" | "model";
@@ -89,18 +89,18 @@ export interface Settings extends ProviderPackage.Settings {
     readonly providerOptions?: Gemini.ProviderOptionsInput;
 }
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<Gemini.ProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<Gemini.ProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<Gemini.ProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<Gemini.ProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
         configure: /*elided*/ any;
     };

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

@@ -4,7 +4,7 @@ import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options";
 export type { OpenResponsesOptionsInput, OpenResponsesProviderOptionsInput } from "./open-responses-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 & ProviderAuthOption<"optional"> & {
     readonly provider?: string;
     readonly baseURL: string;
@@ -105,15 +105,15 @@ export declare const routes: import("../route").Route<{
     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<OpenResponsesProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenResponsesProviderOptionsInput>;
     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<OpenResponsesProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenResponsesProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

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

@@ -3,7 +3,7 @@ import type { RouteDefaultsInput } from "../route/client";
 import { type ProviderAuthOption } from "../route/auth-options";
 import type { ProviderPackage } from "../provider-package";
 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 GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly provider?: string;
     readonly baseURL: string;
@@ -115,52 +115,52 @@ export declare const routes: import("../route").Route<{
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export declare const configure: (input: GenericModelOptions) => {
-    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: GenericModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input: GenericModelOptions) => {
-        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 model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const baseten: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const cerebras: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepinfra: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const deepseek: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const fireworks: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const groq: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export declare const togetherai: {
-    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?: FamilyModelOptions) => /*elided*/ any;
 };
 export {};

package/dist/providers/openai.d.ts

@@ -6,7 +6,7 @@ import { type OpenAIProviderOptionsInput } from "./openai-options";
 import { type OpenAIImageString } from "../protocols/openai-images";
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options";
 export type { OpenAIImageOptions } from "../protocols/openai-images";
-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: (Route<{
     readonly model: string;
     readonly messages: readonly ({
@@ -341,34 +341,34 @@ export interface Settings extends ProviderPackage.Settings {
     readonly providerOptions?: OpenAIProviderOptionsInput;
 }
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responses: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responsesWebSocket: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    chat: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-    chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responses: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    responsesWebSocket: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+    chat: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-        chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        responses: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        responsesWebSocket: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+        chat: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
 export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
-export declare const responses: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-export declare const responsesWebSocket: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
-export declare const chat: (id: string | ModelID) => import("..").Model<OpenAIProviderOptionsInput>;
+export declare const responses: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+export declare const responsesWebSocket: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
+export declare const chat: (id: string | ModelID) => import("..").LanguageModel<OpenAIProviderOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;

package/dist/providers/openrouter.d.ts

@@ -9,7 +9,7 @@ export declare const profile: {
     readonly provider: "openrouter";
     readonly baseURL: "https://openrouter.ai/api/v1";
 };
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 type OpenRouterString<Known extends string> = Known | (string & {});
 export interface OpenRouterProviderRouting {
     readonly [key: string]: unknown;
@@ -80,7 +80,7 @@ export interface OpenRouterOptions {
 export type OpenRouterProviderOptionsInput = ProviderOptions & {
     readonly openrouter?: OpenRouterOptions;
 };
-export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: OpenRouterProviderOptionsInput;
 };
@@ -511,17 +511,17 @@ export declare const routes: Route<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>[];
-export declare const configure: (input?: ModelOptions) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
-    configure: (input?: ModelOptions) => /*elided*/ any;
+export declare const configure: (input?: LanguageModelOptions) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenRouterProviderOptionsInput>;
+    configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
-    configure: (input?: ModelOptions) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<OpenRouterProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<OpenRouterProviderOptionsInput>;
+    configure: (input?: LanguageModelOptions) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<OpenRouterProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };

package/dist/providers/xai.d.ts

@@ -3,11 +3,11 @@ import { Route, type RouteDefaultsInput } from "../route/client";
 import { type ModelID, type ProviderOptions } from "../schema";
 import type { OpenAIOptionsInput } from "./openai-options";
 import type { ProviderPackage } from "../provider-package";
-export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type XAIProviderOptionsInput = ProviderOptions & {
     readonly xai?: OpenAIOptionsInput;
 };
-export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: XAIProviderOptionsInput;
 };
@@ -219,30 +219,30 @@ export declare const routes: (Route<{
     readonly prompt_cache_key?: string | undefined;
     readonly max_output_tokens?: number | undefined;
 }, import("../route/transport/http").HttpPrepared<string>>)[];
-export declare const configure: (input?: ModelOptions) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
+export declare const configure: (input?: LanguageModelOptions) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
-    configure: (input?: ModelOptions) => /*elided*/ any;
+    configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-    model: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-    responses: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-    chat: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+    responses: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+    chat: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
-    configure: (input?: ModelOptions) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
-        model: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-        responses: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-        chat: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
+    configure: (input?: LanguageModelOptions) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+        responses: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+        chat: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"];
-export declare const responses: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
-export declare const chat: (modelID: string | ModelID) => import("..").Model<XAIProviderOptionsInput>;
+export declare const responses: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
+export declare const chat: (modelID: string | ModelID) => import("..").LanguageModel<XAIProviderOptionsInput>;
 export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;

package/dist/providers/zai.d.ts

@@ -1,6 +1,6 @@
 import { type ProviderAuthOption } from "../route/auth-options";
 import { HttpOptions, type ModelID } from "../schema";
-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 = ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly headers?: Record<string, string>;
@@ -8,15 +8,15 @@ export type Config = ProviderAuthOption<"optional"> & {
 };
 export type { ZAIImageOptions } from "../protocols/zai-images";
 export declare const configure: (input?: Config) => {
-    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./zai").ZAIImageOptions>;
     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">;
     image: (modelID: string | ModelID) => import("..").ImageModel<import("./zai").ZAIImageOptions>;
     configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         image: (modelID: string | ModelID) => import("..").ImageModel<import("./zai").ZAIImageOptions>;
         configure: /*elided*/ any;
     };

package/dist/route/auth-options.d.ts

@@ -14,9 +14,9 @@ export type RequiredApiKeyAuth = {
     readonly auth?: never;
 };
 export type ProviderAuthOption<Mode extends ApiKeyMode> = AuthOverride | (Mode extends "optional" ? OptionalApiKeyAuth : RequiredApiKeyAuth);
-export type ModelOptions<Base, Mode extends ApiKeyMode> = Omit<Base, "apiKey" | "auth"> & ProviderAuthOption<Mode>;
-export type ModelArgs<Base, Mode extends ApiKeyMode> = Mode extends "optional" ? readonly [options?: ModelOptions<Base, Mode>] : readonly [options: ModelOptions<Base, Mode>];
-export type ModelFactory<Base, Mode extends ApiKeyMode, Model> = (id: string, ...args: ModelArgs<Base, Mode>) => Model;
+export type LanguageModelOptions<Base, Mode extends ApiKeyMode> = Omit<Base, "apiKey" | "auth"> & ProviderAuthOption<Mode>;
+export type LanguageModelArgs<Base, Mode extends ApiKeyMode> = Mode extends "optional" ? readonly [options?: LanguageModelOptions<Base, Mode>] : readonly [options: LanguageModelOptions<Base, Mode>];
+export type LanguageModelFactory<Base, Mode extends ApiKeyMode, LanguageModel> = (id: string, ...args: LanguageModelArgs<Base, Mode>) => LanguageModel;
 /**
  * Require at least one of the keys in `T`. Use for option shapes where any
  * subset of fields is acceptable but at least one must be present (e.g. Azure

package/dist/route/auth.d.ts

@@ -1,13 +1,13 @@
 import { Config, Effect, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { LLMError, type HttpOptions } from "../schema";
+import { AIError, type HttpOptions } from "../schema";
 export declare class MissingCredentialError extends Error {
     readonly source: string;
     readonly _tag = "MissingCredentialError";
     constructor(source: string);
 }
 export type CredentialError = MissingCredentialError | Config.ConfigError;
-export type AuthError = CredentialError | LLMError;
+export type AuthError = CredentialError | AIError;
 type Secret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>;
 export interface AuthInput {
     readonly request: {
@@ -39,7 +39,7 @@ export declare const effect: (load: Effect.Effect<Redacted.Redacted, CredentialE
 export declare const none: Definition;
 export declare const headers: (input: Headers.Input) => Definition;
 export declare const remove: (name: string) => Definition;
-export declare const custom: (apply: (input: AuthInput) => Effect.Effect<Headers.Headers, LLMError>) => Definition;
+export declare const custom: (apply: (input: AuthInput) => Effect.Effect<Headers.Headers, AIError>) => Definition;
 export declare const passthrough: Definition;
 export declare function bearer(source: Secret | Credential): Definition;
 export declare const apiKey: typeof bearer;
@@ -47,5 +47,5 @@ export declare function header(name: string): (source: Secret | Credential) => D
 export declare function header(name: string, source: Secret | Credential): Definition;
 export declare function bearerHeader(name: string): (source: Secret | Credential) => Definition;
 export declare function bearerHeader(name: string, source: Secret | Credential): Definition;
-export declare const toEffect: (input: Definition) => (authInput: AuthInput) => Effect.Effect<Headers.Headers, LLMError>;
+export declare const toEffect: (input: Definition) => (authInput: AuthInput) => Effect.Effect<Headers.Headers, AIError>;
 export * as Auth from "./auth";

package/dist/route/auth.js

@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { AuthenticationReason, InvalidRequestReason, LLMError } from "../schema";
+import { AuthenticationReason, InvalidRequestReason, AIError } from "../schema";
 export class MissingCredentialError extends Error {
     source;
     _tag = "MissingCredentialError";
@@ -73,9 +73,9 @@ export function bearerHeader(name, source) {
         return render;
     return render(source);
 }
-const toLLMError = (error) => {
+const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
-        return new LLMError({
+        return new AIError({
             module: "Auth",
             method: "apply",
             reason: error instanceof MissingCredentialError
@@ -85,5 +85,5 @@ const toLLMError = (error) => {
     }
     return error;
 };
-export const toEffect = (input) => (authInput) => input.apply(authInput).pipe(Effect.mapError(toLLMError));
+export const toEffect = (input) => (authInput) => input.apply(authInput).pipe(Effect.mapError(toAIError));
 export * as Auth from "./auth";

package/dist/route/client.d.ts

@@ -6,13 +6,13 @@ import { Framing } from "./framing";
 import { HttpTransport } from "./transport";
 import type { HttpRequestTransform, Transport, TransportRuntime } from "./transport";
 import type { Protocol } from "./protocol";
-import type { LLMError, ProtocolID, ProviderOptions } from "../schema";
-import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMEvent, ProviderID } from "../schema";
+import type { ProtocolID, ProviderOptions } from "../schema";
+import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LanguageModelLimits, LLMEvent, ProviderID } from "../schema";
 export interface RouteBody<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 Route<Body, Prepared = unknown> {
     readonly id: string;
@@ -26,24 +26,24 @@ export interface Route<Body, Prepared = unknown> {
     readonly defaults: RouteDefaults;
     readonly body: RouteBody<Body>;
     readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>;
-    readonly model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) => Model<Options>;
-    readonly prepareTransport: (body: Body, request: LLMRequest, options?: StreamOptions) => Effect.Effect<Prepared, LLMError>;
-    readonly streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<LLMEvent, LLMError>;
+    readonly model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) => LanguageModel<Options>;
+    readonly prepareTransport: (body: Body, request: LLMRequest, options?: StreamOptions) => Effect.Effect<Prepared, AIError>;
+    readonly streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<LLMEvent, AIError>;
 }
 export type AnyRoute = Route<any, any>;
 export type HttpOptionsInput = HttpOptions.Input;
-export type RouteModelInput = Omit<Model.Input, "provider" | "route">;
-export type RouteRoutedModelInput = Omit<Model.Input, "route">;
+export type RouteLanguageModelInput = Omit<LanguageModel.Input, "provider" | "route">;
+export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">;
 export interface RouteDefaults {
     readonly headers?: Record<string, string>;
-    readonly limits?: ModelLimits;
+    readonly limits?: LanguageModelLimits;
     readonly generation?: GenerationOptions;
     readonly providerOptions?: ProviderOptions;
     readonly http?: HttpOptions;
 }
 export interface RouteDefaultsInput {
     readonly headers?: Record<string, string>;
-    readonly limits?: ModelLimits.Input;
+    readonly limits?: LanguageModelLimits.Input;
     readonly generation?: GenerationOptions.Input;
     readonly providerOptions?: ProviderOptions;
     readonly http?: HttpOptions.Input;
@@ -55,7 +55,7 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
     readonly transport?: Transport<Body, Prepared, unknown>;
     readonly endpoint?: EndpointPatch<Body>;
 }
-type RouteMappedModelInput = RouteModelInput | RouteRoutedModelInput;
+type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput;
 export declare const generationOptions: (input: GenerationOptions.Input | undefined) => GenerationOptions | undefined;
 export declare const httpOptions: (input: HttpOptionsInput | undefined) => HttpOptions | undefined;
 export interface Interface {
@@ -66,10 +66,10 @@ export interface StreamOptions {
     readonly transform?: HttpRequestTransform;
 }
 export interface StreamMethod {
-    (request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, LLMError>;
+    (request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError>;
 }
 export interface GenerateMethod {
-    (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, LLMError>;
+    (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/LLMClient", Interface>;
 export declare class Service extends Service_base {
@@ -140,7 +140,7 @@ export declare const compileRequest: (request: LLMRequest) => Effect.Effect<{
     id: string;
     route: string;
     protocol: string;
-    model: Model<{
+    model: LanguageModel<{
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
@@ -149,9 +149,9 @@ export declare const compileRequest: (request: LLMRequest) => Effect.Effect<{
     metadata: {
         transport: string;
     };
-}, LLMError, never>;
-export declare function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, LLMError>;
-export declare function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, LLMError>;
+}, AIError, never>;
+export declare function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError>;
+export declare function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>;
 export declare const streamRequest: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<{
     readonly type: "step-start";
     readonly index: number;
@@ -333,7 +333,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-}, LLMError, Service>;
+}, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {
     readonly make: typeof make;