@opencode-ai/core 0.0.0-beta-18155 → 0.0.0-beta-18219

package/dist/chunks/state-gqn2zsfg.js

@@ -0,0 +1,429 @@
+// src/persistent-pty/daemon.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { Data, Duration, Effect, Schema, Semaphore } from "effect";
+var ProtocolVersion = 6;
+var MaxFrameBytes = 8 * 1024 * 1024;
+var Lifecycle = Schema.Union([
+  Schema.Struct({ status: Schema.Literal("running") }),
+  Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
+  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String })
+]);
+var WireTerminal = Schema.Struct({
+  id: Schema.Number,
+  pid: Schema.NullOr(Schema.Number),
+  title: Schema.String,
+  foreground_process: Schema.NullOr(Schema.String),
+  group_id: Schema.String,
+  command: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  cols: Schema.Number,
+  rows: Schema.Number,
+  lifecycle: Lifecycle,
+  output_head: Schema.Number,
+  output_tail: Schema.Number
+});
+var Registration = Schema.Struct({
+  instance_id: Schema.String,
+  pid: Schema.Number,
+  protocol: Schema.Number,
+  socket: Schema.String,
+  token: Schema.String
+});
+var WireResponse = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("pong"),
+    instance_id: Schema.String,
+    pid: Schema.Number,
+    protocol: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal }),
+  Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal) }),
+  Schema.Struct({ type: Schema.Literal("ok") }),
+  Schema.Struct({
+    type: Schema.Literal("snapshot"),
+    terminal: WireTerminal,
+    text: Schema.String,
+    checkpoint_base64: Schema.String,
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("attached"),
+    terminal: WireTerminal,
+    role: Schema.Literals(["controller", "observer"]),
+    generation: Schema.Number,
+    requested_offset: Schema.Number,
+    available_offset: Schema.Number,
+    end_offset: Schema.Number,
+    truncated: Schema.Boolean,
+    replay_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("resized"),
+    cols: Schema.Number,
+    rows: Schema.Number,
+    generation: Schema.Number,
+    checkpoint_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("exited"),
+    exit_code: Schema.NullOr(Schema.Number),
+    final_offset: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("controller_changed"),
+    attachment_id: Schema.NullOr(Schema.String),
+    generation: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("title_changed"), title: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("foreground_process_changed"), process: Schema.NullOr(Schema.String) }),
+  Schema.Struct({ type: Schema.Literal("error"), message: Schema.String })
+]);
+
+class DaemonError extends Data.TaggedError("PersistentPty.DaemonError") {
+}
+var makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport")(function* (directory, binary = () => Promise.resolve(process.env.OPENCODE_PTY_BIN || "opencode-pty")) {
+  const startup = Semaphore.makeUnsafe(1);
+  let registration;
+  const discover = Effect.fn("PersistentPty.daemon.discover")(function* () {
+    const value = yield* Effect.tryPromise({
+      try: () => readFile(path.join(directory, "service.json"), "utf8"),
+      catch: (cause) => failure("connect", cause)
+    });
+    const decoded = yield* Effect.try({
+      try: () => Schema.decodeUnknownSync(Registration)(JSON.parse(value)),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (decoded.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError({
+        kind: "protocol",
+        message: `opencode-pty protocol mismatch: daemon=${decoded.protocol}, client=${ProtocolVersion}`,
+        pid: decoded.pid
+      }));
+    const response = yield* oneShot(decoded, { op: "ping" });
+    if (response.type !== "pong" || response.instance_id !== decoded.instance_id || response.pid !== decoded.pid || response.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError({ kind: "protocol", message: "opencode-pty registration mismatch" }));
+    return decoded;
+  });
+  const start = Effect.fn("PersistentPty.daemon.start")(function* () {
+    const executable = yield* Effect.tryPromise({ try: binary, catch: (cause) => failure("spawn", cause) });
+    yield* Effect.tryPromise({
+      try: () => new Promise((resolve, reject) => {
+        const child = spawn(executable, ["daemon"], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: directory }
+        });
+        child.once("spawn", () => {
+          child.unref();
+          resolve();
+        });
+        child.once("error", reject);
+      }),
+      catch: (cause) => failure("spawn", cause)
+    });
+    const deadline = Date.now() + 5000;
+    let last;
+    while (Date.now() < deadline) {
+      const found = yield* discover().pipe(Effect.map((value) => ({ value })), Effect.catch((error) => {
+        last = error;
+        return Effect.succeed(undefined);
+      }));
+      if (found)
+        return found.value;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(last ?? new DaemonError({ kind: "connect", message: "opencode-pty did not become ready" }));
+  });
+  const connect = Effect.fn("PersistentPty.daemon.connect")(function* (shouldStart) {
+    if (registration)
+      return registration;
+    return yield* startup.withPermit(Effect.gen(function* () {
+      if (registration)
+        return registration;
+      const found = yield* discover().pipe(Effect.catch((error) => {
+        if (!shouldStart)
+          return Effect.fail(error);
+        if (error.kind === "connect")
+          return start();
+        if (error.kind !== "protocol" || error.pid === undefined)
+          return Effect.fail(error);
+        return terminate(error.pid).pipe(Effect.andThen(start()));
+      }));
+      registration = found;
+      return found;
+    }));
+  });
+  const attempt = Effect.fn("PersistentPty.daemon.request-attempt")(function* (value, shouldStart) {
+    const current = yield* connect(shouldStart);
+    return yield* oneShot(current, value).pipe(Effect.catch((error) => {
+      if (error.kind === "registration" && registration === current)
+        registration = undefined;
+      return Effect.fail(error);
+    }));
+  });
+  const request = Effect.fn("PersistentPty.daemon.request")(function* (value, shouldStart = false) {
+    return yield* attempt(value, shouldStart).pipe(Effect.catch((error) => {
+      if (error.kind === "registration")
+        return attempt(value, shouldStart);
+      if (error.kind !== "connect")
+        return Effect.fail(error);
+      registration = undefined;
+      if (!shouldStart)
+        return Effect.fail(error);
+      return attempt(value, true);
+    }));
+  });
+  const requestIfRunning = (value) => request(value).pipe(Effect.catch((error) => error.kind === "connect" ? Effect.succeed(undefined) : Effect.fail(error)));
+  const shutdown = Effect.gen(function* () {
+    const response = yield* requestIfRunning({ op: "shutdown" });
+    registration = undefined;
+    if (!response)
+      return;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const running = yield* discover().pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+      if (!running)
+        return response;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(new DaemonError({ kind: "connect", message: "opencode-pty did not stop" }));
+  });
+  const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (id, input) {
+    const attempt2 = Effect.gen(function* () {
+      const current = yield* connect(false);
+      return yield* Effect.tryPromise({
+        try: () => subscribePromise(current, id, input),
+        catch: (cause) => cause instanceof DaemonError ? cause : failure("connect", cause)
+      }).pipe(Effect.catch((error) => {
+        if (error.kind === "registration" && registration === current)
+          registration = undefined;
+        return Effect.fail(error);
+      }));
+    });
+    return yield* attempt2.pipe(Effect.catch((error) => error.kind === "registration" ? attempt2 : Effect.fail(error)));
+  });
+  return { request, requestIfRunning, shutdown, subscribe };
+});
+var oneShot = Effect.fn("PersistentPty.daemon.oneShot")(function* (registration, request) {
+  const payload = yield* Effect.try({
+    try: () => encode({ token: registration.token, request }),
+    catch: (cause) => failure("protocol", cause)
+  });
+  let dispatched = false;
+  return yield* Effect.acquireUseRelease(Effect.tryPromise({
+    try: (signal) => new Promise((resolve, reject) => {
+      const socket = net.createConnection({ path: registration.socket, signal });
+      socket.once("connect", () => resolve(socket));
+      socket.once("error", reject);
+    }),
+    catch: (cause) => failure("connect", cause)
+  }), (socket) => Effect.gen(function* () {
+    yield* Effect.try({
+      try: () => {
+        dispatched = true;
+        socket.write(payload);
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const first = yield* Effect.tryPromise({
+      try: async (signal) => {
+        const frames = decoder(socket);
+        const abort = () => socket.destroy();
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+          const frame = await frames.next();
+          if (frame.done)
+            throw new Error("opencode-pty closed without response");
+          return frame.value;
+        } finally {
+          signal.removeEventListener("abort", abort);
+        }
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const response = yield* Effect.try({
+      try: () => decode(first),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (response.type === "error")
+      return yield* Effect.fail(new DaemonError({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      }));
+    return response;
+  }), (socket) => Effect.sync(() => socket.destroy())).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError({
+      kind: dispatched ? "response" : "connect",
+      message: "opencode-pty request timed out"
+    }))
+  }));
+});
+async function subscribePromise(registration, id, input) {
+  const socket = net.createConnection(registration.socket);
+  const frames = decoder(socket);
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+    });
+    socket.write(encode({
+      token: registration.token,
+      request: {
+        op: "subscribe",
+        id,
+        offset: input.cursor,
+        attachment_id: input.attachmentID,
+        role: input.role,
+        takeover: input.takeover ?? false
+      }
+    }));
+    const initial = await frames.next();
+    if (initial.done)
+      throw new Error("opencode-pty closed before attachment");
+    const response = decode(initial.value);
+    if (response.type === "error")
+      throw new DaemonError({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      });
+    if (response.type !== "attached")
+      throw new Error(`unexpected opencode-pty response: ${response.type}`);
+    let detached = false;
+    const pump = async () => {
+      try {
+        for await (const frame of frames) {
+          if (frame[0] === 0) {
+            if (frame.length < 17)
+              throw new Error("invalid opencode-pty output frame");
+            input.onEvent({
+              type: "output",
+              start: Number(frame.readBigUInt64BE(1)),
+              end: Number(frame.readBigUInt64BE(9)),
+              data: frame.subarray(17)
+            });
+            continue;
+          }
+          const event = decode(frame);
+          if (event.type === "resized")
+            input.onEvent({
+              type: "resized",
+              cols: event.cols,
+              rows: event.rows,
+              generation: event.generation,
+              checkpoint: Buffer.from(event.checkpoint_base64, "base64")
+            });
+          if (event.type === "controller_changed")
+            input.onEvent({
+              type: "controller_changed",
+              attachmentID: event.attachment_id ?? undefined,
+              generation: event.generation
+            });
+          if (event.type === "title_changed")
+            input.onEvent({ type: "title_changed", title: event.title });
+          if (event.type === "foreground_process_changed")
+            input.onEvent({ type: "foreground_process_changed", process: event.process });
+          if (event.type === "exited") {
+            input.onEvent({
+              type: "exited",
+              exitCode: event.exit_code ?? undefined,
+              finalOffset: event.final_offset
+            });
+            return;
+          }
+        }
+      } finally {
+        if (!detached)
+          input.onEnd();
+      }
+    };
+    let activated = false;
+    return {
+      terminal: response.terminal,
+      role: response.role,
+      generation: response.generation,
+      replay: {
+        requestedOffset: response.requested_offset,
+        availableOffset: response.available_offset,
+        endOffset: response.end_offset,
+        truncated: response.truncated,
+        data: Buffer.from(response.replay_base64, "base64")
+      },
+      activate() {
+        if (activated || detached)
+          return;
+        activated = true;
+        pump().catch(() => {});
+      },
+      detach() {
+        if (detached)
+          return;
+        detached = true;
+        socket.destroy();
+      }
+    };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+function encode(value) {
+  const payload = Buffer.from(JSON.stringify(value));
+  if (payload.length > MaxFrameBytes)
+    throw new Error("opencode-pty frame too large");
+  const output = Buffer.allocUnsafe(payload.length + 4);
+  output.writeUInt32BE(payload.length);
+  payload.copy(output, 4);
+  return output;
+}
+async function* decoder(socket) {
+  let pending = Buffer.alloc(0);
+  for await (const value of socket) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const length = pending.readUInt32BE(0);
+      if (length > MaxFrameBytes)
+        throw new Error("opencode-pty frame too large");
+      if (pending.length < length + 4)
+        break;
+      yield pending.subarray(4, length + 4);
+      pending = pending.subarray(length + 4);
+    }
+  }
+  if (pending.length !== 0)
+    throw new Error("opencode-pty truncated frame");
+}
+function decode(payload) {
+  return Schema.decodeUnknownSync(WireResponse)(JSON.parse(Buffer.from(payload).toString("utf8")));
+}
+function failure(kind, cause) {
+  return new DaemonError({ kind, message: cause instanceof Error ? cause.message : String(cause) });
+}
+var terminate = Effect.fn("PersistentPty.daemon.terminate-incompatible")(function* (pid) {
+  yield* Effect.logWarning("replacing incompatible opencode-pty daemon", { pid });
+  yield* Effect.try({ try: () => process.kill(pid, "SIGTERM"), catch: (cause) => failure("spawn", cause) }).pipe(Effect.catch((error) => isMissingProcess(error) ? Effect.void : Effect.fail(error)));
+  const deadline = Date.now() + 2000;
+  while (Date.now() < deadline && processRunning(pid))
+    yield* Effect.sleep(25);
+  if (!processRunning(pid))
+    return;
+  yield* Effect.try({ try: () => process.kill(pid, "SIGKILL"), catch: (cause) => failure("spawn", cause) }).pipe(Effect.catch((error) => isMissingProcess(error) ? Effect.void : Effect.fail(error)));
+});
+function processRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMissingProcess(error) {
+  return error.message.includes("ESRCH") || error.message.includes("no such process");
+}
+
+export { WireTerminal, WireResponse, DaemonError, makeDaemonTransport };

