@opencode-ai/core 0.0.0-beta-18721 → 0.0.0-beta-18866

package/dist/chunks/{workspace-jvhgzz8q.js → reference-8ngkfkdx.js}

@@ -1,15 +1,15 @@
 import {
   exports_environment1 as exports_environment
-} from "./workspace-rth9afse.js";
+} from "./reference-k5r2vn1t.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};
 __export(exports_stdio, {
-  make: () => make,
-  McpStdio: () => exports_stdio
+  McpStdio: () => exports_stdio,
+  make: () => make
 });
 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";

package/dist/chunks/reference-8q7rztf6.js

@@ -0,0 +1,187 @@
+import {
+  exports_instance
+} from "./reference-qf52r0wh.js";
+import {
+  exports_internal
+} from "./reference-n5yhfyk0.js";
+import {
+  exports_sdk
+} from "./reference-jesbcz0e.js";
+import {
+  exports_update
+} from "./reference-dtm6fkaa.js";
+import {
+  exports_module
+} from "./reference-gte2a4bk.js";
+import {
+  exports_source
+} from "./reference-n256kz7s.js";
+import {
+  exports_plugin
+} from "./reference-g0z4yfdj.js";
+import {
+  exports_bus
+} from "./reference-jghhn6h0.js";
+import {
+  __export
+} from "./reference-vpjkya7h.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  PluginSupervisor: () => exports_supervisor,
+  layer: () => layer,
+  node: () => node
+});
+import { Event } from "@opencode-ai/schema/config";
+import { Cause, Effect, Layer, Stream } from "effect";
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Npm } from "@opencode-ai/util/npm";
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (pre, post, operations, install) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const pending = new Set;
+  const failures = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      if (operation.target === "*")
+        failures.clear();
+      plugins().filter((plugin2) => matches(operation.target, plugin2.id)).forEach((plugin2) => enabled.delete(plugin2.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin2) => matches(operation.target, plugin2.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin2) => enabled.add(plugin2.id));
+      continue;
+    }
+    const plugin = yield* exports_module.load(operation, { install }).pipe(Effect.catchCause((cause) => {
+      const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+      const error = Cause.squash(cause);
+      return Effect.logWarning("failed to load plugin", { target: operation.target, ref, cause }).pipe(Effect.as({ error: error instanceof exports_module.LoadError ? error.message : "Plugin failed to load", ref }));
+    }));
+    if ("pending" in plugin) {
+      pending.add(operation.target);
+      continue;
+    }
+    if ("error" in plugin) {
+      failures.set(operation.target, {
+        source: pluginSource(operation.target),
+        state: { status: "failed", error: plugin.error, ref: plugin.ref },
+        features: { server: true }
+      });
+      continue;
+    }
+    failures.delete(operation.target);
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  return {
+    plugins: [
+      ...pre.filter((plugin) => enabled.has(plugin.id)),
+      ...[...packages.values()].filter((plugin) => enabled.has(plugin.id)),
+      ...post.filter((plugin) => enabled.has(plugin.id))
+    ],
+    failures: [...failures.values()],
+    pending: [...pending]
+  };
+});
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const registry = yield* exports_plugin.Service;
+  const sdk = yield* exports_sdk.Service;
+  const instance = yield* exports_instance.Service;
+  const sources = yield* exports_source.Service;
+  const bus = yield* exports_bus.Service;
+  const updates = yield* exports_update.Service;
+  const internal = yield* exports_internal.list();
+  let release = yield* registry.hold();
+  yield* Effect.addFinalizer(() => release ?? Effect.void);
+  yield* Effect.addFinalizer(registry.close);
+  let packages = new Set;
+  let outdated = new Set;
+  const updating = new Set;
+  let generation = 0;
+  let observed = 0;
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const current = ++generation;
+    const pre = [
+      ...internal.pre.map((plugin) => ({ ...plugin, revision: "internal", source: { type: "builtin" } })),
+      ...sdk.all(),
+      ...instance.all()
+    ];
+    const post = internal.post.map((plugin) => ({
+      ...plugin,
+      revision: "internal",
+      source: { type: "builtin" }
+    }));
+    const operations = yield* sources.operations();
+    const immediate = yield* resolve(pre, post, operations, false);
+    const source = (source2) => source2.type === "package" ? {
+      ...source2,
+      ...outdated.has(source2.target) ? { outdated: true } : {},
+      ...updating.has(source2.target) ? { updating: true } : {}
+    } : source2;
+    const apply = (resolved2) => registry.activate(resolved2.plugins.map((plugin) => plugin.source ? { ...plugin, source: source(plugin.source) } : plugin), resolved2.failures.map((failure) => ({ ...failure, source: source(failure.source) })));
+    yield* apply(immediate);
+    const resolved = immediate.pending.length ? yield* resolve(pre, post, operations, true) : immediate;
+    if (resolved !== immediate)
+      yield* apply(resolved);
+    const loaded = new Set([...resolved.plugins, ...resolved.failures].flatMap((plugin) => plugin.source?.type === "package" ? [plugin.source.target] : []));
+    packages = loaded;
+    yield* Effect.forEach(loaded, (target) => updates.check(target).pipe(Effect.map((available) => [target, available])), { concurrency: "unbounded" }).pipe(Effect.flatMap((checked) => {
+      if (current !== generation)
+        return Effect.void;
+      const next = new Set(checked.flatMap(([target, available]) => available ? [target] : []));
+      if (next.size === outdated.size && [...next].every((target) => outdated.has(target)))
+        return Effect.void;
+      outdated = next;
+      return apply(resolved);
+    }), Effect.forkScoped({ startImmediately: true }));
+  });
+  const reloads = Stream.merge(Stream.merge(sources.changes(), bus.subscribe([Event.Updated, exports_sdk.Updated])), updates.changes().pipe(Stream.filter((update) => packages.has(update.target)), Stream.tap((update) => Effect.sync(() => {
+    update.outdated ? outdated.add(update.target) : outdated.delete(update.target);
+    update.updating ? updating.add(update.target) : updating.delete(update.target);
+  })), Stream.map(() => {
+    return;
+  }))).pipe(Stream.mapEffect(() => Effect.gen(function* () {
+    observed++;
+    if (!release)
+      release = yield* registry.hold();
+    return observed;
+  })));
+  yield* Stream.concat(Stream.succeed(0), reloads).pipe(Stream.buffer({ capacity: 1, strategy: "sliding" }), Stream.debounce("100 millis"), Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })));
+    if (observed !== target)
+      return;
+    const settled = release;
+    release = undefined;
+    if (settled)
+      yield* settled;
+  })), Effect.forkScoped({ startImmediately: true }));
+  yield* Effect.sleep("24 hours").pipe(Effect.andThen(Effect.acquireUseRelease(registry.hold(), () => activate(), (release2) => release2)), Effect.forever, Effect.forkScoped);
+}));
+var nodeDeps = [
+  exports_plugin.node,
+  exports_sdk.node,
+  exports_instance.node,
+  exports_source.node,
+  exports_update.node,
+  exports_bus.node,
+  Npm.node,
+  exports_internal.requirements
+];
+function pluginSource(target) {
+  if (path.isAbsolute(target))
+    return { type: "local", path: target };
+  return { type: "package", target };
+}
+var node = makeLocationNode({ name: "plugin-supervisor", layer, deps: nodeDeps });
+
+export { layer, node, exports_supervisor };

