fix(runtime): emit camelCase OpenAI-compatible provider option keys

packages/runtime/src/__tests__/model-factory-thinking.test.ts

@@ -264,7 +264,7 @@ describe('buildProviderOptions: thinking level', () => {
     });
     // Copilot defaults to its OpenAI-compatible chat wire without a protocol hint.
     assert.deepEqual(buildProviderOptions(conn('github-copilot'), 'gpt-5.4', 'high'), {
-      'github-copilot': { reasoningEffort: 'high' },
+      githubCopilot: { reasoningEffort: 'high' },
     });
   });
 
@@ -295,20 +295,20 @@ describe('buildProviderOptions: thinking level', () => {
     );
     assert.deepEqual(buildProviderOptions(conn('cloudflare-workers-ai'), modelId), {});
     assert.deepEqual(buildProviderOptions(conn('cloudflare-workers-ai'), modelId, 'high'), {
-      'cloudflare-workers-ai': { reasoningEffort: 'high' },
+      cloudflareWorkersAi: { reasoningEffort: 'high' },
     });
     assert.deepEqual(buildProviderOptions(conn('cloudflare-workers-ai'), modelId, 'off'), {
-      'cloudflare-workers-ai': { chat_template_kwargs: { thinking: false } },
+      cloudflareWorkersAi: { chat_template_kwargs: { thinking: false } },
     });
   });
 
   test('StepFun Step Plan sends only officially supported reasoning effort levels', () => {
     assert.deepEqual(buildProviderOptions(conn('stepfun-step-plan'), 'step-3.7-flash', 'medium'), {
-      'stepfun-step-plan': { reasoningEffort: 'medium' },
+      stepfunStepPlan: { reasoningEffort: 'medium' },
     });
     assert.deepEqual(
       buildProviderOptions(conn('stepfun-step-plan'), 'step-3.5-flash-2603', 'high'),
-      { 'stepfun-step-plan': { reasoningEffort: 'high' } },
+      { stepfunStepPlan: { reasoningEffort: 'high' } },
     );
     assert.deepEqual(
       buildProviderOptions(conn('stepfun-step-plan'), 'step-3.5-flash-2603', 'medium'),
@@ -329,13 +329,13 @@ describe('buildProviderOptions: thinking level', () => {
       ['off', 'minimal', 'low', 'medium', 'high'],
     );
     assert.deepEqual(buildProviderOptions(conn('volcengine-ark'), modelId), {
-      'volcengine-ark': { thinking: { type: 'enabled' } },
+      volcengineArk: { thinking: { type: 'enabled' } },
     });
     assert.deepEqual(buildProviderOptions(conn('volcengine-ark'), modelId, 'high'), {
-      'volcengine-ark': { thinking: { type: 'enabled' }, reasoningEffort: 'high' },
+      volcengineArk: { thinking: { type: 'enabled' }, reasoningEffort: 'high' },
     });
     assert.deepEqual(buildProviderOptions(conn('volcengine-ark'), modelId, 'off'), {
-      'volcengine-ark': { thinking: { type: 'disabled' } },
+      volcengineArk: { thinking: { type: 'disabled' } },
     });
   });
 
@@ -369,7 +369,7 @@ describe('buildProviderOptions: thinking level', () => {
       ['low', 'medium', 'high'],
     );
     assert.deepEqual(buildProviderOptions(conn('tencent-token-plan'), 'hy3', 'high'), {
-      'tencent-token-plan': { reasoningEffort: 'high' },
+      tencentTokenPlan: { reasoningEffort: 'high' },
     });
     assert.deepEqual(buildProviderOptions(conn('tencent-token-plan'), 'hy3', 'off'), {});
   });
@@ -394,17 +394,17 @@ describe('buildProviderOptions: thinking level', () => {
       ['off', 'low', 'medium', 'high', 'max'],
     );
     assert.deepEqual(buildProviderOptions(conn('ollama-cloud'), 'glm-5.2', 'high'), {
-      'ollama-cloud': { reasoningEffort: 'high' },
+      ollamaCloud: { reasoningEffort: 'high' },
     });
     assert.deepEqual(buildProviderOptions(conn('ollama-cloud'), 'glm-5.2', 'off'), {
-      'ollama-cloud': { reasoningEffort: 'none' },
+      ollamaCloud: { reasoningEffort: 'none' },
     });
     assert.deepEqual(
       [...thinkingVariantsForModel('ollama-cloud', 'gpt-oss:120b')],
       ['low', 'medium', 'high'],
     );
     assert.deepEqual(buildProviderOptions(conn('ollama-cloud'), 'gpt-oss:120b', 'high'), {
-      'ollama-cloud': { reasoningEffort: 'high' },
+      ollamaCloud: { reasoningEffort: 'high' },
     });
     assert.deepEqual(buildProviderOptions(conn('ollama-cloud'), 'gpt-oss:120b', 'off'), {});
   });
