@opencode/ai 2.0.31 → 2.1.0

package/dist/providers/zai.d.ts

@@ -58,8 +58,20 @@ export declare const routes: Route<{
                 readonly file_data: string;
             };
         })[];
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     } | {
         readonly [x: string]: unknown;
+        readonly role: "assistant";
         readonly content: string | readonly {
             readonly type: "text";
             readonly text: string;
@@ -68,103 +80,85 @@ export declare const routes: Route<{
                 readonly ttl?: string | undefined;
             } | undefined;
         }[] | null;
-        readonly role: "assistant";
-        readonly reasoning?: string | undefined;
-        readonly reasoning_content?: string | undefined;
-        readonly reasoning_text?: string | undefined;
         readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
-            readonly id: string;
-            readonly type: "function";
             readonly extra_content?: {
                 readonly google: {
                     readonly thought_signature: string;
                 };
             } | undefined;
         }[] | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning?: string | undefined;
+        readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
-    } | {
-        readonly role: "tool";
-        readonly tool_call_id: string;
-        readonly content: string | readonly {
-            readonly type: "text";
-            readonly text: string;
-            readonly cache_control?: {
-                readonly type: "ephemeral";
-                readonly ttl?: string | undefined;
-            } | undefined;
-        }[];
     })[];
-    readonly stream: true;
-    readonly max_completion_tokens?: number | undefined;
-    readonly max_tokens?: number | undefined;
-    readonly temperature?: number | undefined;
     readonly tools?: readonly {
+        readonly type: "function";
         readonly function: {
-            readonly description: string;
             readonly name: string;
+            readonly description: string;
             readonly parameters: {
                 readonly [x: string]: unknown;
             };
             readonly strict?: boolean | undefined;
         };
-        readonly type: "function";
         readonly cache_control?: {
             readonly type: "ephemeral";
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly stop?: readonly string[] | undefined;
-    readonly seed?: number | undefined;
-    readonly thinking?: {
-        readonly type?: string | undefined;
-        readonly clear_thinking?: boolean | undefined;
-    } | undefined;
-    readonly user_id?: string | undefined;
-    readonly tool_choice?: "required" | "auto" | "none" | {
+    readonly tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly top_p?: number | undefined;
-    readonly frequency_penalty?: number | undefined;
-    readonly presence_penalty?: number | undefined;
-    readonly store?: boolean | undefined;
-    readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    readonly stream: true;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
+    readonly store?: boolean | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
     readonly tool_stream?: boolean | undefined;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly thinking?: {
+        readonly type?: string | undefined;
+        readonly clear_thinking?: boolean | undefined;
+    } | undefined;
+    readonly do_sample?: boolean | undefined;
     readonly response_format?: {
         readonly type: string;
     } | undefined;
     readonly request_id?: string | undefined;
-    readonly do_sample?: boolean | undefined;
+    readonly user_id?: string | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("./zai.js").ZAIImageOptions>;
-    configure: (input?: Config) => /*elided*/ any;
+    configure: typeof configure;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("./zai.js").ZAIImageOptions>;
-    configure: (input?: Config) => {
-        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
-        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
-        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("./zai.js").ZAIImageOptions>;
-        configure: /*elided*/ any;
-    };
+    configure: typeof configure;
 };
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("./zai.js").ZAIImageOptions>;
 export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ZAIChat.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;

package/dist/route/client.d.ts

@@ -214,32 +214,20 @@ export declare function stream(request: LLMRequest, options?: StreamOptions): St
 export declare function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
 export declare function compact(request: CheckpointRequest, options: TriggerCompactOptions): Effect.Effect<CompactionCheckpointResponse, AIError, Service>;
 export declare function compact(request: CompactionRequest, options?: EndpointCompactOptions): Effect.Effect<CompactionResponse, AIError, Service>;
-export declare const streamRequest: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<({
-    readonly type: "compaction";
-    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    readonly id?: string | undefined;
-    readonly text?: string | null | undefined;
-    readonly encrypted?: string | undefined;
-} & ({
-    readonly encrypted: string;
-    readonly text?: never;
-} | {
-    readonly text: string | null;
-    readonly encrypted?: never;
-})) | {
+export declare const streamRequest: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<{
     readonly type: "step-start";
     readonly index: number;
 } | {
-    readonly id: string;
     readonly type: "text-start";
+    readonly id: string;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "text-delta";
+    readonly id: string;
     readonly text: string;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -247,8 +235,8 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "text-end";
+    readonly id: string;
     readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -256,16 +244,16 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "reasoning-start";
+    readonly id: string;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "reasoning-delta";
+    readonly id: string;
     readonly text: string;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -273,8 +261,8 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "reasoning-end";
+    readonly id: string;
     readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -282,55 +270,56 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-input-start";
+    readonly id: string;
     readonly name: string;
+    readonly namespace?: string | undefined;
+    readonly providerExecuted?: boolean | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly namespace?: string | undefined;
-    readonly providerExecuted?: boolean | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-input-delta";
+    readonly id: string;
     readonly name: string;
+    readonly namespace?: string | undefined;
     readonly text: string;
     readonly input?: unknown;
-    readonly namespace?: string | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-input-end";
+    readonly id: string;
     readonly name: string;
+    readonly namespace?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly namespace?: string | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-input-error";
+    readonly id: string;
     readonly name: string;
-    readonly raw: string;
     readonly namespace?: string | undefined;
+    readonly raw: string;
 } | {
-    readonly id: string;
     readonly type: "tool-call";
+    readonly id: string;
     readonly name: string;
+    readonly namespace?: string | undefined;
     readonly input: unknown;
+    readonly providerExecuted?: boolean | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly namespace?: string | undefined;
-    readonly providerExecuted?: boolean | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-result";
+    readonly id: string;
     readonly name: string;
+    readonly namespace?: string | undefined;
     readonly result: {
         readonly type: "json";
         readonly value: unknown;
@@ -364,28 +353,19 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
             readonly name?: string | undefined;
         })[];
     } | undefined;
+    readonly providerExecuted?: boolean | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly namespace?: string | undefined;
-    readonly providerExecuted?: boolean | undefined;
 } | {
-    readonly id: string;
     readonly type: "tool-error";
-    readonly message: string;
+    readonly id: string;
     readonly name: string;
-    readonly error?: unknown;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
     readonly namespace?: string | undefined;
-} | {
-    readonly type: "media";
-    readonly media: import("../media.js").Asset;
+    readonly message: string;
+    readonly error?: unknown;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -393,33 +373,41 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
     } | undefined;
 } | {
     readonly type: "step-finish";
+    readonly index: number;
     readonly reason: {
-        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
         readonly raw?: string | undefined;
         readonly category?: string | undefined;
         readonly explanation?: string | undefined;
     };
-    readonly index: number;
+    readonly usage?: import("../schema/events.js").Usage | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly usage?: import("../schema/events.js").Usage | undefined;
 } | {
     readonly type: "finish";
     readonly reason: {
-        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
         readonly raw?: string | undefined;
         readonly category?: string | undefined;
         readonly explanation?: string | undefined;
     };
+    readonly usage?: import("../schema/events.js").Usage | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("../media.js").Asset;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly usage?: import("../schema/events.js").Usage | undefined;
 } | {
     readonly type: "provider-error";
     readonly message: string;
@@ -429,7 +417,19 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
             readonly [x: string]: unknown;
         };
     } | undefined;
