@opencode/ai 0.0.0-dev-19364 → 0.0.0-dev-19366

package/README.md

@@ -29,6 +29,78 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+## Alibaba Cloud Model Studio
+
+`Alibaba` provides standard Model Studio inference. Configure a region explicitly, then select
+Chat Completions (`.model` or `.chat`), Anthropic-compatible Messages (`.messages`), or OpenAI-compatible
+Responses (`.responses`). These routes use HTTP/SSE.
+
+```ts
+import { LLM } from "@opencode/ai"
+import { Alibaba } from "@opencode/ai/providers"
+
+const alibaba = Alibaba.configure({
+  region: "ap-southeast-1", // Singapore
+  apiKey: process.env.DASHSCOPE_API_KEY,
+  // workspaceID: "llm-your-workspace", // use a workspace-dedicated endpoint
+})
+
+const request = LLM.request({
+  model: alibaba.model("qwen3.8-max"),
+  prompt: "Explain this design.",
+  providerOptions: { reasoningEffort: "medium" },
+})
+```
+
+### Regions and credentials
+
+| Region              | `region`         | Shared host when `workspaceID` is omitted |
+| ------------------- | ---------------- | ----------------------------------------- |
+| Singapore           | `ap-southeast-1` | `dashscope-intl.aliyuncs.com`             |
+| China (Beijing)     | `cn-beijing`     | `dashscope.aliyuncs.com`                  |
+| China (Hong Kong)   | `cn-hongkong`    | `cn-hongkong.dashscope.aliyuncs.com`      |
+| US (Virginia)       | `us-east-1`      | `dashscope-us.aliyuncs.com`               |
+| Germany (Frankfurt) | `eu-central-1`   | Supply `workspaceID` or `baseURL`         |
+| Japan (Tokyo)       | `ap-northeast-1` | Supply `workspaceID` or `baseURL`         |
+
+With `workspaceID`, the host is `{workspaceID}.{region}.maas.aliyuncs.com`. A complete `baseURL`
+overrides regional setup, including the API prefix: `/compatible-mode/v1` for Chat/Responses,
+or `/apps/anthropic/v1` for Messages. The selector appends its operation path.
+
+Keys and model availability are region-specific. Auth resolves from explicit `auth` or `apiKey`,
+then `DASHSCOPE_API_KEY`, then `ALIBABA_API_KEY`.
+
+The access region and inference scope differ: Virginia's `-us` model IDs request US-only inference;
+some regions select scope through their workspace. Model IDs pass through unchanged.
+Alibaba's [regional guide](https://www.alibabacloud.com/help/en/model-studio/regions) and
+[base URL table](https://www.alibabacloud.com/help/en/model-studio/base-url) disagree about Virginia's
+shared host; the entry above follows the base URL table. Dedicated hosts can be copied from the console.
+
+### Native options
+
+- **Chat:** `reasoningEffort` → `reasoning_effort`, `enableThinking` → `enable_thinking`,
+  `thinkingBudget` → `thinking_budget`, and `preserveThinking` → `preserve_thinking`.
+  Replay complete `response.message` values to retain `reasoning_content` separately from answer text.
+  Qwen 3.8 defaults to preserving thinking; older models have different defaults.
+  Additional options include `toolStream`, `parallelToolCalls`, `repetitionPenalty`, `responseFormat`,
+  `enableSearch`, and native `searchOptions`. `generation.topK` lowers to `top_k`.
+  `clearThinking` is a hosted GLM control, and `thinking.type` is available for hosted MiniMax models.
+- **Messages:** `effort` → `output_config.effort`. `thinking.type` accepts enabled/disabled with an
+  optional `budgetTokens` (or native `budget_tokens`). `outputConfig.format` accepts a JSON schema.
+  Model Studio's empty thinking signatures are accepted; supplied signatures are replayed unchanged.
+- **Responses:** `reasoningEffort` → `reasoning.effort`, plus `enableThinking`, `store`,
+  `previousResponseId`, and `conversation`. Omitted `store` retains the API's default (`true`);
+  set it to `false` for client-managed history. `previousResponseId` requires a stored response.
+  Hosted tools are `Alibaba.webSearch()`, `Alibaba.webExtractor()`, and `Alibaba.codeInterpreter()`.
+  Web extraction is used together with web search. Hosted calls/results carry `providerExecuted: true`.
+
+Omitted options preserve provider defaults. Effort values pass through unchanged and accept future
+strings. Qwen 3.8 Chat rejects requests combining a thinking budget with effort.
+
+Package entrypoints are `@opencode/ai/providers/alibaba`, `alibaba/chat`, `alibaba/messages`,
+and `alibaba/responses`. Live recordings cover all three APIs in Singapore; regional URL construction
+is unit-tested for all six regions.
+
 ## Z.AI
 
 `ZAI` uses the standard API. Chat Completions is the default language-model API;

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";