@opencode/ai 2.1.2 → 2.1.3

package/dist/providers/openrouter.d.ts

@@ -88,8 +88,8 @@ export type Settings = ProviderPackage.Settings & OpenRouterProviderOptionsInput
     readonly baseURL?: string;
 };
 declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
-    model: Schema.String;
-    messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
+    readonly model: Schema.String;
+    readonly messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
         readonly role: Schema.Literal<"system">;
         readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"text">;
@@ -170,7 +170,7 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
             }>>;
         }>>]>;
     }>]>>;
-    tools: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly function: Schema.Struct<{
             readonly name: Schema.String;
@@ -183,34 +183,41 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
             readonly ttl: Schema.optional<Schema.String>;
         }>>;
     }>>>;
-    tool_choice: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
+    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly function: Schema.Struct<{
             readonly name: Schema.String;
         }>;
     }>]>>;
-    stream: Schema.Literal<true>;
-    stream_options: Schema.optional<Schema.Struct<{
+    readonly stream: Schema.Literal<true>;
+    readonly stream_options: Schema.optional<Schema.Struct<{
         readonly include_usage: Schema.Boolean;
     }>>;
-    store: Schema.optional<Schema.Boolean>;
-    prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
-    tool_stream: Schema.optional<Schema.Boolean>;
-    max_completion_tokens: Schema.optional<Schema.Number>;
-    max_tokens: Schema.optional<Schema.Number>;
-    temperature: Schema.optional<Schema.Number>;
-    top_p: Schema.optional<Schema.Number>;
-    frequency_penalty: Schema.optional<Schema.Number>;
-    presence_penalty: Schema.optional<Schema.Number>;
-    seed: Schema.optional<Schema.Number>;
-    stop: Schema.optional<Schema.$Array<Schema.String>>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
+    readonly store: Schema.optional<Schema.Boolean>;
+    readonly prompt_cache_key: Schema.optional<Schema.String>;
+    readonly reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
+    readonly tool_stream: Schema.optional<Schema.Boolean>;
+    readonly max_completion_tokens: Schema.optional<Schema.Number>;
+    readonly max_tokens: Schema.optional<Schema.Number>;
+    readonly temperature: Schema.optional<Schema.Number>;
+    readonly top_p: Schema.optional<Schema.Number>;
+    readonly frequency_penalty: Schema.optional<Schema.Number>;
+    readonly presence_penalty: Schema.optional<Schema.Number>;
+    readonly seed: Schema.optional<Schema.Number>;
+    readonly stop: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly models: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.String>>, never>>;
+    readonly provider: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly plugins: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>, never>>;
+    readonly web_search_options: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly debug: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly user: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.String>, never>>;
+    readonly reasoning: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly usage: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type OpenRouterBody = Schema.Schema.Type<typeof OpenRouterBody>;
 export declare const protocol: Protocol<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -292,7 +299,7 @@ export declare const protocol: Protocol<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -307,28 +314,46 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    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;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly choices?: readonly {
@@ -403,9 +428,8 @@ export declare const protocol: Protocol<{
     } | null | undefined;
 }, OpenAIChat.ParserState>;
 export declare const route: Route<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -487,7 +511,7 @@ export declare const route: Route<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -502,33 +526,50 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    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;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
 export declare const routes: Route<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -610,7 +651,7 @@ export declare const routes: Route<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -625,28 +666,46 @@ export declare const routes: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    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;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/providers/openrouter.js

@@ -7,25 +7,36 @@ import { HttpOptions, ProviderID } from "../schema/index.js";
 import { SystemOne } from "../experimental/system-one.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { cacheControl } from "../protocols/utils/cache.js";
-import { isRecord, ProviderShared } from "../protocols/shared.js";
+import { isRecord, JsonObject, lenient, ProviderShared } from "../protocols/shared.js";
 export const id = ProviderID.make("openrouter");
 const baseURL = "https://openrouter.ai/api/v1";
 const ADAPTER = "openrouter";
-const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
-    Schema.Record(Schema.String, Schema.Any),
-]);
+const Options = Schema.Struct({
+    usage: lenient(Schema.Union([Schema.Boolean, JsonObject])),
+    models: lenient(Schema.Array(Schema.String)),
+    provider: lenient(JsonObject),
+    plugins: lenient(Schema.Array(JsonObject)),
+    web_search_options: lenient(JsonObject),
+    debug: lenient(JsonObject),
+    user: lenient(Schema.String),
+    reasoning: lenient(JsonObject),
+});
+const decodeOptions = Schema.decodeUnknownSync(Options);
+const OpenRouterBody = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    ...Options.fields,
+    usage: Schema.optional(JsonObject),
+}), [JsonObject]);
 export const protocol = Protocol.make({
     id: "openrouter-chat",
     body: {
         schema: OpenRouterBody,
-        from: (request) => OpenAIChat.fromRequest(request, { cacheControl: cacheControl() }).pipe(Effect.map((body) => {
-            const sourceAssistants = request.messages.filter((message) => message.role === "assistant");
-            let assistantIndex = 0;
-            const messages = body.messages.map((message) => {
+        from: (request) => OpenAIChat.fromRequest(request, {
+            cacheControl: cacheControl(),
+            assistant: (source, message) => {
                 if (message.role !== "assistant")
                     return message;
-                const source = sourceAssistants[assistantIndex++];
-                const reasoning = source?.content
+                const reasoning = source.content
                     .filter((part) => part.type === "reasoning")
                     .map((part) => part.text)
                     .join("");
@@ -37,13 +48,8 @@ export const protocol = Protocol.make({
                     reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
                     reasoning_details: reasoningDetails,
                 };
-            });
-            return {
-                ...body,
-                messages,
-                ...bodyOptions(request.providerOptions, request.generation?.maxTokens),
-            };
-        })),
+            },
+        }).pipe(Effect.map((body) => bodyOptions(body, request.providerOptions, request.generation?.maxTokens))),
     },
     stream: OpenAIChat.protocol.stream,
 });
@@ -52,25 +58,26 @@ export const protocol = Protocol.make({
 const fitReasoning = (reasoning, maxTokens) => typeof reasoning.max_tokens === "number"
     ? { ...reasoning, max_tokens: ProviderShared.fitThinkingBudget(reasoning.max_tokens, maxTokens, 1_024) }
     : reasoning;
-const bodyOptions = (input, maxTokens) => {
+const bodyOptions = (body, input, maxTokens) => {
     const openrouter = isRecord(input) ? input : {};
-    const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } = openrouter;
+    const options = Object.fromEntries(Object.entries(openrouter).filter(([key]) => !(key in Options.fields) && key !== "promptCacheKey"));
+    const known = decodeOptions(openrouter);
+    const usage = openrouter.usage === undefined || known.usage === true
+        ? { include: true }
+        : known.usage === false
+            ? { include: false }
+            : known.usage;
     return {
         ...options,
-        ...(usage === undefined || usage === true
-            ? { usage: { include: true } }
-            : usage === false
-                ? { usage: { include: false } }
-                : isRecord(usage)
-                    ? { usage }
-                    : {}),
-        ...(Array.isArray(models) ? { models } : {}),
-        ...(isRecord(provider) ? { provider } : {}),
-        ...(Array.isArray(plugins) ? { plugins } : {}),
-        ...(isRecord(web_search_options) ? { web_search_options } : {}),
-        ...(isRecord(debug) ? { debug } : {}),
-        ...(typeof user === "string" ? { user } : {}),
-        ...(isRecord(reasoning) ? { reasoning: fitReasoning(reasoning, maxTokens) } : {}),
+        ...body,
+        ...(usage !== undefined ? { usage } : {}),
+        ...(known.models !== undefined ? { models: known.models } : {}),
+        ...(known.provider !== undefined ? { provider: known.provider } : {}),
+        ...(known.plugins !== undefined ? { plugins: known.plugins } : {}),
+        ...(known.web_search_options !== undefined ? { web_search_options: known.web_search_options } : {}),
+        ...(known.debug !== undefined ? { debug: known.debug } : {}),
+        ...(known.user !== undefined ? { user: known.user } : {}),
+        ...(known.reasoning !== undefined ? { reasoning: fitReasoning(known.reasoning, maxTokens) } : {}),
     };
 };
 export const route = Route.make({

package/dist/providers/zai-coding-plan.d.ts

@@ -178,15 +178,15 @@ export declare const routes: (Route<{
     } | undefined;
     readonly top_logprobs?: number | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
-    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority"> | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly include?: readonly import("../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">[] | undefined;
     readonly reasoning?: {
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
     } | undefined;
     readonly text?: {
-        readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
+        readonly verbosity?: import("../schema/options.js").OpenString<"high" | "low" | "medium"> | undefined;
     } | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;

package/dist/route/client.d.ts

@@ -214,222 +214,6 @@ 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: "step-start";
-    readonly index: number;
-} | {
-    readonly type: "text-start";
-    readonly id: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "text-delta";
-    readonly id: string;
-    readonly text: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "text-end";
-    readonly id: string;
-    readonly text?: string | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-start";
-    readonly id: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-delta";
-    readonly id: string;
-    readonly text: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-end";
-    readonly id: string;
-    readonly text?: string | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    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 type: "tool-input-delta";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly text: string;
-    readonly input?: unknown;
-} | {
-    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 type: "tool-input-error";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly raw: 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 type: "tool-result";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly result: {
-        readonly type: "json";
-        readonly value: unknown;
-    } | {
-        readonly type: "text";
-        readonly value: unknown;
-    } | {
-        readonly type: "error";
-        readonly value: unknown;
-    } | {
-        readonly type: "content";
-        readonly value: readonly ({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "file";
-            readonly uri: string;
-            readonly mime: string;
-            readonly name?: string | undefined;
-        })[];
-    };
-    readonly output?: {
-        readonly structured: unknown;
-        readonly content: readonly ({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "file";
-            readonly uri: string;
-            readonly mime: string;
-            readonly name?: string | undefined;
-        })[];
-    } | undefined;
-    readonly providerExecuted?: boolean | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-error";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly message: string;
-    readonly error?: unknown;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "step-finish";
-    readonly index: number;
-    readonly reason: {
-        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: "finish";
-    readonly reason: {
-        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 type: "provider-error";
-    readonly message: string;
-    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | ({
-    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/client.js

@@ -271,9 +271,6 @@ export function compact(request, options) {
         return yield* unsupportedCompaction(request, options?.mechanism);
     });
 }
-export const streamRequest = (request, options) => Stream.unwrap(Effect.gen(function* () {
-    return (yield* Service).stream(request, options);
-}));
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     const stream = streamRequestWith({ http: executor });