-}, AIError, LLMClientService>;
+} | ({
+    readonly type: "compaction";
+    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    readonly id?: string | undefined;
+    readonly encrypted?: string | undefined;
+    readonly text?: string | null | undefined;
+} & ({
+    readonly encrypted: string;
+    readonly text?: never;
+} | {
+    readonly text: string | null;
+    readonly encrypted?: never;
+})), AIError, LLMClientService>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {
     readonly make: typeof make;

package/dist/route/media-protocol.d.ts

@@ -154,13 +154,13 @@ export declare const identity: (input: {
         contentPolicy: (message: string) => AIError;
     }, AIError, never>;
     decodeJson: <A>(schema: Schema.Codec<A, unknown>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
-        value: A;
         body: string;
         http: HttpContext;
         invalid: (message: string, cause?: unknown) => AIError;
         ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string, failure?: Failure) => AIError;
         pending: (id: string) => AIError;
         contentPolicy: (message: string) => AIError;
+        value: A;
     }, AIError, never>;
     /** Decode a submission response into the token and first snapshot. */
     decodeStarted: <A, Token>(schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;

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

@@ -17,7 +17,7 @@ export interface HttpPrepared<Frame> {
 }
 export declare const jsonRequestParts: <Body>(input: JsonRequestInput<Body>) => Effect.Effect<{
     url: string;
-    jsonBody: Record<string, unknown> | Body;
+    jsonBody: Body | Record<string, unknown>;
     bodyText: string;
     headers: Headers.Headers;
 }, AIError, never>;

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

@@ -39,18 +39,18 @@ export interface JsonTransport<Body, Message> extends Transport<Body, JsonPrepar
 export declare const json: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
 export declare const jsonTransport: {
     readonly id: "websocket-json";
-    readonly with: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+    readonly with: typeof json;
 };
 export declare const WebSocketTransport: {
-    readonly json: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+    readonly json: typeof json;
     readonly jsonTransport: {
         readonly id: "websocket-json";
-        readonly with: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+        readonly with: typeof json;
     };
     readonly direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
-    readonly makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
-    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, Socket.WebSocketConstructor>;
-    readonly fromWebSocket: (ws: Socket.WebSocketLike, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
-    readonly messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
-    readonly toWebSocketUrl: (value: string) => Effect.Effect<string, AIError, never>;
+    readonly makeDirect: typeof makeDirect;
+    readonly open: typeof open;
+    readonly fromWebSocket: typeof fromWebSocket;
+    readonly messageText: typeof messageText;
+    readonly toWebSocketUrl: typeof toWebSocketUrl;
 };

package/dist/schema/errors.d.ts

@@ -18,23 +18,23 @@ declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Sche
 export declare class HttpRateLimitDetails extends HttpRateLimitDetails_base {
 }
 declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequest", {
-    readonly parameter: Schema.optional<Schema.String>;
-    readonly classification: Schema.optional<Schema.Literals<readonly ["context-overflow", "payload-too-large"]>>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly parameter: Schema.optional<Schema.String>;
+    readonly classification: Schema.optional<Schema.Literals<readonly ["context-overflow", "payload-too-large"]>>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequestError extends InvalidRequestError_base {
 }
 declare const UnsupportedOperationError_base: Schema.Class<UnsupportedOperationError, Schema.TaggedStruct<"UnsupportedOperation", {
-    readonly operation: Schema.String;
-    readonly provider: Schema.optional<Schema.brand<Schema.String, "AI.ProviderID">>;
-    readonly route: Schema.optional<Schema.String>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly operation: Schema.String;
+    readonly provider: Schema.optional<Schema.brand<Schema.String, "AI.ProviderID">>;
+    readonly route: Schema.optional<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A caller-requested operation the selected route does not implement, such as
@@ -57,13 +57,13 @@ declare const ProviderConfigurationError_base: Schema.Class<ProviderConfiguratio
 export declare class ProviderConfigurationError extends ProviderConfigurationError_base {
 }
 declare const NoRouteError_base: Schema.Class<NoRouteError, Schema.TaggedStruct<"NoRoute", {
-    readonly route: Schema.String;
-    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
-    readonly model: Schema.brand<Schema.String, "AI.ModelID">;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly route: Schema.String;
+    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+    readonly model: Schema.brand<Schema.String, "AI.ModelID">;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoRouteError extends NoRouteError_base {
 }
@@ -76,12 +76,12 @@ declare const AuthenticationError_base: Schema.Class<AuthenticationError, Schema
 export declare class AuthenticationError extends AuthenticationError_base {
 }
 declare const RateLimitError_base: Schema.Class<RateLimitError, Schema.TaggedStruct<"RateLimit", {
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
-    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly retryAfterMs: Schema.optional<Schema.Number>;
+    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RateLimitError extends RateLimitError_base {
 }
@@ -102,11 +102,11 @@ declare const ContentPolicyError_base: Schema.Class<ContentPolicyError, Schema.T
 export declare class ContentPolicyError extends ContentPolicyError_base {
 }
 declare const ProviderInternalError_base: Schema.Class<ProviderInternalError, Schema.TaggedStruct<"ProviderInternal", {
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly retryAfterMs: Schema.optional<Schema.Number>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ProviderInternalError extends ProviderInternalError_base {
 }
@@ -115,6 +115,10 @@ export type TransportType = typeof TransportType.Type;
 export declare const TransportOperation: Schema.Literals<readonly ["request", "read", "write"]>;
 export type TransportOperation = typeof TransportOperation.Type;
 declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"Transport", {
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
+    readonly http: Schema.optional<typeof HttpContext>;
+    readonly cause: Schema.optional<Schema.Defect>;
     readonly transport: Schema.Literals<readonly ["http", "websocket"]>;
     readonly operation: Schema.Literals<readonly ["request", "read", "write"]>;
     readonly code: Schema.optional<Schema.String>;
@@ -122,20 +126,16 @@ declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStr
     readonly phase: Schema.optional<Schema.Literals<readonly ["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]>>;
     readonly delivery: Schema.optional<Schema.Literals<readonly ["not-sent", "rejected", "ambiguous", "accepted"]>>;
     readonly recovery: Schema.optional<Schema.Literals<readonly ["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"]>>;
-    readonly message: Schema.String;
-    readonly body: Schema.optional<Schema.String>;
-    readonly http: Schema.optional<typeof HttpContext>;
-    readonly cause: Schema.optional<Schema.Defect>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TransportError extends TransportError_base {
 }
 declare const InvalidProviderOutputError_base: Schema.Class<InvalidProviderOutputError, Schema.TaggedStruct<"InvalidProviderOutput", {
-    readonly classification: Schema.optional<Schema.Literals<readonly ["incomplete-stream"]>>;
-    readonly route: Schema.optional<Schema.String>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly classification: Schema.optional<Schema.Literals<readonly ["incomplete-stream"]>>;
+    readonly route: Schema.optional<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidProviderOutputError extends InvalidProviderOutputError_base {
 }
@@ -148,11 +148,11 @@ declare const UnknownProviderError_base: Schema.Class<UnknownProviderError, Sche
 export declare class UnknownProviderError extends UnknownProviderError_base {
 }
 declare const TimeoutError_base: Schema.Class<TimeoutError, Schema.TaggedStruct<"Timeout", {
-    readonly timeoutMs: Schema.optional<Schema.Number>;
     readonly message: Schema.String;
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
+    readonly timeoutMs: Schema.optional<Schema.Number>;
 }>, import("effect/Cause").YieldableError>;
 /** A caller-supplied deadline elapsed, such as `Generation.await` polling past its `Poll.timeout`. */
 export declare class TimeoutError extends TimeoutError_base {
@@ -163,7 +163,7 @@ declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error"
     readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof UnsupportedOperationError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError, typeof TimeoutError]>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AIError extends AIError_base {
-    readonly cause: InvalidRequestError | UnsupportedOperationError | NoRouteError | AuthenticationError | RateLimitError | QuotaExceededError | ContentPolicyError | ProviderInternalError | TransportError | InvalidProviderOutputError | UnknownProviderError | TimeoutError;
+    readonly cause: AuthenticationError | ContentPolicyError | InvalidProviderOutputError | InvalidRequestError | NoRouteError | ProviderInternalError | QuotaExceededError | RateLimitError | TimeoutError | TransportError | UnknownProviderError | UnsupportedOperationError;
     get message(): string;
 }
 /**