@opencode-ai/core 0.0.0-dev-18673 → 0.0.0-dev-18680

package/dist/chunks/session-aryk6wfr.js

@@ -0,0 +1,330 @@
+import {
+  exports_revert
+} from "./session-2n1fvc6p.js";
+import {
+  exports_execution
+} from "./session-v8p5rtbh.js";
+import {
+  exports_inbox
+} from "./session-6vrp5bxn.js";
+import {
+  exports_prompt
+} from "./session-7j0rtb14.js";
+import {
+  exports_supervisor_service
+} from "./session-s33fw6zm.js";
+import {
+  exports_shell
+} from "./session-ck18qftx.js";
+import {
+  exports_result
+} from "./session-etvrgfqj.js";
+import {
+  exports_store
+} from "./session-hxy5ag1m.js";
+import {
+  BusyError,
+  CompactionConflictError,
+  InboxConflictError,
+  MessageIncompleteError,
+  MessageNotAssistantError,
+  MessageNotFoundError,
+  MessageToolIncompleteError,
+  NotFoundError,
+  PromptConflictError,
+  SyntheticConflictError
+} from "./session-cgqn2mrm.js";
+import {
+  SessionEvent
+} from "./session-a83yvq99.js";
+import {
+  SessionMessage
+} from "./session-8rpfd2h6.js";
+import {
+  exports_bus
+} from "./session-21dv21pt.js";
+import {
+  __export
+} from "./session-rvfvac9x.js";
+
+// src/session/session.ts
+var exports_session = {};
+__export(exports_session, {
+  make: () => make,
+  Session: () => exports_session
+});
+import { DateTime, Effect, Fiber, Schema, Scope } from "effect";
+var make = Effect.fn("Session.make")(function* (servicesFor) {
+  const bus = yield* exports_bus.Service;
+  const store = yield* exports_store.Service;
+  const execution = yield* exports_execution.Service;
+  const admission = yield* exports_inbox.Service;
+  const scope = yield* Scope.Scope;
+  const get = Effect.fn("Session.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError({ sessionID });
+    return session;
+  });
+  const message = Effect.fn("Session.message")(function* (sessionID, messageID) {
+    const stored = yield* store.message(messageID);
+    return stored?.sessionID === sessionID ? stored.message : undefined;
+  });
+  const updateMessage = Effect.fn("Session.updateMessage")(function* (sessionID, input) {
+    const ref = { sessionID, messageID: input.messageID };
+    yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError({ sessionID });
+    const current = yield* message(sessionID, input.messageID);
+    if (!current)
+      return yield* new MessageNotFoundError(ref);
+    if (current.type !== "assistant")
+      return yield* new MessageNotAssistantError(ref);
+    if (!current.time.completed)
+      return yield* new MessageIncompleteError(ref);
+    if (input.content.some(isUnfinishedTool))
+      return yield* new MessageToolIncompleteError(ref);
+    yield* bus.publish(SessionEvent.MessageContentUpdated, {
+      ...ref,
+      content: Schema.encodeSync(Schema.Array(SessionMessage.AssistantContent))(input.content)
+    });
+    const updated = yield* message(sessionID, input.messageID);
+    if (updated?.type !== "assistant")
+      return yield* new MessageNotFoundError(ref);
+    return updated;
+  });
+  const view = Effect.fn("Session.view")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.time.idle === undefined || input.idle > DateTime.toEpochMillis(session.time.idle) || session.time.viewed !== undefined && DateTime.toEpochMillis(session.time.viewed) >= input.idle)
+      return;
+    yield* bus.publish(SessionEvent.Viewed, { sessionID, idle: input.idle });
+  });
+  const rename = Effect.fn("Session.rename")(function* (sessionID, input) {
+    yield* get(sessionID);
+    yield* bus.publish(SessionEvent.Renamed, { sessionID, title: input.title });
+  });
+  const switchAgent = Effect.fn("Session.switchAgent")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    yield* bus.publish(SessionEvent.AgentSelected, { sessionID, agent: input.agent, previous: session.agent });
+  });
+  const switchModel = Effect.fn("Session.switchModel")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.model?.providerID === input.model.providerID && session.model.id === input.model.id && (session.model.variant ?? "default") === (input.model.variant ?? "default"))
+      return;
+    yield* bus.publish(SessionEvent.ModelSelected, { sessionID, model: input.model, previous: session.model });
+  });
+  const mutatePending = (sessionID, inboxID, mutation) => mutation({ sessionID, id: inboxID }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => Effect.gen(function* () {
+    yield* get(sessionID);
+    return yield* new InboxConflictError({ sessionID, inboxID });
+  })));
+  const inbox = Effect.fn("Session.inbox")(function* (sessionID) {
+    yield* get(sessionID);
+    return yield* admission.list(sessionID);
+  });
+  const cancelInbox = Effect.fn("Session.cancelInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.cancel), Effect.uninterruptible);
+  const steerInbox = Effect.fn("Session.steerInbox")(function* (sessionID, inboxID) {
+    yield* mutatePending(sessionID, inboxID, admission.steer);
+    yield* execution.wake(sessionID);
+  }, Effect.uninterruptible);
+  const queueInbox = Effect.fn("Session.queueInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.queue), Effect.uninterruptible);
+  const prompt = Effect.fn("Session.prompt")((sessionID, input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const session = yield* get(sessionID);
+    const messageID = input.id ?? SessionMessage.ID.create();
+    const admitted = yield* Effect.gen(function* () {
+      const existing = yield* admission.reconcile({
+        id: messageID,
+        sessionID: session.id,
+        type: "user",
+        delivery: input.delivery ?? "steer"
+      });
+      if (existing)
+        return existing;
+      const item = yield* restore(exports_prompt.Service.use((preparation) => preparation.prepare({ sessionID, messageID, input })).pipe(Effect.provide(servicesFor(session.location))));
+      if (session.revert)
+        yield* exports_revert.commit(bus, session);
+      return yield* admission.admit({
+        id: messageID,
+        sessionID: session.id,
+        item
+      });
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError({ sessionID, messageID })));
+    if (input.resume !== false)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const shell = Effect.fn("Session.shell")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const running = yield* Effect.gen(function* () {
+      const shell2 = yield* Effect.gen(function* () {
+        const plugins = yield* exports_supervisor_service.Service;
+        yield* plugins.flush;
+        return yield* exports_shell.Service;
+      }).pipe(Effect.provide(servicesFor(session.location)));
+      const started = yield* shell2.create({
+        command: input.command,
+        cwd: session.location.directory,
+        timeout: 0,
+        metadata: { sessionID, background: true }
+      }).pipe(Effect.tapError((error) => synthetic(sessionID, {
+        text: `User shell command failed to start:
+${input.command}
+
+${error.message}`,
+        description: input.command,
+        metadata: { source: "shell", state: "error" },
+        resume: false
+      })), Effect.orDie);
+      yield* bus.publish(SessionEvent.Shell.Started, {
+        sessionID,
+        shell: started
+      }, { id: input.id });
+      const terminal = yield* shell2.result(started);
+      const preview = yield* shell2.output(started.id, { limit: SHELL_MAX_CAPTURE_BYTES }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(exports_result.unavailable)));
+      yield* bus.publish(SessionEvent.Shell.Ended, {
+        sessionID,
+        shell: terminal.info,
+        output: preview
+      });
+      yield* synthetic(sessionID, {
+        ...exports_result.userNotification(terminal),
+        resume: false
+      }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.void), Effect.orDie);
+    }).pipe(Effect.forkIn(scope, { startImmediately: true }));
+    yield* Fiber.join(running);
+  });
+  const compact = Effect.fn("Session.compact")(function* (sessionID, input) {
+    yield* get(sessionID);
+    const inputID = input.id ?? SessionMessage.ID.create();
+    const admitted = yield* admission.admitCompaction({
+      id: inputID,
+      sessionID,
+      delivery: input.delivery ?? "steer"
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new CompactionConflictError({ sessionID, inputID })));
+    yield* execution.wake(sessionID);
+    return admitted;
+  });
+  const wait = Effect.fn("Session.wait")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.awaitIdle(sessionID);
+  });
+  const resume = Effect.fn("Session.resume")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.resume(sessionID);
+  });
+  const synthetic = Effect.fn("Session.synthetic")((sessionID, input) => Effect.uninterruptible(Effect.gen(function* () {
+    yield* get(sessionID);
+    const inputID = input.id ?? SessionMessage.ID.create();
+    const admittedInput = {
+      type: "synthetic",
+      payload: exports_inbox.SyntheticPayload.make({
+        text: input.text,
+        description: input.description,
+        metadata: input.metadata
+      }),
+      delivery: exports_inbox.Delivery.make(input.delivery ?? "steer")
+    };
+    const admitted = yield* admission.admit({
+      id: inputID,
+      sessionID,
+      item: admittedInput
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new SyntheticConflictError({ sessionID, inputID })));
+    if (input.resume !== false && !(yield* get(sessionID)).revert)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const interrupt = Effect.fn("Session.interrupt")((sessionID, options) => Effect.uninterruptible(execution.interrupt(sessionID, options)));
+  const stage = Effect.fn("Session.revert.stage")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError({ sessionID });
+    return yield* exports_revert.Service.use((revert2) => revert2.stage({ session, messageID: input.messageID, files: input.files })).pipe(Effect.provide(servicesFor(session.location)));
+  });
+  const clear = Effect.fn("Session.revert.clear")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError({ sessionID });
+    yield* exports_revert.Service.use((revert2) => revert2.clear(session)).pipe(Effect.provide(servicesFor(session.location)));
+    return yield* execution.wake(sessionID);
+  });
+  const commit = Effect.fn("Session.revert.commit")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError({ sessionID });
+    return yield* exports_revert.commit(bus, session);
+  });
+  const revert = { stage, clear, commit };
+  const operations = {
+    get,
+    message,
+    updateMessage,
+    view,
+    rename,
+    switchAgent,
+    switchModel,
+    inbox,
+    prompt,
+    synthetic,
+    shell,
+    compact,
+    wait,
+    resume,
+    interrupt,
+    cancelInbox,
+    steerInbox,
+    queueInbox,
+    revert
+  };
+  const forSession = (sessionID) => {
+    const get2 = operations.get.bind(undefined, sessionID);
+    const message2 = operations.message.bind(undefined, sessionID);
+    const updateMessage2 = operations.updateMessage.bind(undefined, sessionID);
+    const view2 = operations.view.bind(undefined, sessionID);
+    const rename2 = operations.rename.bind(undefined, sessionID);
+    const switchAgent2 = operations.switchAgent.bind(undefined, sessionID);
+    const switchModel2 = operations.switchModel.bind(undefined, sessionID);
+    const inbox2 = operations.inbox.bind(undefined, sessionID);
+    const prompt2 = operations.prompt.bind(undefined, sessionID);
+    const synthetic2 = operations.synthetic.bind(undefined, sessionID);
+    const shell2 = operations.shell.bind(undefined, sessionID);
+    const compact2 = operations.compact.bind(undefined, sessionID);
+    const wait2 = operations.wait.bind(undefined, sessionID);
+    const resume2 = operations.resume.bind(undefined, sessionID);
+    const interrupt2 = operations.interrupt.bind(undefined, sessionID);
+    const cancelInbox2 = operations.cancelInbox.bind(undefined, sessionID);
+    const steerInbox2 = operations.steerInbox.bind(undefined, sessionID);
+    const queueInbox2 = operations.queueInbox.bind(undefined, sessionID);
+    const stage2 = operations.revert.stage.bind(undefined, sessionID);
+    const clear2 = operations.revert.clear.bind(undefined, sessionID);
+    const commit2 = operations.revert.commit.bind(undefined, sessionID);
+    const revert2 = { stage: stage2, clear: clear2, commit: commit2 };
+    return {
+      id: sessionID,
+      get: get2,
+      message: message2,
+      updateMessage: updateMessage2,
+      view: view2,
+      rename: rename2,
+      switchAgent: switchAgent2,
+      switchModel: switchModel2,
+      inbox: inbox2,
+      prompt: prompt2,
+      synthetic: synthetic2,
+      shell: shell2,
+      compact: compact2,
+      wait: wait2,
+      resume: resume2,
+      interrupt: interrupt2,
+      cancelInbox: cancelInbox2,
+      steerInbox: steerInbox2,
+      queueInbox: queueInbox2,
+      revert: revert2
+    };
+  };
+  return { forSession };
+});
+function isUnfinishedTool(content) {
+  return content.type === "tool" && (content.state.status === "streaming" || content.state.status === "running");
+}
+var SHELL_MAX_CAPTURE_BYTES = 1024 * 1024;
+
+export { make, exports_session };