package/dist/chunks/{instruction-discovery-8j90pnr8.js → state-gwpydf4a.js}

@@ -1,12 +1,12 @@
 import {
   exports_state
-} from "./instruction-discovery-qhdqjp31.js";
+} from "./state-qhdqjp31.js";
 import {
   exports_bus
-} from "./instruction-discovery-kbgqxfka.js";
+} from "./state-4ce5qhvd.js";
 import {
   __export
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/agent.ts
 var exports_agent = {};

package/dist/chunks/state-h094egad.js

@@ -0,0 +1,132 @@
+import {
+  MAX_TOTAL_PATCH_BYTES,
+  PATCH_CONTEXT_LINES,
+  emptyPatch
+} from "./state-vz89hfgr.js";
+import {
+  exports_location
+} from "./state-efvmw2xw.js";
+import {
+  exports_state
+} from "./state-qhdqjp31.js";
+import {
+  exports_bus
+} from "./state-4ce5qhvd.js";
+import {
+  __export
+} from "./state-rvfvac9x.js";
+
+// src/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  node: () => node,
+  Vcs: () => exports_vcs,
+  Service: () => Service,
+  Mode: () => Mode,
+  Info: () => Info,
+  FileStatus: () => FileStatus,
+  BranchList: () => BranchList
+});
+import path from "path";
+import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { BranchList, FileStatus, Info, Mode } from "@opencode-ai/schema/vcs";
+import { VcsEvent } from "@opencode-ai/schema/vcs-event";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+class Service extends Context.Service()("@opencode/Vcs") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const bus = yield* exports_bus.Service;
+  const vcs = location.vcs;
+  const current = { info: { branch: {} } };
+  const scope = {
+    directory: location.directory,
+    worktree: location.project.directory,
+    canonical: location.project.canonical,
+    ...vcs ? { store: vcs.store } : {}
+  };
+  const decodeInfo = Schema.decodeUnknownEffect(Schema.toType(Info));
+  const decodeBranches = Schema.decodeUnknownEffect(BranchList);
+  const decodeStatus = Schema.decodeUnknownEffect(Schema.Array(FileStatus));
+  const decodeDiff = Schema.decodeUnknownEffect(Schema.Array(FileDiff.Info));
+  const state = exports_state.create({
+    name: "vcs",
+    initial: () => ({ providers: new Map }),
+    draft: (draft) => ({
+      add: (provider) => draft.providers.set(provider.id, provider),
+      default: {
+        get: () => draft.selection,
+        set: (selection) => draft.selection = selection
+      }
+    }),
+    finalize: () => refresh()
+  });
+  const selected = () => {
+    const value = state.get();
+    const id = value.selection ?? vcs?.type;
+    return id ? value.providers.get(id) : undefined;
+  };
+  const protect = (provider, operation, effect, fallback) => effect.pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause).pipe(Effect.orDie) : Effect.logWarning("vcs provider failed", { provider: provider.id, operation, cause }).pipe(Effect.as(fallback))));
+  const refresh = Effect.fn("Vcs.refresh")(function* () {
+    const provider = selected();
+    const next = provider ? yield* protect(provider, "info", provider.info(scope).pipe(Effect.flatMap(decodeInfo)), { branch: {} }) : { branch: {} };
+    const changed = current.info.branch.current !== next.branch.current;
+    current.info = next;
+    if (changed)
+      yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current });
+  });
+  if (vcs) {
+    const store = yield* fs.realPath(vcs.store).pipe(Effect.orElseSucceed(() => vcs.store));
+    const isBranchMetadata = vcs.type === "git" ? (file) => path.basename(file) === "HEAD" && FSUtil.contains(store, file) : (file) => path.resolve(file) === path.join(store, "branch");
+    yield* bus.subscribe(FileSystem.Event.Changed).pipe(Stream.filter((event) => isBranchMetadata(event.data.file)), Stream.runForEach((event) => refresh().pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } }))), Effect.forkScoped({ startImmediately: true }));
+  }
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    info: Effect.fn("Vcs.info")(function* () {
+      return current.info;
+    }),
+    branches: Effect.fn("Vcs.branches")(function* (options) {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "branches", provider.branches({ ...scope, ...options }).pipe(Effect.flatMap(decodeBranches)), []);
+      return [];
+    }),
+    status: Effect.fn("Vcs.status")(function* () {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "status", provider.status(scope).pipe(Effect.flatMap(decodeStatus), Effect.map((rows) => Array.from(rows))), []);
+      return [];
+    }),
+    diff: Effect.fn("Vcs.diff")(function* (mode, options) {
+      const provider = selected();
+      if (!provider)
+        return [];
+      const rows = yield* protect(provider, "diff", provider.diff({
+        ...scope,
+        mode,
+        context: options?.context ?? PATCH_CONTEXT_LINES,
+        maxOutputBytes: MAX_TOTAL_PATCH_BYTES
+      }).pipe(Effect.flatMap(decodeDiff)), []);
+      let total = 0;
+      return rows.map((row) => {
+        const bytes = Buffer.byteLength(row.patch);
+        if (total + bytes > MAX_TOTAL_PATCH_BYTES)
+          return { ...row, patch: emptyPatch(row.file) };
+        total += bytes;
+        return row;
+      });
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, exports_location.node, exports_bus.node]
+});
+
+export { BranchList, FileStatus, Info, Mode, Service, node, exports_vcs };

