@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-v5yv7hbv.js

@@ -0,0 +1,184 @@
+import {
+  Service65
+} from "./worktree-rjbw5qw4.js";
+import {
+  Service70
+} from "./worktree-k56d8zdx.js";
+import {
+  ID4,
+  Result2,
+  ProviderRequiredError2,
+  DisabledError2,
+  RequestError2,
+  Service30
+} from "./worktree-2qnjyx3m.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  Input: () => Input2,
+  NO_RESULTS: () => NO_RESULTS2,
+  Plugin: () => Plugin2,
+  WebSearchTool: () => exports_websearch,
+  description: () => description2,
+  name: () => name2
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema, Semaphore } from "effect";
+import { HttpClientError } from "effect/unstable/http";
+var name2 = "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 description2 = `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 Input2 = Schema.Struct({
+  query: Schema.String.annotate({ description: "Websearch query" })
+});
+var Output = Schema.Struct({
+  provider: ID4,
+  results: Schema.Array(Result2)
+});
+var Plugin2 = {
+  id: "opencode.tool.websearch",
+  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
+    const permission = yield* Service70;
+    const forms = yield* Service65;
+    const websearch = yield* Service30;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name2,
+      options: { codemode: false },
+      description: description2,
+      input: Input2,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* permission.assert({
+          action: name2,
+          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[name2];
+    }));
+  })
+};
+
+export { name2, NO_RESULTS2, description2, Input2, Plugin2, exports_websearch };

package/dist/chunks/worktree-vece14gy.js