package/dist/chunks/{job-awg5d31a.js → session-awg5d31a.js}

@@ -1,6 +1,6 @@
 import {
   exports_provider
-} from "./job-krsqcmnj.js";
+} from "./session-krsqcmnj.js";
 
 // src/plugin/provider/zenmux.ts
 import { Effect } from "effect";

package/dist/chunks/{job-52hchg7s.js → session-azvs72ad.js}

@@ -1,15 +1,15 @@
 import {
   makeDaemonTransport
-} from "./job-9maxscqf.js";
+} from "./session-9maxscqf.js";
 import {
   exports_select
-} from "./job-bbhffenw.js";
+} from "./session-bbhffenw.js";
 import {
   exports_bus
-} from "./job-j925pnyr.js";
+} from "./session-21dv21pt.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/persistent-pty/index.ts
 var exports_persistent_pty = {};

package/dist/chunks/{job-69r90z8c.js → session-b8cqhxsc.js}

@@ -1,15 +1,15 @@
 import {
   exports_entry_observer
-} from "./job-kp1t5rcy.js";
+} from "./session-kp1t5rcy.js";
 import {
   exports_config
-} from "./job-gg11cpea.js";
+} from "./session-z40wwesm.js";
 import {
   exports_provider
-} from "./job-krsqcmnj.js";
+} from "./session-krsqcmnj.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/config/plugin/provider.ts
 var exports_provider2 = {};

