@opencode/ai 0.0.0-reserved → 2.0.1

package/dist/llm.d.ts

@@ -0,0 +1,252 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, AIError, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, type ContentPart, type LanguageModelProviderOptions, type ToolEntryInput } from "./schema/index.js";
+import { type ToolSchema } from "./tool.js";
+/** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
+export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
+    readonly model: SelectedLanguageModel;
+    readonly system?: string | SystemPart | ReadonlyArray<SystemPart>;
+    readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>;
+    readonly messages?: ReadonlyArray<Message | Message.Input>;
+    readonly tools?: ReadonlyArray<ToolEntryInput>;
+    readonly toolChoice?: ToolChoice.Input;
+    readonly generation?: GenerationOptions.Input;
+    readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const generate: typeof import("./route/client.js").generate;
+export declare const stream: typeof import("./route/client.js").stream;
+export declare const request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
+type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<RequestInput<SelectedLanguageModel>, "tools" | "toolChoice">;
+export declare class GenerateObjectResponse<T> {
+    readonly object: T;
+    readonly response: LLMResponse;
+    constructor(object: T, response: LLMResponse);
+    get events(): readonly (({
+        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;
+    })) | {
+        readonly type: "step-start";
+        readonly index: number;
+    } | {
+        readonly id: string;
+        readonly type: "text-start";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "text-delta";
+        readonly text: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "text-end";
+        readonly text?: string | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-start";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-delta";
+        readonly text: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-end";
+        readonly text?: string | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "tool-input-start";
+        readonly name: string;
+        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 name: string;
+        readonly text: string;
+        readonly input?: unknown;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "tool-input-end";
+        readonly name: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "tool-input-error";
+        readonly name: string;
+        readonly raw: string;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "tool-call";
+        readonly name: string;
+        readonly input: unknown;
+        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 name: string;
+        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 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 name: string;
+        readonly message: string;
+        readonly error?: unknown;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "step-finish";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
+        readonly index: number;
+        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 raw?: string | undefined;
+        };
+        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;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+    })[];
+    get usage(): import("./schema/events.js").Usage | undefined;
+}
+export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
+    readonly schema: S;
+}
+export interface GenerateObjectDynamicOptions<SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
+    /** Raw JSON Schema object describing the expected output shape. */
+    readonly jsonSchema: JsonSchema.JsonSchema;
+}
+/**
+ * Run a model and decode its output against `schema`. Works on every protocol
+ * because it forces a synthetic tool call internally — provider-native JSON
+ * modes are intentionally avoided so behaviour is uniform.
+ *
+ * Two input modes:
+ *
+ * 1. `schema: EffectSchema<T>` — `.object` is decoded and typed as `T`.
+ *    Decode failures surface as `AIError`.
+ * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
+ *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
+ */
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(options: GenerateObjectOptions<S, SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>;
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel>(options: GenerateObjectDynamicOptions<SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>;
+export {};

package/dist/llm.js

@@ -0,0 +1,74 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { LLMClient, Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputError, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolEntry, } from "./schema/index.js";
+import { make as makeTool, toDefinitions } from "./tool.js";
+export const generate = LLMClient.generate;
+export const stream = LLMClient.stream;
+export const request = (input) => {
+    const { system: requestSystem, prompt, messages, tools, toolChoice: requestToolChoice, generation: requestGeneration, providerOptions: requestProviderOptions, http: requestHttp, ...rest } = input;
+    return new LLMRequest({
+        ...rest,
+        system: SystemPart.content(requestSystem),
+        messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
+        tools: tools?.map(ToolEntry.make) ?? [],
+        toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
+        generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
+        providerOptions: requestProviderOptions,
+        http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
+    });
+};
+const GENERATE_OBJECT_TOOL_NAME = "generate_object";
+const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool.";
+export class GenerateObjectResponse {
+    object;
+    response;
+    constructor(object, response) {
+        this.object = object;
+        this.response = response;
+    }
+    get events() {
+        return this.response.events;
+    }
+    get usage() {
+        return this.response.usage;
+    }
+}
+const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, tool) {
+    const baseRequest = request(options);
+    const generateRequest = LLMRequest.update(baseRequest, {
+        tools: toDefinitions({ [GENERATE_OBJECT_TOOL_NAME]: tool }),
+        toolChoice: ToolChoice.named(GENERATE_OBJECT_TOOL_NAME),
+    });
+    const response = yield* LLMClient.generate(generateRequest);
+    const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
+    if (!call || !LLMEvent.is.toolCall(call))
+        return yield* new AIError({
+            reason: new InvalidProviderOutputError({
+                message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
+            }),
+        });
+    const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new AIError({
+        reason: new InvalidProviderOutputError({
+            message: `generateObject: tool input failed schema decode: ${error.message}`,
+            cause: error,
+        }),
+    })));
+    return new GenerateObjectResponse(object, response);
+});
+export function generateObject(options) {
+    if ("schema" in options) {
+        const { schema, ...rest } = options;
+        return runGenerateObject(rest, makeTool({
+            description: GENERATE_OBJECT_TOOL_DESCRIPTION,
+            parameters: schema,
+            success: Schema.Unknown,
+            execute: () => Effect.void,
+        }));
+    }
+    const { jsonSchema, ...rest } = options;
+    return runGenerateObject(rest, makeTool({
+        description: GENERATE_OBJECT_TOOL_DESCRIPTION,
+        jsonSchema,
+        execute: () => Effect.void,
+    }));
+}

