@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-gn7btdpk.js → event-logger-12wcht6n.js}

@@ -1,42 +1,48 @@
 import {
-  exports_migrate
-} from "./schema-jepqtr73.js";
+  PositiveInt2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_config
-} from "./schema-xe5n6qar.js";
+  Action2
+} from "./event-logger-1cngsnb6.js";
 import {
-  exports_mcp
-} from "./schema-bd2mvb8t.js";
+  Info13
+} from "./event-logger-3wgash5j.js";
 import {
-  exports_provider
-} from "./schema-g9dd0fv6.js";
+  Info15
+} from "./event-logger-h722e297.js";
 import {
-  exports_agent
-} from "./schema-3ep0k87g.js";
+  Info11
+} from "./event-logger-ryr25ayn.js";
 import {
-  exports_permission
-} from "./schema-qfvp8zq7.js";
+  Info17
+} from "./event-logger-3jj6bjb6.js";
 import {
-  exports_attachment
-} from "./schema-ngzr6ypz.js";
+  Spec2
+} from "./event-logger-2k8khapm.js";
 import {
-  exports_plugin
-} from "./schema-wf5w4wph.js";
+  Info10
+} from "./event-logger-jjzmpkqm.js";
 import {
-  exports_command
-} from "./schema-42zyazrq.js";
+  Info8
+} from "./event-logger-8p0zspew.js";
 import {
-  PositiveInt
-} from "./schema-j07kk359.js";
+  migrate2,
+  normalizeAction2,
+  migrateAgent2,
+  commands2,
+  migrateMcp2,
+  migrateProvider2,
+  providerID2
+} from "./event-logger-yba16dxq.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/normalize.ts
 var exports_normalize = {};
 __export(exports_normalize, {
   ConfigNormalize: () => exports_normalize,
-  normalize: () => normalize
+  normalize: () => normalize2
 });
 import { isDeepStrictEqual } from "node:util";
 import { isRecord } from "@opencode-ai/ai/utils/record";
@@ -66,7 +72,7 @@ var unsupportedExperimental = [
 ];
 var unsupportedProvider = ["id", "whitelist", "blacklist"];
 var unsupportedModel = ["release_date", "attachment", "reasoning", "temperature", "experimental"];