package/dist/chunks/{job-bbhffenw.js → session-bbhffenw.js}

@@ -1,12 +1,12 @@
 import {
   which
-} from "./job-k3e42drn.js";
+} from "./session-k3e42drn.js";
 import {
   exports_state
-} from "./job-x89rah0x.js";
+} from "./session-x89rah0x.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/shell/select.ts
 var exports_select = {};

package/dist/chunks/{job-bh1wr8rq.js → session-bh1wr8rq.js}

@@ -1,9 +1,9 @@
 import {
   exports_app
-} from "./job-50jxp3hw.js";
+} from "./session-50jxp3hw.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/plugin/websearch/tavily.ts
 var exports_tavily = {};

package/dist/chunks/{job-x7r2g85h.js → session-bk73cw3p.js}

@@ -1,27 +1,27 @@
-import {
-  exports_token
-} from "./job-v972xay6.js";
 import {
   exports_usage
-} from "./job-sw84ckhj.js";
+} from "./session-sw84ckhj.js";
+import {
+  exports_token
+} from "./session-v972xay6.js";
 import {
   toSessionError
-} from "./job-n2c9k96k.js";
+} from "./session-5h7by0wv.js";
 import {
   llmClient
-} from "./job-393a352g.js";
+} from "./session-393a352g.js";
 import {
   SessionEvent
-} from "./job-a83yvq99.js";
-import {
-  exports_bus
-} from "./job-j925pnyr.js";
+} from "./session-a83yvq99.js";
 import {
   exports_state
-} from "./job-x89rah0x.js";
+} from "./session-x89rah0x.js";
+import {
+  exports_bus
+} from "./session-21dv21pt.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/session/compaction.ts
 var exports_compaction = {};