package/dist/chunks/{workspace-sqsnmb9f.js → reference-8r263vtv.js}

@@ -1,9 +1,9 @@
 import {
   exports_usage
-} from "./workspace-sw84ckhj.js";
+} from "./reference-nn16cgj7.js";
 import {
   SessionEvent
-} from "./workspace-a83yvq99.js";
+} from "./reference-a83yvq99.js";
 
 // src/session/runner/publish-llm-event.ts
 import { Effect, Fiber, Iterable } from "effect";

package/dist/chunks/{workspace-jyhpc08g.js → reference-8ze61944.js}

@@ -1,39 +1,39 @@
-import {
-  exports_context
-} from "./workspace-wfdy75zv.js";
 import {
   exports_usage
-} from "./workspace-sw84ckhj.js";
+} from "./reference-nn16cgj7.js";
+import {
+  exports_context
+} from "./reference-0kz3ajyp.js";
 import {
   llmClient
-} from "./workspace-393a352g.js";
+} from "./reference-326j4s6w.js";
 import {
   exports_store
-} from "./workspace-se07g09y.js";
+} from "./reference-bwqptwn6.js";
 import {
   exports_history
-} from "./workspace-9kmcw9m3.js";
+} from "./reference-z427xjvx.js";
 import {
   SessionEvent
-} from "./workspace-a83yvq99.js";
+} from "./reference-a83yvq99.js";
 import {
   exports_bus
-} from "./workspace-vkgwd1zr.js";
+} from "./reference-jghhn6h0.js";
 import {
   exports_database
-} from "./workspace-gbf8gmfy.js";
+} from "./reference-xwpxh8hr.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/session/title.ts
 var exports_title = {};
 __export(exports_title, {
-  node: () => node,
-  layer: () => layer,
-  isUntitled: () => isUntitled,
+  Service: () => Service,
   SessionTitle: () => exports_title,
-  Service: () => Service
+  isUntitled: () => isUntitled,
+  layer: () => layer,
+  node: () => node
 });
 import { isDeepStrictEqual } from "node:util";
 import { LLMClient, LLMEvent, Message, SystemPart } from "@opencode-ai/ai";