package/dist/chunks/{instruction-discovery-kgzdjpe7.js → state-h9sy0va2.js}

@@ -1,15 +1,15 @@
+import {
+  exports_permission
+} from "./state-rmr740y4.js";
 import {
   exports_websearch
-} from "./instruction-discovery-4zxmnhax.js";
+} from "./state-ftfyk4m7.js";
 import {
   exports_form
-} from "./instruction-discovery-bd5r45k7.js";
-import {
-  exports_permission
-} from "./instruction-discovery-7c8h4kqy.js";
+} from "./state-63gtrn1b.js";
 import {
   __export
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/tool/plugin/websearch.ts
 var exports_websearch2 = {};

package/dist/chunks/{instruction-discovery-sbj9fy12.js → state-hhfaz00h.js}

@@ -1,12 +1,12 @@
 import {
   exports_skill
-} from "./instruction-discovery-rxctdfwx.js";
+} from "./state-z88k6s2w.js";
 import {
   exports_instructions
-} from "./instruction-discovery-ec8vrfw5.js";
+} from "./state-ec8vrfw5.js";
 import {
   __export
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/skill/instructions.ts
 var exports_instructions2 = {};

package/dist/chunks/{instruction-discovery-hhxt27np.js → state-hhxt27np.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./instruction-discovery-djkt4gex.js";
+} from "./state-djkt4gex.js";
 import {
   __require
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/plugin/provider/amazon-bedrock.ts
 import { Effect } from "effect";

package/dist/chunks/{instruction-discovery-bvfght6w.js → state-hk8exvw2.js}

@@ -1,9 +1,9 @@
 import {
   exports_integration
-} from "./instruction-discovery-hf53vrwt.js";
+} from "./state-ayfpp7hf.js";
 import {
   exports_provider
-} from "./instruction-discovery-djkt4gex.js";
+} from "./state-djkt4gex.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";

package/dist/chunks/{instruction-discovery-9rspw0h0.js → state-hk8vx4ga.js}

@@ -1,18 +1,18 @@
 import {
   exports_mcp
-} from "./instruction-discovery-pa35pf5v.js";
+} from "./state-shhqc982.js";
 import {
   exports_tool
-} from "./instruction-discovery-nnvs948e.js";
+} from "./state-e9jfq0e9.js";
 import {
   exports_permission
-} from "./instruction-discovery-7c8h4kqy.js";
+} from "./state-rmr740y4.js";
 import {
   exports_bus
-} from "./instruction-discovery-kbgqxfka.js";
+} from "./state-4ce5qhvd.js";
 import {
   __export
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/tool/mcp.ts
 var exports_mcp2 = {};

package/dist/chunks/{instruction-discovery-hp6rpdnc.js → state-hp6rpdnc.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./instruction-discovery-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/file-retention.ts
 var exports_file_retention = {};