@@ -0,0 +1,329 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  makeUnsafe2
+} from "./worktree-y71avatq.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  SessionMessage2
+} from "./worktree-gftt206x.js";
+import {
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+import {
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./worktree-5c4hm403.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  Compaction: () => Compaction2,
+  CompactionPayload: () => CompactionPayload2,
+  Delivery: () => Delivery2,
+  Info: () => Info5,
+  Item: () => Item2,
+  LifecycleConflict: () => LifecycleConflict2,
+  Move: () => Move2,
+  MovePayload: () => MovePayload2,
+  Service: () => Service34,
+  SessionInbox: () => exports_inbox,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload2,
+  User: () => User2,
+  UserPayload: () => UserPayload2,
+  find: () => find2,
+  has: () => has2,
+  layer: () => layer15,
+  list: () => list3,
+  make: () => make15,
+  moveIDs: () => moveIDs2,
+  nextPromotable: () => nextPromotable2,
+  node: () => node37,
+  projectAdmitted: () => projectAdmitted2,
+  projectCancelled: () => projectCancelled2,
+  projectDelivered: () => projectDelivered2,
+  projectDeliveryChanged: () => projectDeliveryChanged2,
+  promote: () => promote2,
+  serialized: () => serialized2
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import {
+  Compaction as Compaction2,
+  CompactionPayload as CompactionPayload2,
+  Delivery as Delivery2,
+  Info as Info5,
+  Item as Item2,
+  Move as Move2,
+  MovePayload as MovePayload2,
+  Synthetic as Synthetic2,
+  SyntheticPayload as SyntheticPayload2,
+  User as User2,
+  UserPayload as UserPayload2
+} from "@opencode/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload2);
+var encodeUser = Schema.encodeSync(UserPayload2);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload2);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload2);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload2);
+var encodeCompaction = Schema.encodeSync(CompactionPayload2);
+var decodeMove = Schema.decodeUnknownSync(MovePayload2);
+var encodeMove = Schema.encodeSync(MovePayload2);
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var inboxLocks = makeUnsafe2();
+var serialized2 = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict2 extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage2.ID
+}) {
+}
+function matches(stored, request) {
+  return stored.sessionID === request.sessionID && stored.type === request.type;
+}
+var fromRow = (row) => {
+  const base = {
+    id: SessionMessage2.ID.make(row.id),
+    sessionID: SessionSchema2.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction2.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move2.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict2({ id: base.id });
+};
+var find2 = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
+  const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* new LifecycleConflict2({ id });
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
+  const base = { id, sessionID, timeCreated: message.time.created, delivery };
+  if (message.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* new LifecycleConflict2({ id });
+});
+
+class Service34 extends Context.Service()("@opencode/SessionInbox") {
+}
+var make15 = Effect.fn("SessionInbox.make")(function* () {
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
+    const existing = (yield* find2(db, request.id)) ?? (yield* promotedFromMessage(db, request.sessionID, request.id, request.delivery));
+    if (existing === undefined)
+      return;
+    if (existing.type === "compaction" || !matches(existing, request))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return existing;
+  });
+  const admit = Effect.fn("SessionInbox.admit")(function* (request) {
+    const existing = yield* reconcile({ ...request, type: request.item.type, delivery: request.item.delivery });
+    if (existing !== undefined)
+      return existing;
+    const admitted = yield* bus.publish(SessionEvent2.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item
+    }).pipe(Effect.map((event) => Info5.make({
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created),
+      ...request.item
+    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? find2(db, request.id).pipe(Effect.flatMap((stored) => stored === undefined ? Effect.fail(defect) : Effect.succeed(stored))) : Effect.die(defect)));
+    if (!matches(admitted, { ...request, type: request.item.type }))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return admitted;
+  });
+  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
+    return yield* serialized2(input.sessionID, Effect.gen(function* () {
+      const exact = yield* find2(db, input.id);
+      if (exact) {
+        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
+          return exact;
+        return yield* new LifecycleConflict2({ id: input.id });
+      }
+      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
+        return yield* new LifecycleConflict2({ id: input.id });
+      const pending = (yield* list3(db, input.sessionID)).find((item) => item.type === "compaction");
+      if (pending)
+        return pending;
+      return yield* admit({
+        id: input.id,
+        sessionID: input.sessionID,
+        item: { type: "compaction", payload: {}, delivery: Delivery2.make(input.delivery) }
+      });
+    }));
+  });
+  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxCancelled, {
+    sessionID: input.sessionID,
+    inboxID: input.id
+  })));
+  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "steer"
+  })));
+  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "queue"
+  })));
+  return {
+    list: (sessionID) => list3(db, sessionID),
+    reconcile,
+    admit,
+    admitCompaction,
+    cancel,
+    steer,
+    queue
+  };
+});
+var layer15 = Layer.effect(Service34, make15());
+var node37 = makeGlobalNode({ service: Service34, layer: layer15, deps: [node85, node84] });
+var projectAdmitted2 = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(eq(SessionMessageTable2.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable2).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.item.type,
+    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
+    delivery: request.item.delivery,
+    enqueued_seq: request.enqueuedSeq,
+    time_created: request.timeCreated
+  }).onConflictDoNothing().returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+});
+var projectDelivered2 = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled2 = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), or(eq(SessionInboxTable2.delivery, "queue"), eq(SessionInboxTable2.delivery, "steer")))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable2).set({ delivery: input.to }).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), eq(SessionInboxTable2.delivery, input.from))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDeliveryChanged2 = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list3 = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.session_id, sessionID)).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs2 = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.type, "move"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextPromotable2 = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  const steer = (yield* pendingSteers(db, sessionID))[0];
+  if (steer)
+    return fromRow(steer);
+  if (promotable !== "input")
+    return;
+  const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return queued ? fromRow(queued) : undefined;
+});
+var has2 = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable2.delivery, "steer"), eq(SessionInboxTable2.delivery, "queue")) : eq(SessionInboxTable2.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var publishMutation = (input, effect) => serialized2(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? Effect.fail(defect) : Effect.die(defect)));
+var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
+  yield* Effect.forEach(rows, (row) => {
+    const entry = fromRow(row);
+    if (entry.type === "compaction")
+      return Effect.die(new LifecycleConflict2({ id: entry.id }));
+    return bus.publish(SessionEvent2.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect)), Effect.orDie) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote2 = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized2(sessionID, Effect.gen(function* () {
+    const steers = yield* pendingSteers(db, sessionID);
+    if (steers.length > 0 || scope === "steer") {
+      const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      if (control === 0)
+        return;
+      return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control));
+    }
+    const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    if (queued.type === "compaction" || queued.type === "move")
+      return;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* pendingSteers(db, sessionID);
+    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
+    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
+  }));
+});
+var pendingSteers = (db, sessionID) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "steer"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie, Effect.map((rows) => {
+  const control = rows.findIndex((row) => row.type === "compaction" || row.type === "move");
+  if (control > 0 && rows[control].type === "compaction")
+    rows.unshift(...rows.splice(control, 1));
+  return rows;
+}));
+
+export { Compaction2, CompactionPayload2, Delivery2, Info5, Item2, Move2, MovePayload2, Synthetic2, SyntheticPayload2, User2, UserPayload2, serialized2, LifecycleConflict2, find2, Service34, make15, layer15, node37, projectAdmitted2, projectDelivered2, projectCancelled2, projectDeliveryChanged2, list3, moveIDs2, nextPromotable2, has2, promote2, exports_inbox };

package/dist/chunks/worktree-veqvce7d.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./worktree-ym463w8f.js";
+
+// src/plugin/provider/perplexity.ts
+var PerplexityPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.perplexity",
+  package: "@ai-sdk/perplexity",
+  load: async (options) => {
+    const { createPerplexity } = await import("@ai-sdk/perplexity");
+    return createPerplexity(options);
+  }
+});
+
+export { PerplexityPlugin2 };

package/dist/chunks/worktree-vkez6a4k.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/instance/service.ts
+var exports_service2 = {};
+__export(exports_service2, {
+  Instance: () => exports_service2,
+  Service: () => Service35,
+  node: () => node38
+});
+import { Context } from "effect";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+
+class Service35 extends Context.Service()("@opencode/Instance") {
+}
+var node38 = LayerNode.unbound(Service35, Node.tags.values.global);
+
+export { Service35, node38, exports_service2 };