@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-42q4drvy.js

@@ -0,0 +1,331 @@
+import {
+  webSocketConstructor
+} from "./ripgrep-j1a5h53y.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/model-transport.ts
+var exports_model_transport = {};
+__export(exports_model_transport, {
+  node: () => node,
+  makeLayer: () => makeLayer,
+  layer: () => layer,
+  SessionModelTransport: () => exports_model_transport,
+  Service: () => Service
+});
+import {
+  WebSocketTransport
+} from "@opencode-ai/ai/route";
+import { AIError, TransportReason } from "@opencode-ai/ai";
+import { Hash } from "@opencode-ai/util/hash";
+import { Cause, Clock, Context, Effect, Fiber, Layer, Metric, Queue, Scope, Semaphore, Stream } from "effect";
+import { Socket } from "effect/unstable/socket";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var ROTATE_AFTER_MS = 55 * 60 * 1000;
+var INBOUND_CAPACITY = 128;
+var IDLE_TIMEOUT = "5 minutes";
+var events = Metric.counter("opencode_session_websocket_events_total", {
+  description: "Session WebSocket lifecycle events",
+  incremental: true
+});
+var metric = (event, attributes = {}) => Metric.update(events.pipe(Metric.withAttributes({ event, ...attributes })), 1);
+
+class Service extends Context.Service()("@opencode/SessionModelTransport") {
+}
+var transportError = (method, message, input) => new AIError({
+  module: "SessionModelTransport",
+  method,
+  reason: new TransportReason({ message, transport: "websocket", ...input })
+});
+var annotate = (error, input) => {
+  if (error.reason._tag !== "Transport")
+    return error;
+  return new AIError({
+    module: error.module,
+    method: error.method,
+    reason: new TransportReason({
+      message: error.reason.message,
+      transport: error.reason.transport,
+      operation: error.reason.operation,
+      code: error.reason.code,
+      url: error.reason.url,
+      http: error.reason.http,
+      recovery: error.reason.recovery,
+      ...input
+    })
+  });
+};
+var affinity = (exchange) => `${exchange.connect.url}:${Hash.sha256(JSON.stringify(Object.entries(exchange.connect.headers).sort(([a], [b]) => a.localeCompare(b))))}`;
+var observationFrame = (observation) => {
+  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
+    return Effect.succeed(observation.frame);
+  return Effect.fail(observation.error);
+};
+var observationTerminal = (observation) => observation.type !== "frame";
+var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
+  const scope = yield* Scope.Scope;
+  const states = new Map;
+  const state = (sessionID) => {
+    const current = states.get(sessionID);
+    if (current)
+      return current;
+    const created = { lock: Semaphore.makeUnsafe(1), closed: false };
+    states.set(sessionID, created);
+    return created;
+  };
+  const closeChannel = Effect.fn("SessionModelTransport.closeChannel")(function* (owner, channel) {
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    if (channel.reader)
+      yield* Fiber.interrupt(channel.reader);
+    yield* channel.connection.close;
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(transportError("close", "Session WebSocket closed", {
+        operation: "read",
+        code: "close",
+        phase: "close",
+        delivery: channel.active.lifecycle.delivery === "queued" || channel.active.lifecycle.delivery === "connecting" || channel.active.lifecycle.delivery === "ready" ? "not-sent" : channel.active.lifecycle.delivery === "provider-observed" || channel.active.lifecycle.delivery === "terminal" ? "accepted" : "ambiguous"
+      })));
+    yield* metric("close");
+  });
+  const poison = Effect.fn("SessionModelTransport.poison")(function* (owner, channel, error) {
+    channel.poisoned = true;
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error));
+    yield* metric(error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "queue_overflow" : "protocol_failure");
+    yield* channel.connection.close;
+  });
+  const open = Effect.fn("SessionModelTransport.open")(function* (owner, exchange, key) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const connection = yield* restore(connector.open(exchange.connect).pipe(Effect.withSpan("SessionModelTransport.connect")));
+      if (owner.closed) {
+        yield* connection.close;
+        return yield* transportError("open", "Session WebSocket owner closed while connecting", {
+          operation: "request",
+          code: "owner-closed",
+          phase: "connect",
+          delivery: "not-sent"
+        });
+      }
+      const channel = {
+        affinity: key,
+        connection,
+        openedAt: yield* Clock.currentTimeMillis,
+        closing: false,
+        poisoned: false
+      };
+      owner.channel = channel;
+      channel.reader = yield* connection.messages.pipe(Stream.runForEach((message) => Effect.gen(function* () {
+        const active = channel.active;
+        if (!active)
+          return yield* transportError("receive", "WebSocket data arrived without an active exchange", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "idle-data",
+            phase: "receive"
+          });
+        active.lifecycle.delivery = "provider-observed";
+        if (typeof message !== "string")
+          return yield* transportError("receive", "Unsupported binary WebSocket frame", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "message",
+            phase: "receive"
+          });
+        if (Queue.offerUnsafe(active.queue, message))
+          return;
+        return yield* transportError("receive", "Session WebSocket inbound queue overflow", {
+          url: exchange.connect.url,
+          operation: "read",
+          code: "queue-overflow",
+          phase: "receive",
+          delivery: "accepted"
+        });
+      })), Effect.catch((error) => channel.closing ? Effect.void : poison(owner, channel, annotate(error, {
+        phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
+        delivery: channel.active?.lifecycle.delivery === "provider-observed" || channel.active?.lifecycle.delivery === "terminal" || error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "accepted" : "ambiguous"
+      }))), Effect.forkIn(scope, { startImmediately: true }));
+      yield* Effect.logDebug("session websocket connected", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+      yield* metric("connect");
+      return channel;
+    }));
+  });
+  const fallback = (exchange) => ({
+    frames: exchange.fallback(),
+    complete: Effect.void
+  });
+  const start = Effect.fn("SessionModelTransport.start")(function* (owner, exchange, lifecycle) {
+    if (owner.closed)
+      return yield* transportError("start", "Session WebSocket owner is closed", {
+        operation: "request",
+        code: "owner-closed",
+        phase: "queue",
+        delivery: "not-sent"
+      });
+    const key = affinity(exchange);
+    const now = yield* Clock.currentTimeMillis;
+    const current = owner.channel;
+    const rotateAfterMs = exchange.connect.rotateAfterMs ?? ROTATE_AFTER_MS;
+    const rotation = current ? current.poisoned ? "poisoned" : current.affinity !== key ? "affinity" : now - current.openedAt >= rotateAfterMs ? "age" : undefined : undefined;
+    if (current && rotation) {
+      yield* Effect.logDebug("session websocket rotating", {
+        sessionTransport: "websocket",
+        phase: "connect",
+        reason: rotation
+      });
+      yield* metric("rotation", { reason: rotation });
+      yield* metric("reconnect");
+      yield* closeChannel(owner, current);
+    }
+    lifecycle.delivery = owner.channel ? "ready" : "connecting";
+    if (owner.channel)
+      yield* Effect.logDebug("session websocket reused", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+    if (owner.channel)
+      yield* metric("reuse");
+    const channel = owner.channel ? owner.channel : yield* open(owner, exchange, key).pipe(Effect.catch((error) => error.reason._tag === "Transport" && error.reason.code === "owner-closed" ? Effect.fail(error) : Effect.logWarning("session websocket connect failed; using http", {
+      sessionTransport: "websocket",
+      phase: "connect",
+      delivery: "not-sent",
+      code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag
+    }).pipe(Effect.andThen(metric("connect_failure")), Effect.andThen(metric("fallback")), Effect.andThen(Effect.succeed(undefined)))));
+    if (!channel)
+      return fallback(exchange);
+    lifecycle.delivery = "ready";
+    if (channel.pending) {
+      channel.pending = undefined;
+      channel.checkpoint = undefined;
+    }
+    const create = yield* exchange.driver.create(channel.checkpoint).pipe(Effect.tapError(() => closeChannel(owner, channel)), Effect.onInterrupt(() => closeChannel(owner, channel)));
+    if (create.mode === "full")
+      channel.checkpoint = undefined;
+    const active = { queue: yield* Queue.bounded(INBOUND_CAPACITY), lifecycle };
+    channel.active = active;
+    lifecycle.delivery = "send-attempted";
+    const sent = yield* channel.connection.sendText(create.message).pipe(Effect.withSpan("SessionModelTransport.send"), Effect.onInterrupt(() => closeChannel(owner, channel)), Effect.result);
+    if (sent._tag === "Failure") {
+      const failure = sent.failure;
+      const notSent = failure.reason._tag === "Transport" && failure.reason.delivery === "not-sent";
+      yield* closeChannel(owner, channel);
+      if (notSent) {
+        yield* metric("fallback");
+        return fallback(exchange);
+      }
+      yield* metric("ambiguous_delivery");
+      return yield* annotate(failure, { phase: "send", delivery: "ambiguous" });
+    }
+    yield* metric("send");
+    let terminal;
+    const token = {};
+    let staged;
+    const frames = Stream.fromQueue(active.queue).pipe(Stream.timeoutOrElse({
+      duration: IDLE_TIMEOUT,
+      orElse: () => Stream.fail(transportError("receive", "Timed out waiting for WebSocket data", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-timeout",
+        phase: "receive",
+        delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      }))
+    }), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.tap((observation) => Effect.sync(() => {
+      if (!observationTerminal(observation))
+        return;
+      terminal = observation;
+      lifecycle.delivery = "terminal";
+      staged = observation.type === "completed" ? observation.checkpoint : undefined;
+      if (staged)
+        channel.pending = { token, checkpoint: staged };
+      if (observation.type !== "completed" || !staged)
+        channel.checkpoint = undefined;
+    })), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame), Stream.ensuring(Effect.gen(function* () {
+      if (channel.active === active)
+        channel.active = undefined;
+      const pending = yield* Queue.size(active.queue);
+      yield* Queue.shutdown(active.queue);
+      if (terminal && pending === 0) {
+        yield* metric("terminal", { type: terminal.type });
+        if (terminal.type === "rejected")
+          yield* metric("rejection", { recovery: terminal.recovery });
+        if (terminal.type === "rejected" && terminal.recovery === "rotate-and-retry-full")
+          yield* closeChannel(owner, channel);
+        return;
+      }
+      yield* metric("cancellation");
+      channel.checkpoint = undefined;
+      channel.pending = undefined;
+      const error = terminal ? transportError("receive", "WebSocket data arrived after the terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-data",
+        phase: "receive",
+        delivery: "accepted"
+      }) : transportError("execute", "Session WebSocket exchange did not reach a terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "incomplete",
+        phase: "receive",
+        delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      });
+      yield* poison(owner, channel, error);
+    })));
+    const complete = Effect.sync(() => {
+      if (owner.channel !== channel || channel.pending?.token !== token)
+        return;
+      channel.checkpoint = channel.pending.checkpoint;
+      channel.pending = undefined;
+    });
+    return { frames, complete };
+  });
+  const bind = (sessionID) => ({
+    execute: (exchange) => {
+      const owner = state(sessionID);
+      const lifecycle = { delivery: "queued" };
+      let complete = Effect.void;
+      return Effect.succeed({
+        frames: Stream.unwrap(Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(Effect.andThen(start(owner, exchange, lifecycle)), Effect.tap((execution) => Effect.sync(() => {
+          complete = execution.complete;
+        })), Effect.map((execution) => execution.frames))),
+        complete: Effect.suspend(() => complete)
+      });
+    }
+  });
+  const close = Effect.fn("SessionModelTransport.close")(function* (sessionID) {
+    const owner = states.get(sessionID);
+    if (!owner)
+      return;
+    states.delete(sessionID);
+    owner.closed = true;
+    if (owner.channel)
+      yield* closeChannel(owner, owner.channel);
+  });
+  const closeAll = Effect.suspend(() => {
+    const owners = Array.from(states.values());
+    states.clear();
+    return Effect.forEach(owners, (owner) => {
+      owner.closed = true;
+      return owner.channel ? closeChannel(owner, owner.channel) : Effect.void;
+    }, { discard: true });
+  });
+  yield* Effect.addFinalizer(() => closeAll);
+  return Service.of({ bind, close, closeAll });
+}));
+var layer = Layer.unwrap(Effect.map(Socket.WebSocketConstructor, (constructor) => makeLayer({
+  open: (input) => WebSocketTransport.open(input).pipe(Effect.provideService(Socket.WebSocketConstructor, constructor))
+})));
+var node = makeLocationNode({ service: Service, layer, deps: [webSocketConstructor] });
+
+export { Service, makeLayer, layer, node, exports_model_transport };

