@opencode-ai/core 0.0.0-dev-17518 → 0.0.0-dev-17582

package/dist/chunks/{schema-vs1g5fxy.js → websearch-8wkhz4wr.js}

@@ -1,31 +1,31 @@
-import {
-  exports_environment1 as exports_environment
-} from "./schema-2svd8b6f.js";
-import {
-  exports_config
-} from "./schema-c2rbmamy.js";
-import {
-  exports_location
-} from "./schema-ky1ng9km.js";
 import {
   exports_integration
-} from "./schema-b1nzx03n.js";
+} from "./websearch-nkezjycm.js";
 import {
   exports_form
-} from "./schema-he17cn1k.js";
+} from "./websearch-pw7tkxp2.js";
 import {
   exports_credential
-} from "./schema-792kcx40.js";
+} from "./websearch-ma1d0wnv.js";
+import {
+  exports_state
+} from "./websearch-wt193r4g.js";
+import {
+  exports_environment1 as exports_environment
+} from "./websearch-7mfhcadw.js";
+import {
+  exports_location
+} from "./websearch-jjq7wvgp.js";
 import {
   exports_bus
-} from "./schema-5dxsv00z.js";
+} from "./websearch-ckqcetpa.js";
 import {
   exports_keyed_mutex
-} from "./schema-0kvmztkf.js";
+} from "./websearch-0kvmztkf.js";
 import {
   __export,
   __require
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/mcp/index.ts
 var exports_mcp = {};
@@ -58,10 +58,9 @@ __export(exports_mcp, {
 import { Mcp } from "@opencode-ai/schema/mcp";
 import { McpEvent } from "@opencode-ai/schema/mcp-event";
 import { Command } from "@opencode-ai/schema/command";
-import { Event } from "@opencode-ai/schema/config";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { Cause, Context, Deferred, Effect, Exit, FiberSet, Layer, Schema, Scope, Semaphore, Stream } from "effect";
+import { Cause, Context, Deferred, Effect, Exit, FiberSet, Layer, Schema, Scope, Stream } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { waitForAbort } from "@opencode-ai/util/process";
 var ServerName = Schema.String.pipe(Schema.brand("MCP.ServerName"));
@@ -136,7 +135,7 @@ var ResourceCatalog = Mcp.ResourceCatalog;
 var ResourceContentPart = Mcp.ResourceContentPart;
 var ResourceContent = Mcp.ResourceContent;
 
-class NotFoundError extends Schema.TaggedErrorClass()("MCP.NotFoundError", {
+class NotFoundError extends Schema.TaggedError()("MCP.NotFoundError", {
   server: ServerName
 }) {
   get message() {
@@ -144,7 +143,7 @@ class NotFoundError extends Schema.TaggedErrorClass()("MCP.NotFoundError", {
   }
 }
 
-class ToolCallError extends Schema.TaggedErrorClass()("MCP.ToolCallError", {
+class ToolCallError extends Schema.TaggedError()("MCP.ToolCallError", {
   server: ServerName,
   tool: Schema.String,
   message: Schema.String
@@ -152,6 +151,7 @@ class ToolCallError extends Schema.TaggedErrorClass()("MCP.ToolCallError", {
 }
 var GLOBAL_ELICITATION_SESSION_ID = "global";
 var URL_ELICITATION_FIELD_KEY = "elicitation";
+var cloneConfig = (config) => structuredClone(config);
 
 class Service extends Context.Service()("@opencode/MCP") {
 }
@@ -162,7 +162,6 @@ var Options = Schema.Struct({
   }))
 });
 var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const config = yield* exports_config.Service;
   const location = yield* exports_location.Service;
   const environment = yield* exports_environment.Service;
   const bus = yield* exports_bus.Service;
@@ -171,30 +170,9 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const credentials = yield* exports_credential.Service;
   const root = yield* Effect.scope;
   const fork = yield* FiberSet.makeRuntime();
-  const loadConfig = (entries) => {
-    const documents = entries.filter((entry) => entry.type === "document");
-    const timeout = Object.assign({}, ...documents.flatMap((entry) => entry.info.mcp?.timeout ? [entry.info.mcp.timeout] : []));
-    const servers = new Map;
-    for (const entry of documents) {
-      for (const [name, server] of Object.entries(entry.info.mcp?.servers ?? {})) {
-        servers.set(ServerName.make(name), { ...server, timeout: { ...timeout, ...server.timeout } });
-      }
-    }
-    return { timeout, servers };
-  };
-  const initial = loadConfig(yield* config.entries());
-  const configState = { servers: initial.servers, timeout: initial.timeout };
-  const runtime = new Map;
+  const entries = new Map;
   const locks = exports_keyed_mutex.makeUnsafe();
-  const reloadLock = Semaphore.makeUnsafe(1);
   const urlElicitations = new Map;
-  for (const [name, server] of initial.servers) {
-    runtime.set(name, {
-      config: server,
-      status: { status: "pending" },
-      startup: Deferred.makeUnsafe()
-    });
-  }
   const owned = new Set;
   const register = Effect.fnUntraced(function* (name, entry) {
     if (entry.config.type !== "remote" || entry.config.oauth === false)
@@ -221,10 +199,9 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       });
     }).pipe(Scope.provide(scope));
   });
-  yield* Effect.forEach(runtime, ([name, entry]) => register(name, entry), { discard: true });
   const requireServer = Effect.fnUntraced(function* (server) {
     const name = ServerName.make(server);
-    const entry = runtime.get(name);
+    const entry = entries.get(name);
     if (!entry)
       return yield* new NotFoundError({ server: name });
     return { name, entry };
@@ -293,8 +270,8 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
             message: input.params.message
           },
           fields: [{ key: URL_ELICITATION_FIELD_KEY, type: "external", url: input.params.url }]
-        }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.ensuring(Effect.sync(() => urlElicitations.delete(key))), Effect.map((state) => ({
-          action: state.status === "answered" ? "accept" : "cancel"
+        }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.ensuring(Effect.sync(() => urlElicitations.delete(key))), Effect.map((state2) => ({
+          action: state2.status === "answered" ? "accept" : "cancel"
         })));
       }
       const params = input.params;
@@ -306,12 +283,12 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
         title: `${input.server} is requesting input`,
         metadata: { kind: "mcp-elicitation", server: input.server, message: params.message },
         fields: [field, ...fields]
-      }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.map((state) => {
-        if (state.status !== "answered")
+      }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.map((state2) => {
+        if (state2.status !== "answered")
           return { action: "cancel" };
         return {
           action: "accept",
-          content: Object.fromEntries(Object.entries(state.answer).map(([key, value]) => typeof value === "object" ? [key, Array.from(value)] : [key, value]))
+          content: Object.fromEntries(Object.entries(state2.answer).map(([key, value]) => typeof value === "object" ? [key, Array.from(value)] : [key, value]))
         };
       }));
     }),
@@ -357,9 +334,9 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const refreshTools = (name, entry, connection) => connection.tools().pipe(Effect.map((defs) => {
     entry.tools = defs.map((def) => toTool(name, entry, def));
   }));
-  const refreshPrompts = (name, entry, connection) => connection.prompts().pipe(Effect.map((defs) => {
+  const refreshPrompts = (name, entry, connection) => connection.prompts().pipe(Effect.catch(() => Effect.succeed([])), Effect.map((defs) => {
     entry.prompts = defs.map((def) => toPrompt(name, def));
-  }), Effect.andThen(bus.publish(Command.Event.Updated, {})), Effect.catch(() => Effect.sync(() => entry.prompts = []).pipe(Effect.andThen(bus.publish(Command.Event.Updated, {})))));
+  }), Effect.andThen(bus.publish(Command.Event.Updated, {})));
   const whenLive = (name, entry, connection) => (effect) => fork(Effect.suspend(() => entry.client === connection ? effect : Effect.void).pipe(locks.withLock(name), Effect.ignore));
   const watch = (name, entry, connection) => {
     const live = whenLive(name, entry, connection);
@@ -439,7 +416,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       yield* entry.registration.dispose;
   });
   const replaceServer = Effect.fnUntraced(function* (name, serverConfig) {
-    const previous = runtime.get(name);
+    const previous = entries.get(name);
     if (previous)
       yield* disposeServer(name, previous);
     const entry = {
@@ -447,7 +424,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       status: { status: "pending" },
       startup: Deferred.makeUnsafe()
     };
-    runtime.set(name, entry);
+    entries.set(name, entry);
     yield* Effect.gen(function* () {
       yield* register(name, entry);
       if (serverConfig.disabled) {
@@ -459,47 +436,59 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }).pipe(Effect.ensuring(Effect.sync(() => Deferred.doneUnsafe(entry.startup, Exit.void))));
   });
   const removeServer = Effect.fnUntraced(function* (name) {
-    const entry = runtime.get(name);
+    const entry = entries.get(name);
     if (!entry)
       return;
     yield* disposeServer(name, entry);
-    runtime.delete(name);
+    entries.delete(name);
     yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore);
   });
-  const reloadConfig = Effect.fnUntraced(function* () {
-    yield* reloadLock.withPermit(Effect.gen(function* () {
-      const next = loadConfig(yield* config.entries());
-      const names = new Set([...configState.servers.keys(), ...next.servers.keys()]);
-      for (const name of names) {
-        const previous = configState.servers.get(name);
-        const updated = next.servers.get(name);
-        if (isDeepStrictEqual(previous, updated))
-          continue;
-        if (!updated) {
-          yield* removeServer(name).pipe(locks.withLock(name));
+  let applied;
+  const overrides = new Map;
+  const reconcile = Effect.fnUntraced(function* (next) {
+    const servers = new Map(next.list());
+    if (!applied && entries.size === 0) {
+      for (const [name, server] of servers) {
+        entries.set(name, {
+          config: server,
+          status: { status: "pending" },
+          startup: Deferred.makeUnsafe()
+        });
+      }
+      yield* Effect.forEach(entries, ([name, entry]) => register(name, entry), { discard: true });
+      applied = servers;
+      for (const [name, entry] of entries) {
+        if (entry.config.disabled) {
+          entry.status = { status: "disabled" };
+          Deferred.doneUnsafe(entry.startup, Exit.void);
+          yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore);
           continue;
         }
-        yield* replaceServer(name, updated).pipe(locks.withLock(name));
+        fork(startServer(name, entry).pipe(locks.withLock(name)));
       }
-      configState.servers = next.servers;
-      configState.timeout = next.timeout;
-    }));
-  });
-  for (const [name, entry] of runtime) {
-    if (entry.config.disabled) {
-      entry.status = { status: "disabled" };
-      Deferred.doneUnsafe(entry.startup, Exit.void);
-      continue;
+      return;
     }
-    fork(startServer(name, entry).pipe(locks.withLock(name)));
-  }
+    const names = new Set([...applied?.keys() ?? [], ...servers.keys()]);
+    for (const name of names) {
+      const previous = applied?.get(name);
+      const updated = servers.get(name);
+      if (isDeepStrictEqual(previous, updated))
+        continue;
+      if (!updated) {
+        yield* removeServer(name).pipe(locks.withLock(name));
+        continue;
+      }
+      yield* replaceServer(name, updated).pipe(locks.withLock(name));
+    }
+    applied = servers;
+  });
   const reconnect = (integrationID) => Effect.gen(function* () {
-    const match = Array.from(runtime).find(([, entry]) => entry.integrationID === integrationID);
+    const match = Array.from(entries).find(([, entry]) => entry.integrationID === integrationID);
     if (!match)
       return;
     const name = match[0];
     yield* Effect.gen(function* () {
-      const entry = runtime.get(name);
+      const entry = entries.get(name);
       if (!entry || entry.integrationID !== integrationID)
         return;
       if (entry.status.status === "disabled")
@@ -509,19 +498,45 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }).pipe(locks.withLock(name));
   });
   fork(bus.subscribe(exports_integration.Event.ConnectionUpdated).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID)))), Effect.ignore));
