diff --git a/AGENTS.md b/AGENTS.md
index 94f6f22..45c6414 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -136,16 +136,18 @@ tsdown.config.ts      Build config (tsdown -> lib/, ESM, .d.ts + client.js).
   declaration never exists and `slots.inject` never fires — the registration
   silently does not happen; do not "harden" that into an error.
 - **Wire protocol** (reverse-engineered, command-code@1.28.4; re-verified unchanged against 1.44.0):
-  - `POST {apiBase}/alpha/generate` — body `{ config, memory, taste, skills, params: { model, messages, tools, system, max_tokens, temperature, stream, reasoning_effort? }, threadId }`.
-  - Image parts use the official CLI wire shape: `{ type: 'image', source: { type: 'base64', media_type, data } }` (NOT pi's `data:` data-URI form).
-  - Stream: SSE-ish JSONL events `text-delta | reasoning-start/delta/end | tool-call | tool-result | finish | error`.
+  - `POST {apiBase}/alpha/generate` — CLI transport body `{ config, memory, taste, skills, params: { model, messages, tools, system, max_tokens, temperature, stream, reasoning_effort? }, threadId }`. Used for Go-plan accounts (the only plan without Provider API access) and as the fallback when `/provider/v1/chat/completions` returns `upgrade_required`.
+  - `POST {apiBase}/provider/v1/chat/completions` — documented OpenAI-format transport with a flat body `{ model, messages, tools?, max_tokens, temperature, stream, reasoning_effort? }`. Used for accounts with Provider API access; historical reasoning is replayed as `reasoning_content`.
+  - Image parts use the official CLI wire shape on `/alpha/generate`: `{ type: 'image', source: { type: 'base64', media_type, data } }`; OpenAI `/provider/v1/chat/completions` uses `{ type: 'image_url', image_url: { url: 'data:...' } }`.
+  - CLI stream: SSE-ish JSONL events `text-delta | reasoning-start/delta/end | tool-call | tool-result | finish | error`.
+  - OpenAI stream: standard SSE chunks with `delta.reasoning` / `delta.reasoning_content` / `delta.content` / `delta.tool_calls`, a `finish_reason`, and optional `usage`.
   - Catalog: `GET {apiBase}/provider/v1/models` → `{ object: 'list', data: [{ id, name, context_length }] }`.
   - Web search: `POST {apiBase}/alpha/web-search` — body `{ query, numResults, allowedDomains?, blockedDomains? }` → `{ results: [{ title, url, snippet }] }`; same `Authorization: Bearer <key>` + `x-command-code-version` as generate.
   - Defaults: `apiBase = https://api.commandcode.ai`, `COMMAND_CODE_CLI_VERSION = '1.44.0'`.
 - **API key resolution order** (in `src/index.ts`): `config.apiKey` → credential ref `apiKeyEnv` (default `COMMANDCODE_API_KEY`, via the dsh credentials seam) → launch environment → official CLI auth file `~/.commandcode/auth.json`. **pi/OMP auth files are intentionally NOT scanned** — keep it that way.
 - **Multi-account rotation** (`src/accounts.ts` + the adapter's connect loop): the top-level key forms the `default` slot; `Config.accounts` (`[{ label, apiKeyEnv | apiKey }]`) adds more, in rotation order. Rotation is **passive**: a key is marked only on a real pre-stream rejection (429 → `unknown` cooldown, 401 → `disabled`), and the adapter's `rotateApiKey` hook re-sends the same request with the next account's key (safe: nothing streamed, the body is account-independent, `threadId` random per request — mid-stream failures NEVER rotate). When every account is marked, the pool probes `/alpha/billing/credits` per key (`probeFiveHourWindow`) to revive reset windows, else throws `RATE_LIMIT` naming the earliest `resetAt` (all-401 → `INVALID_CREDENTIAL`). State is keyed by API key, not slot — shared credentials share one mark. **Manual selection**: `Config.activeAccount` (a slot id) pins the serving account via the pool's `preferredId` seam + `selectActiveAccount()` (shared with the usage view's active badge); a pinned-but-exhausted or unknown id falls back to rotation order. **Model routing**: `Config.modelAccountRules` (`[{ models: string[], account }]`) lists catalog model ids per account slot; the request's model reaches key resolution (`resolveApiKey(connection, model)`), the pool's `modelAccountRules` seam re-reads rules per resolution, and `matchModelRule()`/`selectAccountForModel()` serve the routed account before preferred/rotation — an unusable routed account falls back, so the router is a hint, never a hard gate. The rules editor's model list comes from a Host-side `commandcode/models` Remote (adapter catalog, sorted), so the browser never calls the Command Code API; `SettingsPageApi.models` is optional, so legacy transports degrade to the empty-catalog state. Extra-account slot ids are the credential reference itself (`COMMANDCODE_API_KEY_2`, …) so a stored selection survives list reorders/removals; only literal-only composition entries keep positional `account-N` ids. The settings page edits `activeAccount` through the generic section-field machinery (a `<select>` bound to a text field) and `modelAccountRules` through its own rules card (staged rows like `accounts`, one `modelAccountRules` write). The picker's billing-access cache is per key. The usage Remote result is `CommandCodeAccountsReport` (`{ accounts: [...] }`); host and client ship in one bundle, so wire-shape changes need no migration — only synced edits in `src/usage-wire.ts`, `src/usage-remote.ts`, `src/client/usage.ts`, and `src/commands.ts`.
 - **Web search (`src/web-search.ts` + the optional `web` seam)**: the model-facing `web_search` tool (from `@deepseek-ai/dsh-tool-web`) is served by a `CommandCodeSearchProvider` registered as `commandcode` on `ctx.web` — same `Authorization: Bearer <key>` + `x-command-code-version` chain, same `apiBase`, so DSH's web search needs NO separate key/endpoint config (unlike `dsh-web-search-deepseek`, which needs its own Anthropic-compatible base). It POSTs `{ query, numResults, allowedDomains?, blockedDomains? }` to `/alpha/web-search` and maps `{ title, url, snippet }` → `WebSearchSource`. Registration rides `ctx.inject(['web'], ...)` exactly like `commands`/`typert`: the provider is registered only when the profile mounts the web service, and the fiber never activates otherwise (this stays an LLM-provider-only plugin without web). The pool's `resolveKey()` (rotation + auth-file revived) is reused, so search benefits from the same multi-account selection; the search endpoint is account-independent so no mid-flight rotation happens. **Selection**: whether the `commandcode` provider WINS over the shipped `deepseek-official` is `Config.webSearch` (default on). The web seam has NO public runtime selector, so the plugin writes its private `searchProviderId` field (read per call by `web.search()`) via `selectCommandCodeSearchProvider()` in `src/web-search.ts` — applied at boot AND on every settings change (the `installSection` `onChange` hook). That write depends on the runtime shape (a plain writable property, not `#private`); the durable alternative is the boot-time `searchProvider: commandcode` cordis patch. `dsh-web` is a `^0.1.2-rc.1` peer (kept external in tsdown); `tests/web-search.test.ts` pins the wire body, header, result mapping, the `WEB_ABORTED`/`WEB_PROVIDER_CREDENTIAL_MISSING`/`WEB_PROVIDER_ERROR` taxonomy, and the selection-field rewrite.
-- **StreamChunk contract** (dsh-llm): each block starts with `block-start`, deltas by `index`, ends with `block-end`; `usage` before `finish`; nothing after `finish`. Tool-call `arguments` are raw JSON strings. Reasoning blocks are intentionally NOT replayed into later turns (matches the CLI; private reasoning must not leak). Only tool calls with a paired tool result are replayed.
+- **StreamChunk contract** (dsh-llm): each block starts with `block-start`, deltas by `index`, ends with `block-end`; `usage` before `finish`; nothing after `finish`. Tool-call `arguments` are raw JSON strings. On the legacy `/alpha/generate` transport, reasoning blocks are intentionally NOT replayed into later turns (matches the CLI; private reasoning must not leak); on the `/provider/v1/chat/completions` transport they are passed back as `reasoning_content` for tool-loop continuity. Only tool calls with a paired tool result are replayed on both transports.
 - **Errors**: throw `LlmError` with stable codes. 401 → `INVALID_CREDENTIAL`; 429 → `RATE_LIMIT`; other HTTP → `PROVIDER_HTTP_ERROR` (403 body's `error.code`, e.g. `MODEL_NOT_IN_PLAN`, is parsed into the message). Unsupported options (`stop`) and image input throw `UNSUPPORTED_OPTION` / `UNSUPPORTED_CONTENT` rather than silently dropping.
 - **Adapter is cordis-free** by design: `src/adapter.ts` takes a per-request `options()` thunk + `resolveApiKey()` from the plugin entry, so settings changes reach the next request without re-registration. It also accepts an injectable `fetchImpl` for tests.
 - **Usage Remote (`commandcode/report`)**: the settings page's account card
diff --git a/README.md b/README.md
index e17d963..7dc2bed 100644
--- a/README.md
+++ b/README.md
@@ -151,7 +151,7 @@ When your deployment's dsh shell mounts the web capability (`@deepseek-ai/dsh-we
 - **Image input is model-gated** — only Vision models accept images; text-only models refuse them.
 - Switching to a text-only model in an image-bearing session is rejected by dsh — pick a model marked *`Image`* or remove the images first.
 - **No `stop` sequences** — requests carrying one fail.
-- Reasoning blocks are not replayed into later turns; only tool calls with a paired tool result are replayed.
+- On the legacy `/alpha/generate` transport, reasoning blocks are not replayed into later turns; on the `/provider/v1/chat/completions` transport, historical reasoning is passed back as `reasoning_content` so tool-calling loops can keep their chain of thought. Only tool calls with a paired tool result are replayed on both transports.
 - The model catalog is browsable without a key; chat requests need one.
 
 ## Permissions & privacy
diff --git a/README.zh-CN.md b/README.zh-CN.md
index aeb5932..8669db7 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -149,7 +149,7 @@ llm-commandcode:
 - **图片输入按模型能力限制**：仅 Vision 模型接受图片，纯文本模型会直接拒绝。
 - 含图片的会话切换到纯文本模型会被 dsh 拒绝——请改选带 *`Image`* 标记的模型，或先移除图片。
 - **不支持 `stop` 序列**：携带它的请求会报错。
-- 推理块不会重放到后续轮次；只有带配对工具结果的工具调用会被重放。
+- 在旧版 `/alpha/generate` 传输中，推理块不会重放到后续轮次；在 `/provider/v1/chat/completions` 传输中，历史推理会以 `reasoning_content` 回传，以便工具调用循环保留思维链。两种传输都只重放带配对工具结果的工具调用。
 - 模型目录无需 key 即可浏览；对话请求需要 key。
 
 ## 权限与隐私
diff --git a/src/adapter.ts b/src/adapter.ts
index 3cd2867..27083e2 100644
--- a/src/adapter.ts
+++ b/src/adapter.ts
@@ -70,6 +70,14 @@ export const DEFAULT_MAX_OUTPUT_TOKENS = 65_536
 export const MODELS_TIMEOUT_MS = 10_000
 /** How long the picker's plan-filter billing facts stay cached before refetching. */
 export const BILLING_ACCESS_TTL_MS = 5 * 60_000
+/**
+ * How long a learned CLI-only protocol preference stays cached per account.
+ * After this TTL a request may probe Provider API again, so an upgraded Go
+ * account can recover without a restart.
+ */
+export const PROTOCOL_CACHE_TTL_MS = 15 * 60_000
+/** Endpoint protocol selected for one generate call. */
+type CommandCodeProtocol = 'cli' | 'openai'
 
 /**
  * Subscription statuses the CLI treats as live (`Mr` in command-code's
@@ -263,9 +271,13 @@ async function writeModelsCache(cachePath: string, models: CommandCodeModel[]):
 
 // ---------------------------------------------------------------------------
 // Message conversion: harness Message[] -> Command Code wire messages.
-// Reasoning blocks are intentionally NOT replayed (matches the pi plugin and
-// the official CLI: prior private reasoning must not leak into later turns).
-// Only tool calls with a paired tool result are replayed.
+// The legacy /alpha/generate transport intentionally does NOT replay reasoning
+// blocks (matches the pi plugin and the official CLI of that era; prior
+// private reasoning must not leak into later turns). The documented
+// /provider/v1/chat/completions transport DOES replay them as
+// `reasoning_content`, because DeepSeek's thinking-mode contract requires it
+// when tools are in play. Only tool calls with a paired tool result are
+// replayed on both transports.
 // ---------------------------------------------------------------------------
 
 /**
@@ -406,6 +418,118 @@ async function messagesToCC(
   return out
 }
 
+/**
+ * Convert one image reference to the OpenAI Chat Completions wire format:
+ * `{ type: 'image_url', image_url: { url: 'data:...;base64,...' } }`.
+ */
+async function imageToOpenAI(
+  ref: ImageAttachmentRef,
+  readImage: (ref: ImageAttachmentRef) => Promise<Uint8Array>,
+): Promise<{ type: 'image_url'; image_url: { url: string } }> {
+  const data = await readImage(ref)
+  return {
+    type: 'image_url',
+    image_url: {
+      url: `data:${ref.mediaType};base64,${Buffer.from(data).toString('base64')}`,
+    },
+  }
+}
+
+/**
+ * Convert harness messages to the OpenAI Chat Completions request shape.
+ *
+ * Unlike the Command Code CLI transport, this transport is the documented
+ * Provider API surface. DeepSeek's thinking-mode contract requires historical
+ * `reasoning_content` to be passed back whenever tools are in play, so this
+ * converter intentionally DOES replay reasoning blocks as `reasoning_content`
+ * on assistant messages. Only tool calls with a paired tool result are
+ * replayed (same policy as the CLI path).
+ */
+async function messagesToOpenAI(
+  messages: readonly Message[],
+  readImage?: (ref: ImageAttachmentRef) => Promise<Uint8Array>,
+): Promise<unknown[]> {
+  const out: unknown[] = []
+  const { ids: paired } = pairedToolCalls(messages)
+
+  for (const message of messages) {
+    // System messages are folded into the single top-level system message by
+    // the caller, matching the existing adapter's conversation folding.
+    if (message.role === 'system') continue
+
+    if (message.role === 'user' && message.source.kind !== 'tool') {
+      const parts: unknown[] = []
+      for (const block of message.content) {
+        if (block.type === 'text') parts.push({ type: 'text', text: block.text })
+        if (block.type === 'image') {
+          if (!readImage) {
+            throw new LlmError(
+              'Image input requires the durable attachment service',
+              'UNSUPPORTED_CONTENT',
+            )
+          }
+          parts.push(await imageToOpenAI(block.attachment, readImage))
+        }
+      }
+      if (parts.length === 0) continue
+      const hasImage = parts.some((part) => (part as { type?: string }).type === 'image_url')
+      if (!hasImage && parts.length === 1) {
+        out.push({ role: 'user', content: (parts[0] as { text: string }).text })
+      } else {
+        // Preserve separate text/image parts rather than silently joining
+        // text blocks together.
+        out.push({ role: 'user', content: parts })
+      }
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      const text = message.content
+        .filter((block): block is Extract<ContentBlock, { type: 'text' }> => block.type === 'text')
+        .map((block) => block.text)
+        .join('')
+      const reasoning = message.content
+        .filter((block): block is Extract<ContentBlock, { type: 'reasoning' }> => block.type === 'reasoning')
+        .map((block) => block.text)
+        .join('')
+      const toolCalls = message.content
+        .filter((block): block is Extract<ContentBlock, { type: 'tool-call' }> => block.type === 'tool-call' && paired.has(block.id))
+        .map((block) => ({
+          id: block.id,
+          type: 'function' as const,
+          function: {
+            name: block.name,
+            arguments: block.arguments,
+          },
+        }))
+
+      if (text === '' && reasoning === '' && toolCalls.length === 0) continue
+      const assistant: Record<string, unknown> = {
+        role: 'assistant',
+        content: text === '' ? null : text,
+      }
+      // Chat Completions / DeepSeek thinking mode: replay historical reasoning
+      // so tool-calling loops can continue from the previous chain of thought.
+      if (reasoning !== '') assistant.reasoning_content = reasoning
+      if (toolCalls.length > 0) assistant.tool_calls = toolCalls
+      out.push(assistant)
+      continue
+    }
+
+    // tool-result message (user role, single tool-result block)
+    if (message.role === 'user' && message.source.kind === 'tool') {
+      const block = message.content[0]
+      if (!block || block.type !== 'tool-result' || !paired.has(block.toolCallId)) continue
+      out.push({
+        role: 'tool',
+        tool_call_id: block.toolCallId,
+        content: toolResultText(block),
+      })
+    }
+  }
+  return out
+}
+
 // ---------------------------------------------------------------------------
 // Adapter
 // ---------------------------------------------------------------------------
@@ -432,6 +556,13 @@ export interface CommandCodeConnectionOptions {
    * keep the full catalog visible. Set false to always list every model.
    */
   filterModelsByPlan?: boolean
+  /**
+   * Optional protocol override. `'auto'` (default) uses billing/cache plus
+   * Provider API fallback; `'cli'` forces `/alpha/generate`; `'openai'` forces
+   * `/provider/v1/chat/completions`. This is a connection-level test/operator
+   * seam and is intentionally not part of the plugin's user settings schema.
+   */
+  protocol?: 'auto' | CommandCodeProtocol
 }
 
 /**
@@ -547,6 +678,11 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
   // the resolved API key (process-local only, never logged).
   private readonly billingAccess = new Map<string, { value: CommandCodeBillingAccess | undefined; at: number }>()
   private readonly billingAccessInflight = new Map<string, Promise<CommandCodeBillingAccess | undefined>>()
+  // Protocol preference is per account: the Go plan is the only plan without
+  // Provider API access, and that fact is independent of model. A negative
+  // result (provider API rejected this key with upgrade_required) is cached so
+  // every request does not pay the double TTFT of probing then falling back.
+  private readonly protocolCache = new Map<string, { useCli: boolean; at: number }>()
 
   constructor(private readonly deps: CommandCodeAdapterDeps<C>) {
     super()
@@ -778,6 +914,42 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
     }
   }
 
+  /** Fresh cached billing tier weight for a key, or undefined when not known. */
+  private cachedBillingTierWeight(apiKey: string): number | undefined {
+    const hit = this.billingAccess.get(apiKey)
+    if (hit === undefined || Date.now() - hit.at >= BILLING_ACCESS_TTL_MS) return undefined
+    return hit.value?.tierWeight
+  }
+
+  /** Cached protocol decision for a key, or undefined when expired/unknown. */
+  private cachedProtocolUseCli(apiKey: string): boolean | undefined {
+    const hit = this.protocolCache.get(apiKey)
+    if (hit === undefined || Date.now() - hit.at >= PROTOCOL_CACHE_TTL_MS) return undefined
+    return hit.useCli
+  }
+
+  private rememberProtocol(apiKey: string, useCli: boolean): void {
+    this.protocolCache.set(apiKey, { useCli, at: Date.now() })
+  }
+
+  /**
+   * Choose the initial protocol for one request. A fresh protocol cache entry
+   * wins; otherwise a cached (not network-fetched) billing tier of Go is
+   * treated as CLI-only. Unknown accounts default to Provider API and fall
+   * back only after an `upgrade_required` rejection.
+   */
+  private resolveProtocol(apiKey: string): CommandCodeProtocol {
+    const forced = this.deps.options().protocol
+    if (forced === 'cli' || forced === 'openai') return forced
+    const cached = this.cachedProtocolUseCli(apiKey)
+    if (cached !== undefined) return cached ? 'cli' : 'openai'
+    if (this.cachedBillingTierWeight(apiKey) === 0) {
+      this.rememberProtocol(apiKey, true)
+      return 'cli'
+    }
+    return 'openai'
+  }
+
   /**
    * Fetch account, usage, credit, and subscription state from the Command
    * Code account endpoints (`/alpha/whoami`, `/alpha/usage/summary`,
@@ -1004,38 +1176,67 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
       .filter(Boolean)
       .join('\n\n')
 
-    const body = {
-      config: {
-        workingDir: connection.workingDir,
-        date: new Date().toISOString().split('T')[0],
-        environment: `${process.platform}-${process.arch}, Node.js ${process.version}`,
-        structure: [],
-        isGitRepo: false,
-        currentBranch: '',
-        mainBranch: '',
-        gitStatus: '',
-        recentCommits: [],
-      },
-      memory: null,
-      taste: null,
-      skills: null,
-      params: {
-        model: options.model,
-        messages: await messagesToCC(options.messages, readImage),
-        tools: (options.tools ?? []).map((tool) => ({
-          type: 'function',
+    // Endpoint protocol: billing/cache may know Go plan -> CLI; unknown
+    // accounts default to the documented Provider Chat Completions surface.
+    let protocol: CommandCodeProtocol = this.resolveProtocol(apiKey)
+    const buildBody = async (target: CommandCodeProtocol): Promise<Record<string, unknown>> => {
+      if (target === 'cli') {
+        return {
+          config: {
+            workingDir: connection.workingDir,
+            date: new Date().toISOString().split('T')[0],
+            environment: `${process.platform}-${process.arch}, Node.js ${process.version}`,
+            structure: [],
+            isGitRepo: false,
+            currentBranch: '',
+            mainBranch: '',
+            gitStatus: '',
+            recentCommits: [],
+          },
+          memory: null,
+          taste: null,
+          skills: null,
+          params: {
+            model: options.model,
+            messages: await messagesToCC(options.messages, readImage),
+            tools: (options.tools ?? []).map((tool) => ({
+              type: 'function',
+              name: tool.name,
+              description: tool.description,
+              input_schema: tool.parameters,
+            })),
+            system: systemText,
+            max_tokens: maxTokens,
+            temperature: options.temperature ?? 0.3,
+            stream: true,
+            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+          },
+          threadId: randomUUID(),
+        }
+      }
+      const openAiMessages = [
+        ...(systemText ? [{ role: 'system', content: systemText }] : []),
+        ...(await messagesToOpenAI(options.messages, readImage)),
+      ]
+      const openAiTools = (options.tools ?? []).map((tool) => ({
+        type: 'function',
+        function: {
           name: tool.name,
           description: tool.description,
-          input_schema: tool.parameters,
-        })),
-        system: systemText,
+          parameters: tool.parameters,
+        },
+      }))
+      return {
+        model: options.model,
+        messages: openAiMessages,
+        ...(openAiTools.length > 0 ? { tools: openAiTools } : {}),
         max_tokens: maxTokens,
         temperature: options.temperature ?? 0.3,
         stream: true,
         ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
-      },
-      threadId: randomUUID(),
+      }
     }
+    let body: Record<string, unknown> = await buildBody(protocol)
 
     // requestTimeoutMs must only bound the wait for response headers.
     // Passing AbortSignal.timeout() straight into fetch() also aborts a healthy
@@ -1052,11 +1253,14 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
     ): Promise<{ response: Response; cleanup: () => void } | { status: number; errText: string; retryAfterMs?: number }> => {
       const connectAbort = new AbortController()
       let connectTimedOut = false
+      const endpoint = protocol === 'cli'
+        ? `${connection.apiBase}/alpha/generate`
+        : `${connection.apiBase}/provider/v1/chat/completions`
       const connectTimer = setTimeout(() => {
         connectTimedOut = true
         connectAbort.abort(
           new DOMException(
-            `Command Code API request to ${connection.apiBase}/alpha/generate did not respond within ${connection.requestTimeoutMs}ms`,
+            `Command Code API request to ${endpoint} did not respond within ${connection.requestTimeoutMs}ms`,
             'TimeoutError',
           ),
         )
@@ -1082,10 +1286,8 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
       }
 
       let response: Response
-      try {
-        response = await this.fetchImpl(`${connection.apiBase}/alpha/generate`, {
-          method: 'POST',
-          headers: {
+      const headers = protocol === 'cli'
+        ? {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${key}`,
             'x-command-code-version': COMMAND_CODE_CLI_VERSION,
@@ -1094,7 +1296,17 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
             'x-taste-learning': 'true',
             'x-co-flag': 'false',
             ...attributionHeaders(),
-          },
+          }
+        : {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${key}`,
+            Accept: 'text/event-stream',
+            ...attributionHeaders(),
+          }
+      try {
+        response = await this.fetchImpl(endpoint, {
+          method: 'POST',
+          headers,
           body: JSON.stringify(body),
           signal: connectAbort.signal,
         })
@@ -1106,7 +1318,7 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
         }
         if (connectTimedOut || (error instanceof DOMException && error.name === 'TimeoutError')) {
           throw new LlmError(
-            `Command Code API request to ${connection.apiBase}/alpha/generate did not respond within ${connection.requestTimeoutMs}ms`
+            `Command Code API request to ${endpoint} did not respond within ${connection.requestTimeoutMs}ms`
             + `: ${errorChain(error)}`
             + `；Command Code API 请求在 ${connection.requestTimeoutMs} 毫秒内未收到响应——通常是网络或代理问题，请检查后重试`,
             'TIMEOUT',
@@ -1119,7 +1331,7 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
         // shown in the web UI (which renders only the message, not `cause`)
         // names the real root cause instead of a generic wrapper.
         throw new LlmError(
-          `Command Code API request to ${connection.apiBase}/alpha/generate failed: ${errorChain(error)}`
+          `Command Code API request to ${endpoint} failed: ${errorChain(error)}`
           + '；Command Code API 请求连接失败——通常是网络或代理问题，请检查网络或代理设置后重试',
           'TRANSPORT',
           { cause: error },
@@ -1150,6 +1362,19 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
         connected = attempt
         break
       }
+      // Provider API is the preferred surface for non-Go accounts. If the
+      // gateway says the key is on the Go plan (the only plan without API
+      // access), remember that and retry the same key through /alpha/generate
+      // without burning the double TTFT on every later request.
+      if (
+        protocol === 'openai'
+        && isUpgradeRequiredError(attempt.status, attempt.errText)
+      ) {
+        protocol = 'cli'
+        this.rememberProtocol(apiKey, true)
+        body = await buildBody('cli')
+        continue
+      }
       const rotate = this.deps.rotateApiKey
       if (
         (attempt.status === 429 || attempt.status === 401)
@@ -1230,7 +1455,7 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
       reasoningContent = ''
     }
 
-    const handleEvent = (event: unknown): StreamChunk[] => {
+    const handleCliEvent = (event: unknown): StreamChunk[] => {
       const chunks: StreamChunk[] = []
       if (!isRecord(event)) return chunks
 
@@ -1340,6 +1565,106 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
       return chunks
     }
 
+    // OpenAI Chat Completions streams are standard SSE chunks. Reasoning is
+    // delivered in either `reasoning_content` (DeepSeek-style) or the Command
+    // Code Provider API's `reasoning` field; both map to harness reasoning.
+    const openAiToolCalls: Array<{ index: number; id?: string; name: string; arguments: string }> = []
+    const emitOpenAiToolCalls = function* (): Generator<StreamChunk> {
+      for (const call of openAiToolCalls) {
+        const id = call.id ?? randomUUID()
+        const name = call.name ?? ''
+        const args = call.arguments || '{}'
+        const index = nextIndex++
+        sawContent = true
+        yield { type: 'block-start', index, blockType: 'tool-call' }
+        yield { type: 'tool-call-delta', index, id: ToolCallId(id), name, argumentsDelta: args }
+        yield {
+          type: 'block-end',
+          index,
+          block: { type: 'tool-call', id: ToolCallId(id), name, arguments: args },
+        }
+      }
+      openAiToolCalls.length = 0
+    }
+    const handleOpenAIEvent = (event: unknown): StreamChunk[] => {
+      const chunks: StreamChunk[] = []
+      if (!isRecord(event)) return chunks
+      const choices = event.choices
+      if (!Array.isArray(choices) || choices.length === 0) {
+        // A standalone usage chunk (some OpenAI-compatible servers send it
+        // before [DONE]) still carries usage.
+        if (event.usage !== undefined) {
+          chunks.push({ type: 'usage', usage: mapOpenAIUsage(event.usage) })
+        }
+        return chunks
+      }
+      const choice = isRecord(choices[0]) ? choices[0] : {}
+      const delta = isRecord(choice.delta) ? choice.delta : {}
+
+      const reasoningDelta = stringValue(delta.reasoning) ?? stringValue(delta.reasoning_content) ?? ''
+      if (reasoningDelta !== '') {
+        chunks.push(...closeText())
+        if (reasoningIndex < 0) {
+          reasoningIndex = nextIndex++
+          chunks.push({ type: 'block-start', index: reasoningIndex, blockType: 'reasoning' })
+        }
+        reasoningContent += reasoningDelta
+        chunks.push({ type: 'reasoning-delta', index: reasoningIndex, text: reasoningDelta })
+      }
+
+      const contentDelta = stringValue(delta.content) ?? ''
+      if (contentDelta !== '') {
+        chunks.push(...closeReasoning())
+        if (textIndex < 0) {
+          textIndex = nextIndex++
+          chunks.push({ type: 'block-start', index: textIndex, blockType: 'text' })
+        }
+        textContent += contentDelta
+        sawContent = true
+        chunks.push({ type: 'text-delta', index: textIndex, text: contentDelta })
+      }
+
+      if (Array.isArray(delta.tool_calls)) {
+        sawContent = true
+        for (const rawCall of delta.tool_calls) {
+          if (!isRecord(rawCall)) continue
+          const callIndex = numberValue(rawCall.index) ?? 0
+          let existing = openAiToolCalls.find((call) => call.index === callIndex)
+          const fn = isRecord(rawCall.function) ? rawCall.function : undefined
+          const id = stringValue(rawCall.id)
+          const name = fn === undefined ? undefined : stringValue(fn.name)
+          const argDelta = fn === undefined
+            ? undefined
+            : (stringValue(fn.arguments) ?? (fn.arguments === undefined ? '' : JSON.stringify(fn.arguments)))
+          if (!existing) {
+            existing = {
+              index: callIndex,
+              name: name ?? '',
+              arguments: argDelta ?? '',
+            }
+            if (id !== undefined) existing.id = id
+            openAiToolCalls.push(existing)
+          } else {
+            if (id !== undefined && existing.id === undefined) existing.id = id
+            if (name !== undefined && existing.name === '') existing.name = name
+            if (argDelta !== undefined) existing.arguments += argDelta
+          }
+        }
+      }
+
+      if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
+        chunks.push(...closeText(), ...closeReasoning(), ...emitOpenAiToolCalls())
+        if (event.usage !== undefined) {
+          chunks.push({ type: 'usage', usage: mapOpenAIUsage(event.usage) })
+        }
+        chunks.push({ type: 'finish', reason: mapOpenAIFinishReason(choice.finish_reason) })
+      }
+      return chunks
+    }
+
+    const handleEvent = (event: unknown): StreamChunk[] =>
+      protocol === 'openai' ? handleOpenAIEvent(event) : handleCliEvent(event)
+
     try {
       let finished = false
       for (;;) {
@@ -1393,6 +1718,7 @@ export class CommandCodeAdapter<C extends CommandCodeConnectionOptions = Command
         // terminate according to the adapter contract (usage, then finish).
         yield* closeText()
         yield* closeReasoning()
+        if (protocol === 'openai') yield* emitOpenAiToolCalls()
         if (!sawContent) {
           throw new LlmError('Command Code returned an empty response；Command Code 返回了空响应，重试通常可恢复', 'EMPTY_RESPONSE')
         }
@@ -1489,3 +1815,66 @@ function mapFinishReason(reason: unknown): FinishReason {
   }
   return { kind: 'stop' }
 }
+
+function mapOpenAIFinishReason(reason: unknown): FinishReason {
+  if (reason === 'tool_calls' || reason === 'tool-calls') return { kind: 'tool-calls' }
+  if (
+    reason === 'length' ||
+    reason === 'max_tokens' ||
+    reason === 'max-tokens' ||
+    reason === 'max_output_tokens'
+  ) {
+    return { kind: 'max-tokens' }
+  }
+  return { kind: 'stop' }
+}
+
+/**
+ * True when a Provider API pre-stream rejection is Command Code's Go-plan
+ * gate (`upgrade_required`). Only this exact class of rejection should fall
+ * back to the CLI /alpha/generate transport; other 4xx/5xx must surface as
+ * ordinary errors so real account/model problems are not masked.
+ */
+function isUpgradeRequiredError(status: number, errText: string): boolean {
+  if (status !== 403) return false
+  const lower = errText.toLowerCase()
+  if (lower.includes('upgrade_required')) return true
+  if (lower.includes('go plan') && lower.includes('api access')) return true
+  if (lower.includes('only plan without api access')) return true
+  if (lower.includes('upgrade to goat or higher')) return true
+  try {
+    const parsed: unknown = JSON.parse(errText)
+    if (isRecord(parsed)) {
+      const error = isRecord(parsed.error) ? parsed.error : parsed
+      const code = stringValue(error.code) ?? stringValue(error.type)
+      if (code?.toLowerCase() === 'upgrade_required') return true
+      const message = stringValue(error.message) ?? ''
+      if (message.toLowerCase().includes('go plan') && message.toLowerCase().includes('api access')) return true
+    }
+  } catch {
+    // Already handled via the plain-text substring checks above.
+  }
+  return false
+}
+
+/** Map an OpenAI Chat Completions usage payload to harness disjoint counts. */
+function mapOpenAIUsage(usage: unknown): TokenUsage {
+  const source = isRecord(usage) ? usage : {}
+  const promptTokens = numberValue(source.prompt_tokens) ?? 0
+  const outputTokens = numberValue(source.completion_tokens) ?? 0
+  const totalTokens = numberValue(source.total_tokens)
+  const promptDetails = isRecord(source.prompt_tokens_details) ? source.prompt_tokens_details : undefined
+  const cacheRead = numberValue(promptDetails?.cached_tokens) ?? 0
+  const cacheWrite = numberValue(promptDetails?.cache_creation_input_tokens) ?? 0
+  const completionDetails = isRecord(source.completion_tokens_details) ? source.completion_tokens_details : undefined
+  const reasoningTokens = numberValue(completionDetails?.reasoning_tokens)
+  const usageOut: TokenUsage = {
+    inputTokens: Math.max(0, promptTokens - cacheRead - cacheWrite),
+    outputTokens,
+    cacheReadTokens: cacheRead,
+  }
+  if (cacheWrite > 0) usageOut.cacheWriteTokens = cacheWrite
+  if (reasoningTokens !== undefined) usageOut.reasoningTokens = reasoningTokens
+  if (totalTokens !== undefined) usageOut.totalTokens = totalTokens
+  return usageOut
+}
diff --git a/tests/adapter.test.ts b/tests/adapter.test.ts
index 1888902..f5c2155 100644
--- a/tests/adapter.test.ts
+++ b/tests/adapter.test.ts
@@ -64,14 +64,18 @@ function fetchReturning(
 }
 
 function makeAdapter(overrides: Partial<CommandCodeAdapterDeps> = {}): CommandCodeAdapter {
+  const options = overrides.options
   return new CommandCodeAdapter({
-    options: () => ({
+    options: options ?? (() => ({
       apiBase: 'https://api.commandcode.ai',
       workingDir: '/tmp/project',
       modelsCachePath: '/tmp/cc-models-cache.json',
       requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
       streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
-    }),
+      // Existing adapter tests pin the legacy CLI transport; Provider API
+      // tests opt in by overriding options.protocol.
+      protocol: 'cli' as const,
+    })),
     resolveApiKey: async () => 'user_test_key',
     ...overrides,
   })
@@ -681,6 +685,208 @@ test('stream() maps max-tokens finish reason', async () => {
   assert.equal(finish.reason.kind, 'max-tokens')
 })
 
+// ---------------------------------------------------------------------------
+// OpenAI Chat Completions protocol
+// ---------------------------------------------------------------------------
+
+test('openai protocol sends flat body and replays reasoning_content in history', async () => {
+  let capturedUrl: string | undefined
+  let capturedBody: Record<string, unknown> | undefined
+  const fetchImpl = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    capturedUrl = String(input)
+    capturedBody = JSON.parse(String(init?.body))
+    return new Response('data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n', {
+      status: 200,
+      headers: { 'content-type': 'text/event-stream' },
+    })
+  }) as unknown as typeof fetch
+
+  const adapter = makeAdapter({
+    options: () => ({
+      apiBase: 'https://api.commandcode.ai',
+      workingDir: '/tmp/project',
+      modelsCachePath: '/tmp/cc-models-cache.json',
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+      streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+      protocol: 'openai' as const,
+    }),
+    fetchImpl,
+  })
+  const callId = 'call-1'
+  const messages: Message[] = [
+    userMessage('weather?'),
+    {
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'I will look it up.' },
+        { type: 'reasoning', text: 'I need the weather tool.' },
+        { type: 'tool-call', id: callId as never, name: 'get_weather', arguments: '{}' },
+      ],
+      source: { kind: 'model', provider: 'commandcode', model: 'm' },
+    },
+    {
+      role: 'user',
+      content: [{ type: 'tool-result', toolCallId: callId as never, isError: false, content: [{ type: 'text', text: 'sunny' }] }],
+      source: { kind: 'tool', callId: callId as never },
+    },
+  ]
+  await collect(adapter.stream({ provider: 'commandcode', model: 'deepseek/deepseek-v4-flash', messages }))
+
+  assert.equal(capturedUrl, 'https://api.commandcode.ai/provider/v1/chat/completions')
+  assert.ok(capturedBody)
+  assert.equal(capturedBody.model, 'deepseek/deepseek-v4-flash')
+  const wireMessages = capturedBody.messages as Record<string, unknown>[]
+  const assistant = wireMessages.find((m) => m.role === 'assistant')!
+  assert.equal(assistant.reasoning_content, 'I need the weather tool.')
+  assert.equal(assistant.content, 'I will look it up.')
+  const toolCalls = assistant.tool_calls as { id: string; type: string; function: { name: string; arguments: string } }[]
+  assert.equal(toolCalls.length, 1)
+  assert.equal(toolCalls[0]!.id, callId)
+  assert.equal(toolCalls[0]!.function.name, 'get_weather')
+  assert.equal(toolCalls[0]!.function.arguments, '{}')
+  const tool = wireMessages.find((m) => m.role === 'tool') as { tool_call_id: string; content: string }
+  assert.equal(tool.tool_call_id, callId)
+  assert.equal(tool.content, 'sunny')
+})
+
+test('openai protocol parses reasoning + content SSE into separate blocks', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"reasoning":"think"}}]}',
+    'data: {"choices":[{"delta":{"content":"Answer"}}]}',
+    'data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15,"prompt_tokens_details":{"cached_tokens":2},"completion_tokens_details":{"reasoning_tokens":3}}}',
+    'data: [DONE]',
+    '',
+  ].join('\n')
+  const adapter = makeAdapter({
+    options: () => ({
+      apiBase: 'https://api.commandcode.ai',
+      workingDir: '/tmp/project',
+      modelsCachePath: '/tmp/cc-models-cache.json',
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+      streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+      protocol: 'openai' as const,
+    }),
+    fetchImpl: fetchReturning(200, sse, { 'content-type': 'text/event-stream' }),
+  })
+  const chunks = await collect(adapter.stream({ provider: 'commandcode', model: 'm', messages: [userMessage('hi')] }))
+  const reasoningBlocks = chunks.filter((c) => c.type === 'block-start' && (c as { blockType: string }).blockType === 'reasoning')
+  const textBlocks = chunks.filter((c) => c.type === 'block-start' && (c as { blockType: string }).blockType === 'text')
+  assert.equal(reasoningBlocks.length, 1)
+  assert.equal(textBlocks.length, 1)
+  const reasoning = chunks.find((c) => c.type === 'reasoning-delta') as { text: string }
+  assert.equal(reasoning.text, 'think')
+  const text = chunks.find((c) => c.type === 'text-delta') as { text: string }
+  assert.equal(text.text, 'Answer')
+  const usage = chunks.find((c) => c.type === 'usage') as { usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number; reasoningTokens?: number } }
+  assert.equal(usage.usage.inputTokens, 8)
+  assert.equal(usage.usage.outputTokens, 5)
+  assert.equal(usage.usage.cacheReadTokens, 2)
+  assert.equal(usage.usage.reasoningTokens, 3)
+  const finish = chunks.find((c) => c.type === 'finish') as { reason: { kind: string } }
+  assert.equal(finish.reason.kind, 'stop')
+})
+
+test('openai protocol assembles streamed tool-call fragments', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"bash","arguments":""}}]}}]}',
+    'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"command\\":"}}]}}]}',
+    'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\\"ls\\"}"}}]}}]}',
+    'data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}',
+    'data: [DONE]',
+    '',
+  ].join('\n')
+  const adapter = makeAdapter({
+    options: () => ({
+      apiBase: 'https://api.commandcode.ai',
+      workingDir: '/tmp/project',
+      modelsCachePath: '/tmp/cc-models-cache.json',
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+      streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+      protocol: 'openai' as const,
+    }),
+    fetchImpl: fetchReturning(200, sse, { 'content-type': 'text/event-stream' }),
+  })
+  const chunks = await collect(adapter.stream({ provider: 'commandcode', model: 'm', messages: [userMessage('hi')] }))
+  const finish = chunks.find((c) => c.type === 'finish') as { reason: { kind: string } }
+  assert.equal(finish.reason.kind, 'tool-calls')
+  const call = chunks.find((c) => c.type === 'block-end' && (c as { block: { type: string } }).block.type === 'tool-call') as {
+    block: { id: string; name: string; arguments: string }
+  }
+  assert.ok(call)
+  assert.equal(call.block.id, 'call_1')
+  assert.equal(call.block.name, 'bash')
+  assert.deepEqual(JSON.parse(call.block.arguments), { command: 'ls' })
+})
+
+test('openai protocol accepts reasoning_content as the reasoning field', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"reasoning_content":"standard thinking"}}]}',
+    'data: {"choices":[{"delta":{"content":"ok"},"finish_reason":"stop"}]}',
+    'data: [DONE]',
+    '',
+  ].join('\n')
+  const adapter = makeAdapter({
+    options: () => ({
+      apiBase: 'https://api.commandcode.ai',
+      workingDir: '/tmp/project',
+      modelsCachePath: '/tmp/cc-models-cache.json',
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+      streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+      protocol: 'openai' as const,
+    }),
+    fetchImpl: fetchReturning(200, sse, { 'content-type': 'text/event-stream' }),
+  })
+  const chunks = await collect(adapter.stream({ provider: 'commandcode', model: 'm', messages: [userMessage('hi')] }))
+  const reasoningBlocks = chunks.filter((c) => c.type === 'block-start' && (c as { blockType: string }).blockType === 'reasoning')
+  assert.equal(reasoningBlocks.length, 1)
+  const reasoning = chunks.find((c) => c.type === 'reasoning-delta') as { text: string }
+  assert.equal(reasoning.text, 'standard thinking')
+})
+
+test('auto protocol falls back to CLI on 403 upgrade_required and caches per account', async () => {
+  const calls: string[] = []
+  const fetchImpl = (async (input: RequestInfo | URL) => {
+    const url = String(input)
+    calls.push(url)
+    if (url.includes('/provider/v1/chat/completions')) {
+      return new Response(JSON.stringify({ error: { code: 'upgrade_required', message: 'Go plan has no API access' } }), {
+        status: 403,
+        headers: { 'content-type': 'application/json' },
+      })
+    }
+    return new Response('data: {"type":"text-delta","text":"hi"}\n\ndata: {"type":"finish","finishReason":"stop"}\n\n', {
+      status: 200,
+      headers: { 'content-type': 'text/event-stream' },
+    })
+  }) as unknown as typeof fetch
+
+  const options = () => ({
+    apiBase: 'https://api.commandcode.ai',
+    workingDir: '/tmp/project',
+    modelsCachePath: '/tmp/cc-models-cache.json',
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+  })
+  const adapter = new CommandCodeAdapter({
+    options,
+    resolveApiKey: async () => 'user_test_key',
+    fetchImpl,
+  })
+
+  const firstChunks = await collect(adapter.stream({ provider: 'commandcode', model: 'deepseek/deepseek-v4-flash', messages: [userMessage('hi')] }))
+  assert.ok(firstChunks.some((c) => c.type === 'text-delta'))
+  assert.equal(calls.length, 2)
+  assert.ok(calls[0]!.includes('/provider/v1/chat/completions'))
+  assert.ok(calls[1]!.includes('/alpha/generate'))
+
+  // Second request should go straight to /alpha/generate because the key's
+  // Go-plan rejection is remembered for PROTOCOL_CACHE_TTL_MS.
+  const secondChunks = await collect(adapter.stream({ provider: 'commandcode', model: 'deepseek/deepseek-v4-flash', messages: [userMessage('hi')] }))
+  assert.ok(secondChunks.some((c) => c.type === 'text-delta'))
+  assert.equal(calls.length, 3)
+  assert.ok(calls[2]!.includes('/alpha/generate'))
+})
+
 // ---------------------------------------------------------------------------
 // HTTP error mapping
 // ---------------------------------------------------------------------------
@@ -873,6 +1079,7 @@ test('stream() does not abort a healthy body when elapsed time exceeds requestTi
       modelsCachePath: '/tmp/cc-models-cache.json',
       requestTimeoutMs: 20,
       streamIdleTimeoutMs: 10_000,
+      protocol: 'cli' as const,
     }),
     fetchImpl: (async () => new Response(body, { status: 200 })) as unknown as typeof fetch,
   })