@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/kv-qyewj5s0.js

@@ -0,0 +1,38 @@
+import {
+  latest2,
+  Service50
+} from "./kv-7m27rx9w.js";
+import {
+  Service48
+} from "./kv-3gng8nv9.js";
+import {
+  observe2
+} from "./kv-qsdy395h.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/config/plugin/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  ConfigSnapshotPlugin: () => exports_snapshot,
+  Plugin: () => Plugin20
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin20 = define({
+  id: "opencode.config.snapshot",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service50;
+    const snapshot = yield* Service48;
+    const loaded = yield* observe2(config, ctx.event, snapshot.reload());
+    yield* snapshot.transform((editor) => {
+      const configured = latest2(loaded.entries, "snapshots");
+      if (configured === undefined)
+        return;
+      editor.configure(configured);
+    });
+  })
+});
+
+export { Plugin20, exports_snapshot };

package/dist/chunks/{instance-52cmjgt6.js → kv-r3y5s33r.js}

@@ -1,65 +1,68 @@
 import {
-  exports_git as exports_git2
-} from "./instance-3mc1hhwa.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 import {
-  DirectoryUnavailableError,
-  canonical
-} from "./instance-gc513wew.js";
+  node76
+} from "./kv-fw8cvjkv.js";
 import {
-  Slug
-} from "./instance-df3v2q6j.js";
+  ID13
+} from "./kv-wb29ggtc.js";
 import {
-  exports_location
-} from "./instance-0xgrsc61.js";
+  Slug2
+} from "./kv-gebd4c9n.js";
 import {
-  WorktreeTable
-} from "./instance-gb1z7yet.js";
+  Service80,
+  node84
+} from "./kv-3rps85z5.js";
 import {
-  exports_schema
-} from "./instance-m7jtgrng.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  ProjectTable
-} from "./instance-c8ya26sa.js";
+  ProjectTable2
+} from "./kv-9qm9egsn.js";
 import {
-  exports_git
-} from "./instance-qz5gwjr7.js";
+  WorktreeTable2
+} from "./kv-ajtjthsy.js";
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  Service70,
+  node74
+} from "./kv-c7r09442.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  DirectoryUnavailableError2,
+  canonical2
+} from "./kv-93a8yfjt.js";
 import {
-  exports_database
-} from "./instance-5ez4e7fn.js";
+  make10
+} from "./kv-4zamrek1.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/worktree.ts
 var exports_worktree = {};
 __export(exports_worktree, {
-  CreateInput: () => CreateInput,
-  DestinationExistsError: () => DestinationExistsError,
-  DirectoryUnavailableError: () => DirectoryUnavailableError,
-  DuplicateStrategyError: () => DuplicateStrategyError,
-  Event: () => Event,
-  Info: () => Info,
-  InvalidDirectoryError: () => InvalidDirectoryError,
-  List: () => List,
-  ListEntry: () => ListEntry,
-  ListInput: () => ListInput,
-  RefreshInput: () => RefreshInput,
-  RefreshResult: () => RefreshResult,
-  RemoveInput: () => RemoveInput,
-  Service: () => Service,
-  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
-  StrategyID: () => StrategyID,
-  StrategyUnavailableError: () => StrategyUnavailableError,
+  CreateInput: () => CreateInput2,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  DuplicateStrategyError: () => DuplicateStrategyError2,
+  Event: () => Event3,
+  Info: () => Info2,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  ListInput: () => ListInput2,
+  RefreshInput: () => RefreshInput2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service14,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
   Worktree: () => exports_worktree,
-  node: () => node,
-  refreshAfterBoot: () => refreshAfterBoot,
-  refreshNode: () => refreshNode
+  node: () => node16,
+  refreshAfterBoot: () => refreshAfterBoot2,
+  refreshNode: () => refreshNode2
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
@@ -69,45 +72,45 @@ import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-n
 import { Worktree } from "@opencode-ai/schema/worktree";
 import { AppProcess } from "@opencode-ai/util/process";
 import { ChildProcess } from "effect/unstable/process";
-var StrategyID = Worktree.StrategyID;
-var CreateInput = Worktree.CreateInput;
-var RemoveInput = Worktree.RemoveInput;
-var RefreshInput = Schema.Struct({
-  projectID: exports_schema.ID
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput2 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshInput2 = Schema.Struct({
+  projectID: ID13
 }).annotate({ identifier: "Worktree.RefreshInput" });
-var RefreshResult = Schema.Struct({
-  updated: Schema.Array(AbsolutePath),
-  removed: Schema.Array(AbsolutePath)
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
 }).annotate({ identifier: "Worktree.RefreshResult" });
-var Info = Worktree.Info;
-var ListInput = Worktree.ListInput;
-var List = Worktree.List;
-var ListEntry = Schema.Struct({
-  directory: AbsolutePath,
+var Info2 = Worktree.Info;
+var ListInput2 = Worktree.ListInput;
+var List2 = Worktree.List;
+var ListEntry3 = Schema.Struct({
+  directory: AbsolutePath2,
   type: Schema.Literals(["root", "worktree"])
 }).annotate({ identifier: "Worktree.ListEntry" });
 
-class SourceDirectoryNotFoundError extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: exports_schema.ID, directory: Schema.optional(AbsolutePath) }) {
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID13, directory: Schema.optional(AbsolutePath2) }) {
 }
 
-class DestinationExistsError extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath }) {
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
 }
 
-class InvalidDirectoryError extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath }) {
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
 }
 