-  yield* bus.subscribe(Event.Updated).pipe(Stream.runForEach(() => reloadConfig().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.forkScoped({ startImmediately: true }));
-  yield* reloadConfig();
-  const whenAllReady = Effect.suspend(() => Effect.forEach(Array.from(runtime.values()), (entry) => Deferred.await(entry.startup), {
+  const state = exports_state.create({
+    name: "mcp",
+    initial: () => ({
+      servers: new Map(Array.from(overrides).flatMap(([name, config]) => config === false ? [] : [[name, cloneConfig(config)]])),
+      removed: new Set(Array.from(overrides).flatMap(([name, config]) => config === false ? [name] : []))
+    }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.servers),
+      get: (server) => draft.servers.get(ServerName.make(server)),
+      set: (server, serverConfig) => {
+        const name = ServerName.make(server);
+        if (draft.removed.has(name))
+          return;
+        draft.servers.set(name, cloneConfig(serverConfig));
+      },
+      update: (server, update) => {
+        const current = draft.servers.get(ServerName.make(server));
+        if (!current)
+          return;
+        update(current);
+      },
+      remove: (server) => draft.servers.delete(ServerName.make(server))
+    }),
+    finalize: reconcile
+  });
+  const whenAllReady = Effect.suspend(() => Effect.forEach(Array.from(entries.values()), (entry) => Deferred.await(entry.startup), {
     concurrency: "unbounded",
     discard: true
   }));
   return Service.of({
+    transform: state.transform,
+    reload: state.reload,
     servers: Effect.fn("MCP.servers")(function* () {
-      return Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, entry]) => new ServerInfo({ name, status: entry.status, integrationID: entry.integrationID }));
+      return Array.from(entries).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, entry]) => new ServerInfo({ name, status: entry.status, integrationID: entry.integrationID }));
     }),
