@opencode/ai 2.1.1 → 2.1.3

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

@@ -1,8 +1,8 @@
 import { type ProviderOptions } from "../schema/index.js";
-import type { OpenAIServiceTier } from "../protocols/utils/openai-options.js";
-import type { Options } from "../protocols/utils/open-responses-options.js";
+import type { Options, ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options.js";
 import type { ContextManagement } from "../protocols/openai-responses.js";
-export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js";
+export type OpenAIResponseIncludable = ResponseIncludable;
+export type OpenAIServiceTier = ServiceTier | "scale" | "fast" | "ultrafast";
 export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
     /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
     readonly contextManagement?: ContextManagement;

package/dist/providers/openai.d.ts

@@ -266,15 +266,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?: 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 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?: OpenString<"high" | "low" | "medium"> | undefined;
     } | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;

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/vercel-ai-gateway.js

@@ -4,19 +4,20 @@ import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion,
 import { AnthropicMessages } from "../protocols/anthropic-messages.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { OpenResponses } from "../protocols/open-responses.js";
-import { optionalNull, ProviderShared } from "../protocols/shared.js";
+import { JsonObject, optionalNull, ProviderShared } from "../protocols/shared.js";
 import { gatewayProtocol } from "../protocols/utils/gateway-protocol.js";
 import { Auth } from "../route/auth.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
+import { RequestExecutor } from "../route/executor.js";
 import { Framing } from "../route/framing.js";
-import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, LLMRequest, ModelID, ProviderID, ProviderMetadata, ReasoningEffort, Usage, } from "../schema/index.js";
+import { AIError, HttpOptions, InvalidProviderOutputError, InvalidRequestError, LLMRequest, ModelID, ProviderID, ProviderMetadata, ProviderOptions, ReasoningEffort, Usage, } from "../schema/index.js";
 export const id = ProviderID.make("vercel-ai-gateway");
 const baseURL = "https://ai-gateway.vercel.sh/v1";
 const GatewayOptionsSchema = Schema.Struct({
     gateway: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    upstream: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    upstream: Schema.optional(ProviderMetadata),
     reasoningEffort: Schema.optional(ReasoningEffort),
     thinking: Schema.optional(Schema.Struct({
         type: Schema.String,
@@ -110,8 +111,8 @@ const Request = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     state: EvaluationInput,
     questions: Schema.Record(Schema.String, EvaluationQuestion),
-    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}), [Schema.Record(Schema.String, Schema.Any)]);
+    providerOptions: Schema.optional(ProviderOptions),
+}), [JsonObject]);
 const Response = Schema.Struct({
     model: optionalNull(Schema.String),
     answers: Schema.Record(Schema.String, EvaluationAnswer),
@@ -170,7 +171,7 @@ export const configure = (input = {}) => {
                     headers: Headers.fromInput({ ...input.headers, ...req.http?.headers }),
                 });
                 const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
-                const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+                const http = RequestExecutor.responseHttp(res);
                 const fail = (message, cause, body) => new AIError({
                     reason: new InvalidProviderOutputError({
                         route: "vercel-evaluation",

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;