-class StrategyUnavailableError extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID }) {
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
 }
 
-class DuplicateStrategyError extends Schema.TaggedError()("Worktree.DuplicateStrategyError", { strategy: StrategyID }) {
+class DuplicateStrategyError2 extends Schema.TaggedError()("Worktree.DuplicateStrategyError", { strategy: StrategyID2 }) {
 }
-var Event = Worktree.Event;
+var Event3 = Worktree.Event;
 
-class Service extends Context.Service()("@opencode/v2/Worktree") {
+class Service14 extends Context.Service()("@opencode/v2/Worktree") {
 }
-var refreshAfterBoot = Effect.gen(function* () {
-  const location = yield* exports_location.Service;
-  const worktrees = yield* Service;
+var refreshAfterBoot2 = Effect.gen(function* () {
+  const location = yield* Service70;
+  const worktrees = yield* Service14;
   yield* Effect.gen(function* () {
     yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
     const result = yield* worktrees.refresh({ projectID: location.project.id });
@@ -118,69 +121,69 @@ var refreshAfterBoot = Effect.gen(function* () {
     });
   }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service14, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
+  const db = (yield* Service80).db;
+  const bus = yield* Service79;
   const processService = yield* AppProcess.Service;
   const changed = Effect.fnUntraced(function* (projectID, update) {
     if (update)
-      yield* bus.publish(Event.Updated, { projectID });
+      yield* bus.publish(Event3.Updated, { projectID });
   });
   const ops = {
     list: Effect.fn("Worktree.list")(function* (projectID) {
-      const rows = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(eq(WorktreeTable.project_id, projectID)).orderBy(desc(WorktreeTable.time_created), asc(WorktreeTable.directory)).all().pipe(Effect.orDie);
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
       return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
     }),
     find: Effect.fnUntraced(function* (projectID, directory) {
-      const row = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).get().pipe(Effect.orDie);
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
       return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
     }),
     primary: Effect.fnUntraced(function* (projectID) {
-      return yield* db.select({ directory: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, projectID)).get().pipe(Effect.orDie);
+      return yield* db.select({ directory: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
     }),
-    create: (input, tx) => (tx ?? db).insert(WorktreeTable).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
-      target: [WorktreeTable.project_id, WorktreeTable.directory],
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
       set: { strategy: input.strategy ?? null },
-      setWhere: input.strategy ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy)) : isNotNull(WorktreeTable.strategy)
-    }).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
-    remove: (projectID, directory, tx) => (tx ?? db).delete(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+      setWhere: input.strategy ? or(isNull(WorktreeTable2.strategy), ne(WorktreeTable2.strategy, input.strategy)) : isNotNull(WorktreeTable2.strategy)
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (projectID, directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
   };
   const registry = new Map;
   const register = Effect.fn("Worktree.register")(function* (strategy) {
     if (registry.has(strategy.id))
-      return yield* new DuplicateStrategyError({ strategy: strategy.id });
+      return yield* new DuplicateStrategyError2({ strategy: strategy.id });
     registry.set(strategy.id, strategy);
   });
-  const gitStrategy = yield* exports_git2.make;
+  const gitStrategy = yield* make10;
   yield* register(gitStrategy).pipe(Effect.orDie);
   const source = Effect.fnUntraced(function* (input, projectID) {
     const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
     if (!sourceDirectory)
-      return yield* new SourceDirectoryNotFoundError({ projectID });
-    const resolved = yield* canonical(fs, sourceDirectory);
+      return yield* new SourceDirectoryNotFoundError2({ projectID });
+    const resolved = yield* canonical2(fs, sourceDirectory);
     if ((yield* ops.find(projectID, resolved)) === undefined)
-      return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved });
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
     return resolved;
   });
   const getStrategy = Effect.fnUntraced(function* (id) {
     const found = registry.get(id);
     if (!found)
-      return yield* new StrategyUnavailableError({ strategy: id });
+      return yield* new StrategyUnavailableError2({ strategy: id });
     return found;
   });
   const create = Effect.fn("Worktree.create")(function* (input) {
     const selected = yield* getStrategy(input.strategy);
     const sourceDirectory = yield* source(input.from, input.projectID);
     yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
-    const name = input.name ?? Slug.create();
+    const name = input.name ?? Slug2.create();
     let suffix = 1;
-    let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name));
+    let worktreeDirectory = AbsolutePath2.make(path.join(input.directory, name));
     while (yield* fs.existsSafe(worktreeDirectory)) {
       suffix++;
       if (suffix > 10)
-        return yield* new DestinationExistsError({ directory: worktreeDirectory });
-      worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(input.directory, `${name}-${suffix}`));
     }
     const result = yield* selected.create({
       directory: worktreeDirectory,
@@ -192,7 +195,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       directory: result.directory,
       strategy: input.strategy
     }));
-    const project = yield* db.select({ commands: ProjectTable.commands }).from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get().pipe(Effect.orDie);
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, input.projectID)).get().pipe(Effect.orDie);
     const command = project?.commands?.start?.trim();
     if (command) {
       const windows = process.platform === "win32";
@@ -210,11 +213,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return result;
   });
   const remove = Effect.fn("Worktree.remove")(function* (input) {
-    const worktreeDirectory = yield* canonical(fs, input.directory);
+    const worktreeDirectory = yield* canonical2(fs, input.directory);
     const stored = yield* ops.find(input.projectID, worktreeDirectory);
     if (!stored?.strategy)
-      return yield* new InvalidDirectoryError({ directory: worktreeDirectory });
-    const strategy = yield* getStrategy(StrategyID.make(stored.strategy));
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy));
     yield* strategy.remove({
       directory: worktreeDirectory,
       force: input.force
@@ -241,7 +244,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
     return changes;
   });