package/dist/protocols/alibaba-chat.d.ts

@@ -0,0 +1,225 @@
+import { Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+import { OpenResponsesOptions } from "./utils/open-responses-options.js";
+export type ReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+declare const Options: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
+    readonly enableThinking: Schema.optional<Schema.Boolean>;
+    readonly thinkingBudget: Schema.optional<Schema.Int>;
+    readonly preserveThinking: Schema.optional<Schema.Boolean>;
+    readonly clearThinking: Schema.optional<Schema.Boolean>;
+    readonly thinking: Schema.optional<Schema.Struct<{
+        readonly type: Schema.declare<"disabled" | (string & {}) | "adaptive", "disabled" | (string & {}) | "adaptive">;
+    }>>;
+    readonly toolStream: Schema.optional<Schema.Boolean>;
+    readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
+    readonly repetitionPenalty: Schema.optional<Schema.Number>;
+    readonly responseFormat: Schema.optional<Schema.Struct<{
+        readonly type: Schema.declare<(string & {}) | "text" | "json_schema" | "json_object", (string & {}) | "text" | "json_schema" | "json_object">;
+        readonly json_schema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>>;
+    readonly enableSearch: Schema.optional<Schema.Boolean>;
+    readonly searchOptions: Schema.optional<Schema.Struct<{
+        readonly forced_search: Schema.optional<Schema.Boolean>;
+        readonly search_strategy: Schema.optional<Schema.declare<(string & {}) | "agent" | "max" | "turbo" | "agent_max", (string & {}) | "agent" | "max" | "turbo" | "agent_max">>;
+        readonly enable_search_extension: Schema.optional<Schema.Boolean>;
+    }>>;
+}>;
+export type OptionsInput = typeof Options.Type;
+export declare const compatibility: {
+    maxTokensField: "max_completion_tokens";
+    supportsStore: false;
+    supportsStrictMode: false;
+    reasoningField: string;
+    zaiToolStream: false;
+};
+export declare const protocol: Protocol<{
+    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 thinking?: {
+        readonly type: "disabled" | (string & {}) | "adaptive";
+    } | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly top_k?: 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 reasoning_effort?: OpenResponsesOptions.ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+    readonly enable_thinking?: boolean | undefined;
+    readonly thinking_budget?: number | undefined;
+    readonly preserve_thinking?: boolean | undefined;
+    readonly clear_thinking?: boolean | undefined;
+    readonly repetition_penalty?: number | undefined;
+    readonly response_format?: {
+        readonly type: (string & {}) | "text" | "json_schema" | "json_object";
+        readonly json_schema?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | undefined;
+    readonly enable_search?: boolean | undefined;
+    readonly search_options?: {
+        readonly forced_search?: boolean | undefined;
+        readonly search_strategy?: (string & {}) | "agent" | "max" | "turbo" | "agent_max" | undefined;
+        readonly enable_search_extension?: boolean | undefined;
+    } | undefined;
+}, string, "[DONE]" | {
+    readonly [x: string]: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly [x: string]: unknown;
+        readonly cached_tokens?: number | null | undefined;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
+        readonly prompt_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
+        } | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly reasoning_tokens?: number | null | undefined;
+            readonly accepted_prediction_tokens?: number | null | undefined;
+            readonly rejected_prediction_tokens?: number | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
+        readonly [x: string]: unknown;
+        readonly delta?: {
+            readonly [x: string]: unknown;
+            readonly reasoning?: string | null | undefined;
+            readonly reasoning_content?: string | null | undefined;
+            readonly reasoning_text?: string | null | undefined;
+            readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
+            readonly tool_calls?: readonly {
+                readonly function?: {
+                    readonly name?: string | null | undefined;
+                    readonly arguments?: string | null | undefined;
+                } | null | undefined;
+                readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
+            }[] | null | undefined;
+            readonly reasoning_details?: unknown;
+        } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
+}, OpenAIChat.ParserState>;
+export * as AlibabaChat from "./alibaba-chat.js";

package/dist/protocols/alibaba-chat.js

@@ -0,0 +1,75 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+import { JsonObject, ProviderShared } from "./shared.js";
+import { OpenResponsesOptions } from "./utils/open-responses-options.js";
+const Options = Schema.Struct({
+    reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
+    enableThinking: Schema.optional(Schema.Boolean),
+    thinkingBudget: Schema.optional(Schema.Int),
+    preserveThinking: Schema.optional(Schema.Boolean),
+    clearThinking: Schema.optional(Schema.Boolean),
+    thinking: Schema.optional(Schema.Struct({
+        type: Schema.declare(Schema.is(Schema.String)),
+    })),
+    toolStream: Schema.optional(Schema.Boolean),
+    parallelToolCalls: OpenResponsesOptions.Options.fields.parallelToolCalls,
+    repetitionPenalty: Schema.optional(Schema.Number),
+    responseFormat: Schema.optional(Schema.Struct({
+        type: Schema.declare(Schema.is(Schema.String)),
+        json_schema: Schema.optional(JsonObject),
+    })),
+    enableSearch: Schema.optional(Schema.Boolean),
+    searchOptions: Schema.optional(Schema.Struct({
+        forced_search: Schema.optional(Schema.Boolean),
+        search_strategy: Schema.optional(Schema.declare(Schema.is(Schema.String))),
+        enable_search_extension: Schema.optional(Schema.Boolean),
+    })),
+});
+export const compatibility = {
+    maxTokensField: "max_completion_tokens",
+    supportsStore: false,
+    supportsStrictMode: false,
+    reasoningField: "reasoning_content",
+    zaiToolStream: false,
+};
+export const protocol = Protocol.make({
+    id: "alibaba-chat",
+    body: {
+        schema: Schema.Struct({
+            ...OpenAIChat.bodyFields,
+            enable_thinking: Options.fields.enableThinking,
+            thinking_budget: Options.fields.thinkingBudget,
+            preserve_thinking: Options.fields.preserveThinking,
+            clear_thinking: Options.fields.clearThinking,
+            thinking: Options.fields.thinking,
+            parallel_tool_calls: Options.fields.parallelToolCalls,
+            repetition_penalty: Options.fields.repetitionPenalty,
+            top_k: Schema.optional(Schema.Int),
+            response_format: Options.fields.responseFormat,
+            enable_search: Options.fields.enableSearch,
+            search_options: Options.fields.searchOptions,
+        }),
+        from: Effect.fn("AlibabaChat.fromRequest")(function* (req) {
+            const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
+            return {
+                ...(yield* OpenAIChat.protocol.body.from(req)),
+                enable_thinking: opts.enableThinking,
+                thinking_budget: opts.thinkingBudget,
+                preserve_thinking: opts.preserveThinking,
+                clear_thinking: opts.clearThinking,
+                thinking: opts.thinking,
+                tool_stream: opts.toolStream,
+                parallel_tool_calls: opts.parallelToolCalls ??
+                    (req.toolChoice?.disableParallelToolUse === undefined ? undefined : !req.toolChoice.disableParallelToolUse),
+                repetition_penalty: opts.repetitionPenalty,
+                top_k: req.generation?.topK,
+                response_format: opts.responseFormat,
+                enable_search: opts.enableSearch,
+                search_options: opts.searchOptions,
+            };
+        }),
+    },
+    stream: OpenAIChat.protocol.stream,
+});
+export * as AlibabaChat from "./alibaba-chat.js";