-    add: Effect.fn("MCP.add")(function* (server, config2) {
+    add: Effect.fn("MCP.add")(function* (server, config) {
       const name = ServerName.make(server);
-      yield* replaceServer(name, { ...config2, timeout: { ...configState.timeout, ...config2.timeout } }).pipe(locks.withLock(name));
+      overrides.set(name, config);
+      yield* state.reload();
     }),
     connect: Effect.fn("MCP.connect")(function* (server) {
       const name = ServerName.make(server);
@@ -542,14 +557,13 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }),
     remove: Effect.fn("MCP.remove")(function* (server) {
       const name = ServerName.make(server);
-      yield* Effect.gen(function* () {
-        yield* requireServer(name);
-        yield* removeServer(name);
-      }).pipe(locks.withLock(name));
+      yield* requireServer(name);
+      overrides.set(name, false);
+      yield* state.reload();
     }),
     tools: Effect.fn("MCP.tools")(function* () {
       yield* whenAllReady;
-      return Array.from(runtime.values()).flatMap((entry) => entry.tools ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+      return Array.from(entries.values()).flatMap((entry) => entry.tools ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
     }),
     callTool: Effect.fn("MCP.callTool")(function* (input) {
       const target = yield* requireServer(input.server);
@@ -571,7 +585,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }),
     instructions: Effect.fn("MCP.instructions")(function* () {
       yield* whenAllReady;
-      return Array.from(runtime).flatMap(([server, entry]) => {
+      return Array.from(entries).flatMap(([server, entry]) => {
         const instructions = entry.client?.instructions;
         if (!instructions)
           return [];
@@ -579,7 +593,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }).toSorted((a, b) => a.server.localeCompare(b.server));
     }),
     prompts: Effect.fn("MCP.prompts")(function* () {
-      return Array.from(runtime.values()).flatMap((entry) => entry.prompts ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+      return Array.from(entries.values()).flatMap((entry) => entry.prompts ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
     }),
     prompt: Effect.fn("MCP.prompt")(function* (input) {
       const target = yield* requireServer(input.server);
@@ -597,7 +611,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }),
     resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
       yield* whenAllReady;
-      const catalogs = yield* Effect.forEach(Array.from(runtime), ([name, entry]) => {
+      const catalogs = yield* Effect.forEach(Array.from(entries), ([name, entry]) => {
         if (!entry.client)
           return Effect.succeed({ resources: [], templates: [] });
         return Effect.all({
@@ -633,7 +647,7 @@ function configured(options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [exports_config.node, exports_location.node, exports_environment.node, exports_bus.node, exports_form.node, exports_integration.node, exports_credential.node]
+    deps: [exports_location.node, exports_environment.node, exports_bus.node, exports_form.node, exports_integration.node, exports_credential.node]
   });
 }
 var node = configured();

package/dist/chunks/{schema-mpgzn6t2.js → websearch-8xyvdy78.js}

@@ -1,18 +1,18 @@
-import {
-  imageGenerationArgsSchema
-} from "./schema-4b2tz2m9.js";
 import {
   webSearchArgsSchema
-} from "./schema-gy500k2r.js";
+} from "./websearch-gy500k2r.js";
 import {
   fileSearchArgsSchema
-} from "./schema-wj4sxzqa.js";
-import {
-  codeInterpreterArgsSchema
-} from "./schema-5a5ch9ts.js";
+} from "./websearch-wj4sxzqa.js";
 import {
   webSearchPreviewArgsSchema
-} from "./schema-7n9qwqk4.js";
+} from "./websearch-7n9qwqk4.js";
+import {
+  imageGenerationArgsSchema
+} from "./websearch-4b2tz2m9.js";
+import {
+  codeInterpreterArgsSchema
+} from "./websearch-5a5ch9ts.js";
 
 // src/github-copilot/responses/openai-responses-prepare-tools.ts
 import { UnsupportedFunctionalityError } from "@ai-sdk/provider";

package/dist/chunks/{schema-8ywqk2j9.js → websearch-8ywqk2j9.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/session/usage.ts
 var exports_usage = {};

package/dist/chunks/{schema-93qdgxxd.js → websearch-93qdgxxd.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/session/model-http.ts
 var exports_model_http = {};

package/dist/chunks/{schema-bw5csxcq.js → websearch-98jrhaw3.js}

@@ -1,18 +1,18 @@
 import {
   iife
-} from "./schema-ehj9csmv.js";
+} from "./websearch-ehj9csmv.js";
 import {
   configuredSettings
-} from "./schema-htc6ksnp.js";
+} from "./websearch-sfg3m1gf.js";
 import {
   exports_app
-} from "./schema-50jxp3hw.js";
+} from "./websearch-50jxp3hw.js";
 import {
   exports_provider
-} from "./schema-d6vvk673.js";
+} from "./websearch-8twz6z1z.js";
 import {
   __require
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/plugin/provider/cloudflare-workers-ai.ts
 import os from "os";

package/dist/chunks/{schema-999qd968.js → websearch-999qd968.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/v1/config/lsp.ts
 var exports_lsp = {};

package/dist/chunks/{schema-9d2xhdr4.js → websearch-9d2xhdr4.js}

@@ -1,13 +1,13 @@
 import {
   ProjectTable
-} from "./schema-88jbfw8z.js";
+} from "./websearch-88jbfw8z.js";
 import {
   directoryColumn,
   pathColumn
-} from "./schema-zbqqnp0n.js";
+} from "./websearch-zbqqnp0n.js";
 import {
   Timestamps
-} from "./schema-sem2g21k.js";
+} from "./websearch-sem2g21k.js";
 
 // src/session/sql.ts
 import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core";

package/dist/chunks/{schema-9f0rnpkn.js → websearch-9f0rnpkn.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/v1/config/plugin.ts
 var exports_plugin = {};

package/dist/chunks/{schema-zgbtcdvt.js → websearch-a16fka1m.js}

@@ -1,48 +1,48 @@
 import {
   MAX_STEPS_PROMPT
-} from "./schema-qaarhjrp.js";
+} from "./websearch-qaarhjrp.js";
 import {
   exports_prompt_cache_diagnostics
-} from "./schema-wd268jeg.js";
+} from "./websearch-wd268jeg.js";
 import {
   toLLMMessages
-} from "./schema-6jtjggv5.js";
+} from "./websearch-dgjzraq6.js";
 import {
   exports_system_prompt
-} from "./schema-v80zsxnb.js";
+} from "./websearch-v80zsxnb.js";
 import {
   exports_prompt_cache_key
-} from "./schema-52jzav25.js";
+} from "./websearch-52jzav25.js";
 import {
   exports_model_headers
-} from "./schema-1xksxgzs.js";
+} from "./websearch-1xksxgzs.js";
 import {
   exports_model_http
-} from "./schema-93qdgxxd.js";
+} from "./websearch-93qdgxxd.js";
 import {
   exports_question
-} from "./schema-fxamgera.js";
+} from "./websearch-vyeprebe.js";
 import {
   exports_tool
-} from "./schema-zb9fdh7e.js";
+} from "./websearch-hvqcyvjd.js";
 import {
   exports_model_transport
-} from "./schema-42q4drvy.js";
-import {
-  exports_app
-} from "./schema-50jxp3hw.js";
+} from "./websearch-42q4drvy.js";
 import {
   exports_hooks
-} from "./schema-0dwyqmzq.js";
+} from "./websearch-0dwyqmzq.js";
+import {
+  exports_app
+} from "./websearch-50jxp3hw.js";
 import {
   exports_permission
-} from "./schema-fks0wyp0.js";
+} from "./websearch-2q9bjvm8.js";
 import {
   exports_provider
-} from "./schema-d6vvk673.js";
+} from "./websearch-8twz6z1z.js";
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/session/model-request.ts
 var exports_model_request = {};