package/dist/chunks/{job-s7azyhqy.js → session-bphfm9wc.js}

@@ -1,18 +1,18 @@
 import {
   exports_config
-} from "./job-gg11cpea.js";
+} from "./session-z40wwesm.js";
 import {
   exports_watcher
-} from "./job-ns0sdez7.js";
+} from "./session-ns0sdez7.js";
 import {
   exports_location
-} from "./job-knm8yv8d.js";
+} from "./session-gsq62xr5.js";
 import {
   exports_source_directory
-} from "./job-6272rtjg.js";
+} from "./session-6272rtjg.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/config/plugin/source.ts
 var exports_source = {};

package/dist/chunks/{job-byab506k.js → session-byab506k.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/database/v1-migration.ts
 var exports_v1_migration = {};

package/dist/chunks/{job-c4wcb9vc.js → session-c4wcb9vc.js}

@@ -1,9 +1,9 @@
 import {
   collectBoundedResponseBody
-} from "./job-jve7t217.js";
+} from "./session-jve7t217.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./session-rvfvac9x.js";
 
 // src/plugin/websearch/mcp.ts
 var exports_mcp = {};

package/dist/chunks/{job-yd18a1xb.js → session-c5588xfk.js}

@@ -1,21 +1,21 @@
 import {
   openaiCompatibleProviderOptions
-} from "./job-a02svayp.js";
+} from "./session-a02svayp.js";
 import {
   convertToOpenAICompatibleChatMessages
-} from "./job-brsh5f65.js";
-import {
-  defaultOpenAICompatibleErrorStructure
-} from "./job-1wcz8fvj.js";
+} from "./session-brsh5f65.js";
 import {
   getResponseMetadata
-} from "./job-bbqs2y60.js";
+} from "./session-bbqs2y60.js";
 import {
   prepareTools
-} from "./job-ezs3tagn.js";
+} from "./session-ezs3tagn.js";
 import {
   mapOpenAICompatibleFinishReason
-} from "./job-0cgt0xh2.js";
+} from "./session-0cgt0xh2.js";
+import {
+  defaultOpenAICompatibleErrorStructure
+} from "./session-1wcz8fvj.js";
 
 // src/github-copilot/chat/openai-compatible-chat-language-model.ts
 import {

package/dist/chunks/{job-c8ya26sa.js → session-c8ya26sa.js}

@@ -1,10 +1,10 @@
 import {
   absoluteArrayColumn,
   absoluteColumn
-} from "./job-zbqqnp0n.js";
+} from "./session-zbqqnp0n.js";
 import {
   Timestamps
-} from "./job-sem2g21k.js";
+} from "./session-sem2g21k.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/session-cgqn2mrm.js