package/dist/chunks/{workspace-f3fdb301.js → reference-8zsay21d.js}

@@ -1,12 +1,12 @@
 import {
   foldSettings
-} from "./workspace-wg766mjt.js";
+} from "./reference-f821qzap.js";
 import {
   exports_config
-} from "./workspace-m4a2h2aa.js";
+} from "./reference-4v53bvyt.js";
 import {
   exports_model
-} from "./workspace-t683wdge.js";
+} from "./reference-8ck72gm8.js";
 
 // src/plugin/provider/lmstudio.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";

package/dist/chunks/{workspace-0j6xhazk.js → reference-90je674c.js}

@@ -1,15 +1,15 @@
 import {
   exports_app
-} from "./workspace-50jxp3hw.js";
-import {
-  exports_provider
-} from "./workspace-fex42j86.js";
+} from "./reference-hs51b0fc.js";
 import {
   exports_integration
-} from "./workspace-96h2ckbg.js";
+} from "./reference-ak8kj9h3.js";
 import {
   exports_credential
-} from "./workspace-geyszmd1.js";
+} from "./reference-thngpag9.js";
+import {
+  exports_provider
+} from "./reference-zq5w46q0.js";
 
 // src/plugin/provider/xai.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";

package/dist/chunks/{workspace-gn1b6j0w.js → reference-97q0eayt.js}

