Merge remote-tracking branch 'henry701/dev' into dev

Integrate upstream provider reasoning variant changes and drop fork-only
sdk reasoning_options sanitization superseded by upstream transform logic.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: henry701

.opencode/tool/github-triage.ts

@@ -4,7 +4,7 @@ import { tool } from "@opencode-ai/plugin"
 const TEAM = {
   tui: ["kommander", "simonklee"],
   desktop_web: ["Hona", "Brendonovich"],
-  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton", "starptech"],
+  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton"],
   inference: ["fwang", "MrMushrooooom", "starptech"],
   windows: ["Hona"],
 } as const

packages/app/src/components/prompt-input.tsx

@@ -2410,7 +2410,7 @@ function ModelControlContent(props: { state: ComposerModelControlState; v2?: boo
           />
         )}
       </Show>
-      <span class="truncate">{props.state.modelName}</span>
+      <span class="truncate leading-4">{props.state.modelName}</span>
       <span class={props.v2 ? "-ml-0.5 -mr-1 flex shrink-0" : "-ml-1 shrink-0 flex size-fit"}>
         <Icon name="chevron-down" size="small" class="text-v2-icon-icon-muted" />
       </span>

packages/app/src/components/prompt-workspace-selector.tsx

@@ -1,5 +1,6 @@
 import { For, Show } from "solid-js"
 import { MenuV2 } from "@opencode-ai/ui/v2/menu-v2"