package/dist/chunks/{schema-a65h300v.js → websearch-a65h300v.js}

@@ -1,9 +1,9 @@
 import {
   AbsolutePath
-} from "./schema-j07kk359.js";
+} from "./websearch-j07kk359.js";
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/skill/discovery.ts
 var exports_discovery = {};

package/dist/chunks/{schema-prxczz0j.js → websearch-acwmv3j7.js}

@@ -1,12 +1,12 @@
-import {
-  upgradeIfNeeded
-} from "./schema-8bkmtpp6.js";
 import {
   SQLiteEffectDatabase
-} from "./schema-5zyvcvaz.js";
+} from "./websearch-fh0tj73a.js";
+import {
+  upgradeIfNeeded
+} from "./websearch-8bkmtpp6.js";
 import {
   mapResultRow
-} from "./schema-ma07p6tt.js";
+} from "./websearch-ma07p6tt.js";
 
 // src/database/drizzle/sqlite-core/effect/session.ts
 import * as Cause from "effect/Cause";

package/dist/chunks/{schema-e7swh6s2.js → websearch-afqwkys2.js}

@@ -1,15 +1,15 @@
 import {
   iife
-} from "./schema-ehj9csmv.js";
+} from "./websearch-ehj9csmv.js";
 import {
   configuredSettings
-} from "./schema-htc6ksnp.js";
+} from "./websearch-sfg3m1gf.js";
 import {
   exports_provider
-} from "./schema-d6vvk673.js";
+} from "./websearch-8twz6z1z.js";
 import {
   __require
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/plugin/provider/azure.ts
 import { Effect } from "effect";

package/dist/chunks/{schema-7g8rq8ax.js → websearch-ah6m5ygb.js}

@@ -1,27 +1,27 @@
 import {
   exports_location_mutation
-} from "./schema-j9m695kz.js";
+} from "./websearch-nq5yc02p.js";
 import {
   exports_permission
-} from "./schema-fks0wyp0.js";
+} from "./websearch-2q9bjvm8.js";
 import {
   exports_filesystem
-} from "./schema-c06ekbye.js";
+} from "./websearch-n9pgr18k.js";
 import {
   exports_ripgrep
-} from "./schema-je19dw6d.js";
+} from "./websearch-pgf5qdh8.js";
 import {
   exports_environment1 as exports_environment
-} from "./schema-2svd8b6f.js";
+} from "./websearch-7mfhcadw.js";
 import {
   exports_location
-} from "./schema-ky1ng9km.js";
+} from "./websearch-jjq7wvgp.js";
 import {
   RelativePath
-} from "./schema-j07kk359.js";
+} from "./websearch-j07kk359.js";
 import {
   __export
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/tool/plugin/glob.ts
 var exports_glob = {};

package/dist/chunks/{schema-ayfwnm78.js → websearch-ayfwnm78.js}

@@ -1,9 +1,9 @@
 import {
   createProviderPlugin
-} from "./schema-0zz82cjq.js";
+} from "./websearch-0zz82cjq.js";
 import {
   __require
-} from "./schema-rvfvac9x.js";
+} from "./websearch-rvfvac9x.js";
 
 // src/plugin/provider/groq.ts
 var GroqPlugin = createProviderPlugin({