@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-y71jz153.js → event-logger-b84bthst.js}

@@ -1,58 +1,61 @@
 import {
-  exports_tool
-} from "./schema-svrgfpe2.js";
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./event-logger-3t738kvx.js";
 import {
-  definition,
-  effectiveName,
-  execute,
-  normalizeContent,
-  normalizedName
-} from "./schema-xx9qfgev.js";
+  create2,
+  catalog2
+} from "./event-logger-6tf8tr4v.js";
 import {
-  exports_image
-} from "./schema-22x56hdn.js";
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
-  exports_wildcard
-} from "./schema-edxnhgvj.js";
+  Service55,
+  node58
+} from "./event-logger-rt2rznzy.js";
 import {
-  exports_hooks
-} from "./schema-xws7arpm.js";
+  Service74,
+  node79
+} from "./event-logger-t00n1yfv.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  match2
+} from "./event-logger-y1fvbwt7.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool.ts
-var exports_tool2 = {};
-__export(exports_tool2, {
-  CallID: () => CallID,
-  Content: () => Content,
-  Error: () => Error2,
-  FileContent: () => FileContent,
-  RegistrationError: () => RegistrationError,
-  Service: () => Service,
-  TextContent: () => TextContent,
-  Tool: () => exports_tool2,
-  node: () => node
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
+  Error: () => Error3,
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service43,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node46
 });