-function normalize(input) {
+function normalize2(input) {
   if (!isRecord(input))
     return {
       type: "rejected",
@@ -78,18 +84,18 @@ function normalize(input) {
   const encoded = {};
   unsupportedTopLevel.forEach((key) => unsupportedIfPresent(input, key, [key], diagnostics));
   const legacySnapshots = own(input, "snapshot") ? decodeEncoded(Schema.Boolean, input.snapshot, ["snapshot"], diagnostics) : undefined;
-  const legacyUpdate = own(input, "autoupdate") ? decodeValue(exports_config.Info.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics) : undefined;
-  const nativeUpdate = own(input, "update") ? input.update === "auto" ? "notify" : decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics) : undefined;
+  const legacyUpdate = own(input, "autoupdate") ? decodeValue(Info8.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics) : undefined;
+  const nativeUpdate = own(input, "update") ? decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics) : undefined;
   const legacyShare = own(input, "autoshare") ? decodeValue(Schema.Boolean, input.autoshare, ["autoshare"], diagnostics) === true ? "auto" : undefined : undefined;
-  const legacyMedia = own(input, "attachment") ? decodeValue(exports_attachment.Info, input.attachment, ["attachment"], diagnostics) : undefined;
+  const legacyMedia = own(input, "attachment") ? decodeValue(Info15, input.attachment, ["attachment"], diagnostics) : undefined;
   if (legacyMedia !== undefined) {
-    const migrated = exports_migrate.migrate({ attachment: legacyMedia }).media;
+    const migrated = migrate2({ attachment: legacyMedia }).media;
     if (migrated !== undefined)
       encoded.media = canonical(ConfigMedia.Info, migrated);
   }
   if (legacySnapshots !== undefined)
     encoded.snapshots = legacySnapshots;
-  const migratedUpdate = legacyUpdate === undefined ? undefined : exports_migrate.migrate({ autoupdate: legacyUpdate }).update;
+  const migratedUpdate = legacyUpdate === undefined ? undefined : migrate2({ autoupdate: legacyUpdate }).update;
   const update = prefer(migratedUpdate, nativeUpdate, ["update"], diagnostics);
   if (update !== undefined)
     encoded.update = update;
@@ -98,17 +104,17 @@ function normalize(input) {
   const legacyReferences = decodeMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics, decodeEncoded);
   const nativeReferences = decodeMap(input.references, ConfigReference.Entry, ["references"], diagnostics, decodeEncoded);
   mergeMap(encoded, "references", legacyReferences, nativeReferences, isRecord(input.reference) || isRecord(input.references), diagnostics);
-  const legacyCommands = decodeMap(input.command, exports_command.Info, ["command"], diagnostics, decodeValue);
+  const legacyCommands = decodeMap(input.command, Info11, ["command"], diagnostics, decodeValue);
   diagnoseSelectionMap(input.command, ["command"], diagnostics);
   const migratedCommands = mapValues(legacyCommands, (value) => {
-    const migrated = exports_migrate.commands({ value })?.value;
+    const migrated = commands2({ value })?.value;
     return migrated === undefined ? undefined : canonical(ConfigCommand.Info, migrated);
   });
   const nativeCommands = decodeMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics, decodeEncoded);
   mergeMap(encoded, "commands", migratedCommands, nativeCommands, isRecord(input.command) || isRecord(input.commands), diagnostics);
-  const legacyAgents = mapValues(decodeMap(input.agent, exports_agent.Info, ["agent"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, exports_migrate.migrateAgent(value)));
+  const legacyAgents = mapValues(decodeMap(input.agent, Info13, ["agent"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2(value)));
   const legacySmallModel = own(input, "small_model") ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics) : undefined;
-  const migratedSmallModel = legacySmallModel ? exports_migrate.migrate({ small_model: legacySmallModel }).agents?.title?.model : undefined;
+  const migratedSmallModel = legacySmallModel ? migrate2({ small_model: legacySmallModel }).agents?.title?.model : undefined;
   if (legacySmallModel && !migratedSmallModel)
     diagnostics.push({
       kind: "unsupported",
@@ -120,7 +126,7 @@ function normalize(input) {
       model: migratedSmallModel,
       ...legacyAgents.title
     };
-  const modeAgents = mapValues(decodeMap(input.mode, exports_agent.Info, ["mode"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, exports_migrate.migrateAgent({ ...value, mode: "primary" })));
+  const modeAgents = mapValues(decodeMap(input.mode, Info13, ["mode"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2({ ...value, mode: "primary" })));
   const migratedAgents = mergeMaps(legacyAgents, modeAgents, ["agents"], diagnostics);
   const nativeAgents = decodeMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics, decodeEncoded);
   diagnoseAgentUnsupported(input.agent, ["agent"], diagnostics);
@@ -135,7 +141,7 @@ function normalize(input) {
   const permissions = [...toolRules, ...permissionRules, ...nativePermissions];
   if (permissions.length || Array.isArray(input.permissions))
     encoded.permissions = permissions;
-  const legacyPlugins = decodeList(input.plugin, exports_plugin.Spec, ["plugin"], diagnostics, decodeValue).map((plugin) => typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] });
+  const legacyPlugins = decodeList(input.plugin, Spec2, ["plugin"], diagnostics, decodeValue).map((plugin) => typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] });
   const nativePlugins = decodeList(input.plugins, ConfigPlugin.Plugin, ["plugins"], diagnostics, decodeEncoded);
   if (legacyPlugins.length || nativePlugins.length || Array.isArray(input.plugin) || Array.isArray(input.plugins))
     encoded.plugins = [...legacyPlugins, ...nativePlugins];
@@ -158,6 +164,7 @@ function normalize(input) {
     media: Info.fields.media,
     tool_output: Info.fields.tool_output,
     websearch: Info.fields.websearch,
+    worktree: Info.fields.worktree,
     warming: Info.fields.warming
   };
   Object.entries(nativeAtomic).forEach(([key, schema]) => {
@@ -194,7 +201,7 @@ function normalizeMcp(input, encoded, diagnostics) {
   const nativeServers = {};
   const timeout = {};
   if (isRecord(input.experimental) && own(input.experimental, "mcp_timeout")) {
-    const value = decodeEncoded(PositiveInt, input.experimental.mcp_timeout, ["experimental", "mcp_timeout"], diagnostics);
+    const value = decodeEncoded(PositiveInt2, input.experimental.mcp_timeout, ["experimental", "mcp_timeout"], diagnostics);
     if (value !== undefined) {
       timeout.catalog = value;
       timeout.execution = value;
@@ -211,16 +218,16 @@ function normalizeMcp(input, encoded, diagnostics) {
           return;
         }
         if (name === "servers" && !isDirectLegacyMcp(value)) {
-          Object.entries(decodeMap(value, ConfigMCP.Server, path, diagnostics, decodeEncoded)).forEach(([key, server2]) => setOwn(nativeServers, key, server2));
+          Object.entries(decodeMap(value, ConfigMCP.Server, path, diagnostics, decodeEncoded)).forEach(([key, server]) => setOwn(nativeServers, key, server));
           return;
         }
         if (name === "timeout" && !isDirectLegacyMcp(value)) {
           normalizeMcpTimeout(value, timeout, path, diagnostics);
           return;
         }
-        const server = decodeValue(exports_mcp.Info, value, path, diagnostics);
+        const server = decodeValue(Info17, value, path, diagnostics);
         if (server !== undefined)
-          setOwn(legacyServers, name, canonical(ConfigMCP.Server, exports_migrate.migrateMcp(server)));
+          setOwn(legacyServers, name, canonical(ConfigMCP.Server, migrateMcp2(server)));
       });
     }
   }
@@ -291,14 +298,14 @@ function normalizeExperimental(input, encoded, diagnostics) {
     generated.push({ action: "provider.use", resource: "*", effect: "deny" });
     generated.push(...enabled.values.map((resource) => ({
       action: "provider.use",
-      resource: exports_migrate.providerID(resource),
+      resource: providerID2(resource),
       effect: "allow"
     })));
   }
   const disabled = decodeProviderList(input, "disabled_providers", diagnostics);
   generated.push(...disabled.values.map((resource) => ({
     action: "provider.use",
-    resource: exports_migrate.providerID(resource),
+    resource: providerID2(resource),
     effect: "deny"
   })));
   const native = [];
@@ -373,14 +380,14 @@ function migrateTools(value, diagnostics) {
     const enabled = decodeValue(Schema.Boolean, raw, ["tools", action], diagnostics);
     if (enabled === undefined)
       return [];
-    return [{ action: exports_migrate.normalizeAction(action), resource: "*", effect: enabled ? "allow" : "deny" }];
+    return [{ action: normalizeAction2(action), resource: "*", effect: enabled ? "allow" : "deny" }];
   });
 }
 function migratePermissions(value, diagnostics) {
   if (value === undefined)
     return [];
   if (typeof value === "string") {
-    const effect = decodeValue(exports_permission.Action, value, ["permission"], diagnostics);
+    const effect = decodeValue(Action2, value, ["permission"], diagnostics);
     return effect === undefined ? [] : [{ action: "*", resource: "*", effect }];
   }
   if (!isRecord(value)) {
@@ -389,16 +396,16 @@ function migratePermissions(value, diagnostics) {
   }
   return Object.entries(value).flatMap(([action, raw]) => {
     if (typeof raw === "string") {
-      const effect = decodeValue(exports_permission.Action, raw, ["permission", action], diagnostics);
-      return effect === undefined ? [] : [{ action: exports_migrate.normalizeAction(action), resource: "*", effect }];
+      const effect = decodeValue(Action2, raw, ["permission", action], diagnostics);
+      return effect === undefined ? [] : [{ action: normalizeAction2(action), resource: "*", effect }];
     }
     if (!isRecord(raw)) {
       invalid(["permission", action], diagnostics);
       return [];
     }
     return Object.entries(raw).flatMap(([resource, effect], index) => {
-      const decoded = decodeValue(exports_permission.Action, effect, ["permission", action, String(index)], diagnostics);
-      return decoded === undefined ? [] : [{ action: exports_migrate.normalizeAction(action), resource, effect: decoded }];
+      const decoded = decodeValue(Action2, effect, ["permission", action, String(index)], diagnostics);
+      return decoded === undefined ? [] : [{ action: normalizeAction2(action), resource, effect: decoded }];
     });
   });
 }
@@ -414,15 +421,15 @@ function migrateProviders(value, diagnostics) {
     diagnoseProviderUnsupported(raw, path, diagnostics);
     if (invalidProviderOverlays(raw, path, diagnostics))
       return [];
-    const provider = decodeValue(exports_provider.Info, raw, path, diagnostics);
+    const provider = decodeValue(Info10, raw, path, diagnostics);
     if (provider === undefined)
       return [];
-    const destination = exports_migrate.providerID(name);
+    const destination = providerID2(name);
     return [
       {
         name,
         destination,
-        provider: canonical(ConfigProvider.Info, exports_migrate.migrateProvider(name, provider))
+        provider: canonical(ConfigProvider.Info, migrateProvider2(name, provider))
       }
     ];
   });
@@ -623,4 +630,4 @@ function setOwn(value, key, item) {
   Object.defineProperty(value, key, { value: item, enumerable: true, configurable: true, writable: true });
 }
 
-export { normalize, exports_normalize };
+export { normalize2, exports_normalize };

package/dist/chunks/{schema-dwvtf5ds.js → event-logger-14h757nk.js}

@@ -1,18 +1,23 @@
 import {
-  exports_model
-} from "./schema-8manx9kj.js";
+  ID11,
+  aisdk2,
+  mergeOverlay2
+} from "./event-logger-rwbhhn1p.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  ID10,
+  VariantID2,
+  Family2,
+  Info24
+} from "./event-logger-ar3vq2rb.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/github-copilot/models.ts
 var exports_models = {};
 __export(exports_models, {
   CopilotModels: () => exports_models,
-  get: () => get
+  get: () => get2
 });
 import { Money } from "@opencode-ai/schema/money";
 import { Option, Schema } from "effect";
@@ -61,7 +66,7 @@ var RemoteModel = Schema.Struct({
 var Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) });
 var decodeResponse = Schema.decodeUnknownSync(Response);
 var decodeModel = Schema.decodeUnknownOption(RemoteModel);
-async function get(baseURL, headers, existing) {
+async function get2(baseURL, headers, existing) {
   const response = await fetch(`${baseURL}/models`, {
     headers,
     signal: AbortSignal.timeout(5000)
@@ -82,7 +87,7 @@ async function get(baseURL, headers, existing) {
     result.set(id, build(id, current, baseURL, model));
   }
   for (const [id, model] of remote) {
-    const key = exports_model.ID.make(id);
+    const key = ID10.make(id);
     if (result.has(key))
       continue;
     result.set(key, build(key, model, baseURL));
@@ -106,15 +111,15 @@ function build(id, remote, baseURL, previous) {
   const usdPerMillion = prices && prices.batch_size > 0 ? 1e4 / prices.batch_size : 0;
   const version = remote.version.startsWith(`${remote.id}-`) ? remote.version.slice(remote.id.length + 1) : remote.version;
   const released = previous?.time.released || Date.parse(version);
-  return exports_model.Info.make({
-    ...exports_model.Info.default(exports_provider.ID.githubCopilot, id),
+  return Info24.make({
+    ...Info24.default(ID11.githubCopilot, id),
     id,
-    modelID: exports_model.ID.make(remote.id),
-    providerID: exports_provider.ID.githubCopilot,
-    family: previous?.family ?? exports_model.Family.make(remote.capabilities.family),
+    modelID: ID10.make(remote.id),
+    providerID: ID11.githubCopilot,
+    family: previous?.family ?? Family2.make(remote.capabilities.family),
     name: previous?.name ?? remote.name,
-    package: exports_provider.aisdk(messages ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot"),
-    settings: exports_provider.mergeOverlay(previous?.settings, {
+    package: aisdk2(messages ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot"),
+    settings: mergeOverlay2(previous?.settings, {
       baseURL: messages ? `${baseURL}/v1` : baseURL,
       ...endpoint ? { endpoint } : {}
     }),
@@ -150,7 +155,7 @@ function variants(remote, messages) {
   const efforts = remote.capabilities.supports.reasoning_effort ?? [];
   if (!messages && efforts.length) {
     return efforts.map((effort) => ({
-      id: exports_model.VariantID.make(effort),
+      id: VariantID2.make(effort),
       settings: {
         reasoningEffort: effort,
         reasoningSummary: "auto",
@@ -160,7 +165,7 @@ function variants(remote, messages) {
   }
   if (efforts.length && remote.capabilities.supports.adaptive_thinking) {
     return efforts.map((effort) => ({
-      id: exports_model.VariantID.make(effort),
+      id: VariantID2.make(effort),
       settings: {
         thinking: {
           type: "adaptive",
@@ -175,14 +180,14 @@ function variants(remote, messages) {
     return [];
   return [
     {
-      id: exports_model.VariantID.make("max"),
+      id: VariantID2.make("max"),
       settings: { thinking: { type: "enabled", budgetTokens: max - 1 } }
     },
     {
-      id: exports_model.VariantID.make("high"),
+      id: VariantID2.make("high"),
       settings: { thinking: { type: "enabled", budgetTokens: Math.floor(max / 2) } }
     }
   ];
 }
 
-export { get, exports_models };
+export { get2, exports_models };

package/dist/chunks/{schema-my53s247.js → event-logger-16r38w9g.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/mcp-codemode-exclusion.ts
 var exports_mcp_codemode_exclusion = {};
 __export(exports_mcp_codemode_exclusion, {
   McpCodeModeExclusionPlugin: () => exports_mcp_codemode_exclusion,
-  Plugin: () => Plugin
+  Plugin: () => Plugin13
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
 var urls = [/^https:\/\/executor\.sh\/[^/]+\/mcp$/];
-var Plugin = define({
+var Plugin13 = define({
   id: "opencode.mcp.codemode.exclusion",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.mcp.transform((editor) => {
@@ -34,4 +34,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_mcp_codemode_exclusion };
+export { Plugin13, exports_mcp_codemode_exclusion };

package/dist/chunks/{schema-r9d3d23r.js → event-logger-1bbkgx8g.js}

@@ -1,13 +1,13 @@
 import {
-  which
-} from "./schema-k3e42drn.js";
+  which2
+} from "./event-logger-qaymkmh1.js";
 
 // src/formatter/builtins.ts
 import { Effect } from "effect";
 import { ChildProcess } from "effect/unstable/process";
-function make(input) {
+function make7(input) {
   const disabled = false;
-  const findExecutable = (name) => which(name, undefined, input.bin);
+  const findExecutable = (name) => which2(name, undefined, input.bin);
   const findUp = (target) => input.fs.findUp(target, input.directory, input.worktree);
   const readText = (file) => input.fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""));
   const commandOutput = (command) => input.processes.run(ChildProcess.make(command[0], command.slice(1), {
@@ -261,4 +261,4 @@ function isRecord(input) {
   return Boolean(input && typeof input === "object" && !Array.isArray(input));
 }
 
-export { make };
+export { make7 };

package/dist/chunks/event-logger-1cngsnb6.js

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Action: () => Action2,
+  ConfigPermissionV1: () => exports_permission,
+  Info: () => Info14,
+  Object: () => Object2,
+  Rule: () => Rule2
+});
+import { Schema, SchemaGetter } from "effect";
+var Action2 = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object2 = Schema.Record(Schema.String, Action2).annotate({ identifier: "PermissionObjectConfig" });
+var Rule2 = Schema.Union([Action2, Object2]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule2),
+  edit: Schema.optional(Rule2),
+  glob: Schema.optional(Rule2),
+  grep: Schema.optional(Rule2),
+  list: Schema.optional(Rule2),
+  bash: Schema.optional(Rule2),
+  task: Schema.optional(Rule2),
+  external_directory: Schema.optional(Rule2),
+  question: Schema.optional(Action2),
+  webfetch: Schema.optional(Action2),
+  websearch: Schema.optional(Action2),
+  lsp: Schema.optional(Rule2),
+  doom_loop: Schema.optional(Action2),
+  skill: Schema.optional(Rule2)
+}), [Schema.Record(Schema.String, Rule2)]);
+var InputSchema = Schema.Union([Action2, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info14 = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action2, Object2, Rule2, Info14, exports_permission };

package/dist/chunks/{schema-0pc4kdn1.js → event-logger-1ct4r87x.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./schema-0zz82cjq.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  createProviderPlugin2
+} from "./event-logger-se0s1eqw.js";
 
 // src/plugin/provider/alibaba.ts
-var AlibabaPlugin = createProviderPlugin({
+var AlibabaPlugin2 = createProviderPlugin2({
   id: "opencode.provider.alibaba",
   package: "@ai-sdk/alibaba",
   load: async (options) => {
@@ -15,4 +12,4 @@ var AlibabaPlugin = createProviderPlugin({
   }
 });
 
-export { AlibabaPlugin };
+export { AlibabaPlugin2 };

package/dist/chunks/{schema-53jxjgr1.js → event-logger-1ezz2wmh.js}

@@ -1,14 +1,11 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  ID11
+} from "./event-logger-rwbhhn1p.js";
 
 // src/plugin/provider/snowflake-cortex.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-function cortexFetch(upstream = fetch) {
+function cortexFetch2(upstream = fetch) {
   return async (url, init) => {
     if (init?.body && typeof init.body === "string") {
       try {
@@ -51,11 +48,11 @@ function cortexFetch(upstream = fetch) {
     return response;
   };
 }
-var SnowflakeCortexPlugin = define({
+var SnowflakeCortexPlugin2 = define({
   id: "opencode.provider.snowflake.cortex",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== exports_provider.ID.make("snowflake-cortex"))
+      if (evt.model.providerID !== ID11.make("snowflake-cortex"))
         return;
       const token = process.env.SNOWFLAKE_CORTEX_TOKEN ?? process.env.SNOWFLAKE_CORTEX_PAT ?? (typeof evt.options.token === "string" ? evt.options.token : undefined) ?? (typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined);
       const upstream = typeof evt.options.fetch === "function" ? evt.options.fetch : undefined;
@@ -65,10 +62,10 @@ var SnowflakeCortexPlugin = define({
       evt.sdk = mod.createOpenAICompatible({
         ...evt.options,
         ...token ? { apiKey: token } : {},
-        fetch: cortexFetch(upstream)
+        fetch: cortexFetch2(upstream)
       });
     }));
   })
 });
 
-export { cortexFetch, SnowflakeCortexPlugin };
+export { cortexFetch2, SnowflakeCortexPlugin2 };

package/dist/chunks/event-logger-1kg9ymc8.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife2(fn) {
+  return fn();
+}
+
+export { iife2 };