@opencode/ai 0.0.0-beta-19275

package/dist/protocols/zai-images.js

@@ -0,0 +1,79 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const ADAPTER = "zai-images";
+export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+export const PATH = "/images/generations";
+const ZAIImageResponse = Schema.Struct({
+    created: Schema.optional(Schema.Int),
+    id: Schema.optional(Schema.String),
+    request_id: Schema.optional(Schema.String),
+    data: Schema.Array(Schema.Struct({ url: Schema.String })),
+    content_filter: Schema.optional(Schema.Array(Schema.Struct({
+        role: Schema.optional(Schema.String),
+        level: Schema.optional(Schema.Number),
+    }))),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { userID, ...native } = options;
+    return {
+        user_id: userID,
+        ...native,
+    };
+};
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("ZAIImages.generate")(function* (request, execute) {
+            if ((request.images?.length ?? 0) > 0)
+                return yield* ImageInputs.invalid("Z.ai hosted image generation does not support image inputs");
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Z.ai Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ZAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Z.ai Images returned an invalid response", cause)));
+            if (decoded.data.length === 0)
+                return yield* output.invalid("Z.ai Images returned no images");
+            return new ImageResponse({
+                images: decoded.data.map((item) => new GeneratedImage({
+                    mediaType: "application/octet-stream",
+                    data: item.url,
+                })),
+                providerMetadata: {
+                    zai: {
+                        created: decoded.created,
+                        id: decoded.id,
+                        requestID: decoded.request_id,
+                        contentFilter: decoded.content_filter,
+                    },
+                },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "zai", route, http: input.http });
+};
+export const ZAIImages = {
+    model,
+};

package/dist/protocols.d.ts

@@ -0,0 +1 @@
+export * from "./protocols/index.js";

package/dist/protocols.js

@@ -0,0 +1 @@
+export * from "./protocols/index.js";

package/dist/provider-error.d.ts

@@ -0,0 +1,15 @@
+import { AIError, type HttpContext, type HttpRateLimitDetails } from "./schema/index.js";
+export declare const isContextOverflow: (message: string) => boolean;
+export declare const isPayloadTooLarge: (message: string) => boolean;
+export declare const isContextOverflowFailure: (failure: unknown) => boolean;
+export interface ProviderFailure {
+    readonly message: string;
+    readonly status?: number | undefined;
+    readonly rawBody?: string | undefined;
+    readonly data?: unknown;
+    readonly http?: HttpContext | undefined;
+    readonly cause?: unknown;
+    readonly retryAfterMs?: number | undefined;
+    readonly rateLimit?: HttpRateLimitDetails | undefined;
+}
+export declare function classifyProviderFailure(input: ProviderFailure): AIError["reason"];

package/dist/provider-error.js

@@ -0,0 +1,125 @@
+import { Option, Schema } from "effect";
+import { AuthenticationError, ContentPolicyError, InvalidRequestError, AIError, ProviderErrorEvent, ProviderInternalError, QuotaExceededError, RateLimitError, UnknownProviderError, } from "./schema/index.js";
+const patterns = [
+    /prompt is too long/i,
+    /input is too long for requested model/i,
+    /exceeds the context window/i,
+    /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+    /input token count.*exceeds the maximum/i,
+    /tokens in request more than max tokens allowed/i,
+    /maximum prompt length is \d+/i,
+    /reduce the length of the messages/i,
+    /maximum context length is \d+ tokens/i,
+    /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+    /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+    /exceeds the limit of \d+/i,
+    /exceeds the available context size/i,
+    /greater than the context length/i,
+    /context window exceeds limit/i,
+    /exceeded model token limit/i,
+    /context[_ ]length[_ ]exceeded/i,
+    /context length is only \d+ tokens/i,
+    /input length.*exceeds.*context length/i,
+    /prompt too long; exceeded (?:max )?context length/i,
+    /too large for model with \d+ maximum context length/i,
+    /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+    /model_context_window_exceeded/i,
+    /range of input length should be/i,
+    /too many tokens/i,
+    /token limit exceeded/i,
+    /request_too_large/i,
+];
+const payloadPatterns = [/request entity too large/i, /payload too large/i, /request too large/i];
+const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i];
+export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
+    (patterns.some((pattern) => pattern.test(message)) || /^4(?:00|13)\s*(status code)?\s*\(no body\)/i.test(message));
+export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) => pattern.test(message));
+export const isContextOverflowFailure = (failure) => failure instanceof AIError
+    ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
+    : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"]);
+const AUTH_CODES = new Set(["authentication_error", "permission_error"]);
+const SERVER_CODES = new Set([
+    "api_error",
+    "internal_error",
+    "internalserverexception",
+    "modelstreamerrorexception",
+    "overloaded_error",
+    "server_error",
+    "server_is_overloaded",
+    "slow_down",
+    "serviceunavailableexception",
+]);
+const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"]);
+const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i;
+const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i;
+const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i;
+const SERVER_ERROR_TEXT = /\b(?:try again|(?:please |you can )?retry (?:the |this |your )?request|try (?:the |this |your )?request again|(?:currently |temporarily )?at capacity|overloaded|temporarily unavailable|service[-_\s]?unavailable|(?:server|internal)[-_\s]?error|server (?:is )?busy|provider returned (?:an )?error|resource[-_\s]?exhausted|upstream (?:connect|connection|request)|request buffer limit while retrying upstream)\b/i;
+// Classification records affirmative evidence about a failure. Deterministic
+// failures need positive identification (a 4xx status, quota/auth/policy
+// signals); anything unrecognized stays UnknownProvider, which the session
+// retry policy treats as retry-eligible because transient failures arrive in
+// unpredictable shapes while deterministic rejections almost always carry a
+// status or known code.
+export function classifyProviderFailure(input) {
+    const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause };
+    const body = input.rawBody ?? "";
+    const codes = [...providerCodes(input.data), ...providerCodes(body), ...providerCodes(input.message)].map((code) => code.toLowerCase());
+    // Scan the raw payload too so signals missing from the summary message
+    // (e.g. overflow phrases nested in a JSON error body) still classify.
+    const text = [input.message, body].filter((value) => value.length > 0).join("\n");
+    const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500);
+    if (clientScoped &&
+        (codes.includes("context_length_exceeded") ||
+            codes.includes("model_context_window_exceeded") ||
+            codes.includes("request_too_large") ||
+            isContextOverflow(text)))
+        return new InvalidRequestError({ ...details, classification: "context-overflow" });
+    if (input.status === 413 || isPayloadTooLarge(text))
+        return new InvalidRequestError({ ...details, classification: "payload-too-large" });
+    if (CONTENT_POLICY_TEXT.test(text))
+        return new ContentPolicyError(details);
+    if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
+        return new QuotaExceededError(details);
+    if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
+        return new AuthenticationError(details);
+    if (input.status === 429 ||
+        codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception") ||
+        RATE_LIMIT_TEXT.test(text))
+        return new RateLimitError({
+            ...details,
+            retryAfterMs: input.retryAfterMs,
+            rateLimit: input.rateLimit,
+        });
+    if (input.status === 408 ||
+        input.status === 409 ||
+        (input.status !== undefined && input.status >= 500) ||
+        ((input.status === undefined || input.status < 400) &&
+            !codes.some((code) => INVALID_REQUEST_CODES.has(code)) &&
+            SERVER_ERROR_TEXT.test(text)) ||
+        codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+        return new ProviderInternalError({
+            ...details,
+            retryAfterMs: input.retryAfterMs,
+        });
+    if (codes.some((code) => INVALID_REQUEST_CODES.has(code)))
+        return new InvalidRequestError(details);
+    // Any remaining 4xx is a deterministic rejection of this request.
+    if (input.status !== undefined && input.status >= 400 && input.status < 500)
+        return new InvalidRequestError(details);
+    return new UnknownProviderError(details);
+}
+function providerCodes(value) {
+    const decoded = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value;
+    if (!isRecord(decoded))
+        return [];
+    const error = isRecord(decoded.error) ? decoded.error : undefined;
+    const response = isRecord(decoded.response) ? decoded.response : undefined;
+    const responseError = response && isRecord(response.error) ? response.error : undefined;
+    const exception = isRecord(decoded.exception) ? decoded.exception : undefined;
+    return [decoded.code, error?.code, error?.type, error?.status, responseError?.code, exception?.type].filter((value) => typeof value === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/provider-package.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageModel, ProviderOptions } from "./schema/index.js";
+import type { CompactionOperations } from "./route/client.js";
+export interface Settings extends Readonly<Record<string, unknown>> {
+    readonly baseURL?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: Readonly<Record<string, unknown>>;
+}
+export interface Definition<ProviderSettings extends Settings = Settings, Options extends ProviderOptions = ProviderOptions, Compact extends CompactionOperations | undefined = CompactionOperations | undefined> {
+    readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options, Compact>;
+}
+export * as ProviderPackage from "./provider-package.js";

package/dist/provider-package.js

@@ -0,0 +1 @@
+export * as ProviderPackage from "./provider-package.js";

package/dist/provider.d.ts

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

package/dist/provider.js

@@ -0,0 +1,2 @@
+export const make = (definition) => definition;
+export * as Provider from "./provider.js";

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

@@ -0,0 +1,2 @@
+export { chatModel as model } from "../../amazon-bedrock-mantle.js";
+export type { Settings } from "../../amazon-bedrock-mantle.js";

package/dist/providers/amazon-bedrock/mantle/chat.js

@@ -0,0 +1 @@
+export { chatModel as model } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,2 @@
+export { responsesModel as model } from "../../amazon-bedrock-mantle.js";
+export type { Settings } from "../../amazon-bedrock-mantle.js";

package/dist/providers/amazon-bedrock/mantle/responses.js

@@ -0,0 +1 @@
+export { responsesModel as model } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,2 @@
+export { responsesModel as model } from "../amazon-bedrock-mantle.js";
+export type { Settings } from "../amazon-bedrock-mantle.js";

package/dist/providers/amazon-bedrock/mantle.js

@@ -0,0 +1 @@
+export { responsesModel as model } from "../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,371 @@
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import type { ProviderPackage } from "../provider-package.js";
+import { type Credentials } from "../protocols/utils/bedrock-auth.js";
+import { type ModelID } from "../schema/index.js";
+import { type OpenAIProviderOptionsInput } from "./openai-options.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = RouteDefaultsInput & {
+    /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
+    readonly apiKey?: string;
+    /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
+    readonly auth?: "bearer" | "sigv4";
+    readonly baseURL?: string;
+    /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
+    readonly credentials?: Credentials;
+    /** Shared config profile for the default credential chain. */
+    readonly profile?: string;
+    readonly region?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly apiKey?: string;
+    readonly auth?: "bearer" | "sigv4";
+    readonly baseURL?: string;
+    readonly credentials?: Credentials;
+    readonly profile?: string;
+    readonly region?: string;
+    readonly topP?: number;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+}
+export declare const routes: (Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: 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 tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: 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 temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        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 prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | Route<{
+    readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "compaction";
+        readonly encrypted_content: string;
+        readonly id?: string | null | undefined;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+        readonly role: "user";
+        readonly id?: string | undefined;
+        readonly type?: "message" | undefined;
+        readonly status?: string | undefined;
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly status?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_video";
+            readonly video_url: string;
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "computer_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+        readonly call_id?: string | undefined;
+        readonly pending_safety_checks?: readonly {
+            readonly [x: string]: unknown;
+        }[] | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_preview_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "image_generation_call";
+        readonly status?: string | undefined;
+        readonly result?: string | null | undefined;
+        readonly revised_prompt?: string | null | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    readonly tools?: readonly ({
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly action?: "generate" | "auto" | "edit" | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
+        readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly output_compression?: number | undefined;
+        readonly input_fidelity?: "low" | "high" | undefined;
+        readonly partial_images?: number | undefined;
+    } | {
+        readonly type: "namespace";
+        readonly name: string;
+        readonly description: string;
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        }[];
+    })[] | undefined;
+    readonly text?: {
+        readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
+    readonly context_management?: readonly {
+        readonly type: "compaction";
+        readonly compact_threshold?: number | undefined;
+    }[] | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | {
+        readonly type: "image_generation";
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | 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<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
+export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;