@opencode/core 0.0.0-dev-19619 → 0.0.0-dev-19621

package/dist/chunks/{state-vqjrrrw6.js → location-activity-e6tp1f32.js}

@@ -1,10 +1,6 @@
-import {
-  isAISDK2,
-  packageName2
-} from "./state-vzy7bsbz.js";
 import {
   ID11
-} from "./state-r0r5a59z.js";
+} from "./location-activity-fcpfj2f6.js";
 
 // src/plugin/provider/openrouter.ts
 import { Effect } from "effect";
@@ -14,9 +10,7 @@ var OpenRouterPlugin2 = define({
   effect: Effect.fn(function* (ctx) {
     yield* ctx.provider.transform((evt) => {
       for (const item of evt.list()) {
-        if (!isAISDK2(item.provider.package))
-          continue;
-        if (packageName2(item.provider.package) !== "@openrouter/ai-sdk-provider")
+        if (item.provider.package !== "@opencode/ai/providers/openrouter")
           continue;
         evt.update(item.provider.id, (provider) => {
           provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
@@ -25,9 +19,7 @@ var OpenRouterPlugin2 = define({
     });
     yield* ctx.model.transform((models) => {
       for (const item of models.provider.list()) {
-        if (!isAISDK2(item.provider.package))
-          continue;
-        if (packageName2(item.provider.package) !== "@openrouter/ai-sdk-provider")
+        if (item.provider.package !== "@opencode/ai/providers/openrouter")
           continue;
         for (const modelID of [ID11.make("gpt-5-chat-latest"), ID11.make("openai/gpt-5-chat")]) {
           if (!models.get(item.provider.id, modelID))

package/dist/chunks/{state-3jqje4at.js → location-activity-ea8d760j.js}

@@ -1,66 +1,66 @@
 import {
   Service80,
   node85
-} from "./state-zmhc1ceh.js";
+} from "./location-activity-p1epjeyw.js";
 import {
-  Service76,
-  node81
-} from "./state-ezc4vqg9.js";
+  Service77,
+  node82
+} from "./location-activity-s86c7pyr.js";
 import {
-  ID9
-} from "./state-h47he10w.js";
+  ID2
+} from "./location-activity-0mesazry.js";
 import {
-  Service75,
+  Service66,
   login2,
-  node80
-} from "./state-3jwvk6df.js";
+  node71
+} from "./location-activity-sc5vqhje.js";
 import {
   lazy2
-} from "./state-88xbtdfr.js";
+} from "./location-activity-88xbtdfr.js";
 import {
   __export
-} from "./state-9rqn6x4v.js";
+} from "./location-activity-9rqn6x4v.js";
 
 // src/pty.ts
 var exports_pty = {};
 __export(exports_pty, {
-  CreateInput: () => CreateInput3,
-  Event: () => Event13,
+  CreateInput: () => CreateInput2,
+  Event: () => Event2,
   ExitedError: () => ExitedError2,
-  Info: () => Info13,
-  NotFoundError: () => NotFoundError8,
+  Info: () => Info2,
+  NotFoundError: () => NotFoundError2,
   Pty: () => exports_pty,
-  Service: () => Service59,
+  Service: () => Service14,
   UpdateInput: () => UpdateInput2,
-  node: () => node63
+  node: () => node17
 });
 import { makeLocationNode } from "@opencode/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Pty } from "@opencode/schema/pty";
-import { Event as Event13 } from "@opencode/schema/pty";
+import { Event as Event2 } from "@opencode/schema/pty";
 var BUFFER_LIMIT = 1024 * 1024 * 2;
 var EXITED_LIMIT = 25;
 var pty = lazy2(() => import("#pty"));
-var Info13 = Pty.Info;
-var CreateInput3 = Pty.CreateInput;
+var Info2 = Pty.Info;
+var CreateInput2 = Pty.CreateInput;
 var UpdateInput2 = Pty.UpdateInput;
 
-class NotFoundError8 extends Schema.TaggedError()("Pty.NotFoundError", {
-  ptyID: ID9
+class NotFoundError2 extends Schema.TaggedError()("Pty.NotFoundError", {
+  ptyID: ID2
 }) {
 }
 
 class ExitedError2 extends Schema.TaggedError()("Pty.ExitedError", {
-  ptyID: ID9
+  ptyID: ID2
 }) {
 }
 
-class Service59 extends Context.Service()("@opencode/Pty") {
+class Service14 extends Context.Service()("@opencode/Pty") {
 }
-var layer = Layer.effect(Service59, Effect.gen(function* () {
+var layer = Layer.effect(Service14, Effect.gen(function* () {
   const bus = yield* Service80;
-  const location = yield* Service76;
-  const shell = yield* Service75;
+  const location = yield* Service77;
+  const shell = yield* Service66;
   const context = yield* Effect.context();
   const runFork = Effect.runForkWith(context);
   const sessions = new Map;
@@ -97,7 +97,7 @@ var layer = Layer.effect(Service59, Effect.gen(function* () {
   const requireSession = Effect.fn("Pty.requireSession")(function* (id) {
     const session = sessions.get(id);
     if (!session)
-      return yield* new NotFoundError8({ ptyID: id });
+      return yield* new NotFoundError2({ ptyID: id });
     return session;
   });
   const removeSession = Effect.fnUntraced(function* (id) {
@@ -123,7 +123,7 @@ var layer = Layer.effect(Service59, Effect.gen(function* () {
     return (yield* requireSession(id)).info;
   });
   const create = Effect.fn("Pty.create")(function* (input) {
-    const id = ID9.ascending();
+    const id = ID2.ascending();
     const command = input.command || (yield* shell.resolve({ priority: "config" }));
     const args = login2(command) ? [...input.args ?? [], "-l"] : [...input.args ?? []];
     const cwd = input.cwd || location.directory;
@@ -268,12 +268,12 @@ var layer = Layer.effect(Service59, Effect.gen(function* () {
       }
     };
   });
-  return Service59.of({ list, get, create, update, remove, write, attach });
+  return Service14.of({ list, get, create, update, remove, write, attach });
 }));
-var node63 = makeLocationNode({
-  service: Service59,
+var node17 = makeLocationNode({
+  service: Service14,
   layer,
-  deps: [node85, node81, node80]
+  deps: [node85, node82, node71]
 });
 
-export { Info13, CreateInput3, UpdateInput2, NotFoundError8, ExitedError2, Service59, node63, exports_pty, Event13 };
+export { Info2, CreateInput2, UpdateInput2, NotFoundError2, ExitedError2, Service14, node17, exports_pty, Event2 };

package/dist/chunks/location-activity-ebpp3bj8.js

@@ -0,0 +1,500 @@
+import {
+  aisdk2
+} from "./location-activity-mfssdfvv.js";
+import {
+  VariantID2
+} from "./location-activity-fcpfj2f6.js";
+import {
+  __export
+} from "./location-activity-9rqn6x4v.js";
+
+// src/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  Variant: () => exports_variant,
+  resolve: () => resolve2
+});
+function resolve2(model, supports = [{ type: "effort" }]) {
+  const protocol = model.package === undefined ? undefined : PROTOCOLS[model.package];
+  if (!protocol)
+    return [];
+  const toggle = supports.some((support) => support.type === "toggle") ? protocol(model, { type: "toggle" }) : [];
+  const effort = supports.find((support) => support.type === "effort");
+  const budget = supports.find((support) => support.type === "budget_tokens");
+  const main = effort ? protocol(model, effort) : budget ? protocol(model, budget) : toggle;
+  const variants = [...toggle.filter((variant) => variant.id === "none"), ...main];
+  return variants.filter((variant, index) => variants.findIndex((other) => other.id === variant.id) === index);
+}
+var EFFORTS = ["low", "medium", "high"];
+var ENCRYPTED_REASONING = ["reasoning.encrypted_content"];
+var ADAPTIVE_THINKING = { type: "adaptive", display: "summarized" };
+var variant = (id, overlay) => ({ id: VariantID2.make(id), ...overlay });
+var efforts = (values, spell) => values.map((effort) => variant(effort, spell(effort)));
+var toggle = (off, on) => [variant("none", off), variant("thinking", on)];
+function budgets(model, support, spell) {
+  const maximum = Math.min(support.max ?? model.limit.output - 1, model.limit.output - 1);
+  if (maximum <= 0)
+    return [];
+  const high = Math.min(Math.max(support.min ?? 0, Math.floor((maximum + 1) / 2)), maximum);
+  return [variant("high", spell(high)), variant("max", spell(maximum))];
+}
+var modelID = (model) => model.modelID ?? model.id;
+function claudeInfo(model) {
+  const id = modelID(model);
+  const familyFirst = /(?:claude-)?(opus|sonnet|haiku|fable|mythos)-(\d+)(?:[.-](\d+))?/i.exec(id);
+  const versionFirst = /claude-(\d+)(?:[.-](\d+))?-(opus|sonnet|haiku|fable|mythos)/i.exec(id);
+  const family = (familyFirst?.[1] ?? versionFirst?.[3])?.toLowerCase();
+  const major = Number(familyFirst?.[2] ?? versionFirst?.[1]);
+  const minor = Number(familyFirst?.[3] ?? versionFirst?.[2] ?? 0);
+  return {
+    family,
+    major,
+    minor,
+    manual: major === 3 && minor === 7 || major === 4 && minor < 6,
+    always: family === "fable" || family === "mythos" || id.toLowerCase().includes("mythos-preview")
+  };
+}
+function manualThinking(model) {
+  const tokens = Math.min(16000, model.limit.output - 1);
+  if (tokens < 1024)
+    return;
+  return { settings: { thinking: { type: "enabled", budgetTokens: tokens } } };
+}
+var openaiChat = (_, support) => {
+  if (support.type !== "effort")
+    return [];
+  return efforts(support.values ?? EFFORTS, (effort) => ({ settings: { reasoningEffort: effort } }));
+};
+var openaiResponses = (_, support) => {
+  if (support.type !== "effort")
+    return [];
+  return efforts(support.values ?? ["none", "minimal", ...EFFORTS, "xhigh"], responsesEffort);
+};
+var responsesEffort = (effort) => ({
+  settings: { reasoningEffort: effort, reasoningSummary: "auto", include: ENCRYPTED_REASONING }
+});
+var cloudflareAIGateway = (model, support) => {
+  const id = modelID(model);
+  if (id.startsWith("openai/"))
+    return openaiResponses(model, support);
+  if (id.startsWith("anthropic/"))
+    return anthropicMessages(model, support);
+  return openaiChat(model, support);
+};
+var deepseekChat = (_, support) => {
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? ["low", "high", "max"], (effort) => {
+        if (effort === "none")
+          return { body: { thinking: { type: "disabled" } } };
+        return { settings: { reasoningEffort: effort }, body: { thinking: { type: "enabled" } } };
+      });
+    case "toggle":
+      return toggle({ body: { thinking: { type: "disabled" } } }, { body: { thinking: { type: "enabled" } } });
+    case "budget_tokens":
+      return [];
+  }
+};
+var nvidiaTemplate = (chat_template_kwargs) => ({
+  body: { chat_template_kwargs }
+});
+var nvidiaToggle = (key) => toggle(nvidiaTemplate({ [key]: false }), nvidiaTemplate({ [key]: true }));
+var nvidiaChat = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  if (id.includes("deepseek-v4")) {
+    if (support.type === "toggle")
+      return nvidiaToggle("thinking");
+    if (support.type !== "effort")
+      return [];
+    return efforts(support.values ?? ["none", "high", "max"], (effort) => effort === "none" ? nvidiaTemplate({ thinking: false }) : nvidiaTemplate({ thinking: true, reasoning_effort: effort }));
+  }
+  if (id.includes("kimi-k2.6") || id.includes("kimi-k2-6"))
+    return nvidiaToggle("thinking");
+  if (id.includes("kimi-k3")) {
+    if (support.type === "toggle")
+      return nvidiaToggle("thinking");
+    if (support.type !== "effort")
+      return [];
+    return efforts(support.values ?? ["low", "high", "max"], (effort) => ({
+      settings: { reasoningEffort: effort }
+    }));
+  }
+  if (id.includes("minimax-m3"))
+    return toggle(nvidiaTemplate({ thinking_mode: "disabled" }), nvidiaTemplate({ thinking_mode: "enabled" }));
+  if (id.includes("glm"))
+    return toggle(nvidiaTemplate({ enable_thinking: false }), nvidiaTemplate({ enable_thinking: true, clear_thinking: false }));
+  const toggleOnly = id.includes("qwen") || id.includes("gemma") || id.includes("nemotron");
+  switch (support.type) {
+    case "effort":
+      return toggleOnly && support.values === undefined ? nvidiaToggle("enable_thinking") : openaiChat(model, support);
+    case "toggle":
+      return nvidiaToggle("enable_thinking");
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        body: { chat_template_kwargs: { enable_thinking: true }, reasoning_budget: tokens }
+      }));
+  }
+};
+var basetenTemplate = (enable_thinking) => ({
+  body: { chat_template_args: { enable_thinking } }
+});
+var basetenChat = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  switch (support.type) {
+    case "effort": {
+      const glm = id.includes("glm-5.2") || id.includes("glm-5-2") || id.includes("glm-5p2");
+      return efforts(support.values ?? EFFORTS, (effort) => ({
+        settings: { reasoningEffort: effort },
+        ...glm ? basetenTemplate(effort !== "none") : {},
+        ...id.includes("deepseek-v4-pro-0813") && effort !== "none" ? { body: { thinking: { type: "enabled" } } } : {}
+      }));
+    }
+    case "toggle":
+      return toggle(basetenTemplate(false), basetenTemplate(true));
+    case "budget_tokens":
+      return [];
+  }
+};
+var deepinfraChat = (model, support) => {
+  if (/kimi[-.]?k2[.-]7-code/i.test(modelID(model)))
+    return [];
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => ({ settings: { reasoningEffort: effort } }));
+    case "toggle":
+      return toggle({ body: { reasoning: { enabled: false } } }, { body: { reasoning: { enabled: true } } });
+    case "budget_tokens":
+      return [];
+  }
+};
+var openaiCompatible = (model, support) => {
+  if (model.providerID === "nvidia")
+    return nvidiaChat(model, support);
+  return openaiChat(model, support);
+};
+var moonshotChat = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  const toggleable = id.includes("k2.5") || id.includes("k2-5") || id.includes("k2.6") || id.includes("k2-6");
+  const fixed = id.includes("k2-thinking") || id.includes("k2.7-code") || id.includes("k2-7-code");
+  if (fixed)
+    return [];
+  if (toggleable && (support.type === "toggle" || support.type === "effort" && support.values === undefined))
+    return toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "enabled" } } });
+  if (toggleable || support.type !== "effort")
+    return [];
+  return efforts(support.values ?? ["low", "high", "max"], (effort) => ({
+    settings: { reasoningEffort: effort }
+  }));
+};
+var alibabaChat = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  const fixed = id.includes("-thinking") || id.includes("qwq") || id.includes("deepseek-r1") || id.includes("minimax-m2");
+  switch (support.type) {
+    case "effort": {
+      if (fixed && support.values === undefined)
+        return [];
+      const hosted = id.includes("glm") || id.includes("deepseek");
+      const values = support.values ?? (hosted ? ["high", "max"] : ["low", "medium", "xhigh"]);
+      return efforts(values, (effort) => {
+        if (effort === "none")
+          return { settings: { enableThinking: false } };
+        return { settings: { enableThinking: true, reasoningEffort: effort } };
+      });
+    }
+    case "toggle":
+      return toggle({ settings: { enableThinking: false } }, { settings: { enableThinking: true } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        settings: { enableThinking: true, thinkingBudget: tokens }
+      }));
+  }
+};
+var zaiChat = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  const version = /glm-?(\d+)(?:(?:[.-]|p)(\d+))?/.exec(id);
+  const major = Number(version?.[1]);
+  const minor = Number(version?.[2] ?? 0);
+  const coding = model.package?.includes("zai-coding-plan") ?? false;
+  const latest = coding || !Number.isFinite(major) || major > 5 || major === 5 && minor >= 3;
+  const effort = major === 5 && minor === 2;
+  if (support.type === "toggle" || !latest && !effort && support.type === "effort" && support.values === undefined) {
+    if (latest)
+      return [];
+    return toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "enabled", clear_thinking: false } } });
+  }
+  if (support.type !== "effort")
+    return [];
+  return efforts(support.values ?? (latest ? ["low", "high", "max"] : ["high", "max"]), (value) => {
+    if (value === "none" || value === "minimal")
+      return { settings: { thinking: { type: "disabled" } } };
+    return {
+      settings: { thinking: { type: "enabled", clear_thinking: false }, reasoningEffort: value }
+    };
+  });
+};
+var anthropicMessages = (model, support) => {
+  const info = claudeInfo(model);
+  const opus45 = info.family === "opus" && info.major === 4 && info.minor === 5;
+  switch (support.type) {
+    case "effort": {
+      if (info.manual && !opus45)
+        return anthropicMessages(model, { type: "budget_tokens", min: 1024 });
+      const thinking = opus45 ? manualThinking(model) : { settings: { thinking: ADAPTIVE_THINKING } };
+      if (!thinking)
+        return [];
+      const defaults = info.major === 4 && info.minor === 6 ? [...EFFORTS, "max"] : [...EFFORTS, "xhigh", "max"];
+      const values = support.values ?? defaults;
+      return efforts(values, (effort) => ({
+        settings: { ...thinking.settings, effort }
+      }));
+    }
+    case "toggle": {
+      if (info.always)
+        return [];
+      const thinking = info.manual ? manualThinking(model) : { settings: { thinking: ADAPTIVE_THINKING } };
+      if (!thinking)
+        return [];
+      return toggle({ settings: { thinking: { type: "disabled" } } }, thinking);
+    }
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        settings: { thinking: { type: "enabled", budgetTokens: tokens } }
+      }));
+  }
+};
+var minimaxMessages = (model, support) => {
+  if (/minimax[-.]?m2(?:[.-]|$)/i.test(modelID(model)))
+    return [];
+  const configurable = support.type === "toggle" || support.type === "effort" && support.values === undefined;
+  if (!configurable)
+    return [];
+  return toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "adaptive" } } });
+};
+var moonshotMessages = (model, support) => {
+  if (support.type !== "effort" || /kimi[-.]?k2/i.test(modelID(model)))
+    return [];
+  return efforts(support.values ?? ["low", "high", "max"], (effort) => ({ settings: { effort } }));
+};
+var alibabaMessages = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  switch (support.type) {
+    case "effort": {
+      const hosted = id.includes("glm") || id.includes("deepseek");
+      const values = support.values ?? (hosted ? ["high", "max"] : ["low", "medium", "xhigh"]);
+      return efforts(values, (effort) => {
+        if (effort === "none")
+          return { settings: { thinking: { type: "disabled" } } };
+        return { settings: { thinking: { type: "enabled" }, effort } };
+      });
+    }
+    case "toggle":
+      return toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "enabled" } } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        settings: { thinking: { type: "enabled", budgetTokens: tokens } }
+      }));
+  }
+};
+var zaiMessages = (model, support) => {
+  const id = modelID(model).toLowerCase();
+  const forced = id.includes("glm-5.3") || id.includes("glm-5-3") || id.includes("glm-5p3");
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? (forced ? ["low", "high", "max"] : ["high", "max"]), (effort) => ({
+        settings: {
+          thinking: { type: effort === "none" || effort === "minimal" ? "disabled" : "enabled" },
+          effort
+        }
+      }));
+    case "toggle":
+      return forced ? [] : toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "enabled" } } });
+    case "budget_tokens":
+      return [];
+  }
+};
+var gemini = (model, support) => {
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => ({
+        settings: { thinkingConfig: { includeThoughts: true, thinkingLevel: effort } }
+      }));
+    case "toggle":
+      return toggle({ settings: { thinkingConfig: { includeThoughts: false, thinkingBudget: 0 } } }, { settings: { thinkingConfig: { includeThoughts: true, thinkingBudget: -1 } } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        settings: { thinkingConfig: { includeThoughts: true, thinkingBudget: tokens } }
+      }));
+  }
+};
+var openrouter = (model, support) => {
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => ({ settings: { reasoning: { effort } } }));
+    case "toggle":
+      return toggle({ settings: { reasoning: { enabled: false } } }, { settings: { reasoning: { enabled: true } } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({ settings: { reasoning: { max_tokens: tokens } } }));
+  }
+};
+var bedrockConverse = (model, support) => {
+  const id = modelID(model);
+  const claude = id.includes("anthropic");
+  const fields = (fields) => ({ body: { additionalModelRequestFields: fields } });
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => {
+        if (claude)
+          return fields({
+            ...claudeInfo(model).manual ? {} : { thinking: ADAPTIVE_THINKING },
+            output_config: { effort }
+          });
+        if (id.includes("openai.gpt-oss"))
+          return fields({ reasoning_effort: effort });
+        if (id.includes("openai."))
+          return fields({ reasoning: { effort } });
+        return fields({ reasoningConfig: { type: "enabled", maxReasoningEffort: effort } });
+      });
+    case "toggle":
+      return claude ? toggle(fields({ thinking: { type: "disabled" } }), fields({ thinking: ADAPTIVE_THINKING })) : toggle(fields({ reasoningConfig: { type: "disabled" } }), fields({ reasoningConfig: { type: "enabled" } }));
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => claude ? fields({ thinking: { type: "enabled", budget_tokens: tokens } }) : fields({ reasoningConfig: { type: "enabled", budgetTokens: tokens } }));
+  }
+};
+var alibabaAISDK = (model, support) => {
+  switch (support.type) {
+    case "effort":
+      return [];
+    case "toggle":
+      return toggle({ settings: { enableThinking: false } }, { settings: { enableThinking: true } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({ settings: { enableThinking: true, thinkingBudget: tokens } }));
+  }
+};
+var cohere = (model, support) => {
+  switch (support.type) {
+    case "effort":
+      return [];
+    case "toggle":
+      return toggle({ settings: { thinking: { type: "disabled" } } }, { settings: { thinking: { type: "enabled" } } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({ settings: { thinking: { type: "enabled", tokenBudget: tokens } } }));
+  }
+};
+var bedrockAISDK = (model, support) => {
+  const claude = modelID(model).includes("anthropic");
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => ({
+        settings: claude ? {
+          reasoningConfig: {
+            ...claudeInfo(model).manual ? {} : ADAPTIVE_THINKING,
+            maxReasoningEffort: effort
+          }
+        } : { reasoningConfig: { type: "enabled", maxReasoningEffort: effort } }
+      }));
+    case "toggle":
+      return claude ? toggle({ settings: { additionalModelRequestFields: { thinking: { type: "disabled" } } } }, { settings: { additionalModelRequestFields: { thinking: ADAPTIVE_THINKING } } }) : toggle({ settings: { additionalModelRequestFields: { reasoningConfig: { type: "disabled" } } } }, { settings: { additionalModelRequestFields: { reasoningConfig: { type: "enabled" } } } });
+    case "budget_tokens":
+      return budgets(model, support, (tokens) => ({
+        settings: { reasoningConfig: { type: "enabled", budgetTokens: tokens } }
+      }));
+  }
+};
+var vercelGateway = (model, support) => {
+  const prefix = modelID(model).split("/")[0];
+  if (prefix === "anthropic")
+    return anthropicMessages(model, support);
+  if (prefix === "google")
+    return gemini(model, support);
+  if (prefix === "amazon")
+    return bedrockAISDK(model, support);
+  if (prefix === "alibaba")
+    return alibabaAISDK(model, support);
+  return support.type === "effort" ? openaiChat(model, support) : openrouter(model, support);
+};
+var sapAICore = (model, support) => {
+  const id = modelID(model);
+  const sap = (modelParams) => ({ settings: { modelParams } });
+  switch (support.type) {
+    case "effort":
+      return efforts(support.values ?? EFFORTS, (effort) => {
+        if (id.includes("anthropic"))
+          return sap({
+            additionalModelRequestFields: {
+              ...claudeInfo(model).manual ? {} : { thinking: ADAPTIVE_THINKING },
+              output_config: { effort }
+            }
+          });
+        if (id.includes("gemini"))
+          return sap({ thinkingConfig: { includeThoughts: true, thinkingLevel: effort } });
+        if (id.includes("amazon--nova"))
+          return sap({ additionalModelRequestFields: { output_config: { effort } } });
+        return sap({ reasoning_effort: effort });
+      });
+    case "toggle":
+      if (id.includes("gemini"))
+        return toggle(sap({ thinkingConfig: { includeThoughts: false, thinkingBudget: 0 } }), sap({ thinkingConfig: { includeThoughts: true, thinkingBudget: -1 } }));
+      if (id.includes("cohere"))
+        return toggle(sap({ thinking: { type: "disabled" } }), sap({ thinking: { type: "enabled" } }));
+      if (id.includes("amazon--nova"))
+        return toggle(sap({ additionalModelRequestFields: { thinking: { type: "disabled" } } }), sap({ additionalModelRequestFields: { thinking: { type: "enabled" } } }));
+      if (id.includes("anthropic"))
+        return toggle(sap({ additionalModelRequestFields: { thinking: { type: "disabled" } } }), sap({ additionalModelRequestFields: { thinking: ADAPTIVE_THINKING } }));
+      return [];
+    case "budget_tokens":
+      if (id.includes("anthropic"))
+        return budgets(model, support, (tokens) => sap({ additionalModelRequestFields: { thinking: { type: "enabled", budget_tokens: tokens } } }));
+      if (id.includes("gemini"))
+        return budgets(model, support, (tokens) => sap({ thinkingConfig: { includeThoughts: true, thinkingBudget: tokens } }));
+      if (id.includes("cohere"))
+        return budgets(model, support, (tokens) => sap({ thinking: { type: "enabled", token_budget: tokens } }));
+      return [];
+  }
+};
+var PROTOCOLS = {
+  "@opencode/ai/providers/openai": openaiResponses,
+  "@opencode/ai/providers/azure/responses": openaiResponses,
+  "@opencode/ai/providers/amazon-bedrock/mantle/chat": openaiResponses,
+  "@opencode/ai/providers/amazon-bedrock/mantle/responses": openaiResponses,
+  "@opencode/ai/providers/alibaba/responses": openaiResponses,
+  "@opencode/ai/providers/meta/responses": openaiResponses,
+  "@opencode/ai/providers/minimax/responses": openaiResponses,
+  "@opencode/ai/providers/moonshot/responses": openaiResponses,
+  "@opencode/ai/providers/zai-coding-plan/responses": openaiResponses,
+  "@opencode/ai/providers/openai-compatible": openaiCompatible,
+  "@opencode/ai/providers/google-vertex/chat": openaiChat,
+  "@opencode/ai/providers/alibaba/chat": alibabaChat,
+  "@opencode/ai/providers/baseten": basetenChat,
+  "@opencode/ai/providers/cerebras": openaiChat,
+  "@opencode/ai/providers/cloudflare-workers-ai": openaiChat,
+  "@opencode/ai/providers/deepinfra": deepinfraChat,
+  "@opencode/ai/providers/deepseek": deepseekChat,
+  "@opencode/ai/providers/fireworks": openaiChat,
+  "@opencode/ai/providers/groq": openaiChat,
+  "@opencode/ai/providers/meta/chat": openaiChat,
+  "@opencode/ai/providers/minimax/chat": openaiChat,
+  "@opencode/ai/providers/mistral": openaiChat,
+  "@opencode/ai/providers/moonshot/chat": moonshotChat,
+  "@opencode/ai/providers/togetherai": openaiChat,
+  "@opencode/ai/providers/xai": openaiChat,
+  "@opencode/ai/providers/zai/chat": zaiChat,
+  "@opencode/ai/providers/zai-coding-plan/chat": zaiChat,
+  "@opencode/ai/providers/anthropic": anthropicMessages,
+  "@opencode/ai/providers/google-vertex/messages": anthropicMessages,
+  "@opencode/ai/providers/alibaba/messages": alibabaMessages,
+  "@opencode/ai/providers/meta/messages": anthropicMessages,
+  "@opencode/ai/providers/minimax/messages": minimaxMessages,
+  "@opencode/ai/providers/moonshot/messages": moonshotMessages,
+  "@opencode/ai/providers/zai-coding-plan/messages": zaiMessages,
+  "@opencode/ai/providers/google": gemini,
+  "@opencode/ai/providers/google-vertex": gemini,
+  "@opencode/ai/providers/amazon-bedrock": bedrockConverse,
+  "@opencode/ai/providers/openrouter": openrouter,
+  [aisdk2("venice-ai-sdk-provider")]: openaiChat,
+  "@opencode/ai/providers/cloudflare-ai-gateway": cloudflareAIGateway,
+  [aisdk2("@ai-sdk/gateway")]: vercelGateway,
+  [aisdk2("@jerome-benoit/sap-ai-provider-v2")]: sapAICore,
+  [aisdk2("@ai-sdk/cohere")]: cohere
+};
+
+export { resolve2, exports_variant };