+import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { getFilename } from "@opencode-ai/core/util/path"
@@ -96,10 +97,17 @@ export function PromptWorkspaceSelector(props: {
         {(branch) => (
           <>
             <span class="hidden select-none opacity-50 sm:inline mx-1">/</span>
-            <div class="flex h-7 min-w-0 max-w-[220px] items-center gap-1.5 px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px]">
-              <Icon name="branch" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-              <span class="min-w-0 truncate">{branch()}</span>
-            </div>
+            <TooltipV2
+              placement="top"
+              value={branch()}
+              class="min-w-0 max-w-[220px]"
+              contentClass="max-w-[calc(100vw-32px)] break-all"
+            >
+              <div class="flex h-7 min-w-0 max-w-[220px] items-center gap-1.5 px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px]">
+                <Icon name="branch" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+                <span class="min-w-0 truncate">{branch()}</span>
+              </div>
+            </TooltipV2>
           </>
         )}
       </Show>

packages/core/src/models-dev.ts

@@ -44,18 +44,31 @@ const Cost = Schema.Struct({
   ),
 })
 
+const ReasoningOption = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("effort"),
+    values: Schema.Array(Schema.NullOr(Schema.String)),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("toggle"),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("budget_tokens"),
+    min: Schema.optional(Schema.Finite),
+    max: Schema.optional(Schema.Finite),
+  }),
+])
+
 export const Model = Schema.Struct({
   id: Schema.String,
   name: Schema.String,
   family: Schema.optional(Schema.String),
   release_date: Schema.String,
   attachment: Schema.Boolean,
   reasoning: Schema.Boolean,
-  // models.dev is external metadata and reasoning controls are expected to evolve.
-  // Provider normalization extracts the subset understood by this client.
-  reasoning_options: Schema.optional(Schema.Unknown),
   temperature: Schema.Boolean,
   tool_call: Schema.Boolean,
+  reasoning_options: Schema.optional(Schema.Array(ReasoningOption)),
   interleaved: Schema.optional(
     Schema.Union([
       Schema.Literal(true),

packages/core/test/models.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, beforeAll, beforeEach, afterAll, test } from "bun:test"
-import { Effect, Layer, Ref, Schema } from "effect"
+import { describe, expect, beforeAll, beforeEach, afterAll } from "bun:test"
+import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
@@ -126,21 +126,6 @@ const initialState: MockState = {
   calls: [],
 }
 
-test("models.dev model schema keeps reasoning options permissive", () => {
-  const model = Schema.decodeUnknownSync(ModelsDev.Model)({
-    id: "acme-1",
-    name: "Acme One",
-    release_date: "2026-01-01",
-    attachment: false,
-    reasoning: true,
-    reasoning_options: [{ type: "future_control", value: { nested: true } }, "future-shape"],
-    temperature: true,
-    tool_call: true,
-    limit: { context: 128000, output: 8192 },
-  })
-  expect(model.reasoning_options).toEqual([{ type: "future_control", value: { nested: true } }, "future-shape"])
-})
-
 describe("ModelsDev Service", () => {
   it.live("get() returns providers from disk when cache file exists", () =>
     Effect.gen(function* () {

packages/opencode/src/plugin/openai/codex.ts

@@ -285,6 +285,7 @@ export async function CodexAuthPlugin(input: PluginInput, options: CodexAuthPlug
             .filter(([, model]) => {
               if (ALLOWED_MODELS.has(model.api.id)) return true
               if (DISALLOWED_MODELS.has(model.api.id)) return false
+              if (model.api.id === "gpt-5.6") return false
               const match = model.api.id.match(/^gpt-(\d+\.\d+)/)
               return match ? parseFloat(match[1]) > 5.4 : false
             })

packages/opencode/src/provider/provider.ts

@@ -982,21 +982,6 @@ const ProviderInterleaved = Schema.Union([
   }),
 ])
 
-const ProviderReasoningOption = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("effort"),
-    values: Schema.Array(Schema.NullOr(Schema.String)),
-  }),
-  Schema.Struct({
-    type: Schema.Literal("toggle"),
-  }),
-  Schema.Struct({
-    type: Schema.Literal("budget_tokens"),
-    min: optional(Schema.Finite),
-    max: optional(Schema.Finite),
-  }),
-])
-
 const ProviderCapabilities = Schema.Struct({
   temperature: Schema.Boolean,
   reasoning: Schema.Boolean,
@@ -1055,7 +1040,6 @@ export const Model = Schema.Struct({
   options: Schema.Record(Schema.String, Schema.Any),
   headers: Schema.Record(Schema.String, Schema.String),
   release_date: Schema.String,
-  reasoning_options: optional(Schema.Array(ProviderReasoningOption)),
   variants: optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Any))),
 }).annotate({ identifier: "Model" })
 export type Model = Types.DeepMutable<Schema.Schema.Type<typeof Model>>
@@ -1091,11 +1075,7 @@ export function toPublicInfo(provider: Info): Info {
     JSON.stringify(
       {
         ...provider,
-        models: Object.fromEntries(
-          Object.entries(provider.models)
-            .filter(([, model]) => Schema.is(Model)(model))
-            .map(([id, model]) => [id, publicModel(model)]),
-        ),
+        models: Object.fromEntries(Object.entries(provider.models).filter(([, model]) => Schema.is(Model)(model))),
       },
       (_, value) => {
         if (typeof value === "function" || typeof value === "symbol" || value === undefined) return undefined
@@ -1223,66 +1203,6 @@ function cost(c: ModelsDev.Model["cost"]): Model["cost"] {
   return result
 }
 
-type ReasoningOption = NonNullable<Model["reasoning_options"]>[number]
-
-function reasoningOptions(input: unknown): Model["reasoning_options"] {
-  if (!Array.isArray(input)) return []
-  return input.flatMap((option) => {
-    const normalized = normalizeReasoningOption(option)
-    return normalized ? [normalized] : []
-  })
-}
-
-function normalizeReasoningOption(option: unknown): ReasoningOption | undefined {
-  if (!isRecord(option)) return
-  if (option.type === "effort") {
-    if (!Array.isArray(option.values)) return
-    return {
-      type: "effort",
-      values: option.values.filter((value): value is string | null => value === null || typeof value === "string"),
-    }
-  }
-  if (option.type === "toggle") return { type: "toggle" }
-  if (option.type !== "budget_tokens") return
-  const min = typeof option.min === "number" && Number.isFinite(option.min) ? option.min : undefined
-  const max = typeof option.max === "number" && Number.isFinite(option.max) ? option.max : undefined
-  return {
-    type: "budget_tokens",
-    ...(min === undefined ? {} : { min }),
-    ...(max === undefined ? {} : { max }),
-  }
-}
-
-type PublicReasoningOption = NonNullable<import("@opencode-ai/sdk/v2").Model["reasoning_options"]>[number]
-
-function publicReasoningOptions(options: Model["reasoning_options"]): PublicReasoningOption[] | undefined {
-  if (!options) return undefined
-  const next: PublicReasoningOption[] = []
-  for (const option of options) {
-    if (option.type === "effort") {
-      const values = option.values.filter((value): value is string => typeof value === "string")
-      if (values.length > 0) next.push({ type: "effort", values })
-      continue
-    }
-    if (option.type === "toggle") {
-      next.push({ type: "toggle" })
-      continue
-    }
-    next.push({
-      type: "budget_tokens",
-      ...(option.min === undefined ? {} : { min: option.min }),
-      ...(option.max === undefined ? {} : { max: option.max }),
-    })
-  }
-  return next.length > 0 ? next : undefined
-}
-
-export function publicModel(model: Model): Model {
-  const reasoning_options = publicReasoningOptions(model.reasoning_options)
-  if (reasoning_options === undefined) return model
-  return { ...model, reasoning_options: reasoning_options as Model["reasoning_options"] }
-}
-
 function fromModelsDevModel(provider: ModelsDev.Provider, model: ModelsDev.Model): Model {
   const base: Model = {
     id: ModelV2.ID.make(model.id),
@@ -1325,13 +1245,14 @@ function fromModelsDevModel(provider: ModelsDev.Provider, model: ModelsDev.Model
       interleaved: model.interleaved ?? false,
     },
     release_date: model.release_date ?? "",
-    reasoning_options: reasoningOptions(model.reasoning_options),
     variants: {},
   }
 
+  const variants = ProviderTransform.reasoningVariants(model, base) ?? ProviderTransform.variants(base)
+
   return {
     ...base,
-    variants: mapValues(ProviderTransform.variants(base), (v) => v),
+    variants: mapValues(variants, (v) => v),
   }
 }
 
@@ -1572,10 +1493,13 @@ const layer = Layer.effect(
               headers: mergeDeep(existingModel?.headers ?? {}, model.headers ?? {}),
               family: model.family ?? existingModel?.family ?? "",
               release_date: model.release_date ?? existingModel?.release_date ?? "",
-              reasoning_options: existingModel?.reasoning_options,
               variants: {},
             }
-            const merged = mergeDeep(ProviderTransform.variants(parsedModel), model.variants ?? {})
+            const variants =
+              existingModel?.api.npm === parsedModel.api.npm
+                ? (existingModel.variants ?? ProviderTransform.variants(parsedModel))
+                : ProviderTransform.variants(parsedModel)
+            const merged = mergeDeep(variants, model.variants ?? {})
             parsedModel.variants = mapValues(
               pickBy(merged, (v) => !v.disabled),
               (v) => omit(v, ["disabled"]),
@@ -1703,7 +1627,7 @@ const layer = Layer.effect(
             )
               delete provider.models[modelID]
 
-            if (!model.variants || Object.keys(model.variants).length === 0) {
+            if (model.variants === undefined) {
               model.variants = mapValues(ProviderTransform.variants(model), (v) => v)
             }