package/dist/chunks/ripgrep-42z9db90.js

@@ -0,0 +1,91 @@
+import {
+  exports_markdown
+} from "./ripgrep-7wcmqxrc.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  Plugin: () => Plugin,
+  ConfigCommandPlugin: () => exports_command
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode-ai/schema/config/command";
+import path from "path";
+import { Effect, Option, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const fs = yield* FSUtil.Service;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), (entry) => {
+        if (entry.type === "document")
+          return Effect.succeed([{ commands: entry.info.commands }]);
+        if (entry.type !== "directory")
+          return Effect.succeed([]);
+        return loadDirectory(fs, entry.path).pipe(Effect.map((commands) => [
+          { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }
+        ]));
+      }).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
+    const sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))));
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"));
+    yield* Stream.merge(sourceChanges, configUpdates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((draft) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          draft.update(name, (item) => {
+            item.template = command.template;
+            if (command.description !== undefined)
+              item.description = command.description;
+            if (command.agent !== undefined)
+              item.agent = command.agent;
+            if (command.model !== undefined)
+              item.model = {
+                id: command.model.model,
+                providerID: command.model.providerID,
+                ...command.model.variant === undefined ? {} : { variant: command.model.variant }
+              };
+            if (command.subtask !== undefined)
+              item.subtask = command.subtask;
+          });
+        }
+      }
+    });
+  })
+});
+var sourceDirectories = ["command", "commands"];
+function isCommandSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function loadDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const files = yield* fs.scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.catch(() => Effect.succeed([])));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.catch(() => Effect.succeed(undefined)))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return;
+  const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
+  if (!info)
+    return;
+  return {
+    name: path.relative(directory, filepath).replaceAll("\\", "/").replace(/^(command|commands)\//, "").replace(/\.md$/, ""),
+    info
+  };
+}
+
+export { Plugin, exports_command };

