Merge pull request #23 from mammouth-ai/mammouth-code-reasoning-effort-n2846

fixed xhigh and max reasoning efforts for Mammouth API models

Author: Zenwoh

packages/core/src/models-dev.ts

@@ -51,6 +51,7 @@ export const Model = Schema.Struct({
   release_date: Schema.String,
   attachment: Schema.Boolean,
   reasoning: Schema.Boolean,
+  efforts: Schema.optional(Schema.Array(Schema.String)),
   temperature: Schema.Boolean,
   tool_call: Schema.Boolean,
   interleaved: Schema.optional(
@@ -174,6 +175,20 @@ function humanizeModelName(name: string): string {
   return parts.map((p) => specialCases[p.toLowerCase()] ?? capitalize(p)).join(" ")
 }
 
+// litellm's supports_reasoning implies the default low/medium/high effort
+// range; none/minimal and the exceptional xhigh/max tiers are opted into
+// per-model via their own supports_* flags in the litellm config.
+function reasoningEfforts(info: any): string[] | undefined {
+  if (!info.supports_reasoning) return undefined
+  const efforts: string[] = []
+  if (info.supports_none_reasoning_effort) efforts.push("none")
+  if (info.supports_minimal_reasoning_effort) efforts.push("minimal")
+  efforts.push("low", "medium", "high")
+  if (info.supports_xhigh_reasoning_effort) efforts.push("xhigh")
+  if (info.supports_max_reasoning_effort) efforts.push("max")
+  return efforts
+}
+
 function transformApiResponse(data: any): Model[] {
   if (!data?.data || !Array.isArray(data.data)) return []
 
@@ -196,6 +211,7 @@ function transformApiResponse(data: any): Model[] {
         release_date: "",
         attachment: info.supports_vision || info.supports_pdf_input || false,
         reasoning: info.supports_reasoning || false,
+        efforts: reasoningEfforts(info),
         temperature: true,
         tool_call: info.supports_function_calling || info.supports_tool_choice || false,
         cost: {

packages/core/src/plugin/models-dev.ts

@@ -38,11 +38,21 @@ function cost(input: ModelsDev.Model["cost"]) {
 }
 
 function variants(model: ModelsDev.Model) {
-  return Object.entries(model.experimental?.modes ?? {}).map(([id, item]) => ({
+  const result = Object.entries(model.experimental?.modes ?? {}).map(([id, item]) => ({
     id: ModelV2.VariantID.make(id),
     headers: { ...(item.provider?.headers ?? {}) },
     body: { ...(item.provider?.body ?? {}) },
   }))
+  const ids = new Set<string>(result.map((item) => item.id))
+  for (const effort of model.efforts ?? []) {
+    if (ids.has(effort)) continue
+    result.push({
+      id: ModelV2.VariantID.make(effort),
+      headers: {},
+      body: { reasoning_effort: effort },
+    })
+  }
+  return result
 }
 
 export const ModelsDevPlugin = define({

packages/core/test/plugin/fixtures/models-dev.json

@@ -2,13 +2,36 @@
   "acme": {
     "id": "acme",
     "name": "Acme",
-    "env": ["ACME_API_KEY"],
-    "models": {}
+    "env": [
+      "ACME_API_KEY"
+    ],
+    "models": {
+      "deluxe": {
+        "id": "deluxe",
+        "name": "Deluxe",
+        "release_date": "2025-01-01",
+        "attachment": false,
+        "reasoning": true,
+        "efforts": [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        "temperature": true,
+        "tool_call": true,
+        "limit": {
+          "context": 200000,
+          "output": 64000
+        }
+      }
+    }
   },
   "local": {
     "id": "local",
     "name": "Local",
     "env": [],
     "models": {}
   }
-}
+}

packages/core/test/plugin/models-dev.test.ts

@@ -7,9 +7,11 @@ import { Credential } from "@opencode-ai/core/credential"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Location } from "@opencode-ai/core/location"
+import { ModelV2 } from "@opencode-ai/core/model"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { ModelsDevPlugin } from "@opencode-ai/core/plugin/models-dev"
 import { Policy } from "@opencode-ai/core/policy"
+import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
@@ -29,48 +31,87 @@ const catalog = Catalog.layer.pipe(
 const layer = Layer.mergeAll(catalog.pipe(Layer.provide(connections)), integrations, connections, events, locationLayer)
 const it = testEffect(layer)
 
+const withFixture = <A, E, R>(use: Effect.Effect<A, E, R>) =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const previous = {
+        path: Flag.OPENCODE_MODELS_PATH,
+        disabled: Flag.OPENCODE_DISABLE_MODELS_FETCH,
+      }
+      Flag.OPENCODE_MODELS_PATH = path.join(import.meta.dir, "fixtures", "models-dev.json")
+      Flag.OPENCODE_DISABLE_MODELS_FETCH = true
+      return previous
+    }),
+    () => use.pipe(Effect.provide(ModelsDev.defaultLayer)),
+    (previous) =>
+      Effect.sync(() => {
+        Flag.OPENCODE_MODELS_PATH = previous.path
+        Flag.OPENCODE_DISABLE_MODELS_FETCH = previous.disabled
+      }),
+  )
+
 describe("ModelsDevPlugin", () => {
   it.effect("registers key methods for providers with environment variables", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const previous = {
-          path: Flag.OPENCODE_MODELS_PATH,
-          disabled: Flag.OPENCODE_DISABLE_MODELS_FETCH,
-        }
-        Flag.OPENCODE_MODELS_PATH = path.join(import.meta.dir, "fixtures", "models-dev.json")
-        Flag.OPENCODE_DISABLE_MODELS_FETCH = true
-        return previous
+    withFixture(
+      Effect.gen(function* () {
+        const integrations = yield* Integration.Service
+        const catalog = yield* Catalog.Service
+        yield* ModelsDevPlugin.effect(
+          host({
+            catalog: catalogHost(catalog),
+            integration: integrationHost(integrations),
+          }),
+        )
+        expect(yield* integrations.list()).toEqual([
+          new Integration.Info({
+            id: Integration.ID.make("acme"),
+            name: "Acme",
+            methods: [
+              { type: "key" },
+              {
+                type: "env",
+                names: ["ACME_API_KEY"],
+              },
+            ],
+            connections: [],
+          }),
+          new Integration.Info({
+            id: Integration.ID.make("mammouth-ai"),
+            name: "Mammouth AI",
+            methods: [
+              { type: "key" },
+              {
+                type: "env",
+                names: ["MAMMOUTH_API_KEY"],
+              },
+            ],
+            connections: [],
+          }),
+        ])
+      }),
+    ),
+  )
+
+  it.effect("maps explicit model efforts to reasoning_effort variants", () =>
+    withFixture(
+      Effect.gen(function* () {
+        const integrations = yield* Integration.Service
+        const catalog = yield* Catalog.Service
+        yield* ModelsDevPlugin.effect(
+          host({
+            catalog: catalogHost(catalog),
+            integration: integrationHost(integrations),
+          }),
+        )
+        const model = yield* catalog.model.get(ProviderV2.ID.make("acme"), ModelV2.ID.make("deluxe"))
+        expect(model?.variants).toEqual([
+          expect.objectContaining({ id: "low", body: { reasoning_effort: "low" } }),
+          expect.objectContaining({ id: "medium", body: { reasoning_effort: "medium" } }),
+          expect.objectContaining({ id: "high", body: { reasoning_effort: "high" } }),
+          expect.objectContaining({ id: "xhigh", body: { reasoning_effort: "xhigh" } }),
+          expect.objectContaining({ id: "max", body: { reasoning_effort: "max" } }),
+        ])
       }),
-      () =>
-        Effect.gen(function* () {
-          const integrations = yield* Integration.Service
-          const catalog = yield* Catalog.Service
-          yield* ModelsDevPlugin.effect(
-            host({
-              catalog: catalogHost(catalog),
-              integration: integrationHost(integrations),
-            }),
-          )
-          expect(yield* integrations.list()).toEqual([
-            new Integration.Info({
-              id: Integration.ID.make("acme"),
-              name: "Acme",
-              methods: [
-                { type: "key" },
-                {
-                  type: "env",
-                  names: ["ACME_API_KEY"],
-                },
-              ],
-              connections: [],
-            }),
-          ])
-        }).pipe(Effect.provide(ModelsDev.defaultLayer)),
-      (previous) =>
-        Effect.sync(() => {
-          Flag.OPENCODE_MODELS_PATH = previous.path
-          Flag.OPENCODE_DISABLE_MODELS_FETCH = previous.disabled
-        }),
     ),
   )
 })

packages/opencode/src/provider/provider.ts

@@ -1052,6 +1052,7 @@ export const Model = Schema.Struct({
   options: Schema.Record(Schema.String, Schema.Any),
   headers: Schema.Record(Schema.String, Schema.String),
   release_date: Schema.String,
+  efforts: optionalOmitUndefined(Schema.Array(Schema.String)),
   variants: optionalOmitUndefined(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Any))),
 }).annotate({ identifier: "Model" })
 export type Model = Types.DeepMutable<Schema.Schema.Type<typeof Model>>
@@ -1251,6 +1252,7 @@ function fromModelsDevModel(provider: ModelsDev.Provider, model: ModelsDev.Model
       interleaved: model.interleaved ?? false,
     },
     release_date: model.release_date ?? "",
+    efforts: model.efforts ? [...model.efforts] : undefined,
     variants: {},
   }
 
@@ -1497,6 +1499,7 @@ export const layer = Layer.effect(
               headers: mergeDeep(existingModel?.headers ?? {}, model.headers ?? {}),
               family: model.family ?? existingModel?.family ?? "",
               release_date: model.release_date ?? existingModel?.release_date ?? "",
+              efforts: existingModel?.efforts,
               variants: {},
             }
             const merged = mergeDeep(ProviderTransform.variants(parsedModel), model.variants ?? {})

packages/opencode/src/provider/transform.ts

@@ -665,6 +665,13 @@ function googleThinkingVariants(model: Provider.Model): Record<string, Record<st
 export function variants(model: Provider.Model): Record<string, Record<string, any>> {
   if (!model.capabilities.reasoning) return {}
 
+  // Models fetched from the Mammouth API carry an explicit effort list derived
+  // from litellm's supports_* flags; litellm translates reasoning_effort to
+  // each upstream's native control, so it overrides the heuristics below.
+  if (model.efforts?.length) {
+    return Object.fromEntries(model.efforts.map((effort) => [effort, { reasoningEffort: effort }]))
+  }
+
   const id = model.id.toLowerCase()
   const glm52 = ["glm-5.2", "glm-5-2", "glm-5p2"].some(
     (name) => id.includes(name) || model.api.id.toLowerCase().includes(name),

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

@@ -2820,6 +2820,68 @@ describe("ProviderTransform.variants", () => {
     expect(result).toEqual({})
   })
 
+  test("explicit efforts override npm heuristics", () => {
+    const model = createMockModel({
+      id: "mammouth-ai/claude-opus-4-8",
+      providerID: "mammouth-ai",
+      api: {
+        id: "claude-opus-4-8",
+        url: "https://api.mammouth.ai/v1",
+        npm: "@ai-sdk/openai-compatible",
+      },
+      efforts: ["low", "medium", "high", "xhigh", "max"],
+    })
+    expect(ProviderTransform.variants(model)).toEqual({
+      low: { reasoningEffort: "low" },
+      medium: { reasoningEffort: "medium" },
+      high: { reasoningEffort: "high" },
+      xhigh: { reasoningEffort: "xhigh" },
+      max: { reasoningEffort: "max" },
+    })
+  })
+
+  test("explicit efforts override the no-variant id blocklist", () => {
+    const model = createMockModel({
+      id: "mammouth-ai/kimi-k2.6",
+      providerID: "mammouth-ai",
+      api: {
+        id: "kimi-k2.6",
+        url: "https://api.mammouth.ai/v1",
+        npm: "@ai-sdk/openai-compatible",
+      },
+      efforts: ["low", "medium", "high"],
+    })
+    expect(ProviderTransform.variants(model)).toEqual({
+      low: { reasoningEffort: "low" },
+      medium: { reasoningEffort: "medium" },
+      high: { reasoningEffort: "high" },
+    })
+  })
+
+  test("explicit efforts still require reasoning capability", () => {
+    const model = createMockModel({
+      capabilities: { reasoning: false },
+      efforts: ["low", "medium", "high"],
+    })
+    expect(ProviderTransform.variants(model)).toEqual({})
+  })
+
+  test("empty efforts list falls through to npm heuristics", () => {
+    const model = createMockModel({
+      api: {
+        id: "test-model",
+        url: "https://api.test.com",
+        npm: "@ai-sdk/openai-compatible",
+      },
+      efforts: [],
+    })
+    expect(ProviderTransform.variants(model)).toEqual({
+      low: { reasoningEffort: "low" },
+      medium: { reasoningEffort: "medium" },
+      high: { reasoningEffort: "high" },
+    })
+  })
+
   test("deepseek returns empty object", () => {
     const model = createMockModel({
       id: "deepseek/deepseek-chat",