@@ -1,34 +1,37 @@
 import {
   exports_subagent_completion
-} from "./workspace-a7zp47hx.js";
+} from "./reference-kr9vgar1.js";
 import {
-  exports_runtime
-} from "./workspace-0p8q1qw1.js";
+  exports_session
+} from "./reference-f6687h7n.js";
+import {
+  exports_job
+} from "./reference-s4nkbdgv.js";
+import {
+  exports_config
+} from "./reference-4v53bvyt.js";
 import {
   exports_permission
-} from "./workspace-ekr1z8vx.js";
+} from "./reference-yt5sqzpx.js";
 import {
   exports_agent
-} from "./workspace-xanq1mxd.js";
+} from "./reference-wghtbf73.js";
 import {
   SessionSchema
-} from "./workspace-bjwj8hwv.js";
-import {
-  exports_config
-} from "./workspace-m4a2h2aa.js";
+} from "./reference-bjwj8hwv.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/tool/plugin/subagent.ts
 var exports_subagent = {};
 __export(exports_subagent, {
-  name: () => name,
-  description: () => description,
-  SubagentTool: () => exports_subagent,
-  Plugin: () => Plugin,
+  Input: () => Input,
   Output: () => Output,
-  Input: () => Input
+  Plugin: () => Plugin,
+  SubagentTool: () => exports_subagent,
+  description: () => description,
+  name: () => name
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema, Scope } from "effect";
@@ -72,14 +75,15 @@ var description = [
 var Plugin = {
   id: "opencode.tool.subagent",
   effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
-    const runtime = yield* exports_runtime.Service;
+    const sessions = yield* exports_session.Service;
+    const jobs = yield* exports_job.Service;
     const agents = yield* exports_agent.Service;
     const config = yield* exports_config.Service;
     const permission = yield* exports_permission.Service;
     const scope = yield* Scope.Scope;
     const notifications = new Set;
     const latestAssistantText = Effect.fn("SubagentTool.latestAssistantText")(function* (sessionID) {
-      const messages = yield* runtime.session.messages({ sessionID, order: "desc", limit: 20 });
+      const messages = yield* sessions.messages({ sessionID, order: "desc", limit: 20 });
       const assistant = messages.find((message) => message.type === "assistant" && message.time.completed !== undefined && message.error === undefined);
       if (assistant === undefined || assistant.type !== "assistant")
         return NO_TEXT;
@@ -92,9 +96,9 @@ var Plugin = {
         return;
       notifications.add(key);
       yield* Effect.gen(function* () {
-        const info = (yield* runtime.job.wait({ id: recovery.childSessionID })).info;
+        const info = (yield* jobs.wait({ id: recovery.childSessionID })).info;
         if (info)
-          yield* exports_subagent_completion.deliver(runtime.session, runtime.job, { ...info, recovery });
+          yield* exports_subagent_completion.deliver(sessions, jobs, { ...info, recovery });
       }).pipe(Effect.ensuring(Effect.sync(() => notifications.delete(key))), Effect.forkIn(scope, { startImmediately: true }));
     });
     yield* ctx.tool.transform((draft) => draft.add({
@@ -104,12 +108,12 @@ var Plugin = {
       input: Input,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
-        const parent = yield* runtime.session.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
+        const parent = yield* sessions.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
         let current = parent;
         let depth = 0;
         while (current.parentID) {
           depth++;
-          current = yield* runtime.session.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
+          current = yield* sessions.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
         }
         const limit = exports_config.latest(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
         if (depth >= limit)
@@ -133,16 +137,16 @@ var Plugin = {
             id: context.id
           }
         }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent denied: ${agent.id}`, error })));
-        const existing = input.sessionID === undefined ? undefined : yield* runtime.session.get(input.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent session not found: ${input.sessionID}`, error })));
+        const existing = input.sessionID === undefined ? undefined : yield* sessions.get(input.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent session not found: ${input.sessionID}`, error })));
         if (existing !== undefined && existing.parentID !== context.sessionID)
           return yield* new ToolFailure({
             message: `Session ${existing.id} is not a child of the current session`
           });
         if (existing !== undefined && existing.agent !== agent.id) {
-          yield* runtime.session.switchAgent({ sessionID: existing.id, agent: agent.id }).pipe(Effect.andThen(agent.model === undefined ? Effect.void : runtime.session.switchModel({ sessionID: existing.id, model: agent.model })), Effect.mapError((error) => new ToolFailure({ message: `Failed to switch subagent session agent: ${existing.id}`, error })));
+          yield* sessions.switchAgent({ sessionID: existing.id, agent: agent.id }).pipe(Effect.andThen(agent.model === undefined ? Effect.void : sessions.switchModel({ sessionID: existing.id, model: agent.model })), Effect.mapError((error) => new ToolFailure({ message: `Failed to switch subagent session agent: ${existing.id}`, error })));
         }
         const model = agent.model ?? parent.model;
-        const child = existing ?? (yield* runtime.session.create({
+        const child = existing ?? (yield* sessions.create({
           parentID: context.sessionID,
           title: input.description,
           agent: exports_agent.ID.make(input.agent),
@@ -150,7 +154,7 @@ var Plugin = {
         }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }))));
         const background = input.background === true;
         yield* context.progress({ sessionID: child.id, status: "running" });
-        yield* runtime.session.prompt({
+        yield* sessions.prompt({
           sessionID: child.id,
           text: existing === undefined ? ["You are a subagent spawned by another session.", input.prompt].join(`
 `) : input.prompt,
@@ -163,20 +167,20 @@ var Plugin = {
           agent: agent.name,
           description: input.description
         };
-        const info = yield* runtime.job.start({
+        const info = yield* jobs.start({
           id: child.id,
           type: name,
           title: input.description,
           metadata: {},
           recovery,
-          run: runtime.session.resume(child.id).pipe(Effect.andThen(latestAssistantText(child.id)))
+          run: sessions.resume(child.id).pipe(Effect.andThen(latestAssistantText(child.id)))
         });
         if (background) {
-          yield* runtime.job.background(info.id);
+          yield* jobs.background(info.id);
           yield* notifyWhenDone(recovery, info.started_at);
           return backgroundResult(child.id);
         }
-        const result = yield* runtime.job.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([runtime.session.interrupt(child.id), runtime.job.cancel(child.id)], {
+        const result = yield* jobs.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([sessions.interrupt(child.id), jobs.cancel(child.id)], {
           discard: true
         })));
         if (result?.type === "backgrounded") {