@opencode/core 0.0.0-dev-19618 → 0.0.0-dev-19620

package/dist/chunks/config-thzkma29.js

@@ -0,0 +1,500 @@
+import {
+  aisdk2
+} from "./config-f2p7c97r.js";
+import {
+  VariantID2
+} from "./config-vr0jy3rn.js";
+import {
+  __export
+} from "./config-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/{filesystem-s4bmhrbd.js → config-tk5pet79.js}

@@ -1,28 +1,28 @@
 import {
-  Service75
-} from "./filesystem-req2f1zf.js";
+  Service77
+} from "./config-k3942g9h.js";
 import {
   latest2,
-  Service41
-} from "./filesystem-b339w5wj.js";
+  Service58
+} from "./config-t1rx5jyv.js";
 import {
-  Service13
-} from "./filesystem-bcfqw6ff.js";
+  Service12
+} from "./config-sk01cyn9.js";
 import {
-  make10
-} from "./filesystem-73tb2d7t.js";
+  make8
+} from "./config-eq1pz5kg.js";
 import {
   observe2
-} from "./filesystem-qsdy395h.js";
+} from "./config-qsdy395h.js";
 import {
   __export
-} from "./filesystem-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/config/plugin/formatter.ts
 var exports_formatter = {};
 __export(exports_formatter, {
   ConfigFormatterPlugin: () => exports_formatter,
-  Plugin: () => Plugin16
+  Plugin: () => Plugin17
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
@@ -30,14 +30,14 @@ import { Global } from "@opencode/util/global";
 import { Npm } from "@opencode/util/npm";
 import { AppProcess } from "@opencode/util/process";
 import { Effect } from "effect";
-var Plugin16 = define({
+var Plugin17 = define({
   id: "opencode.config.formatter",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service41;
-    const formatter = yield* Service13;
+    const config = yield* Service58;
+    const formatter = yield* Service12;
     const fs = yield* FSUtil.Service;
     const global = yield* Global.Service;
-    const location = yield* Service75;
+    const location = yield* Service77;
     const npm = yield* Npm.Service;
     const processes = yield* AppProcess.Service;
     const loaded = yield* observe2(config, ctx.event, formatter.reload());
@@ -45,7 +45,7 @@ var Plugin16 = define({
       const configured = latest2(loaded.entries, "formatter");
       if (!configured)
         return;
-      const builtIns = make10({
+      const builtIns = make8({
         directory: location.directory,
         worktree: location.project.directory,
         fs,
@@ -74,4 +74,4 @@ var Plugin16 = define({
   })
 });
 
-export { Plugin16, exports_formatter };
+export { Plugin17, exports_formatter };

package/dist/chunks/{filesystem-tvtrv512.js → config-tvtrv512.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./filesystem-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/id/id.ts
 var exports_id = {};

package/dist/chunks/{filesystem-zh0vtjyr.js → config-v00ee303.js}

@@ -3,34 +3,34 @@ import {
   WrongKind2,
   Failed2,
   typeFollowing2
-} from "./filesystem-2a5m3afh.js";
+} from "./config-2a5m3afh.js";
 import {
   execDefaults2
-} from "./filesystem-1dazxqgg.js";
+} from "./config-1dazxqgg.js";
 import {
   makeLocalDriver2
-} from "./filesystem-b6gygkdw.js";
+} from "./config-b6gygkdw.js";
 import {
   makeMemoryDriver2
-} from "./filesystem-aaet6srn.js";
+} from "./config-aaet6srn.js";
 import {
-  Service75,
-  node80
-} from "./filesystem-req2f1zf.js";
+  Service77,
+  node82
+} from "./config-k3942g9h.js";
 import {
-  Service63,
-  node67
-} from "./filesystem-ck5yfnd1.js";
+  Service56,
+  node60
+} from "./config-hhxyj69g.js";
 import {
   __export
-} from "./filesystem-9rqn6x4v.js";
+} from "./config-9rqn6x4v.js";
 
 // src/environment/environment.ts
 var exports_environment2 = {};
 __export(exports_environment2, {
   EnvironmentService: () => exports_environment2,
-  Service: () => Service62,
-  node: () => node66
+  Service: () => Service55,
+  node: () => node59
 });
 import { CrossSpawnSpawner } from "@opencode/util/cross-spawn-spawner";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
@@ -43,13 +43,13 @@ __export(exports_environment3, {
   Environment: () => exports_environment3,
   Failed: () => Failed2,
   NotFound: () => NotFound2,
-  Service: () => Service62,
+  Service: () => Service55,
   WrongKind: () => WrongKind2,
   execDefaults: () => execDefaults2,
   makeFiles: () => makeFiles2,
   makeLocalDriver: () => makeLocalDriver2,
   makeMemoryDriver: () => makeMemoryDriver2,
-  node: () => node66,
+  node: () => node59,
   typeFollowing: () => typeFollowing2
 });
 var makeFiles2 = (driver) => ({
@@ -58,19 +58,19 @@ var makeFiles2 = (driver) => ({
 });
 
 // src/environment/environment.ts
-class Service62 extends Context.Service()("@opencode/Environment") {
+class Service55 extends Context.Service()("@opencode/Environment") {
 }
-var layer = Layer.effect(Service62, Effect.gen(function* () {
+var layer = Layer.effect(Service55, Effect.gen(function* () {
   const spawner = yield* ChildProcessSpawner;
-  const location = yield* Service75;
-  const workspace = yield* Service63;
+  const location = yield* Service77;
+  const workspace = yield* Service56;
   const driver = location.workspaceID ? yield* workspace.connect(location.workspaceID).pipe(Effect.mapError((cause) => new Error(`Failed to bind Environment to workspace ${location.workspaceID}`, { cause })), Effect.orDie) : makeLocalDriver2(spawner);
-  return Service62.of({ files: makeFiles2(driver), spawner: driver.spawner });
+  return Service55.of({ files: makeFiles2(driver), spawner: driver.spawner });
 }));
-var node66 = makeLocationNode({
-  service: Service62,
+var node59 = makeLocationNode({
+  service: Service55,
   layer,
-  deps: [CrossSpawnSpawner.node, node80, node67]
+  deps: [CrossSpawnSpawner.node, node82, node60]
 });
 
-export { Service62, node66, exports_environment2, makeFiles2, exports_environment3 };
+export { Service55, node59, exports_environment2, makeFiles2, exports_environment3 };