fix(provider): honor strict temperature requirements over agent override

Some providers reject any temperature value other than the one they require
(e.g. Moonshot's kimi-k2.* returns HTTP 400 "invalid temperature: only 1 is
allowed for this model"). The previous chain in session/llm.ts let the
agent's preference win:

  input.agent.temperature ?? ProviderTransform.temperature(input.model)

The built-in title agent hard-codes temperature: 0.5, so any session that
started with title generation on one of these models silently failed. OSS
Laminar telemetry over the past 13 days shows 27 occurrences on kimi-k2.6
alone, plus failures on minimax-m2, glm-4.6/4.7, gemini.

Split the model->temperature mapping into:

  - temperatureStrict(model): only returns a value when the provider rejects
    other values. These must override agent/user preferences.
  - temperature(model): falls through to temperatureStrict, otherwise
    returns a recommended default (qwen=0.55) or undefined. Used as the
    soft fallback when no agent/user temperature is set.

session/llm.ts call site becomes:

  temperatureStrict(model) ?? agent.temperature ?? temperature(model)

so the strict value always wins, the user/agent override still applies on
flexible models, and we keep recommended defaults when nothing is set.

Author: bcode

packages/opencode/src/provider/transform.ts

@@ -475,16 +475,21 @@ export function message(msgs: ModelMessage[], model: Provider.Model, options: Re
   return msgs
 }
 
-export function temperature(model: Provider.Model) {
+// Returns the *required* temperature for models whose provider rejects any
+// other value. When this returns a number, it MUST override agent/user
+// preferences at the call site — sending a different value will fail the API
+// call (e.g. Moonshot's kimi-k2.* returns HTTP 400 "invalid temperature: only
+// 1 is allowed for this model"). Returns undefined for models that accept a
+// range of temperatures, in which case the agent/user preference wins and
+// `temperature()` below supplies a recommended default.
+export function temperatureStrict(model: Provider.Model): number | undefined {
   const id = model.id.toLowerCase()
-  if (id.includes("qwen")) return 0.55
-  if (id.includes("claude")) return undefined
   if (id.includes("gemini")) return 1.0
   if (id.includes("glm-4.6")) return 1.0
   if (id.includes("glm-4.7")) return 1.0
   if (id.includes("minimax-m2")) return 1.0
   if (id.includes("kimi-k2")) {
-    // kimi-k2-thinking & kimi-k2.5 && kimi-k2p5 && kimi-k2-5
+    // kimi-k2-thinking & kimi-k2.5 && kimi-k2p5 && kimi-k2-5 && kimi-k2.6
     if (["thinking", "k2.", "k2p", "k2-5"].some((s) => id.includes(s))) {
       return 1.0
     }
@@ -493,6 +498,18 @@ export function temperature(model: Provider.Model) {
   return undefined
 }
 
+// Returns the recommended default temperature for models whose API accepts a
+// range of values. Used as a fallback when no agent/user temperature is set.
+// Models with a strict requirement should be handled by `temperatureStrict`.
+export function temperature(model: Provider.Model): number | undefined {
+  const strict = temperatureStrict(model)
+  if (strict !== undefined) return strict
+  const id = model.id.toLowerCase()
+  if (id.includes("qwen")) return 0.55
+  if (id.includes("claude")) return undefined
+  return undefined
+}
+
 export function topP(model: Provider.Model) {
   const id = model.id.toLowerCase()
   if (id.includes("qwen")) return 1

packages/opencode/src/session/llm.ts

@@ -169,7 +169,9 @@ const live: Layer.Layer<
         },
         {
           temperature: input.model.capabilities.temperature
-            ? (input.agent.temperature ?? ProviderTransform.temperature(input.model))
+            ? (ProviderTransform.temperatureStrict(input.model) ??
+              input.agent.temperature ??
+              ProviderTransform.temperature(input.model))
             : undefined,
           topP: input.agent.topP ?? ProviderTransform.topP(input.model),
           topK: ProviderTransform.topK(input.model),

packages/opencode/test/provider/transform.test.ts

@@ -3686,3 +3686,50 @@ describe("ProviderTransform.providerOptions - ai-gateway-provider", () => {
     expect(result).toEqual({ openaiCompatible: { reasoningEffort: "high" } })
   })
 })
+
+describe("ProviderTransform.temperatureStrict", () => {
+  // Returns the *required* temperature for models that reject anything else.
+  // Regression for OSS telemetry: title agent's hard-coded 0.5 was being sent
+  // to kimi-k2.6, which Moonshot rejects with "invalid temperature: only 1 is
+  // allowed for this model" (~27 occurrences over 13 days).
+  const model = (id: string) => ({ id }) as any
+
+  test("kimi-k2.6 requires 1.0", () => {
+    expect(ProviderTransform.temperatureStrict(model("kimi-k2.6"))).toBe(1.0)
+  })
+
+  test("kimi-k2-thinking requires 1.0", () => {
+    expect(ProviderTransform.temperatureStrict(model("kimi-k2-thinking"))).toBe(1.0)
+  })
+
+  test("kimi-k2 (base) requires 0.6", () => {
+    expect(ProviderTransform.temperatureStrict(model("kimi-k2"))).toBe(0.6)
+  })
+
+  test("gemini / glm-4.6 / glm-4.7 / minimax-m2 require 1.0", () => {
+    expect(ProviderTransform.temperatureStrict(model("gemini-3-pro-preview"))).toBe(1.0)
+    expect(ProviderTransform.temperatureStrict(model("glm-4.6"))).toBe(1.0)
+    expect(ProviderTransform.temperatureStrict(model("glm-4.7"))).toBe(1.0)
+    expect(ProviderTransform.temperatureStrict(model("minimax-m2.7"))).toBe(1.0)
+  })
+
+  test("qwen has no strict requirement (recommended-only)", () => {
+    expect(ProviderTransform.temperatureStrict(model("qwen35-27b-fp8"))).toBeUndefined()
+    // But the recommended default still applies.
+    expect(ProviderTransform.temperature(model("qwen35-27b-fp8"))).toBe(0.55)
+  })
+
+  test("claude / openai have no strict requirement and no recommendation", () => {
+    expect(ProviderTransform.temperatureStrict(model("claude-opus-4-7"))).toBeUndefined()
+    expect(ProviderTransform.temperature(model("claude-opus-4-7"))).toBeUndefined()
+    expect(ProviderTransform.temperatureStrict(model("gpt-5.5"))).toBeUndefined()
+    expect(ProviderTransform.temperature(model("gpt-5.5"))).toBeUndefined()
+  })
+
+  test("temperature() falls through to temperatureStrict() for strict models", () => {
+    // Ensures the recommended-default helper still serves the correct value
+    // when no agent override is present.
+    expect(ProviderTransform.temperature(model("kimi-k2.6"))).toBe(1.0)
+    expect(ProviderTransform.temperature(model("gemini-3-pro-preview"))).toBe(1.0)
+  })
+})