@@ -490,14 +490,14 @@ describe('getAIModel: models.dev registry providers', () => {
 });
 
 describe('buildProviderOptions: openai-compatible namespace', () => {
-  test('zai-coding-plan emits reasoningEffort under the raw dashed namespace', () => {
+  test('zai-coding-plan emits reasoningEffort under the camelCase namespace', () => {
     assert.deepEqual(
       buildProviderOptions(conn('zai-coding-plan', 'zai-coding-plan'), 'glm-5.2', 'high'),
-      { 'zai-coding-plan': { reasoningEffort: 'high' } },
+      { zaiCodingPlan: { reasoningEffort: 'high' } },
     );
     assert.deepEqual(
       buildProviderOptions(conn('zai-coding-plan', 'zai-coding-plan'), 'glm-5.2', 'max'),
-      { 'zai-coding-plan': { reasoningEffort: 'max' } },
+      { zaiCodingPlan: { reasoningEffort: 'max' } },
     );
   });
   test('deepseek wires provider-native effort on both chat and Responses dialects', () => {
@@ -599,4 +599,96 @@ describe('buildProviderOptions: openai-compatible namespace', () => {
       JSON.stringify(result.warnings),
     );
   });
+
+  test('built-in dashed provider effort reaches the chat request body without deprecation', async () => {
+    // Built-in counterpart of the relay capture above: built-in dashed
+    // providerTypes must emit the SDK's camelCase alias too.
+    const bodies: Record<string, unknown>[] = [];
+    const captureFetch: typeof globalThis.fetch = async (_input, init) => {
+      bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return new Response(
+        JSON.stringify({
+          id: 'chatcmpl-1',
+          object: 'chat.completion',
+          created: 1,
+          model: 'glm-5.2',
+          choices: [
+            {
+              index: 0,
+              message: { role: 'assistant', content: 'ok' },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+        { status: 200, headers: { 'content-type': 'application/json' } },
+      );
+    };
+    const connection = conn('zai-coding-plan', 'zai-coding-plan');
+    const model = getAIModel({
+      connection,
+      apiKey: 'zai-key',
+      modelId: 'glm-5.2',
+      fetch: captureFetch,
+    });
+    const result = await model.doGenerate({
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+      providerOptions: buildProviderOptions(connection, 'glm-5.2', 'high'),
+    });
+    assert.equal(bodies.length, 1);
+    assert.equal(bodies[0]?.reasoning_effort, 'high');
+    assert.equal(
+      (result.warnings ?? []).some((warning) => warning.type === 'deprecated'),
+      false,
+      JSON.stringify(result.warnings),
+    );
+    // The options key also selects the SDK's response metadata namespace:
+    // metadata must come back under the camelCase alias, not the dashed name.
+    assert.deepEqual(Object.keys(result.providerMetadata ?? {}), ['zaiCodingPlan']);
+  });
+
+  test('passthrough provider options reach the chat request body without deprecation', async () => {
+    // reasoningEffort above travels the SDK's schema lane, which parses both
+    // spellings. Volcengine Ark's `thinking` object is not in the schema and
+    // travels the passthrough spread instead — pin that lane at the wire too.
+    const bodies: Record<string, unknown>[] = [];
+    const captureFetch: typeof globalThis.fetch = async (_input, init) => {
+      bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return new Response(
+        JSON.stringify({
+          id: 'chatcmpl-1',
+          object: 'chat.completion',
+          created: 1,
+          model: 'doubao-seed-2-0-pro-260215',
+          choices: [
+            {
+              index: 0,
+              message: { role: 'assistant', content: 'ok' },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+        { status: 200, headers: { 'content-type': 'application/json' } },
+      );
+    };
+    const connection = conn('volcengine-ark', 'volcengine-ark');
+    const model = getAIModel({
+      connection,
+      apiKey: 'ark-key',
+      modelId: 'doubao-seed-2-0-pro-260215',
+      fetch: captureFetch,
+    });
+    const result = await model.doGenerate({
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+      providerOptions: buildProviderOptions(connection, 'doubao-seed-2-0-pro-260215'),
+    });
+    assert.equal(bodies.length, 1);
+    assert.deepEqual(bodies[0]?.thinking, { type: 'enabled' });
+    assert.equal(
+      (result.warnings ?? []).some((warning) => warning.type === 'deprecated'),
+      false,
+      JSON.stringify(result.warnings),
+    );
+  });
 });

packages/runtime/src/__tests__/request-shape.test.ts

@@ -247,8 +247,8 @@ describe('prepared provider request capture', () => {
     const openaiMax = hash({ kimiCodingPlan: { reasoningEffort: 'max' } }, 32_768);
     const nativeOpenaiMax = hash({ openai: { reasoningEffort: 'max' } }, 32_768);
     const nativeOpenaiHigh = hash({ openai: { reasoningEffort: 'high' } }, 32_768);
-    const zaiHigh = hash({ 'zai-coding-plan': { reasoningEffort: 'high' } }, 32_768);
-    const zaiLow = hash({ 'zai-coding-plan': { reasoningEffort: 'low' } }, 32_768);
+    const zaiHigh = hash({ zaiCodingPlan: { reasoningEffort: 'high' } }, 32_768);
+    const zaiLow = hash({ zaiCodingPlan: { reasoningEffort: 'low' } }, 32_768);
 
     assert.equal(anthropicMax, openaiMax);
     assert.equal(anthropicMax, nativeOpenaiMax);

packages/runtime/src/model-factory.ts

@@ -468,7 +468,7 @@ export function buildProviderOptions(
       return buildFamilyWire(connection, modelId, level, thinkingOptions);
     case 'volcengine-ark':
       return {
-        [connection.providerType]: {
+        [toCamelCase(connection.providerType)]: {
           thinking: { type: level === 'off' ? 'disabled' : 'enabled' },
           ...(level && level !== 'off' ? { reasoningEffort: level } : {}),
         },
@@ -495,7 +495,7 @@ export function buildProviderOptions(
     case 'cloudflare-workers-ai':
       return level
         ? {
-            [connection.providerType]:
+            [toCamelCase(connection.providerType)]:
               level === 'off'
                 ? thinkingOptions?.offBehavior === 'cloudflare-chat-template-thinking-false'
                   ? { chat_template_kwargs: { thinking: false } }
@@ -584,7 +584,7 @@ function buildFamilyWire(
       if (copilotProtocol === 'anthropic-messages') {
         return level !== 'off' ? { anthropic: { effort: level } } : {};
       }
-      return { 'github-copilot': { reasoningEffort } };
+      return { githubCopilot: { reasoningEffort } };
     }
     default:
       return {};
@@ -612,18 +612,21 @@ function toCamelCase(name: string): string {
 }
 
 /**
- * The providerOptions key for an openai-compatible model. The SDK still
- * accepts the raw provider name but flags dashed keys as deprecated (a
- * `type: 'deprecated'` warning on every doGenerate result); its canonical
- * key is the camelCase alias. Only the custom-relay path keys options by
- * the connection slug, so only that path camelCases — built-in adapter
- * namespaces stay as they were.
+ * The providerOptions key for an openai-compatible model: the camelCase
+ * alias of the identity passed to `createOpenAICompatible`. The SDK
+ * resolves both spellings — known options and passthrough fields alike —
+ * but flags dashed keys as deprecated (a `type: 'deprecated'` warning on
+ * every doGenerate result), so the camelCase alias is the canonical key.
+ *
+ * The same alias also selects the SDK's *response* metadata namespace:
+ * once options are keyed `zaiCodingPlan`, provider metadata comes back as
+ * `providerMetadata.zaiCodingPlan`, not `providerMetadata['zai-coding-plan']`.
+ * A metadata reader keyed by the raw `connection.providerType` would
+ * silently read nothing for dashed providers.
  */
 function openAiCompatibleProviderOptionsKey(
   adapter: ProviderRuntimeAdapter,
   connection: RuntimeExecutionConnection,
 ): string {
-  return adapter.kind === 'openai-compatible' && adapter.name === 'connection'
-    ? toCamelCase(connection.slug)
-    : connection.providerType;
+  return toCamelCase(openAiCompatibleProviderName(adapter, connection));
 }