-import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { CallID as CallID2, Content as Content3, Error as Error3, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode-ai/schema/tool";
 import { ToolDefinition } from "@opencode-ai/ai";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-class RegistrationError extends Schema.TaggedError()("Tool.RegistrationError", {
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
   name: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Tool") {
+class Service43 extends Context.Service()("@opencode/Tool") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const hooks = yield* exports_hooks.Service;
-  const image = yield* exports_image.Service;
+var layer = Layer.effect(Service43, Effect.gen(function* () {
+  const hooks = yield* Service74;
+  const image = yield* Service55;
   const normalizeImages = Effect.fnUntraced(function* (content) {
     const normalized = yield* Effect.forEach(content, (item) => {
       if (item.type !== "file" || !item.mime.startsWith("image/"))
@@ -88,7 +91,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     input
   });
   const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
-    const execution = yield* execute(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
     const base = {
       tool: name,
       sessionID: context.sessionID,
@@ -98,13 +101,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       input
     };
     if ("failure" in execution) {
-      const afterEvent2 = {
+      const afterEvent = {
         ...base,
         status: "error",
         error: execution.failure
       };
-      yield* hooks.trigger("tool", "execute.after", afterEvent2);
-      return yield* afterEvent2.error;
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
     }
     const afterEvent = {
       ...base,
@@ -116,14 +119,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }
     };
     yield* hooks.trigger("tool", "execute.after", afterEvent);
-    const afterContent = yield* normalizeImages(normalizeContent(afterEvent.result.content, afterEvent.result.output));
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
     return {
       ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
       content: afterContent,
       ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
     };
   });
-  const state = exports_state.create({
+  const state = create3({
     name: "tool",
     initial: () => ({
       tools: new Map,
@@ -147,7 +150,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
           return;
         }
-        const id = effectiveName(tool);
+        const id = effectiveName2(tool);
         editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
       },
       update: (id, update) => {
@@ -177,7 +180,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       error: error.message
     }), { discard: true })
   });
-  return Service.of({
+  return Service43.of({
     transform: state.transform,
     reload: state.reload,
     snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
@@ -193,13 +196,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const namespaces = state.get().namespaces;
       const codeModeInventory = { tools: codeModeTools, namespaces };
       const codeModeEnabled = !whollyDisabled("execute", rules);
-      const codeModeTool = codeModeEnabled ? exports_tool.create(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
-      const codeModeCatalog = codeModeEnabled ? exports_tool.catalog(codeModeInventory) : undefined;
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
       return {
         ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
         definitions: [
-          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
-          ...codeModeTool ? [definition(codeModeTool)] : []
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
         ],
         execute: Effect.fnUntraced(function* (input) {
           const context = {
@@ -226,7 +229,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
 }));
 var whollyDisabled = (action, rules) => {
-  const rule = rules.findLast((rule2) => exports_wildcard.match(action, rule2.action));
+  const rule = rules.findLast((rule) => match2(action, rule.action));
   return rule?.resource === "*" && rule.effect === "deny";
 };
 var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
@@ -242,27 +245,27 @@ function registrationError(tool) {
     if (error)
       return error;
   }
-  const name = normalizedName(tool);
+  const name = normalizedName2(tool);
   if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
-    return new RegistrationError({ name, message: `Invalid tool name: ${name}` });
-  const id = effectiveName(tool);
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
   if (tool.options?.codemode === false && id === "execute")
-    return new RegistrationError({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
   const result = Result.try({
-    try: () => ToolDefinition.make(definition(tool)),
-    catch: (error) => new RegistrationError({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
   });
   return Result.isFailure(result) ? result.failure : undefined;
 }
 function namespaceError(name) {
   if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
     return;
-  return new RegistrationError({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
 }
-var node = makeLocationNode({
-  service: Service,
+var node46 = makeLocationNode({
+  service: Service43,
   layer,
-  deps: [exports_hooks.node, exports_image.node]
+  deps: [node79, node58]
 });
 
-export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };
+export { RegistrationError2, Service43, node46, exports_tool, CallID2, Content3, Error3, FileContent3, TextContent2 };

package/dist/chunks/event-logger-b9wsbatv.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/plugin/promise.ts
+var exports_promise = {};
+__export(exports_promise, {
+  PluginPromise: () => exports_promise,
+  fromPromise: () => fromPromise2
+});
+import { fromPromise as fromPromise2 } from "@opencode-ai/plugin/promise/adapter";
+
+export { exports_promise, fromPromise2 };

package/dist/chunks/{schema-0nhdpq2e.js → event-logger-bezsr0nz.js}

@@ -1,34 +1,39 @@
 import {
-  exports_repository
-} from "./schema-s32nnj3r.js";
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_git
-} from "./schema-qz5gwjr7.js";
+  Service77,
+  node82
+} from "./event-logger-jasnfvjs.js";
 import {
-  exports_kv
-} from "./schema-y2b04s9v.js";
+  parse4,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./event-logger-2402vzrj.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  Service64,
+  node68
+} from "./event-logger-1vjz4200.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};
 __export(exports_repository_cache, {
-  CacheOperationError: () => CacheOperationError,
-  CheckoutFailedError: () => CheckoutFailedError,
-  CloneFailedError: () => CloneFailedError,
-  FetchFailedError: () => FetchFailedError,
-  InvalidBranchError: () => InvalidBranchError,
-  LockFailedError: () => LockFailedError,
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
   RepositoryCache: () => exports_repository_cache,
-  ResetFailedError: () => ResetFailedError,
-  Service: () => Service,
-  isError: () => isError,
-  node: () => node,
-  validateBranch: () => validateBranch
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service63,
+  isError: () => isError2,
+  node: () => node67,
+  validateBranch: () => validateBranch2
 });
 import path from "path";
 import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
@@ -41,82 +46,82 @@ var Refresh = Schema.Struct({
 });
 var refreshInterval = Duration.toMillis(Duration.days(1));
 
-class InvalidBranchError extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CloneFailedError extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class FetchFailedError extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CheckoutFailedError extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
   repository: Schema.String,
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class ResetFailedError extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class LockFailedError extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
   localPath: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CacheOperationError extends Schema.TaggedError()("RepositoryCacheOperationError", {
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
   operation: Schema.String,
   path: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/RepositoryCache") {
+class Service63 extends Context.Service()("@opencode/RepositoryCache") {
 }
-function isError(error) {
-  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+function isError2(error) {
+  return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
 }
-var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
   return yield* Effect.try({
-    try: () => exports_repository.validateBranch(branch),
-    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
   });
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service63, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service77;
   const flock = yield* EffectFlock.Service;
   const global = yield* Global.Service;
-  const kv = yield* exports_kv.Service;
-  return Service.of({
+  const kv = yield* Service64;
+  return Service63.of({
     ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
       if (input.branch)
-        yield* validateBranch(input.branch);
+        yield* validateBranch2(input.branch);
       const repository = input.reference.label;
-      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
       const key = `repository-cache:${localPath}`;
-      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      const cloneTarget = parse4(input.reference.remote) ?? input.reference;
       return yield* flock.withLock(Effect.gen(function* () {
         yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
-        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const existing = yield* git.repo.discover(AbsolutePath2.make(localPath));
         const origin = existing ? yield* git.remote.get(existing) : undefined;
-        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const originReference = origin ? parse4(origin) : undefined;
         const worktree = existing ? yield* fs.resolve(localPath) : undefined;
-        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
         if (!reuse && (yield* fs.existsSafe(localPath))) {
           yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
         }
@@ -129,26 +134,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           if (status === "cloned") {
             yield* git.repo.clone({
               remote: input.reference.remote,
-              directory: AbsolutePath.make(localPath),
+              directory: AbsolutePath2.make(localPath),
               branch: input.branch
-            }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
           }
           if (status === "refreshed") {
             if (!existing)
-              return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
-            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             if (input.branch) {
-              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             }
             const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
             if (branch) {
-              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError2({ repository, branch, message: error.message })));
             }
             const target = branch ?? (yield* git.history.branch(existing));
-            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError2({ repository, message: error.message })));
           }
         }
-        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const checkout = yield* git.repo.discover(AbsolutePath2.make(localPath));
         return {
           repository,
           host: input.reference.host,
@@ -158,20 +163,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           head: checkout ? yield* git.history.head(checkout) : undefined,
           branch: checkout ? yield* git.history.branch(checkout) : undefined
         };
-      }), key).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
     })
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node67 = makeGlobalNode({
+  service: Service63,
   layer,
-  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node, exports_kv.node]
+  deps: [EffectFlock.node, FSUtil.node, node82, Global.node, node68]
 });
 function errorMessage(error) {
   return error instanceof globalThis.Error ? error.message : String(error);
 }
 function cacheOperation(effect, operation, target) {
-  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
 }
 
-export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service63, isError2, validateBranch2, node67, exports_repository_cache };

package/dist/chunks/{schema-aseryw3y.js → event-logger-bphmvjfp.js}

@@ -1,20 +1,20 @@
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-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: () => make9,
+  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 make9 = (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, make9, exports_retry };

package/dist/chunks/{schema-264e1nfp.js → event-logger-bpnz08mb.js}

@@ -1,10 +1,10 @@
 import {
-  SessionSchema
-} from "./schema-bjwj8hwv.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  AbsolutePath,
-  RelativePath
-} from "./schema-j07kk359.js";
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
 
 // src/session/info.ts
 import { DateTime, Schema } from "effect";
@@ -17,14 +17,14 @@ import { Workspace } from "@opencode-ai/schema/workspace";
 import { PersistedRevert } from "@opencode-ai/schema/session-revert";
 import { Money } from "@opencode-ai/schema/money";
 var decodeRevert = Schema.decodeUnknownSync(PersistedRevert);
-function fromRow(row) {
-  return SessionSchema.Info.make({
-    id: SessionSchema.ID.make(row.id),
+function fromRow2(row) {
+  return SessionSchema2.Info.make({
+    id: SessionSchema2.ID.make(row.id),
     projectID: Project.ID.make(row.project_id),
     title: row.title ?? undefined,
-    parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
+    parentID: row.parent_id ? SessionSchema2.ID.make(row.parent_id) : undefined,
     fork: row.fork_session_id && row.fork_boundary ? {
-      sessionID: SessionSchema.ID.make(row.fork_session_id),
+      sessionID: SessionSchema2.ID.make(row.fork_session_id),
       boundary: row.fork_boundary
     } : undefined,
     agent: row.agent ? Agent.ID.make(row.agent) : undefined,
@@ -44,10 +44,10 @@ function fromRow(row) {
       }
     },
     location: Location.Ref.make({
-      directory: AbsolutePath.make(row.directory),
+      directory: AbsolutePath2.make(row.directory),
       workspaceID: row.workspace_id ? Workspace.ID.make(row.workspace_id) : undefined
     }),
-    subpath: row.path ? RelativePath.make(row.path) : undefined,
+    subpath: row.path ? RelativePath2.make(row.path) : undefined,
     metadata: row.metadata ?? undefined,
     revert: row.revert ? decodeRevert(row.revert) : undefined,
     outcome: row.idle_outcome ?? undefined,
@@ -61,4 +61,4 @@ function fromRow(row) {
   });
 }
 
-export { fromRow };
+export { fromRow2 };

package/dist/chunks/{schema-g1j3gwgp.js → event-logger-brevw2rp.js}

@@ -1,34 +1,34 @@
 import {
-  exports_models
-} from "./schema-zr29p06e.js";
+  Service79
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_catalog
-} from "./schema-32ypdbhb.js";
+  ID11
+} from "./event-logger-rwbhhn1p.js";
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  ID10
+} from "./event-logger-ar3vq2rb.js";
 import {
-  exports_model
-} from "./schema-8manx9kj.js";
+  Event16
+} from "./event-logger-3n6w8qeh.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  ID8
+} from "./event-logger-r3nfe89y.js";
 import {
-  exports_credential
-} from "./schema-jgzett5g.js";
+  Service67
+} from "./event-logger-hdqmeh3c.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  get3
+} from "./event-logger-c9cdp0vn.js";
 
 // src/plugin/provider/modal.ts
 import { Effect, Semaphore, Stream } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var providerID = exports_provider.ID.make("modal");
-var ModalPlugin = define({
+var providerID = ID11.make("modal");
+var ModalPlugin2 = define({
   id: "opencode.provider.modal",
   effect: Effect.fn(function* (ctx) {
-    const catalog = yield* exports_catalog.Service;
-    const bus = yield* exports_bus.Service;
+    const catalog = yield* Service67;
+    const bus = yield* Service79;
     const loading = Semaphore.makeUnsafe(1);
     const loaded = {};
     const load = Effect.fn("ModalPlugin.load")(function* () {
@@ -47,7 +47,7 @@ var ModalPlugin = define({
       loaded.baseURL = baseURL;
       const existing = (yield* catalog.model.all()).filter((model) => model.providerID === providerID);
       loaded.models = yield* Effect.tryPromise({
-        try: () => exports_models.get(baseURL, apiKey, existing),
+        try: () => get3(baseURL, apiKey, existing),
         catch: (cause) => cause
       }).pipe(Effect.catch((cause) => Effect.logWarning("failed to sync Modal models", { cause }).pipe(Effect.as(undefined))));
     });
@@ -58,7 +58,7 @@ var ModalPlugin = define({
       if (!loaded.models)
         return;
       for (const id of item.models.keys()) {
-        if (!loaded.models.has(exports_model.ID.make(id)))
+        if (!loaded.models.has(ID10.make(id)))
           evt.model.remove(item.provider.id, id);
       }
       for (const [id, model] of loaded.models) {
@@ -66,9 +66,9 @@ var ModalPlugin = define({
       }
     });
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(exports_credential.Event.Switched).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("modal")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID8.make("modal")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
     yield* refresh().pipe(Effect.forkScoped);
   })
 });
 
-export { ModalPlugin };
+export { ModalPlugin2 };