@opencode-ai/core 0.0.0-beta-18600 → 0.0.0-beta-18707

package/dist/chunks/model-bym1j60d.js

@@ -0,0 +1,129 @@
+import {
+  exports_history
+} from "./model-cz5tjv9w.js";
+import {
+  fromRow
+} from "./model-264e1nfp.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./model-q606pcse.js";
+import {
+  exports_database
+} from "./model-rrbd0qbq.js";
+import {
+  __export
+} from "./model-rvfvac9x.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  node: () => node,
+  SessionStore: () => exports_store,
+  Service: () => Service,
+  ListInput: () => ListInput
+});
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, notInArray, or, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode-ai/schema/project";
+import { Workspace } from "@opencode-ai/schema/workspace";
+import { AbsolutePath, PositiveInt, RelativePath } from "@opencode-ai/schema/schema";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Session } from "@opencode-ai/schema/session";
+var ListInputBase = {
+  workspaceID: Workspace.ID.pipe(Schema.optional),
+  search: Schema.String.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
+  parentID: Schema.NullOr(Session.ID).pipe(Schema.optional),
+  anchor: Session.ListAnchor.pipe(Schema.optional)
+};
+var ListDirectoryInput = Schema.Struct({
+  ...ListInputBase,
+  directory: AbsolutePath
+});
+var ListProjectInput = Schema.Struct({
+  ...ListInputBase,
+  project: Project.ID,
+  subpath: RelativePath.pipe(Schema.optional)
+});
+var ListAllInput = Schema.Struct(ListInputBase);
+var ListInput = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
+
+class Service extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  return Service.of({
+    get: Effect.fnUntraced(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow(row) : undefined;
+    }),
+    list: Effect.fn("SessionStore.list")(function* (input = {}) {
+      const direction = input.anchor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const sortColumn = SessionTable.time_updated;
+      const conditions = [];
+      if ("directory" in input)
+        conditions.push(eq(SessionTable.directory, input.directory));
+      if (input.workspaceID)
+        conditions.push(eq(SessionTable.workspace_id, input.workspaceID));
+      if ("project" in input)
+        conditions.push(eq(SessionTable.project_id, input.project));
+      if ("project" in input && input.subpath !== undefined)
+        conditions.push(eq(SessionTable.path, input.subpath));
+      if (input.search)
+        conditions.push(like(SessionTable.title, `%${input.search}%`));
+      if (input.parentID !== undefined)
+        conditions.push(input.parentID === null ? isNull(SessionTable.parent_id) : eq(SessionTable.parent_id, input.parentID));
+      if (input.anchor) {
+        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id))));
+      }
+      const query = db.select().from(SessionTable).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row));
+    }),
+    messages: Effect.fn("SessionStore.messages")(function* (input) {
+      const direction = input.cursor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
+      if (input.cursor && !anchor)
+        return [];
+      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable.seq, anchor.seq) : lt(SessionMessageTable.seq, anchor.seq) : undefined;
+      const where = boundary ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary) : eq(SessionMessageTable.session_id, input.sessionID);
+      const query = db.select().from(SessionMessageTable).where(where).orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, exports_history.decodeMessageRow);
+    }),
+    context: Effect.fn("SessionStore.context")((sessionID) => exports_history.load(db, sessionID)),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* exports_history.decodeMessageRow(row).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable.id }).from(SessionTable).where(and(isNotNull(SessionTable.time_suspended), isNull(SessionTable.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable.time_updated}` }).where(and(eq(SessionTable.id, sessionID), isNull(SessionTable.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: Effect.fn("SessionStore.releaseChildClaims")((recoverable) => db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(and(isNotNull(SessionTable.time_suspended), isNotNull(SessionTable.parent_id), recoverable.length > 0 ? notInArray(SessionTable.id, Array.from(recoverable)) : undefined)).run().pipe(Effect.orDie, Effect.asVoid)),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable).set({
+        resume_attempts: sql`${SessionTable.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable.time_updated}`
+      }).where(eq(SessionTable.id, sessionID)).returning({ attempts: SessionTable.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ListInput, Service, node, exports_store };

package/dist/chunks/{project-2tnd1ag8.js → model-c14t2hjy.js}

@@ -1,12 +1,12 @@
 import {
   foldSettings
-} from "./project-sdcydb11.js";
+} from "./model-nbw8awg7.js";
 import {
   exports_config
-} from "./project-6kmefejb.js";
+} from "./model-qmpdqet2.js";
 import {
   exports_model
-} from "./project-r13w8t0w.js";
+} from "./model-t683wdge.js";
 
 // src/plugin/provider/lmstudio.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";

package/dist/chunks/{project-0r1p85sc.js → model-c48mcab4.js}

@@ -1,15 +1,15 @@
 import {
   exports_mcp
-} from "./project-26cqkxws.js";
+} from "./model-vcthhb3r.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/command.ts
 var exports_command = {};
@@ -249,7 +249,10 @@ var Plugin = define({
   })
 });
 function append(template, input) {
-  return [template, input.trim()].filter(Boolean).join(`
+  const value = input.trim();
+  if (template.includes("$ARGUMENTS"))
+    return template.replaceAll("$ARGUMENTS", () => value);
+  return [template, value].filter(Boolean).join(`
 
 `);
 }

package/dist/chunks/{project-c4wcb9vc.js → model-c4wcb9vc.js}

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

package/dist/chunks/model-c8fhf3ac.js

@@ -0,0 +1,353 @@
+import {
+  exports_execution
+} from "./model-wk5ccvwp.js";
+import {
+  exports_inbox
+} from "./model-kvhsphac.js";
+import {
+  exports_prompt
+} from "./model-6tpset1y.js";
+import {
+  exports_revert
+} from "./model-0r5t5x9k.js";
+import {
+  exports_supervisor_service
+} from "./model-s33fw6zm.js";
+import {
+  exports_shell
+} from "./model-6cxkhhme.js";
+import {
+  exports_result
+} from "./model-etvrgfqj.js";
+import {
+  exports_skill
+} from "./model-9w1y4hdv.js";
+import {
+  exports_store
+} from "./model-bym1j60d.js";
+import {
+  BusyError,
+  CompactionConflictError,
+  InboxConflictError,
+  MessageIncompleteError,
+  MessageNotAssistantError,
+  MessageNotFoundError,
+  MessageToolIncompleteError,
+  NotFoundError,
+  PromptConflictError,
+  SkillNotFoundError,
+  SyntheticConflictError
+} from "./model-cgqn2mrm.js";
+import {
+  SessionMessage
+} from "./model-8rpfd2h6.js";
+import {
+  SessionEvent
+} from "./model-a83yvq99.js";
+import {
+  exports_bus
+} from "./model-vwkfg4n5.js";
+import {
+  __export
+} from "./model-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";
+import { Event } from "@opencode-ai/schema/event";
+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 skill = Effect.fn("Session.skill")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const skills = yield* exports_skill.Service.pipe(Effect.provide(servicesFor(session.location)));
+    const skill2 = yield* skills.get(input.skill);
+    if (!skill2)
+      return yield* new SkillNotFoundError({ skill: input.skill });
+    yield* bus.publish(SessionEvent.Skill.Activated, {
+      sessionID,
+      id: skill2.id,
+      name: skill2.name,
+      text: skill2.content
+    }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
+    if (input.resume !== false)
+      yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+  });
+  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,
+    skill,
+    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 skill2 = operations.skill.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,
+      skill: skill2,
+      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/{project-c8ya26sa.js → model-c8ya26sa.js}

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