-  return Service.of({
+  return Service14.of({
     register,
     list: ops.list,
     create,
@@ -249,15 +252,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     refresh
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node16 = makeGlobalNode({
+  service: Service14,
   layer,
-  deps: [FSUtil.node, exports_git.node, exports_bus.node, exports_database.node, AppProcess.node]
+  deps: [FSUtil.node, node76, node83, node84, AppProcess.node]
 });
-var refreshNode = makeLocationNode({
+var refreshNode2 = makeLocationNode({
   name: "worktree-refresh",
-  layer: Layer.effectDiscard(refreshAfterBoot),
-  deps: [node, exports_location.node]
+  layer: Layer.effectDiscard(refreshAfterBoot2),
+  deps: [node16, node74]
 });
 
-export { StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Info, ListInput, List, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, InvalidDirectoryError, StrategyUnavailableError, DuplicateStrategyError, Event, Service, refreshAfterBoot, node, refreshNode, exports_worktree };
+export { StrategyID2, CreateInput2, RemoveInput2, RefreshInput2, RefreshResult2, Info2, ListInput2, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, DuplicateStrategyError2, Event3, Service14, refreshAfterBoot2, node16, refreshNode2, exports_worktree };

package/dist/chunks/{instance-aseryw3y.js → kv-r5s1f9ds.js}

@@ -1,20 +1,20 @@
 import {
-  SessionEvent
-} from "./instance-a83yvq99.js";
+  SessionEvent2
+} from "./kv-mntxs535.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/session/runner/retry.ts
 var exports_retry = {};
 __export(exports_retry, {
   SessionRunnerRetry: () => exports_retry,
-  isRetryable: () => isRetryable,
-  make: () => make,
-  policy: () => policy
+  isRetryable: () => isRetryable2,
+  make: () => make6,
+  policy: () => policy2
 });
 import { Clock, Duration, Effect, Pull, Schedule } from "effect";
-function isRetryable(error) {
+function isRetryable2(error) {
   const override = error.reason.http?.headers["x-should-retry"];
   if (override === "true")
     return true;
@@ -54,7 +54,7 @@ var schedule = Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(
   const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum));
   return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))));
 }));
