@opencode/core 2.0.2 → 2.0.4

package/dist/chunks/location-a8d2vvnh.js

@@ -0,0 +1,500 @@
+import {
+  aisdk2
+} from "./location-1gfezbxs.js";
+import {
+  VariantID2
+} from "./location-eshsynjd.js";
+import {
+  __export
+} from "./location-9rqn6x4v.js";
+
+// src/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  Variant: () => exports_variant,
+  resolve: () => resolve4
+});
+function resolve4(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 { resolve4, exports_variant };

package/dist/chunks/{location-services-aaet6srn.js → location-aaet6srn.js}

@@ -2,10 +2,10 @@ import {
   NotFound2,
   WrongKind2,
   Failed2
-} from "./location-services-2a5m3afh.js";
+} from "./location-2a5m3afh.js";
 import {
   __export
-} from "./location-services-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/environment/memory.ts
 var exports_memory = {};

package/dist/chunks/{location-services-nwd6ekzm.js → location-aqxshtk7.js}

@@ -1,63 +1,63 @@
 import {
-  Service80,
-  node85
-} from "./location-services-v9b1dqp1.js";
+  Service82,
+  node86
+} from "./location-yq2q1mjm.js";
 import {
-  Service79,
-  node84
-} from "./location-services-69j49pks.js";
+  Service78,
+  node82
+} from "./location-tsjh32me.js";
 import {
   CredentialTable2
-} from "./location-services-pknna89w.js";
+} from "./location-pknna89w.js";
 import {
   from2
-} from "./location-services-0q0f95c6.js";
+} from "./location-0q0f95c6.js";
 import {
   __export
-} from "./location-services-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/credential.ts
 var exports_credential = {};
 __export(exports_credential, {
   Credential: () => exports_credential,
-  Event: () => Event15,
-  ID: () => ID9,
-  Info: () => Info23,
-  Key: () => Key3,
+  Event: () => Event19,
+  ID: () => ID15,
+  Info: () => Info30,
+  Key: () => Key4,
   OAuth: () => OAuth3,
-  Service: () => Service66,
+  Service: () => Service74,
   Value: () => Value2,
-  node: () => node71
+  node: () => node78
 });
 import { asc, desc, eq } from "drizzle-orm";
 import { Cause, Context, Effect, Layer, Schema } from "effect";
 import { Credential } from "@opencode/schema/credential";
 import { Integration } from "@opencode/schema/integration";
 import { makeGlobalNode } from "@opencode/util/effect/app-node";
-var ID9 = Credential.ID;
+var ID15 = Credential.ID;
 var OAuth3 = Credential.OAuth;
-var Key3 = Credential.Key;
+var Key4 = Credential.Key;
 var Value2 = Credential.Value;
-var Event15 = Credential.Event;
+var Event19 = Credential.Event;
 
-class Info23 extends Schema.Class("Credential.Info")({
-  id: ID9,
+class Info30 extends Schema.Class("Credential.Info")({
+  id: ID15,
   integrationID: Integration.ID,
   label: Schema.String,
   value: Value2
 }) {
 }
 
-class Service66 extends Context.Service()("@opencode/Credential") {
+class Service74 extends Context.Service()("@opencode/Credential") {
 }
-var layer = Layer.effect(Service66, Effect.gen(function* () {
-  const db = (yield* Service80).db;
-  const bus = yield* Service79;
+var layer = Layer.effect(Service74, Effect.gen(function* () {
+  const db = (yield* Service82).db;
+  const bus = yield* Service78;
   const decode = Schema.decodeUnknownSync(Value2);
   const stored = (row) => {
     if (!row.integration_id)
       return;
-    return new Info23({
+    return new Info30({
       id: row.id,
       integrationID: row.integration_id,
       label: row.label,
@@ -68,7 +68,7 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
     const credential = stored(row);
     return credential ? [credential] : [];
   });
-  return Service66.of({
+  return Service74.of({
     all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable2).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
     list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable2).where(eq(CredentialTable2.integration_id, integrationID)).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
     get: Effect.fn("Credential.get")(function* (id) {
@@ -76,8 +76,8 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
       return row ? stored(row) : undefined;
     }),
     create: Effect.fn("Credential.create")(function* (input) {
-      const credential = new Info23({
-        id: ID9.create(),
+      const credential = new Info30({
+        id: ID15.create(),
         integrationID: input.integrationID,
         label: input.label ?? "default",
         value: input.value
@@ -101,8 +101,8 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
         integrationID: credential.integrationID,
         type: credential.value.type
       });
-      yield* bus.publish(Event15.Updated, {}, { global: true });
-      yield* bus.publish(Event15.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
+      yield* bus.publish(Event19.Updated, {}, { global: true });
+      yield* bus.publish(Event19.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
       return credential;
     }),
     activate: Effect.fn("Credential.activate")(function* (id) {
@@ -122,7 +122,7 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
       })), Effect.orDie);
       if (integrationID) {
         yield* Effect.logInfo("credential activated", { integrationID, credentialID: id });
-        yield* bus.publish(Event15.Switched, { integrationID, credentialID: id }, { global: true });
+        yield* bus.publish(Event19.Switched, { integrationID, credentialID: id }, { global: true });
       }
     }),
     update: Effect.fn("Credential.update")(function* (id, updates) {
@@ -154,7 +154,7 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
         labelChanged: updates.label !== undefined && updates.label !== credential.label
       });
       if (updates.label !== undefined && updates.label !== credential.label)
-        yield* bus.publish(Event15.Updated, {}, { global: true });
+        yield* bus.publish(Event19.Updated, {}, { global: true });
     }),
     remove: Effect.fn("Credential.remove")(function* (id) {
       const removed = yield* db.transaction((tx) => Effect.gen(function* () {
@@ -187,12 +187,12 @@ var layer = Layer.effect(Service66, Effect.gen(function* () {
         active: removed.switched,
         ...removed.switched ? { replacementID: removed.credentialID } : {}
       });
-      yield* bus.publish(Event15.Updated, {}, { global: true });
+      yield* bus.publish(Event19.Updated, {}, { global: true });
       if (removed.switched)
-        yield* bus.publish(Event15.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
+        yield* bus.publish(Event19.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
     })
   });
 }));
-var node71 = makeGlobalNode({ service: Service66, layer, deps: [node85, node84] });
+var node78 = makeGlobalNode({ service: Service74, layer, deps: [node86, node82] });
 
-export { ID9, OAuth3, Key3, Value2, Event15, Info23, Service66, node71, exports_credential };
+export { ID15, OAuth3, Key4, Value2, Event19, Info30, Service74, node78, exports_credential };