@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-b6gygkdw.js

@@ -0,0 +1,83 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./aisdk-native-2a5m3afh.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/environment/local.ts
+var exports_local = {};
+__export(exports_local, {
+  EnvironmentLocal: () => exports_local,
+  makeLocalDriver: () => makeLocalDriver2
+});
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Effect } from "effect";
+var makeLocalDriver2 = (spawner) => {
+  const overrides = {
+    read: (value, range) => Effect.gen(function* () {
+      const info = yield* stat(value, true);
+      if (info.type !== "file")
+        return yield* new WrongKind2({ path: value, actual: info.type });
+      if (range === undefined) {
+        const bytes = yield* attempt(value, () => fs.readFile(value), true);
+        return { info, bytes };
+      }
+      const bytes = yield* attempt(value, async () => {
+        const handle = await fs.open(value, "r");
+        try {
+          const buffer = new Uint8Array(range.length);
+          const result = await handle.read(buffer, 0, range.length, range.offset);
+          return buffer.subarray(0, result.bytesRead);
+        } finally {
+          await handle.close();
+        }
+      }, true);
+      return { info, bytes };
+    }),
+    stat: (value) => stat(value, false),
+    list: (value) => Effect.gen(function* () {
+      const info = yield* stat(value, true);
+      if (info.type !== "directory")
+        return yield* new WrongKind2({ path: value, actual: info.type });
+      const entries = yield* attempt(value, () => fs.readdir(value, { withFileTypes: true }), true);
+      return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }));
+    }),
+    write: (value, bytes) => attempt(value, async () => {
+      await fs.mkdir(path.dirname(value), { recursive: true });
+      await fs.writeFile(value, bytes);
+    }),
+    remove: (value) => attempt(value, () => fs.rm(value, { recursive: true, force: true })),
+    move: (from, to) => Effect.gen(function* () {
+      yield* stat(from, false);
+      const destination = yield* stat(to, false).pipe(Effect.map((info) => info.type === "directory" ? path.join(to, path.basename(from)) : to), Effect.catchIf((error) => error instanceof NotFound2, () => Effect.succeed(to)));
+      yield* attempt(from, () => fs.rename(from, destination));
+    }),
+    mkdir: (value) => attempt(value, () => fs.mkdir(value, { recursive: true }).then(() => {
+      return;
+    }))
+  };
+  return { spawner, overrides };
+};
+var stat = (value, follow) => attempt(value, () => follow ? fs.stat(value) : fs.lstat(value), true).pipe(Effect.map((stats) => ({ type: fileType(stats), size: stats.size, mtimeMs: stats.mtimeMs })));
+var fileType = (entry) => {
+  if (entry.isFile())
+    return "file";
+  if (entry.isDirectory())
+    return "directory";
+  if (entry.isSymbolicLink())
+    return "symlink";
+  return "other";
+};
+function attempt(value, run, missing = false) {
+  return Effect.tryPromise({
+    try: run,
+    catch: (cause) => missing && isMissing(cause) ? new NotFound2({ path: value }) : new Failed2({ path: value, cause })
+  });
+}
+var isMissing = (cause) => cause !== null && typeof cause === "object" && ("code" in cause) && (cause.code === "ENOENT" || cause.code === "ENOTDIR");
+
+export { makeLocalDriver2, exports_local };

package/dist/chunks/aisdk-native-bfexjxds.js

