@opencode/core 2.0.3 → 2.0.5

package/dist/chunks/instruction-discovery-ampvn4qt.js

@@ -0,0 +1,500 @@
+import {
+  aisdk2
+} from "./instruction-discovery-58ka6e3j.js";
+import {
+  VariantID2
+} from "./instruction-discovery-n9bg66xr.js";
+import {
+  __export
+} from "./instruction-discovery-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 };

package/dist/chunks/{mime-9pm6y0s1.js → instruction-discovery-aq5y8b9e.js}

@@ -1,13 +1,13 @@
 import {
   __export
-} from "./mime-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/plugin/hooks.ts
 var exports_hooks = {};
 __export(exports_hooks, {
   PluginHooks: () => exports_hooks,
-  Service: () => Service69,
-  node: () => node74
+  Service: () => Service58,
+  node: () => node61
 });
 import { Context, Effect, Layer, Scope } from "effect";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
@@ -20,9 +20,9 @@ var eventProviderID = (event) => {
   return typeof model.providerID === "string" ? model.providerID : undefined;
 };
 
-class Service69 extends Context.Service()("@opencode/PluginHooks") {
+class Service58 extends Context.Service()("@opencode/PluginHooks") {
 }
-var layer = Layer.effect(Service69, Effect.gen(function* () {
+var layer = Layer.effect(Service58, Effect.gen(function* () {
   const callbacks = new Map;
   const key = (domain, name) => `${domain}.${String(name)}`;
   const register = Effect.fn("PluginHooks.register")(function* (domain, name, callback, options) {
@@ -48,14 +48,14 @@ var layer = Layer.effect(Service69, Effect.gen(function* () {
     for (const entry of callbacks.get(key(domain, name)) ?? []) {
       if (entry.options?.providerID !== undefined && entry.options.providerID !== eventProviderID(event))
         continue;
-      const result = Reflect.apply(entry.callback, undefined, [event]);
+      const result = entry.callback(event);
       yield* result;
     }
     return event;
   });
   const has = (domain, name, providerID) => Effect.sync(() => (callbacks.get(key(domain, name)) ?? []).some((entry) => entry.options?.providerID === undefined || entry.options.providerID === providerID));
-  return Service69.of({ has, register, trigger });
+  return Service58.of({ has, register, trigger });
 }));
-var node74 = makeLocationNode({ service: Service69, layer, deps: [] });
+var node61 = makeLocationNode({ service: Service58, layer, deps: [] });
 
-export { Service69, node74, exports_hooks };
+export { Service58, node61, exports_hooks };

package/dist/chunks/{mime-g6878fex.js → instruction-discovery-ay615zsc.js}

@@ -1,23 +1,23 @@
 import {
-  Service62,
-  node67,
-  canonical2
-} from "./mime-esaayfhr.js";
+  Service69,
+  node72,
+  canonical3
+} from "./instruction-discovery-3vhfgt92.js";
 import {
-  Service40,
-  node43
-} from "./mime-qfzde7bh.js";
+  Service50,
+  node53
+} from "./instruction-discovery-hq8zt1th.js";
 import {
-  Service15
-} from "./mime-824vcv1n.js";
+  Service17
+} from "./instruction-discovery-r1p3dd79.js";
 import {
   layer2
-} from "./mime-9jxymrt4.js";
+} from "./instruction-discovery-7aagt1ep.js";
 
 // src/location-services.ts
 import { Context, Duration, Effect, Exit, Layer, LayerMap, MutableHashMap, Option } from "effect";
 function buildLocationServiceMap2(replacements = []) {
-  return Layer.effect(Service62, Effect.gen(function* () {
+  return Layer.effect(Service69, Effect.gen(function* () {
     const owner = yield* Effect.scope;
     const builds = MutableHashMap.empty();
     const inner = yield* LayerMap.make((ref) => {
@@ -28,7 +28,7 @@ function buildLocationServiceMap2(replacements = []) {
           if (Option.getOrUndefined(MutableHashMap.get(builds, ref)) !== build)
             return Effect.void;
           if (Exit.isSuccess(exit)) {
-            build.close = Context.get(exit.value, Service15).close;
+            build.close = Context.get(exit.value, Service17).close;
             return Effect.void;
           }
           MutableHashMap.remove(builds, ref);
@@ -39,22 +39,22 @@ function buildLocationServiceMap2(replacements = []) {
     }, { idleTimeToLive: Duration.infinity });
     const map = {
       ...inner,
-      get: (ref) => inner.get(canonical2(ref)),
-      contextEffect: (ref) => inner.contextEffect(canonical2(ref)),
-      contextEffectOption: (ref) => inner.contextEffectOption(canonical2(ref)),
+      get: (ref) => inner.get(canonical3(ref)),
+      contextEffect: (ref) => inner.contextEffect(canonical3(ref)),
+      contextEffectOption: (ref) => inner.contextEffectOption(canonical3(ref)),
       invalidate: (ref) => Effect.suspend(() => {
-        const key = canonical2(ref);
+        const key = canonical3(ref);
         const build = Option.getOrUndefined(MutableHashMap.get(builds, key));
         MutableHashMap.remove(builds, key);
         return inner.invalidate(key).pipe(Effect.andThen(build?.close ?? Effect.void));
       })
     };
     const bindings = [
-      node43.replace(Layer.succeed(Service40, {
+      node53.replace(Layer.succeed(Service50, {
         provide: (session) => Effect.provide(map.get(session.location))
       })),
       ...replacements,
-      node67.replace(Layer.succeed(Service62, map))
+      node72.replace(Layer.succeed(Service69, map))
     ];
     return map;
   }));