@@ -0,0 +1,147 @@
+import {
+  SessionMessage
+} from "./session-8rpfd2h6.js";
+import {
+  SessionSchema
+} from "./session-bjwj8hwv.js";
+import {
+  __export
+} from "./session-rvfvac9x.js";
+
+// src/session/error.ts
+var exports_error = {};
+__export(exports_error, {
+  UserInterruptedError: () => UserInterruptedError,
+  SyntheticConflictError: () => SyntheticConflictError,
+  StepFailedError: () => StepFailedError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionErrors: () => exports_error,
+  PromptConflictError: () => PromptConflictError,
+  NotFoundError: () => NotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageDecodeError: () => MessageDecodeError,
+  InboxConflictError: () => InboxConflictError,
+  ForkEmptyError: () => ForkEmptyError,
+  CompactionConflictError: () => CompactionConflictError,
+  BusyError: () => BusyError,
+  AttachmentError: () => AttachmentError,
+  AgentNotFoundError: () => AgentNotFoundError
+});
+import { Schema } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Skill } from "@opencode-ai/schema/skill";
+import { SessionError } from "@opencode-ai/schema/session-error";
+
+class NotFoundError extends Schema.TaggedError()("Session.NotFoundError", {
+  sessionID: SessionSchema.ID
+}) {
+}
+
+class MessageNotFoundError extends Schema.TaggedError()("Session.MessageNotFoundError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageNotAssistantError extends Schema.TaggedError()("Session.MessageNotAssistantError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageIncompleteError extends Schema.TaggedError()("Session.MessageIncompleteError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageToolIncompleteError extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class ForkEmptyError extends Schema.TaggedError()("Session.ForkEmptyError", {
+  sessionID: SessionSchema.ID
+}) {
+  get message() {
+    return `Cannot fork empty session: ${this.sessionID}`;
+  }
+}
+
+class MessageDecodeError extends Schema.TaggedError()("Session.MessageDecodeError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+  get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`;
+  }
+}
+
+class AgentNotFoundError extends Schema.TaggedError()("Session.AgentNotFoundError", {
+  sessionID: SessionSchema.ID,
+  agent: Agent.ID
+}) {
+  get message() {
+    return `Agent not found: "${this.agent}"`;
+  }
+}
+
+class StepFailedError extends Schema.TaggedError()("Session.StepFailedError", {
+  error: SessionError.Error
+}) {
+  get message() {
+    return this.error.message;
+  }
+}
+
+class UserInterruptedError extends Schema.TaggedError()("Session.UserInterruptedError", {}) {
+  get message() {
+    return "Session interrupted by user";
+  }
+}
+
+class PromptConflictError extends Schema.TaggedError()("Session.PromptConflictError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class SyntheticConflictError extends Schema.TaggedError()("Session.SyntheticConflictError", {
+  sessionID: SessionSchema.ID,
+  inputID: SessionMessage.ID
+}) {
+}
+
+class AttachmentError extends Schema.TaggedError()("Session.AttachmentError", {
+  uri: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CompactionConflictError extends Schema.TaggedError()("Session.CompactionConflictError", {
+  sessionID: SessionSchema.ID,
+  inputID: SessionMessage.ID
+}) {
+}
+
+class BusyError extends Schema.TaggedError()("Session.BusyError", {
+  sessionID: SessionSchema.ID
+}) {
+}
+
+class InboxConflictError extends Schema.TaggedError()("Session.InboxConflictError", {
+  sessionID: SessionSchema.ID,
+  inboxID: SessionMessage.ID
+}) {
+}
+
+class SkillNotFoundError extends Schema.TaggedError()("Session.SkillNotFoundError", {
+  skill: Skill.ID
+}) {
+}
+
+export { NotFoundError, MessageNotFoundError, MessageNotAssistantError, MessageIncompleteError, MessageToolIncompleteError, ForkEmptyError, MessageDecodeError, AgentNotFoundError, StepFailedError, UserInterruptedError, PromptConflictError, SyntheticConflictError, AttachmentError, CompactionConflictError, BusyError, InboxConflictError, SkillNotFoundError, exports_error };