-var policy = (sessionID) => Effect.gen(function* () {
+var policy2 = (sessionID) => Effect.gen(function* () {
   const step = yield* Schedule.toStep(schedule);
   let attempt = 1;
   return (input) => Effect.gen(function* () {
@@ -80,11 +80,11 @@ var policy = (sessionID) => Effect.gen(function* () {
     return { retry: true, attempt, delay: normalized };
   });
 });
-var make = (bus, sessionID) => Effect.gen(function* () {
-  const decide = yield* policy(sessionID);
+var make6 = (bus, sessionID) => Effect.gen(function* () {
+  const decide = yield* policy2(sessionID);
   const wait = (input) => Effect.gen(function* () {
     const scheduled = yield* Clock.currentTimeMillis;
-    yield* bus.publish(SessionEvent.RetryScheduled, {
+    yield* bus.publish(SessionEvent2.RetryScheduled, {
       sessionID,
       assistantMessageID: input.assistantMessageID,
       attempt: input.decision.attempt,
@@ -97,4 +97,4 @@ var make = (bus, sessionID) => Effect.gen(function* () {
   return { decide, wait };
 });
 
-export { isRetryable, policy, make, exports_retry };
+export { isRetryable2, policy2, make6, exports_retry };

package/dist/chunks/{instance-zbqqnp0n.js → kv-r8dhm0tv.js}

@@ -1,6 +1,6 @@
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 
 // src/database/path.ts
 import nodePath from "path";
@@ -26,7 +26,7 @@ function toPlatform(input) {
     return input;
   return input.replaceAll("/", "\\");
 }
-var absoluteColumn = customType({
+var absoluteColumn2 = customType({
   dataType() {
     return "text";
   },
@@ -34,10 +34,10 @@ var absoluteColumn = customType({
     return absolute(input);
   },
   fromDriver(input) {
-    return AbsolutePath.make(toPlatform(absolute(input)));
+    return AbsolutePath2.make(toPlatform(absolute(input)));
   }
 });
-var directoryColumn = customType({
+var directoryColumn2 = customType({
   dataType() {
     return "text";
   },
@@ -48,7 +48,7 @@ var directoryColumn = customType({
     return input ? toPlatform(absolute(input)) : input;
   }
 });
-var pathColumn = customType({
+var pathColumn2 = customType({
   dataType() {
     return "text";
   },
@@ -60,7 +60,7 @@ var pathColumn = customType({
   }
 });
 var decodeAbsoluteArray = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(Schema.String)));
-var absoluteArrayColumn = customType({
+var absoluteArrayColumn2 = customType({
   dataType() {
     return "text";
   },
@@ -68,8 +68,8 @@ var absoluteArrayColumn = customType({
     return JSON.stringify(input.map(absolute));
   },
   fromDriver(input) {
-    return decodeAbsoluteArray(input).map((item) => AbsolutePath.make(toPlatform(absolute(item))));
+    return decodeAbsoluteArray(input).map((item) => AbsolutePath2.make(toPlatform(absolute(item))));
   }
 });
 
-export { absoluteColumn, directoryColumn, pathColumn, absoluteArrayColumn };
+export { absoluteColumn2, directoryColumn2, pathColumn2, absoluteArrayColumn2 };

package/dist/chunks/{instance-ntev5d3k.js → kv-rbss7vdr.js}

@@ -1,24 +1,24 @@
 import {
-  exports_mcp
-} from "./instance-etbnsc4s.js";
+  useragent2
+} from "./kv-y0bse006.js";
 import {
-  exports_app
-} from "./instance-hs51b0fc.js";
+  call2
+} from "./kv-6abnk40k.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/plugin/websearch/parallel.ts
 var exports_parallel = {};
 __export(exports_parallel, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin34,
   WebSearchParallel: () => exports_parallel,
-  endpoint: () => endpoint
+  endpoint: () => endpoint4
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { HttpClient } from "effect/unstable/http";
-var endpoint = "https://search.parallel.ai/mcp";
+var endpoint4 = "https://search.parallel.ai/mcp";
 var McpInput = Schema.Struct({
   objective: Schema.String,
   search_queries: Schema.Array(Schema.String),
@@ -47,7 +47,7 @@ var McpOutput = Schema.Struct({
   content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
   structuredContent: SearchResponse
 });
-var Plugin = define({
+var Plugin34 = define({
   id: "opencode.websearch.parallel",
   effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
@@ -69,11 +69,11 @@ var Plugin = define({
         execute: (input) => Effect.gen(function* () {
           const connection = yield* ctx.integration.connection.active("parallel");
           const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
-          const result = yield* exports_mcp.call(http, endpoint, "web_search", { input: McpInput, output: McpOutput }, {
+          const result = yield* call2(http, endpoint4, "web_search", { input: McpInput, output: McpOutput }, {
             objective: input.query,
             search_queries: [input.query]
           }, {
-            "User-Agent": exports_app.useragent(ctx.app),
+            "User-Agent": useragent2(ctx.app),
             ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
           });
           return result?.structuredContent.results.map((item) => {
@@ -93,4 +93,4 @@ var Plugin = define({
   })
 });
 
-export { endpoint, Plugin, exports_parallel };
+export { endpoint4, Plugin34, exports_parallel };