fix(core): migrate the v1 thinking block-binding opt-out

packages/client/src/promise/generated/types.ts

@@ -1467,6 +1467,7 @@ export type ModelCompatibility = {
   requireFinishReason?: boolean
   requireAssistantAfterTool?: boolean
   supportsPromptCacheKey?: boolean
+  supportsThinkingBlockBinding?: boolean
 }
 
 export type ModelCost = {

packages/core/src/v1/config/migrate.ts

@@ -302,7 +302,20 @@ export function providerID(input: string) {
 }
 
 function migrateModel(info: typeof ConfigProviderV1.Model.Type) {
-  const settings = info.options && ConfigProviderOptionsV1.model(info.options)
+  // V1 opted out of Anthropic thinking block binding with `blockBinding: false` in the model's provider options.
+  // V2 reads that decision from compatibility, so move it there instead of forwarding an option nothing consumes.
+  const optOut = (["thinking", "reasoningConfig"] as const).find((key) => info.options?.[key]?.blockBinding === false)
+  const options =
+    optOut && info.options
+      ? Object.fromEntries(
+          Object.entries(info.options).flatMap(([key, value]) => {
+            if (key !== optOut) return [[key, value]]
+            const { blockBinding, ...rest } = value
+            return Object.keys(rest).length ? [[key, rest]] : []
+          }),
+        )
+      : info.options
+  const settings = options && ConfigProviderOptionsV1.model(options)
   const costs = info.cost && [
     {
       input: info.cost.input,
@@ -333,7 +346,9 @@ function migrateModel(info: typeof ConfigProviderV1.Model.Type) {
     modelID: info.id,
     family: info.family,
     name: info.name,
-    compatibility: Model.compatibility(info.interleaved),
+    compatibility: optOut
+      ? { ...Model.compatibility(info.interleaved), supportsThinkingBlockBinding: false }
+      : Model.compatibility(info.interleaved),
     package: info.provider?.npm ? Provider.aisdk(info.provider.npm) : undefined,
     settings: info.provider?.api ? { ...settings, baseURL: info.provider.api } : settings,
     capabilities,

packages/core/test/config/normalization.test.ts

@@ -481,6 +481,34 @@ describe("ConfigNormalize", () => {
     ])
   })
 
+  test("migrates the legacy thinking block-binding opt-out into model compatibility", () => {
+    const result = normalized({
+      provider: {
+        gateway: {
+          models: {
+            anthropic: { options: { thinking: { type: "adaptive", blockBinding: false }, effort: "high" } },
+            bedrock: { options: { reasoningConfig: { blockBinding: false } } },
+            untouched: { options: { thinking: { type: "adaptive" } } },
+          },
+        },
+      },
+    })
+    expect(result.encoded.providers).toMatchObject({
+      gateway: {
+        models: {
+          anthropic: {
+            compatibility: { supportsThinkingBlockBinding: false },
+            settings: { thinking: { type: "adaptive" }, effort: "high" },
+          },
+          bedrock: { compatibility: { supportsThinkingBlockBinding: false }, settings: {} },
+          untouched: { settings: { thinking: { type: "adaptive" } } },
+        },
+      },
+    })
+    expect(result.encoded.providers).not.toHaveProperty(["gateway", "models", "bedrock", "settings", "reasoningConfig"])
+    expect(result.encoded.providers).not.toHaveProperty(["gateway", "models", "untouched", "compatibility"])
+  })
+
   test("invalid legacy provider overlays skip only that provider", () => {
     const result = normalized({
       provider: {

packages/schema/src/model.ts

@@ -80,6 +80,7 @@ export const Compatibility = Schema.Struct({
   requireFinishReason: Schema.Boolean.pipe(optional),
   requireAssistantAfterTool: Schema.Boolean.pipe(optional),
   supportsPromptCacheKey: Schema.Boolean.pipe(optional),
+  supportsThinkingBlockBinding: Schema.Boolean.pipe(optional),
 }).annotate({ identifier: "Model.Compatibility" })
 
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {}