@opencode-ai/core 0.0.0-dev-19196 → 0.0.0-dev-19202

package/dist/chunks/{shell-2xs51w6t.js → model-resolver-mh7ehz1v.js}

@@ -1,32 +1,32 @@
 import {
   useragent2
-} from "./shell-hmeey3k9.js";
+} from "./model-resolver-qvpg2584.js";
 import {
   Service79
-} from "./shell-hjjb040h.js";
+} from "./model-resolver-hm42kar1.js";
 import {
   OAuth3,
   Event19
-} from "./shell-zsf5n11x.js";
+} from "./model-resolver-gsfshahz.js";
 import {
-  ID16,
+  ID9,
   MethodID2
-} from "./shell-xb5d6gcm.js";
+} from "./model-resolver-1nfczbs6.js";
 import {
-  ID15,
+  ID16,
   isAISDK2,
   packageName2,
   mergeOverlay2
-} from "./shell-hc4b3kyg.js";
+} from "./model-resolver-rvb2zp0m.js";
 import {
   iife2
-} from "./shell-1kg9ymc8.js";
+} from "./model-resolver-1kg9ymc8.js";
 import {
   which2
-} from "./shell-qaymkmh1.js";
+} from "./model-resolver-qaymkmh1.js";
 import {
   configuredSettings2
-} from "./shell-43q760fm.js";
+} from "./model-resolver-jjv4cws2.js";
 
 // src/plugin/provider/azure.ts
 import { Clock, Effect, Schema, Semaphore, Stream } from "effect";
@@ -57,7 +57,7 @@ function selectLanguage(sdk, modelID, useChat) {
 var AzurePlugin2 = define({
   id: "opencode.provider.azure",
   effect: Effect.fn(function* (ctx) {
-    const configured = yield* configuredSettings2(ID15.azure);
+    const configured = yield* configuredSettings2(ID16.azure);
     const processes = yield* AppProcess.Service;
     const bus = yield* Service79;
     const tokens = new Map;
@@ -93,13 +93,13 @@ var AzurePlugin2 = define({
     });
     yield* ctx.integration.transform((editor) => {
       editor.method.update({
-        integrationID: ID15.azure,
+        integrationID: ID16.azure,
         method: { type: "key", label: "API key", form: form() }
       });
       if (!available)
         return;
       editor.method.update({
-        integrationID: ID15.azure,
+        integrationID: ID16.azure,
         method: {
           id: methodID,
           type: "oauth",
@@ -131,7 +131,7 @@ var AzurePlugin2 = define({
       });
     });
     const load = Effect.fn("AzurePlugin.load")(function* () {
-      const connection = yield* ctx.integration.connection.active(ID15.azure);
+      const connection = yield* ctx.integration.connection.active(ID16.azure);
       const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
         return;
       })) : undefined;
@@ -145,7 +145,7 @@ var AzurePlugin2 = define({
     yield* load();
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        if (item.provider.id !== ID15.azure && packageName2(item.provider.package) !== "@ai-sdk/azure")
+        if (item.provider.id !== ID16.azure && packageName2(item.provider.package) !== "@ai-sdk/azure")
           continue;
         const resourceName = resolveResourceName(item.provider.settings, loaded.resource);
         if (resourceName)
@@ -167,11 +167,11 @@ var AzurePlugin2 = define({
       }
     });
     const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID16.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID9.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
     yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
-      if (evt.model.providerID !== ID15.azure)
+      if (evt.model.providerID !== ID16.azure)
         return;
-      const connection = yield* ctx.integration.connection.active(ID15.azure);
+      const connection = yield* ctx.integration.connection.active(ID16.azure);
       const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
         return;
       })) : undefined;
@@ -184,11 +184,11 @@ var AzurePlugin2 = define({
       evt.request.headers.delete("x-api-key");
       evt.request.headers.set("authorization", `Bearer ${current.access}`);
       evt.request.headers.set("user-agent", useragent2(ctx.app));
-    }), { providerID: ID15.azure });
+    }), { providerID: ID16.azure });
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
       if (evt.package !== "@ai-sdk/azure")
         return;
-      if (evt.model.providerID === ID15.azure) {
+      if (evt.model.providerID === ID16.azure) {
         if (!evt.options.resourceName && !evt.options.baseURL && (!isAISDK2(evt.model.package) || typeof evt.model.settings?.baseURL !== "string")) {
           throw new Error("Azure resource name is missing; set AZURE_RESOURCE_NAME or configure resourceName/baseURL");
         }
@@ -197,7 +197,7 @@ var AzurePlugin2 = define({
       evt.sdk = mod.createAzure(evt.options);
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID15.azure)
+      if (evt.model.providerID !== ID16.azure)
         return;
       evt.language = selectLanguage(evt.sdk, evt.model.modelID ?? evt.model.id, Boolean(evt.options.useCompletionUrls));
     }));

package/dist/chunks/model-resolver-mj9y1f9w.js

@@ -0,0 +1,193 @@
+import {
+  Service79,
+  node84
+} from "./model-resolver-hm42kar1.js";
+import {
+  Service76,
+  node81
+} from "./model-resolver-w7krw9hh.js";
+import {
+  create3
+} from "./model-resolver-kg06axw8.js";
+import {
+  __export
+} from "./model-resolver-9rqn6x4v.js";
+
+// src/websearch.ts
+var exports_websearch3 = {};
+__export(exports_websearch3, {
+  DisabledError: () => DisabledError2,
+  Event: () => Event5,
+  ID: () => ID3,
+  Input: () => Input13,
+  Provider: () => Provider2,
+  ProviderKey: () => ProviderKey2,
+  ProviderNotFoundError: () => ProviderNotFoundError2,
+  ProviderRequiredError: () => ProviderRequiredError2,
+  RequestError: () => RequestError2,
+  Response: () => Response2,
+  Result: () => Result2,
+  Selection: () => Selection2,
+  Service: () => Service20,
+  WebSearch: () => exports_websearch3,
+  node: () => node24
+});
+import { WebSearch } from "@opencode-ai/schema/websearch";
+import { SessionEvent } from "@opencode-ai/schema/session-event";
+import { Clock, Context, Effect, Layer, Option, Schema, Stream } from "effect";
+import { HttpClientError } from "effect/unstable/http";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Event as Event5 } from "@opencode-ai/schema/websearch";
+var ID3 = WebSearch.ID;
+var Provider2 = WebSearch.Provider;
+var Input13 = WebSearch.Input;
+var Result2 = WebSearch.Result;
+var Response2 = WebSearch.Response;
+var ProviderKey2 = "websearch:provider";
+var Selection2 = Schema.Union([ID3, Schema.Literal("random"), Schema.Literal(false)]);
+
+class ProviderRequiredError2 extends Schema.TaggedError()("WebSearch.ProviderRequired", {}) {
+}
+
+class ProviderNotFoundError2 extends Schema.TaggedError()("WebSearch.ProviderNotFound", {
+  providerID: ID3
+}) {
+}
+
+class DisabledError2 extends Schema.TaggedError()("WebSearch.Disabled", {}) {
+}
+
+class RequestError2 extends Schema.TaggedError()("WebSearch.Request", {
+  providerID: ID3,
+  cause: Schema.Defect()
+}) {
+}
+
+class Service20 extends Context.Service()("@opencode/WebSearch") {
+}
+var layer = Layer.effect(Service20, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const kv = yield* Service76;
+  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result2));
+  const cooldowns = new Map;
+  const preferred = new Map;
+  yield* Effect.addFinalizer(() => Effect.sync(() => preferred.clear()));
+  yield* bus.subscribe([SessionEvent.Deleted, SessionEvent.Moved]).pipe(Stream.runForEach((event) => Effect.sync(() => {
+    preferred.delete(event.data.sessionID);
+  })), Effect.forkScoped({ startImmediately: true }));
+  const state = create3({
+    initial: () => ({ providers: new Map }),
+    editor: (editor) => ({
+      add: (provider) => editor.providers.set(provider.id, provider),
+      default: {
+        get: () => editor.selection,
+        set: (selection) => editor.selection = selection
+      }
+    }),
+    notify: () => bus.publish(WebSearch.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const requireProvider = (providers, providerID) => {
+    const provider = providers.get(providerID);
+    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError2({ providerID }));
+  };
+  const selection = Effect.fn("WebSearch.selection")(function* () {
+    const data = state.get();
+    if (data.selection === false || data.selection === "random" || data.selection && data.providers.has(data.selection))
+      return data.selection;
+    const stored = yield* kv.get(ProviderKey2);
+    const decoded = Schema.decodeUnknownOption(Selection2)(stored);
+    if (stored !== undefined && Option.isNone(decoded))
+      yield* kv.remove(ProviderKey2);
+    return Option.getOrUndefined(decoded);
+  });
+  const randomProvider = (now, affinity, attempted) => {
+    const providers = state.get().providers;
+    cooldowns.forEach((cooldown, id) => {
+      if (cooldown.until <= now || !providers.has(id))
+        cooldowns.delete(id);
+    });
+    const current = affinity.provider === undefined ? undefined : providers.get(affinity.provider);
+    if (current && !cooldowns.has(current.id) && !attempted?.has(current.id))
+      return current;
+    const available = Array.from(providers.values()).filter((provider) => !cooldowns.has(provider.id) && !attempted?.has(provider.id));
+    const provider = available[Math.floor(Math.random() * available.length)];
+    if (provider)
+      affinity.provider = provider.id;
+    return provider;
+  };
+  const defaultProvider = Effect.fn("WebSearch.default")(function* (choice) {
+    if (choice === false)
+      return yield* new DisabledError2;
+    if (choice === "random") {
+      const active = preferred.get(undefined)?.provider;
+      return (active === undefined ? undefined : state.get().providers.get(active)) ?? state.get().providers.values().next().value;
+    }
+    return choice ? state.get().providers.get(choice) : undefined;
+  });
+  return Service20.of({
+    transform: state.transform,
+    reload: state.reload,
+    providers: Effect.fn("WebSearch.providers")(function* () {
+      return Array.from(state.get().providers.values(), (provider) => ({
+        id: provider.id,
+        name: provider.name
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+    }),
+    default: Effect.fn("WebSearch.defaultInfo")(function* () {
+      const provider = yield* defaultProvider(yield* selection());
+      return provider && { id: provider.id, name: provider.name };
+    }),
+    select: Effect.fn("WebSearch.select")(function* (selection) {
+      yield* kv.set(ProviderKey2, selection);
+    }),
+    query: Effect.fn("WebSearch.query")(function* (input, options) {
+      const choice = input.providerID ? undefined : yield* selection();
+      let provider = input.providerID ? yield* requireProvider(state.get().providers, input.providerID) : yield* defaultProvider(choice);
+      if (!provider)
+        return yield* new ProviderRequiredError2;
+      const affinity = preferred.get(options?.sessionID) ?? { provider: undefined };
+      if (choice === "random") {
+        preferred.set(options?.sessionID, affinity);
+        provider = randomProvider(yield* Clock.currentTimeMillis, affinity) ?? provider;
+      }
+      const attempted = new Set;
+      while (true) {
+        if (options?.onProvider)
+          yield* options.onProvider({ id: provider.id, name: provider.name });
+        let cooldown = choice === "random" ? cooldowns.get(provider.id) : undefined;
+        if (!cooldown || cooldown.until <= (yield* Clock.currentTimeMillis)) {
+          attempted.add(provider.id);
+          const result = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.result);
+          if (result._tag === "Success")
+            return new Response2({ providerID: provider.id, results: result.success });
+          const cause = result.failure;
+          const error = new RequestError2({ providerID: provider.id, cause });
+          if (choice !== "random" || !HttpClientError.isHttpClientError(cause) || cause.response?.status !== 429)
+            return yield* error;
+          const now = yield* Clock.currentTimeMillis;
+          cooldown = { until: now + cooldownMillis(cause.response.headers["retry-after"], now), error };
+          cooldowns.set(provider.id, cooldown);
+        }
+        provider = randomProvider(yield* Clock.currentTimeMillis, affinity, attempted);
+        if (!provider)
+          return yield* cooldown.error;
+      }
+    })
+  });
+}));
+function cooldownMillis(value, now) {
+  if (!value?.trim())
+    return 60000;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds))
+    return seconds >= 0 ? seconds * 1000 : 60000;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - now) : 60000;
+}
+var node24 = makeLocationNode({
+  service: Service20,
+  layer,
+  deps: [node84, node81]
+});
+
+export { ID3, Provider2, Input13, Result2, Response2, ProviderKey2, Selection2, ProviderRequiredError2, ProviderNotFoundError2, DisabledError2, RequestError2, Service20, node24, exports_websearch3, Event5 };

package/dist/chunks/{shell-aybqrser.js → model-resolver-mrca8mn9.js}

@@ -1,23 +1,23 @@
 import {
-  Service44,
+  Service43,
   node47
-} from "./shell-fcxhebz1.js";
+} from "./model-resolver-rz6a3sbe.js";
 import {
   Key3,
   removed2,
-  make18,
+  make20,
   diffByKey2
-} from "./shell-mtcjf44p.js";
+} from "./model-resolver-97f5v037.js";
 import {
   __export
-} from "./shell-9rqn6x4v.js";
+} from "./model-resolver-9rqn6x4v.js";
 
 // src/reference/instructions.ts
-var exports_instructions5 = {};
-__export(exports_instructions5, {
-  ReferenceInstructions: () => exports_instructions5,
-  Service: () => Service32,
-  node: () => node36
+var exports_instructions3 = {};
+__export(exports_instructions3, {
+  ReferenceInstructions: () => exports_instructions3,
+  Service: () => Service30,
+  node: () => node35
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -57,18 +57,18 @@ var update = (previous, current) => {
 `);
 };
 
-class Service32 extends Context.Service()("@opencode/ReferenceInstructions") {
+class Service30 extends Context.Service()("@opencode/ReferenceInstructions") {
 }
-var layer = Layer.effect(Service32, Effect.gen(function* () {
-  const references = yield* Service44;
-  return Service32.of({
+var layer = Layer.effect(Service30, Effect.gen(function* () {
+  const references = yield* Service43;
+  return Service30.of({
     load: Effect.fn("ReferenceInstructions.load")(function* () {
       const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
         name: reference.name,
         path: reference.path,
         description: reference.description
       })).toSorted((a, b) => a.name.localeCompare(b.name));
-      return make18({
+      return make20({
         key: Key3.make("core/reference-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
         read: Effect.succeed(available.length === 0 ? removed2 : available),
@@ -81,6 +81,6 @@ var layer = Layer.effect(Service32, Effect.gen(function* () {
     })
   });
 }));
-var node36 = makeLocationNode({ service: Service32, layer, deps: [node47] });
+var node35 = makeLocationNode({ service: Service30, layer, deps: [node47] });
 
-export { Service32, node36, exports_instructions5 };
+export { Service30, node35, exports_instructions3 };

package/dist/chunks/{shell-mvfsc1pv.js → model-resolver-mvfsc1pv.js}

@@ -1,6 +1,6 @@
 import {
   which2
-} from "./shell-qaymkmh1.js";
+} from "./model-resolver-qaymkmh1.js";
 
 // src/formatter/builtins.ts
 import { Effect } from "effect";

package/dist/chunks/{shell-myqn1vwn.js → model-resolver-n0qm516r.js}

@@ -1,13 +1,13 @@
 import {
-  ID14,
+  ID15,
   Family2
-} from "./shell-sxaj9jh7.js";
+} from "./model-resolver-3mrm2hwf.js";
 import {
-  Service63
-} from "./shell-2yk8myve.js";
+  Service67
+} from "./model-resolver-rfwpvx00.js";
 import {
   foldSettings2
-} from "./shell-43q760fm.js";
+} from "./model-resolver-jjv4cws2.js";
 
 // src/plugin/provider/lmstudio.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -36,7 +36,7 @@ function make6(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
     id: "opencode.provider.lmstudio",
     effect: Effect.fn(function* (ctx) {
       const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-      const config = yield* Service63;
+      const config = yield* Service67;
       const source = { current: configured(yield* config.entries(), origin) };
       const loaded = { models: [], hash: "[]" };
       yield* ctx.integration.transform((integrations) => {
@@ -63,7 +63,7 @@ function make6(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
         });
         for (const item of loaded.models) {
           catalog.model.update(providerID, item.key, (model) => {
-            model.modelID = ID14.make(item.key);
+            model.modelID = ID15.make(item.key);
             model.name = item.display_name || item.key;
             model.family = item.architecture ? Family2.make(item.architecture) : undefined;
             model.capabilities = {

package/dist/chunks/{shell-9sy3m4ps.js → model-resolver-n52wrphd.js}

@@ -1,44 +1,44 @@
 import {
-  Service40
-} from "./shell-2x7hewgh.js";
+  Service53
+} from "./model-resolver-pmt5dx08.js";
 import {
   MAX_MARKDOWN_BYTES2,
   convertHTMLToMarkdown2
-} from "./shell-a1tpkmh4.js";
+} from "./model-resolver-a1tpkmh4.js";
 import {
   collectBoundedResponseBody2
-} from "./shell-3v8g72cx.js";
+} from "./model-resolver-3v8g72cx.js";
 import {
   __export
-} from "./shell-9rqn6x4v.js";
+} from "./model-resolver-9rqn6x4v.js";
 
 // src/tool/plugin/webfetch.ts
 var exports_webfetch = {};
 __export(exports_webfetch, {
   DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS2,
-  Input: () => Input10,
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
+  Input: () => Input9,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES3,
   MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS2,
-  Plugin: () => Plugin28,
+  Plugin: () => Plugin40,
   WebFetchTool: () => exports_webfetch,
   convertHTMLToMarkdown: () => convertHTMLToMarkdown2,
   description: () => description5,
   extractTextFromHTML: () => extractTextFromHTML2,
-  name: () => name10
+  name: () => name9
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { Parser } from "htmlparser2";
-var name10 = "webfetch";
-var MAX_RESPONSE_BYTES2 = MAX_MARKDOWN_BYTES2;
+var name9 = "webfetch";
+var MAX_RESPONSE_BYTES3 = MAX_MARKDOWN_BYTES2;
 var DEFAULT_TIMEOUT_SECONDS2 = 30;
 var MAX_TIMEOUT_SECONDS2 = 120;
 var description5 = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
 
 Use a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.`;
 var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS2));
-var Input10 = Schema.Struct({
+var Input9 = Schema.Struct({
   url: Schema.String.annotate({ description: "The HTTP or HTTPS URL to fetch content from" }),
   format: Schema.Literals(["text", "markdown", "html"]).annotate({ description: "The format to return the content in. Defaults to markdown." }).pipe(Schema.withDecodingDefaultKey(Effect.succeed("markdown"))),
   timeout: Schema.optionalKey(Timeout).annotate({
@@ -48,7 +48,7 @@ var Input10 = Schema.Struct({
 var Output = Schema.Struct({
   url: Schema.String,
   contentType: Schema.String,
-  format: Input10.fields.format,
+  format: Input9.fields.format,
   output: Schema.String
 });
 var acceptHeader = (format) => {
@@ -79,7 +79,7 @@ var assertHttpUrl = (url) => {
     throw new Error("URL must use http:// or https://");
 };
 var execute = (http, url, format, userAgent = openCodeUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
-var collectBody = (response) => collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES2} byte limit)`));
+var collectBody = (response) => collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES3, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES3} byte limit)`));
 var mimeFrom = (contentType) => contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
 var isImageAttachment = (mime) => mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
 var isTextualMime = (mime) => !mime || mime.startsWith("text/") || mime === "application/json" || mime.endsWith("+json") || mime === "application/xml" || mime.endsWith("+xml") || mime === "application/javascript" || mime === "application/x-javascript";
@@ -92,16 +92,16 @@ var convert = (content, contentType, format) => {
     return extractTextFromHTML2(content);
   return content;
 };
-var Plugin28 = {
+var Plugin40 = {
   id: "opencode.tool.webfetch",
   effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
-    const permission = yield* Service40;
+    const permission = yield* Service53;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name10,
+      name: name9,
       options: { codemode: false },
       description: description5,
-      input: Input10,
+      input: Input9,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
         yield* Effect.try({
@@ -109,7 +109,7 @@ var Plugin28 = {
           catch: (error) => error
         });
         yield* permission.assert({
-          action: name10,
+          action: name9,
           resources: [input.url],
           save: ["*"],
           metadata: input,
@@ -167,4 +167,4 @@ function extractTextFromHTML2(html) {
   parser.end();
   return text.trim();
 }
-export { name10, MAX_RESPONSE_BYTES2, DEFAULT_TIMEOUT_SECONDS2, MAX_TIMEOUT_SECONDS2, description5, Input10, Plugin28, extractTextFromHTML2, exports_webfetch };
+export { name9, MAX_RESPONSE_BYTES3, DEFAULT_TIMEOUT_SECONDS2, MAX_TIMEOUT_SECONDS2, description5, Input9, Plugin40, extractTextFromHTML2, exports_webfetch };

package/dist/chunks/{shell-pxcwkz2f.js → model-resolver-n7z8rwmy.js}

@@ -1,27 +1,27 @@
 import {
-  ID15,
+  ID16,
   aisdk2,
   mergeOverlay2
-} from "./shell-hc4b3kyg.js";
+} from "./model-resolver-rvb2zp0m.js";
 import {
-  ID14,
+  ID15,
   VariantID2,
   Info28,
   compatibility2
-} from "./shell-sxaj9jh7.js";
+} from "./model-resolver-3mrm2hwf.js";
 import {
   __export
-} from "./shell-9rqn6x4v.js";
+} from "./model-resolver-9rqn6x4v.js";
 
 // src/modal/models.ts
-var exports_models2 = {};
-__export(exports_models2, {
-  ModalModels: () => exports_models2,
-  get: () => get3
+var exports_models = {};
+__export(exports_models, {
+  ModalModels: () => exports_models,
+  get: () => get2
 });
 import { Money } from "@opencode-ai/schema/money";
 import { Option, Schema } from "effect";
-var providerID = ID15.make("modal");
+var providerID = ID16.make("modal");
 var ReasoningOption = Schema.Struct({
   type: Schema.Literal("effort"),
   values: Schema.Array(Schema.NullOr(Schema.String))
@@ -53,7 +53,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 get3(baseURL, apiKey, existing) {
+async function get2(baseURL, apiKey, existing) {
   const response = await fetch(`${baseURL.replace(/\/+$/, "")}/models`, {
     headers: {
       Authorization: `Bearer ${apiKey}`
@@ -69,8 +69,8 @@ async function get3(baseURL, apiKey, existing) {
   const templates = new Map(existing.map((model) => [model.id, model]));
   const result = new Map;
   for (const item of remote) {
-    const template = templates.get(ID14.make(item.base_model_id ?? item.hugging_face_id ?? item.id));
-    const id = ID14.make(item.id);
+    const template = templates.get(ID15.make(item.base_model_id ?? item.hugging_face_id ?? item.id));
+    const id = ID15.make(item.id);
     result.set(id, build(id, item, baseURL, template));
   }
   return result;
@@ -91,7 +91,7 @@ function build(id, remote, baseURL, previous) {
   return Info28.make({
     ...Info28.default(providerID, id),
     id,
-    modelID: ID14.make(remote.id),
+    modelID: ID15.make(remote.id),
     providerID,
     name: remote.name ?? previous?.name ?? remote.id,
     family: previous?.family,
@@ -138,4 +138,4 @@ function variants(remote) {
   return [...seen.values()];
 }
 
-export { get3, exports_models2 };
+export { get2, exports_models };

package/dist/chunks/{shell-zhrc5y8g.js → model-resolver-n8qe30xq.js}

@@ -1,30 +1,30 @@
 import {
   makeUnsafe2
-} from "./shell-y71avatq.js";
+} from "./model-resolver-y71avatq.js";
 import {
   __export
-} from "./shell-9rqn6x4v.js";
+} from "./model-resolver-9rqn6x4v.js";
 
 // src/plugin/update.ts
 var exports_update = {};
 __export(exports_update, {
   PluginUpdate: () => exports_update,
-  Service: () => Service5,
-  node: () => node7
+  Service: () => Service3,
+  node: () => node5
 });
 import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
 import { Npm } from "@opencode-ai/util/npm";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 var interval = 24 * 60 * 60 * 1000;
 
-class Service5 extends Context.Service()("@opencode/PluginUpdate") {
+class Service3 extends Context.Service()("@opencode/PluginUpdate") {
 }
-var layer = Layer.effect(Service5, Effect.gen(function* () {
+var layer = Layer.effect(Service3, Effect.gen(function* () {
   const npm = yield* Npm.Service;
   const locks = makeUnsafe2();
   const status = new Map;
   const changes = yield* PubSub.unbounded();
-  return Service5.of({
+  return Service3.of({
     check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
       const checkedAt = yield* Clock.currentTimeMillis;
       const current = status.get(target);
@@ -49,6 +49,6 @@ var layer = Layer.effect(Service5, Effect.gen(function* () {
     changes: () => Stream.fromPubSub(changes)
   });
 }));
-var node7 = makeGlobalNode({ service: Service5, layer, deps: [Npm.node] });
+var node5 = makeGlobalNode({ service: Service3, layer, deps: [Npm.node] });
 
-export { Service5, node7, exports_update };
+export { Service3, node5, exports_update };