@@ -0,0 +1,104 @@
+import {
+  migrations2
+} from "./aisdk-native-b00gradr.js";
+import {
+  schema_gen_default
+} from "./aisdk-native-twg0f83k.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/database/migration.ts
+var exports_migration = {};
+__export(exports_migration, {
+  DatabaseMigration: () => exports_migration,
+  apply: () => apply3,
+  applyOnly: () => applyOnly2
+});
+import { sql } from "drizzle-orm";
+import { Effect } from "effect";
+import { supportsForeignKeyToggle } from "#sqlite";
+function apply3(db) {
+  return Effect.gen(function* () {
+    const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
+    if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
+      return yield* applyOnly2(db, migrations2);
+    if (tables.length > 0)
+      return yield* Effect.die(new Error("Database is not empty and has no session table"));
+    const started = Date.now();
+    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations2.length });
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* schema_gen_default.up(tx);
+      yield* tx.run(sql`CREATE TABLE ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+      yield* Effect.forEach(migrations2, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
+    }));
+    yield* Effect.logInfo("database schema bootstrap completed", {
+      migrations: migrations2.length,
+      durationMs: Date.now() - started
+    });
+  });
+}
+function applyOnly2(db, input) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+    let completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+    if (completed.size === 0) {
+      if (yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${"__drizzle_migrations"}`)) {
+        const named = (yield* db.all(sql`SELECT name FROM pragma_table_info('__drizzle_migrations')`)).some((column) => column.name === "name");
+        if (named) {
+          yield* db.run(sql`
+            INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
+            SELECT name, ${Date.now()}
+            FROM ${sql.identifier("__drizzle_migrations")}
+            WHERE name IS NOT NULL
+          `);
+        }
+        if (!named) {
+          const entries = yield* db.all(sql`
+            SELECT created_at, strftime('%Y%m%d%H%M%S', created_at / 1000, 'unixepoch') AS prefix
+            FROM ${sql.identifier("__drizzle_migrations")}
+            WHERE created_at IS NOT NULL
+          `);
+          for (const entry of entries) {
+            const migration = input.find((item) => item.id.startsWith(`${entry.prefix}_`));
+            if (!migration) {
+              return yield* Effect.die(new Error(`Legacy migration timestamp ${entry.created_at} does not match any known migration`));
+            }
+            yield* db.run(sql`
+              INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
+              VALUES (${migration.id}, ${Date.now()})
+            `);
+          }
+        }
+        completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+      }
+    }
+    for (const migration of input) {
+      if (completed.has(migration.id))
+        continue;
+      const started = Date.now();
+      yield* Effect.logInfo("database migration started", { migration: migration.id });
+      const apply = db.transaction((tx) => Effect.gen(function* () {
+        yield* migration.up(tx);
+        yield* tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`);
+      }));
+      const run = migration.foreignKeys !== false ? apply : Effect.gen(function* () {
+        const relaxForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = OFF`) : db.run(sql`PRAGMA defer_foreign_keys = ON`);
+        const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void;
+        yield* relaxForeignKeys;
+        yield* apply.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)));
+      });
+      yield* run.pipe(Effect.tapError((error) => Effect.logError("database migration failed", {
+        migration: migration.id,
+        durationMs: Date.now() - started,
+        error
+      })));
+      yield* Effect.logInfo("database migration completed", {
+        migration: migration.id,
+        durationMs: Date.now() - started
+      });
+    }
+  });
+}
+
+export { apply3, applyOnly2, exports_migration };

package/dist/chunks/aisdk-native-bkyjaxrp.js

@@ -0,0 +1,32 @@
+// src/database/migration/20260228203230_blue_harpoon.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260228203230_blue_harpoon",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`account\` (
+          \`id\` text PRIMARY KEY,
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`selected_org_id\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`account_state\` (
+          \`id\` integer PRIMARY KEY NOT NULL,
+          \`active_account_id\` text,
+          FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON UPDATE no action ON DELETE set null
+        );
+      `);
+    });
+  }
+};
+var _20260228203230_blue_harpoon_default = migration;
+
+export { _20260228203230_blue_harpoon_default };