package/dist/chunks/ripgrep-45cexccz.js

@@ -0,0 +1,32 @@
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  Plugin: () => Plugin,
+  ConfigWebSearchPlugin: () => exports_websearch
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.websearch",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.websearch.transform((websearch) => {
+      const selection = exports_config.latest(loaded.entries, "websearch");
+      if (selection === false)
+        websearch.default.set(false);
+      if (selection)
+        websearch.default.set(selection.provider);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.websearch.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_websearch };

package/dist/chunks/ripgrep-45h9dj6z.js

@@ -0,0 +1,206 @@
+import {
+  exports_websearch
+} from "./ripgrep-tsmrmbvn.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_form
+} from "./ripgrep-75tpgmct.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/websearch.ts
+var exports_websearch2 = {};
+__export(exports_websearch2, {
+  name: () => name,
+  description: () => description,
+  WebSearchTool: () => exports_websearch2,
+  Plugin: () => Plugin,
+  NO_RESULTS: () => NO_RESULTS,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema, Semaphore } from "effect";
+import { HttpClientError } from "effect/unstable/http";
+var name = "websearch";
+var NO_RESULTS = "No search results found. Please try a different query.";
+var providerSelectionLock = Semaphore.makeUnsafe(1);
+var description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+
+The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`;
+var Input = Schema.Struct({
+  query: Schema.String.annotate({ description: "Websearch query" })
+});
+var Output = Schema.Struct({
+  provider: exports_websearch.ID,
+  results: Schema.Array(exports_websearch.Result)
+});
+var Plugin = {
+  id: "opencode.tool.websearch",
+  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
+    const permission = yield* exports_permission.Service;
+    const forms = yield* exports_form.Service;
+    const config = yield* exports_config.Service;
+    const websearch = yield* exports_websearch.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* permission.assert({
+          action: name,
+          resources: [input.query],
+          save: ["*"],
+          metadata: input,
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: { type: "tool", messageID: context.messageID, id: context.id }
+        });
+        const search = () => websearch.default().pipe(Effect.flatMap((provider) => {
+          if (!provider)
+            return ctx.websearch.query(input);
+          return context.progress({ provider: provider.id }).pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID: provider.id })));
+        }), Effect.catch((error) => {
+          if (!Schema.is(exports_websearch.ProviderRequiredError)(error))
+            return Effect.fail(error);
+          return providerSelectionLock.withPermit(Effect.gen(function* () {
+            if (yield* websearch.default())
+              return;
+            const providers = (yield* ctx.websearch.providers()).data;
+            const defaultProvider = providers[0];
+            if (!defaultProvider)
+              return yield* new exports_websearch.ProviderRequiredError;
+            const response = yield* forms.ask({
+              sessionID: context.sessionID,
+              title: "Web Search",
+              metadata: { kind: "websearch.provider" },
+              fields: [
+                {
+                  key: "choice",
+                  description: "Allow OpenCode to search the web for up-to-date information?",
+                  type: "string",
+                  required: true,
+                  custom: false,
+                  options: [
+                    {
+                      value: "allow",
+                      label: `Allow search via ${providers.map((provider) => provider.name).join(", ")}`
+                    },
+                    {
+                      value: "choose",
+                      label: "Choose another provider"
+                    },
+                    { value: "disable", label: "Disable web search" }
+                  ]
+                }
+              ]
+            });
+            if (response.status === "cancelled")
+              return yield* Effect.fail(new Error("Web search cancelled"));
+            if (response.answer.choice === "disable") {
+              yield* config.update((draft2) => {
+                draft2.websearch = false;
+              });
+              return yield* new exports_websearch.DisabledError;
+            }
+            const selection = response.answer.choice === "choose" ? yield* forms.ask({
+              sessionID: context.sessionID,
+              title: "Choose a web search provider",
+              metadata: { kind: "websearch.provider" },
+              fields: [
+                {
+                  key: "provider",
+                  description: "Choose a provider for web search.",
+                  type: "string",
+                  required: true,
+                  custom: false,
+                  options: providers.map((provider) => ({
+                    value: provider.id,
+                    label: provider.name
+                  }))
+                }
+              ]
+            }) : undefined;
+            if (selection?.status === "cancelled")
+              return yield* Effect.fail(new Error("Web search cancelled"));
+            const providerID = selection?.answer.provider ?? "random";
+            if (typeof providerID !== "string" || providerID !== "random" && !providers.some((provider) => provider.id === providerID))
+              return yield* new exports_websearch.ProviderRequiredError;
+            yield* config.update((draft2) => {
+              draft2.websearch = {
+                provider: providerID === "random" ? "random" : exports_websearch.ID.make(providerID)
+              };
+            });
+            if (providerID !== "random")
+              return exports_websearch.ID.make(providerID);
+            return providers[Math.floor(Math.random() * providers.length)]?.id;
+          })).pipe(Effect.timeoutOrElse({
+            duration: "1 minute",
+            orElse: () => Effect.fail(new Error("Web search cancelled"))
+          }), Effect.flatMap((providerID) => {
+            if (!providerID)
+              return Effect.suspend(search);
+            return context.progress({ provider: providerID }).pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID })));
+          }));
+        }));
+        const result = yield* search();
+        const output = {
+          provider: result.data.providerID,
+          results: result.data.results
+        };
+        const content = output.results.length ? output.results.map((result2) => {
+          const title = result2.title ?? result2.url;
+          const published = result2.time.published ? `
+Published: ${new Date(result2.time.published).toISOString()}` : "";
+          return `## [${title}](${result2.url})${published}${result2.content ? `
+
+${result2.content}` : ""}`;
+        }).join(`
+
+`) : NO_RESULTS;
+        return { output, content, metadata: { provider: output.provider } };
+      }).pipe(Effect.mapError((error) => {
+        const fallback = `Unable to search the web for ${input.query}`;
+        if (!Schema.is(exports_websearch.RequestError)(error))
+          return new ToolFailure({ message: fallback, error });
+        const status = HttpClientError.isHttpClientError(error.cause) ? error.cause.response?.status : undefined;
+        switch (status) {
+          case 429:
+            return new ToolFailure({
+              message: "Web search rate limited (HTTP 429)",
+              error,
+              metadata: { provider: error.providerID }
+            });
+          case 401:
+            return new ToolFailure({
+              message: "Web search authentication failed (HTTP 401)",
+              error,
+              metadata: { provider: error.providerID }
+            });
+          case undefined:
+            return new ToolFailure({ message: fallback, error, metadata: { provider: error.providerID } });
+          default:
+            return new ToolFailure({
+              message: `Web search request failed (HTTP ${status})`,
+              error,
+              metadata: { provider: error.providerID }
+            });
+        }
+      }))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const disabled = exports_config.latest(yield* config.entries(), "websearch") === false;
+      if (disabled)
+        delete event.tools[name];
+    }));
+  })
+};
+
+export { name, NO_RESULTS, description, Input, Plugin, exports_websearch2 as exports_websearch };

package/dist/chunks/ripgrep-47ty4mvs.js

@@ -0,0 +1,18 @@
+// src/database/migration/20260511000411_data_migration_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260511000411_data_migration_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`data_migration\` (
+          \`name\` text PRIMARY KEY,
+          \`time_completed\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260511000411_data_migration_state_default = migration;
+
+export { _20260511000411_data_migration_state_default };