@opencode-ai/core 0.0.0-dev-18359 → 0.0.0-dev-18363

package/dist/chunks/{app-h2j6dq7a.js → tool-output-2fjh607y.js}

@@ -1,17 +1,17 @@
 import {
   EventSequenceTable,
   EventTable
-} from "./app-zsf8rs93.js";
+} from "./tool-output-zsf8rs93.js";
 import {
   exports_keyed_mutex
-} from "./app-0kvmztkf.js";
+} from "./tool-output-0kvmztkf.js";
 import {
   exports_database
-} from "./app-pt88wz1q.js";
+} from "./tool-output-e3g8tbcq.js";
 import {
   __export,
   __require
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/bus.ts
 var exports_bus = {};
@@ -34,6 +34,8 @@ import { and, asc, eq, gt, lte, sql } from "drizzle-orm";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { isDeepStrictEqual } from "node:util";
 import { Durable } from "@opencode-ai/schema/durable-event-manifest";
+import { SessionEvent } from "@opencode-ai/schema/session-event";
+import { AbsolutePath } from "@opencode-ai/schema/schema";
 var latestSequence = Effect.fn("Bus.latestSequence")(function* (db, aggregateID) {
   const row = yield* db.select({ seq: EventSequenceTable.seq }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
   return row?.seq ?? -1;
@@ -82,6 +84,7 @@ function configured(options) {
     deps: [exports_database.node],
     layer: Layer.effect(Service, Effect.gen(function* () {
       const { Location } = yield* Effect.promise(() => import("../location.js"));
+      const { SessionTable } = yield* Effect.promise(() => import("../session/sql.js"));
       const pubsub = {
         live: yield* PubSub.unbounded(),
         durable: new Map,
@@ -93,6 +96,55 @@ function configured(options) {
       const { db } = yield* exports_database.Service;
       const logReadPageSize = options?.logReadPageSize ?? 512;
       const persist = options?.persist ?? false;
+      const sessions = new Map;
+      const routes = new WeakMap;
+      const isSessionEvent = (event) => Object.hasOwn(SessionEvent.All.cases, event.type);
+      const prepareRoutes = Effect.fnUntraced(function* (events) {
+        const updates = new Map;
+        const resolved = new Map;
+        for (const event of events) {
+          if (!isSessionEvent(event))
+            continue;
+          const id = event.data.sessionID;
+          if (event.type === "session.created") {
+            updates.set(id, event.data.location);
+            resolved.set(event, [event.location ?? event.data.location]);
+            continue;
+          }
+          if (event.location && event.type !== "session.forked" && event.type !== "session.moved") {
+            if (event.type === "session.deleted")
+              updates.set(id, undefined);
+            continue;
+          }
+          const owner = event.type === "session.forked" ? event.data.parentID : id;
+          let ref = updates.has(owner) ? updates.get(owner) : sessions.get(owner);
+          if (!ref && !updates.has(owner)) {
+            const row = yield* db.select({ directory: SessionTable.directory, workspaceID: SessionTable.workspace_id }).from(SessionTable).where(eq(SessionTable.id, owner)).get().pipe(Effect.orDie);
+            ref = row ? { directory: AbsolutePath.make(row.directory), workspaceID: row.workspaceID ?? undefined } : undefined;
+            updates.set(owner, ref);
+          }
+          if (event.type === "session.moved") {
+            updates.set(id, event.data.location);
+            resolved.set(event, ref ? [ref, event.data.location] : [event.data.location]);
+            continue;
+          }
+          if (event.type === "session.forked")
+            updates.set(id, ref);
+          resolved.set(event, event.location ? [event.location] : ref ? [ref] : []);
+          if (event.type === "session.deleted")
+            updates.set(id, undefined);
+        }
+        return () => {
+          for (const [id, ref] of updates) {
+            if (ref)
+              sessions.set(id, ref);
+            else
+              sessions.delete(id);
+          }
+          for (const [event, ref] of resolved)
+            routes.set(event, ref);
+        };
+      });
       const getOrCreate = (definition) => Effect.gen(function* () {
         const existing = pubsub.typed.get(definition.type);
         if (existing)
@@ -172,6 +224,7 @@ function configured(options) {
                     ...event,
                     durable: { aggregateID, seq, version: durable2.version }
                   };
+                  const route = yield* prepareRoutes([committed2]);
                   for (const projector of list) {
                     yield* projector(committed2);
                   }
@@ -195,9 +248,10 @@ function configured(options) {
                         data: encoded
                       }
                     ]).run().pipe(Effect.orDie);
-                  return { aggregateID, seq };
+                  return { aggregateID, seq, event: committed2, route };
                 }), { behavior: "immediate" }).pipe(Effect.orDie);
                 if (committed) {
+                  committed.route();
                   yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
                 }
                 return committed;
@@ -221,14 +275,13 @@ function configured(options) {
               const committed = yield* commitDurableEvent(definition, event, undefined, commit);
               if (!committed)
                 return event;
-              event = {
-                ...event,
-                durable: envelope(committed.aggregateID, committed.seq, definition.durable.version)
-              };
+              event = committed.event;
               yield* notify(event, true);
               return event;
             }));
           }
+          const route = yield* prepareRoutes([event]);
+          route();
           yield* notify(event, false);
           return event;
         });
@@ -295,7 +348,11 @@ function configured(options) {
               const row = yield* db.select({ seq: EventSequenceTable.seq }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
               const firstSeq = (row?.seq ?? -1) + 1;
               const finalSeq = firstSeq + payloads.length - 1;
-              const result = new Array;
+              const queued = payloads.map((item, index) => ({
+                ...item.event,
+                durable: envelope(aggregateID, firstSeq + index, item.definition.durable.version)
+              }));
+              const route = yield* prepareRoutes(queued);
               const rows = new Array;
               const ids = new Set;
               for (const [index, item] of payloads.entries()) {
@@ -315,10 +372,7 @@ function configured(options) {
                       message: `Event ${item.event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
                     }));
                 }
-                const event = {
-                  ...item.event,
-                  durable: envelope(aggregateID, seq, item.definition.durable.version)
-                };
+                const event = queued[index];
                 for (const projector of projectors.get(versionedType(item.definition.type, item.definition.durable.version)) ?? []) {
                   yield* projector(event);
                 }
@@ -333,18 +387,18 @@ function configured(options) {
                     type: versionedType(item.definition.type, item.definition.durable.version),
                     data: encoded
                   });
-                result.push(event);
               }
               yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq: finalSeq }]).onConflictDoUpdate({ target: EventSequenceTable.aggregate_id, set: { seq: finalSeq } }).run().pipe(Effect.orDie);
               if (persist)
                 yield* db.insert(EventTable).values(rows).run().pipe(Effect.orDie);
-              return result;
+              return { events: queued, route };
             }), { behavior: "immediate" }).pipe(Effect.orDie);
+            committed.route();
             yield* Effect.forEach(pubsub.durable.get(aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), {
               discard: true
             });
-            yield* Effect.forEach(committed, (event) => notify(event, true), { discard: true });
-            return committed;
+            yield* Effect.forEach(committed.events, (event) => notify(event, true), { discard: true });
+            return committed.events;
           })));
         });
       }
@@ -367,10 +421,7 @@ function configured(options) {
               strictOwner: options2?.strictOwner
             });
             if (committed && options2?.publish) {
-              yield* notify({
-                ...payload,
-                durable: envelope(committed.aggregateID, committed.seq, definition.durable.version)
-              }, true);
+              yield* notify(committed.event, true);
             }
           }));
         });
@@ -379,14 +430,22 @@ function configured(options) {
         return db.transaction(() => Effect.gen(function* () {
           yield* db.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run();
           yield* db.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run();
-        })).pipe(Effect.orDie);
+        })).pipe(Effect.tap(() => Effect.sync(() => sessions.delete(aggregateID))), Effect.orDie);
       }
       function claim(aggregateID, ownerID) {
         return db.update(EventSequenceTable).set({ owner_id: ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
       }
       const local = (stream) => Stream.unwrap(Effect.serviceOption(Location.Service).pipe(Effect.map((location) => Option.match(location, {
         onNone: () => stream,
-        onSome: (location2) => stream.pipe(Stream.filter((event) => !event.location || event.location.directory === location2.directory && event.location.workspaceID === location2.workspaceID))
+        onSome: (location2) => {
+          const matches = (ref) => ref.directory === location2.directory && ref.workspaceID === location2.workspaceID;
+          return stream.pipe(Stream.filter((event) => {
+            const refs = routes.get(event);
+            if (refs)
+              return refs.some(matches);
+            return !event.location || matches(event.location);
+          }));
+        }
       }))));
       function subscribe(input) {
         if (input === undefined)

package/dist/chunks/{app-2m0hgr65.js → tool-output-2m0hgr65.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/session/runner/index.ts
 var exports_runner = {};

package/dist/chunks/{app-2nmyybe0.js → tool-output-2nmyybe0.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/v1/config/formatter.ts
 var exports_formatter = {};

package/dist/chunks/{app-p6r16h3e.js → tool-output-2v3wz6r1.js}

@@ -1,18 +1,18 @@
 import {
   exports_location
-} from "./app-20bsrrbe.js";
+} from "./tool-output-pvjmhzxh.js";
 import {
   exports_project
-} from "./app-fkwxdb9g.js";
+} from "./tool-output-2w2enhs1.js";
 import {
   exports_markers
-} from "./app-b42wkxmf.js";
+} from "./tool-output-m068y7cv.js";
 import {
   AbsolutePath
-} from "./app-j07kk359.js";
+} from "./tool-output-j07kk359.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/location-mutation.ts
 var exports_location_mutation = {};

package/dist/chunks/{app-cfwxa790.js → tool-output-2w198pxx.js}

@@ -1,60 +1,60 @@
 import {
-  exports_instructions as exports_instructions5
-} from "./app-18vnqwwx.js";
+  exports_builtins
+} from "./tool-output-qxgr67h2.js";
 import {
-  exports_instructions as exports_instructions4
-} from "./app-gz3c1qgg.js";
+  exports_instructions as exports_instructions3
+} from "./tool-output-xxpvz42q.js";
 import {
   exports_instructions as exports_instructions2
-} from "./app-s42dkbr8.js";
+} from "./tool-output-81883fe4.js";
 import {
-  exports_mcp
-} from "./app-nedtb4qc.js";
+  exports_supervisor
+} from "./tool-output-18m009b8.js";
 import {
-  exports_builtins
-} from "./app-3jnjs6sa.js";
+  exports_instructions as exports_instructions4
+} from "./tool-output-0rzth1aj.js";
 import {
-  exports_supervisor
-} from "./app-v3zbdyyt.js";
+  exports_mcp
+} from "./tool-output-3nydrbs4.js";
 import {
-  exports_instructions as exports_instructions3
-} from "./app-xxpvz42q.js";
+  exports_instructions as exports_instructions5
+} from "./tool-output-87766h7b.js";
 import {
   exports_instruction_discovery
-} from "./app-x96jsz8w.js";
+} from "./tool-output-0a8h94fy.js";
+import {
+  exports_tool
+} from "./tool-output-3agq1wnd.js";
 import {
   exports_instruction_entry
-} from "./app-0nt39kfx.js";
+} from "./tool-output-zsnnkyk9.js";
 import {
   exports_model
-} from "./app-b6hrhewk.js";
-import {
-  exports_tool
-} from "./app-z6wgd494.js";
+} from "./tool-output-77dk6zr7.js";
 import {
   exports_store
-} from "./app-n3ra7647.js";
+} from "./tool-output-4fytw32d.js";
 import {
   exports_history
-} from "./app-66kns9ss.js";
+} from "./tool-output-q70gvhbx.js";
 import {
   AgentNotFoundError
-} from "./app-fb7nfzf2.js";
-import {
-  exports_agent
-} from "./app-n6pvv255.js";
+} from "./tool-output-fb7nfzf2.js";
 import {
   exports_instructions
-} from "./app-ec8vrfw5.js";
+} from "./tool-output-ec8vrfw5.js";
+import {
+  exports_agent
+} from "./tool-output-2eza2vrt.js";
 import {
   exports_location
-} from "./app-20bsrrbe.js";
+} from "./tool-output-pvjmhzxh.js";
 import {
   exports_database
-} from "./app-pt88wz1q.js";
+} from "./tool-output-e3g8tbcq.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/session/context.ts
 var exports_context = {};

package/dist/chunks/{app-fkwxdb9g.js → tool-output-2w2enhs1.js}

@@ -1,31 +1,31 @@
 import {
   exports_markers
-} from "./app-b42wkxmf.js";
+} from "./tool-output-m068y7cv.js";
 import {
   exports_schema
-} from "./app-h94zdhz8.js";
+} from "./tool-output-h94zdhz8.js";
 import {
   WorktreeTable
-} from "./app-mh28new4.js";
+} from "./tool-output-mh28new4.js";
 import {
   ProjectTable,
   upsertProject
-} from "./app-88jbfw8z.js";
+} from "./tool-output-88jbfw8z.js";
 import {
   exports_git
-} from "./app-rt37qqhk.js";
+} from "./tool-output-rt37qqhk.js";
 import {
   AbsolutePath
-} from "./app-j07kk359.js";
+} from "./tool-output-j07kk359.js";
 import {
   exports_bus
-} from "./app-h2j6dq7a.js";
+} from "./tool-output-2fjh607y.js";
 import {
   exports_database
-} from "./app-pt88wz1q.js";
+} from "./tool-output-e3g8tbcq.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/project.ts
 var exports_project = {};

package/dist/chunks/{app-2wds5nk3.js → tool-output-2wds5nk3.js}

@@ -1,6 +1,6 @@
 import {
   exports_provider
-} from "./app-krsqcmnj.js";
+} from "./tool-output-krsqcmnj.js";
 
 // src/plugin/provider/cerebras.ts
 import { Effect } from "effect";

package/dist/chunks/{app-qqf79bfa.js → tool-output-2wv0y1df.js}

@@ -1,17 +1,17 @@
 import {
   exports_model
-} from "./app-b6hrhewk.js";
+} from "./tool-output-77dk6zr7.js";
 import {
   exports_integration
-} from "./app-xpvs6ds1.js";
+} from "./tool-output-zh0epqr0.js";
 import {
   exports_permission
-} from "./app-9cyb4dkk.js";
+} from "./tool-output-6gvkwn2p.js";
 import {
   AgentNotFoundError,
   StepFailedError,
   UserInterruptedError
-} from "./app-fb7nfzf2.js";
+} from "./tool-output-fb7nfzf2.js";
 
 // src/session/to-session-error.ts
 import { AIError, ToolFailure } from "@opencode-ai/ai";

package/dist/chunks/{app-3f3db5rj.js → tool-output-318t1dsk.js}

@@ -1,96 +1,96 @@
 import {
-  LLMGatewayPlugin
-} from "./app-y2qhjyv6.js";
+  VLLMPlugin
+} from "./tool-output-6h2nfd0j.js";
 import {
-  VenicePlugin
-} from "./app-xwftk1fd.js";
+  OpencodePlugin
+} from "./tool-output-jhd7ttg8.js";
 import {
-  PerplexityPlugin
-} from "./app-wps8gh8n.js";
+  GoogleVertexPlugin
+} from "./tool-output-7thnevmq.js";
 import {
   LMStudioPlugin
-} from "./app-pz7p4ceg.js";
+} from "./tool-output-myn060tq.js";
 import {
-  CerebrasPlugin
-} from "./app-2wds5nk3.js";
-import {
-  AzurePlugin
-} from "./app-68n20fk3.js";
+  VenicePlugin
+} from "./tool-output-xwftk1fd.js";
 import {
   MistralPlugin
-} from "./app-3thh6229.js";
+} from "./tool-output-3thh6229.js";
 import {
-  ZenmuxPlugin
-} from "./app-awg5d31a.js";
+  AlibabaPlugin
+} from "./tool-output-4zzdwbaz.js";
 import {
-  CloudflareWorkersAIPlugin
-} from "./app-7krak072.js";
+  ZenmuxPlugin
+} from "./tool-output-awg5d31a.js";
 import {
-  GoogleVertexPlugin
-} from "./app-7thnevmq.js";
+  AzurePlugin
+} from "./tool-output-qa567n4v.js";
 import {
   SnowflakeCortexPlugin
-} from "./app-fgyjabww.js";
-import {
-  DynamicProviderPlugin
-} from "./app-3q6gbwmd.js";
+} from "./tool-output-fgyjabww.js";
 import {
   SapAICorePlugin
-} from "./app-rameyvmv.js";
-import {
-  VLLMPlugin
-} from "./app-7apacsf3.js";
+} from "./tool-output-rameyvmv.js";
 import {
   GitLabPlugin
-} from "./app-gpybhmhb.js";
+} from "./tool-output-gpybhmhb.js";
 import {
   CloudflareAIGatewayPlugin
-} from "./app-2zfs2dwp.js";
-import {
-  OpenAIPlugin
-} from "./app-vnbqxx2h.js";
+} from "./tool-output-7p1w7dnc.js";
 import {
-  VercelPlugin
-} from "./app-tgbb2ckq.js";
+  CerebrasPlugin
+} from "./tool-output-2wds5nk3.js";
 import {
-  OpencodePlugin
-} from "./app-er8qbb7j.js";
+  KiloPlugin
+} from "./tool-output-enpg66yn.js";
 import {
-  GatewayPlugin
-} from "./app-smpeg8c9.js";
+  LLMGatewayPlugin
+} from "./tool-output-2ddkf7xe.js";
 import {
-  KiloPlugin
-} from "./app-enpg66yn.js";
+  AnthropicPlugin
+} from "./tool-output-h12kt9pa.js";
 import {
-  OllamaPlugin
-} from "./app-hnpbgacj.js";
+  CloudflareWorkersAIPlugin
+} from "./tool-output-4h3b61q6.js";
 import {
-  OpenRouterPlugin
-} from "./app-8pngjawd.js";
+  CoherePlugin
+} from "./tool-output-qe0d689s.js";
 import {
-  AmazonBedrockPlugin
-} from "./app-m55whf0h.js";
+  DynamicProviderPlugin
+} from "./tool-output-3q6gbwmd.js";
 import {
-  AnthropicPlugin
-} from "./app-h12kt9pa.js";
+  OpenAIPlugin
+} from "./tool-output-znbrzr5t.js";
 import {
-  AlibabaPlugin
-} from "./app-4zzdwbaz.js";
+  VercelPlugin
+} from "./tool-output-tgbb2ckq.js";
 import {
   OpenAICompatiblePlugin
-} from "./app-mxvw03gv.js";
+} from "./tool-output-mxvw03gv.js";
 import {
-  CoherePlugin
-} from "./app-qe0d689s.js";
+  GatewayPlugin
+} from "./tool-output-smpeg8c9.js";
 import {
   GithubCopilotPlugin
-} from "./app-6vm57z3r.js";
+} from "./tool-output-y9w0a0bn.js";
+import {
+  AmazonBedrockPlugin
+} from "./tool-output-m55whf0h.js";
 import {
   NvidiaPlugin
-} from "./app-3qv8nf0b.js";
+} from "./tool-output-3qv8nf0b.js";
+import {
+  PerplexityPlugin
+} from "./tool-output-wps8gh8n.js";
 import {
   XAIPlugin
-} from "./app-mqv2bs59.js";
+} from "./tool-output-qy6z9fjv.js";
+import {
+  OllamaPlugin
+} from "./tool-output-7w2x9c6j.js";
+import {
+  OpenRouterPlugin
+} from "./tool-output-8pngjawd.js";
 
 // src/plugin/provider.ts
 var ProviderPlugins = [

package/dist/chunks/{app-ee2x677q.js → tool-output-376c84pt.js}

@@ -7,13 +7,13 @@ import {
   countPatch,
   deletePatch,
   emptyPatch
-} from "./app-vz89hfgr.js";
+} from "./tool-output-vz89hfgr.js";
 import {
   exports_location
-} from "./app-20bsrrbe.js";
+} from "./tool-output-pvjmhzxh.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/plugin/vcs/hg.ts
 var exports_hg = {};

package/dist/chunks/{app-z6wgd494.js → tool-output-3agq1wnd.js}

@@ -1,26 +1,26 @@
 import {
   exports_tool
-} from "./app-5z4zwtb4.js";
+} from "./tool-output-5z4zwtb4.js";
 import {
   definition,
   execute,
   normalizeContent
-} from "./app-drean1vx.js";
+} from "./tool-output-drean1vx.js";
 import {
   exports_image
-} from "./app-6psr7mbb.js";
+} from "./tool-output-0ape6qbg.js";
 import {
   exports_wildcard
-} from "./app-y67x6rf6.js";
+} from "./tool-output-y67x6rf6.js";
 import {
   exports_hooks
-} from "./app-v2wshkax.js";
+} from "./tool-output-v2wshkax.js";
 import {
   exports_state
-} from "./app-x89rah0x.js";
+} from "./tool-output-x89rah0x.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./tool-output-rvfvac9x.js";
 
 // src/tool.ts
 var exports_tool2 = {};
@@ -130,13 +130,36 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       errors: []
     }),
     draft: (draft) => ({
+      list: () => Array.from(draft.tools.values()),
+      get: (id) => draft.tools.get(id),
       add: (tool) => {
         const error = registrationError(tool);
         if (error) {
           draft.errors.push({ tool, error });
           return;
         }
-        draft.tools.set(effectiveName(tool), { ...tool, options: tool.options && { ...tool.options } });
+        const id = effectiveName(tool);
+        draft.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
+      },
+      update: (id, update) => {
+        const current = draft.tools.get(id);
+        if (!current)
+          return;
+        const tool = { ...current, options: current.options && { ...current.options } };
+        update(tool);
+        tool.name = current.name;
+        tool.id = id;
+        if (tool.options?.namespace !== current.options?.namespace)
+          tool.options = { ...tool.options, namespace: current.options?.namespace };
+        const error = registrationError(tool);
+        if (error) {
+          draft.errors.push({ tool, error });
+          return;
+        }
+        draft.tools.set(id, tool);
+      },
+      remove: (id) => {
+        draft.tools.delete(id);
       }
     }),
     finalize: () => Effect.forEach(state.get().errors, ({ tool, error }) => Effect.logError("Skipping invalid tool registration", {