package/dist/chunks/aisdk-native-bmr6ed5q.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260812181746_session_inbox.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260812181746_session_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`);
+    });
+  }
+};
+var _20260812181746_session_inbox_default = migration;
+
+export { _20260812181746_session_inbox_default };

package/dist/chunks/aisdk-native-bp3wckns.js

@@ -0,0 +1,84 @@
+import {
+  AgentNotFoundError2,
+  StepFailedError2,
+  UserInterruptedError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  BlockedError2
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  AuthorizationError2
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  ModelNotSelectedError2,
+  ModelUnavailableError2,
+  VariantUnavailableError2,
+  UnsupportedPackageError2,
+  ModelConfigurationError2,
+  ModelInitializationError2,
+  UnresolvedProviderVariablesError2,
+  UnsupportedCompactionError2
+} from "./aisdk-native-tmmjahvp.js";
+
+// src/session/to-session-error.ts
+import { AIError, ToolFailure } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+function toSessionError2(cause) {
+  if (cause instanceof AIError) {
+    switch (cause.reason._tag) {
+      case "RateLimit":
+        return providerError("provider.rate-limit", cause.reason);
+      case "Authentication":
+        return providerError("provider.auth", cause.reason);
+      case "QuotaExceeded":
+        return providerError("provider.quota", cause.reason);
+      case "ContentPolicy":
+        return providerError("provider.content-filter", cause.reason);
+      case "Transport":
+        return providerError("provider.transport", cause.reason);
+      case "ProviderInternal":
+        return providerError("provider.internal", cause.reason);
+      case "InvalidProviderOutput":
+        return providerError("provider.invalid-output", cause.reason);
+      case "InvalidRequest":
+        return providerError("provider.invalid-request", cause.reason);
+      case "UnsupportedOperation":
+        return providerError("provider.unsupported-operation", cause.reason);
+      case "NoRoute":
+        return providerError("provider.no-route", cause.reason);
+      case "UnknownProvider":
+        return providerError("provider.unknown", cause.reason);
+      default: {
+        const exhaustive = cause.reason;
+        return exhaustive;
+      }
+    }
+  }
+  if (cause instanceof BlockedError2)
+    return { type: "permission.rejected", message: cause.message };
+  if (cause instanceof ToolFailure || cause instanceof Tool.Error) {
+    if (cause.error === undefined)
+      return { type: "tool.execution", message: cause.message };
+    const unwrapped = toSessionError2(cause.error);
+    return unwrapped.message === "" ? { ...unwrapped, type: "tool.execution", message: cause.message } : unwrapped;
+  }
+  if (cause instanceof StepFailedError2)
+    return cause.error;
+  if (cause instanceof UnsupportedCompactionError2)
+    return { type: "provider.unsupported-operation", message: cause.message };
+  if (cause instanceof AgentNotFoundError2)
+    return { type: "unknown", message: cause.message };
+  if (cause instanceof UserInterruptedError2)
+    return { type: "aborted", message: cause.message };
+  if (cause instanceof ModelNotSelectedError2 || cause instanceof ModelUnavailableError2 || cause instanceof VariantUnavailableError2 || cause instanceof UnsupportedPackageError2 || cause instanceof ModelConfigurationError2 || cause instanceof ModelInitializationError2 || cause instanceof UnresolvedProviderVariablesError2)
+    return { type: "provider.no-route", message: cause.message };
+  if (cause instanceof AuthorizationError2)
+    return { type: "provider.auth", message: cause.message };
+  return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) };
+}
+function providerError(type, reason) {
+  const status = reason.http?.status;
+  return { type, message: reason.message, ...status === undefined ? {} : { status } };
+}
+
+export { toSessionError2 };

package/dist/chunks/aisdk-native-bqaq7pjn.js

@@ -0,0 +1,157 @@
+import {
+  typeFollowing2
+} from "./aisdk-native-2a5m3afh.js";
+import {
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service71
+} from "./aisdk-native-ms882c9x.js";
+import {
+  InvalidPatternError2,
+  Service70
+} from "./aisdk-native-dp3vq9x5.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GrepInput2,
+  Entry2,
+  Match2
+} from "./aisdk-native-twwx0ekz.js";
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service17
+} from "./aisdk-native-svw2bsx3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  GrepTool: () => exports_grep,
+  Input: () => Input7,
+  Output: () => Output6,
+  Plugin: () => Plugin39,
+  name: () => name7,
+  toModelContent: () => toModelContent4
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name7 = "grep";
+var Input7 = Schema.Struct({
+  pattern: GrepInput2.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
+    description: "Regular expression or literal text to match in file contents."
+  }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "File or directory to search. Defaults to the current working directory."
+  }),
+  include: GrepInput2.fields.include.annotate({
+    description: 'Glob pattern to filter files (for example, "*.js" or "*.{ts,tsx}")'
+  }),
+  literal: GrepInput2.fields.literal.annotate({
+    description: "Treat `pattern` as exact text instead of a regular expression (default: false)."
+  }),
+  caseSensitive: GrepInput2.fields.caseSensitive.annotate({
+    description: "Use case-sensitive matching (default: true)."
+  }),
+  limit: GrepInput2.fields.limit.annotate({
+    description: `Maximum number of matching lines to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output6 = Schema.Array(Match2);
+var toModelContent4 = (matches, truncated = false) => {
+  const lines = matches.length === 0 ? ["No matches found"] : [`Found ${matches.length} matches`];
+  let current = "";
+  for (const match of matches) {
+    if (current !== match.entry.path) {
+      if (current)
+        lines.push("");
+      current = match.entry.path;
+      lines.push(`${match.entry.path}:`);
+    }
+    lines.push(`  Line ${match.line}: ${match.text}`);
+  }
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${matches.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin39 = {
+  id: "opencode.tool.grep",
+  effect: Effect.fn("GrepTool.Plugin")(function* (ctx) {
+    const environment = yield* Service71;
+    const ripgrep = yield* Service70;
+    const location = yield* Service73;
+    const access = yield* Service17;
+    const permission = yield* Service59;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name7,
+      options: { codemode: false },
+      description: "Search file contents using ripgrep's regular expression syntax or literal text matching. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
+      input: Input7,
+      output: Output6,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: input.path ?? "." });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name7,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: ".",
+            path: input.path,
+            include: input.include,
+            literal: input.literal,
+            caseSensitive: input.caseSensitive,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const root = target.absolute;
+        const type = yield* typeFollowing2(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
+        const cwd = type === "directory" ? root : path.dirname(root);
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const matches = yield* ripgrep.grep({
+          cwd,
+          pattern: input.pattern,
+          file: type === "file" ? path.basename(root) : undefined,
+          include: input.include,
+          literal: input.literal,
+          caseSensitive: input.caseSensitive,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((match) => Match2.make({
+          ...match,
+          entry: Entry2.make({
+            ...match.entry,
+            path: RelativePath2.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
+          })
+        }))));
+        return { matches: matches.slice(0, limit), truncated: matches.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.matches,
+        content: toModelContent4(result.matches.map((match) => ({
+          ...match,
+          entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) }
+        })), result.truncated),
+        metadata: { matches: result.matches.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof InvalidPatternError2 ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name7, Input7, Output6, toModelContent4, Plugin39, exports_grep };

package/dist/chunks/aisdk-native-bqe1qhvg.js

@@ -0,0 +1,184 @@
+import {
+  Service68
+} from "./aisdk-native-qb9gpeer.js";
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  ID6,
+  Result2,
+  ProviderRequiredError2,
+  DisabledError2,
+  RequestError2,
+  Service56
+} from "./aisdk-native-76xfeaks.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/websearch.ts
+var exports_websearch2 = {};
+__export(exports_websearch2, {
+  Input: () => Input11,
+  NO_RESULTS: () => NO_RESULTS2,
+  Plugin: () => Plugin43,
+  WebSearchTool: () => exports_websearch2,
+  description: () => description5,
+  name: () => name11
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema, Semaphore } from "effect";
+import { HttpClientError } from "effect/unstable/http";
+var name11 = "websearch";
+var NO_RESULTS2 = "No search results found. Please try a different query.";
+var providerSelectionLock = Semaphore.makeUnsafe(1);
+var httpErrors = new Map([
+  [429, "Web search rate limited (HTTP 429)"],
+  [401, "Web search authentication failed (HTTP 401)"]
+]);
+var description5 = `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 Input11 = Schema.Struct({
+  query: Schema.String.annotate({ description: "Websearch query" })
+});
+var Output = Schema.Struct({
+  provider: ID6,
+  results: Schema.Array(Result2)
+});
+var Plugin43 = {
+  id: "opencode.tool.websearch",
+  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
+    const permission = yield* Service59;
+    const forms = yield* Service68;
+    const websearch = yield* Service56;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name11,
+      options: { codemode: false },
+      description: description5,
+      input: Input11,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* permission.assert({
+          action: name11,
+          resources: [input.query],
+          save: ["*"],
+          metadata: input,
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: { type: "tool", messageID: context.messageID, id: context.id }
+        });
+        const search = (providerID) => websearch.query({ ...input, providerID }, {
+          sessionID: context.sessionID,
+          onProvider: (provider) => context.progress({ provider: provider.id })
+        });
+        const result = yield* search().pipe(Effect.catchTag("WebSearch.ProviderRequired", () => {
+          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 ProviderRequiredError2;
+            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* websearch.select(false);
+              return yield* new DisabledError2;
+            }
+            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 (providerID === "random") {
+              yield* websearch.select("random");
+              return;
+            }
+            const provider = providers.find((provider) => provider.id === providerID);
+            if (!provider)
+              return yield* new ProviderRequiredError2;
+            yield* websearch.select(provider.id);
+            return provider.id;
+          })).pipe(Effect.timeoutOrElse({
+            duration: "1 minute",
+            orElse: () => Effect.fail(new Error("Web search cancelled"))
+          }), Effect.flatMap(search));
+        }));
+        const output = {
+          provider: result.providerID,
+          results: result.results
+        };
+        const content = output.results.length ? output.results.map((result) => {
+          const title = result.title ?? result.url;
+          const published = result.time.published ? `
+Published: ${new Date(result.time.published).toISOString()}` : "";
+          return `## [${title}](${result.url})${published}${result.content ? `
+
+${result.content}` : ""}`;
+        }).join(`
+
+`) : NO_RESULTS2;
+        return { output, content, metadata: { provider: output.provider } };
+      }).pipe(Effect.mapError((error) => {
+        const fallback = `Unable to search the web for ${input.query}`;
+        if (!Schema.is(RequestError2)(error))
+          return new ToolFailure({ message: fallback, error });
+        const status = HttpClientError.isHttpClientError(error.cause) ? error.cause.response?.status : undefined;
+        return new ToolFailure({
+          message: status === undefined ? fallback : httpErrors.get(status) ?? `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 = yield* websearch.default().pipe(Effect.as(false), Effect.catchTag("WebSearch.Disabled", () => Effect.succeed(true)));
+      if (disabled)
+        delete event.tools[name11];
+    }));
+  })
+};
+
+export { name11, NO_RESULTS2, description5, Input11, Plugin43, exports_websearch2 };