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

package/dist/chunks/{schema-vq0y3v9f.js → pty-kh5wzj48.js}

@@ -1,64 +1,73 @@
 import {
-  exports_location_mutation
-} from "./schema-qc2gqwkb.js";
+  typeFollowing2
+} from "./pty-2a5m3afh.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  RelativePath2
+} from "./pty-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./schema-s5c7wyma.js";
+  Service72
+} from "./pty-5aq0nxp3.js";
 import {
-  exports_ripgrep
-} from "./schema-bbwsb44a.js";
+  Service66
+} from "./pty-nry7nvbp.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  InvalidPatternError2,
+  Service19
+} from "./pty-vn9f2x03.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GrepInput2,
+  Entry2,
+  Match2
+} from "./pty-wdq8bkk0.js";
 import {
-  RelativePath
-} from "./schema-j07kk359.js";
+  externalDirectoryPermission2,
+  Service17
+} from "./pty-6jea8mds.js";
+import {
+  Service53
+} from "./pty-eqyz6y0f.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/tool/plugin/grep.ts
 var exports_grep = {};
 __export(exports_grep, {
   GrepTool: () => exports_grep,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
-  name: () => name,
-  toModelContent: () => toModelContent
+  Input: () => Input3,
+  Output: () => Output2,
+  Plugin: () => Plugin3,
+  name: () => name3,
+  toModelContent: () => toModelContent2
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import path from "path";
-var name = "grep";
-var Input = Schema.Struct({
-  pattern: exports_filesystem.GrepInput.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
+var name3 = "grep";
+var Input3 = Schema.Struct({
+  pattern: GrepInput2.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
     description: "Regular expression or literal text to match in file contents."
   }),
-  path: Schema.optionalKey(RelativePath).annotate({
+  path: Schema.optionalKey(RelativePath2).annotate({
     description: "File or directory to search. Defaults to the current working directory."
   }),
-  include: exports_filesystem.GrepInput.fields.include.annotate({
+  include: GrepInput2.fields.include.annotate({
     description: 'Glob pattern to filter files (for example, "*.js" or "*.{ts,tsx}")'
   }),
-  literal: exports_filesystem.GrepInput.fields.literal.annotate({
+  literal: GrepInput2.fields.literal.annotate({
     description: "Treat `pattern` as exact text instead of a regular expression (default: false)."
   }),
-  caseSensitive: exports_filesystem.GrepInput.fields.caseSensitive.annotate({
+  caseSensitive: GrepInput2.fields.caseSensitive.annotate({
     description: "Use case-sensitive matching (default: true)."
   }),
-  limit: exports_filesystem.GrepInput.fields.limit.annotate({
-    description: `Maximum number of matching lines to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  limit: GrepInput2.fields.limit.annotate({
+    description: `Maximum number of matching lines to return (default: ${DEFAULT_SEARCH_LIMIT2})`
   })
 });
-var Output = Schema.Array(exports_filesystem.Match);
-var toModelContent = (matches, truncated = false) => {
+var Output2 = Schema.Array(Match2);
+var toModelContent2 = (matches, truncated = false) => {
   const lines = matches.length === 0 ? ["No matches found"] : [`Found ${matches.length} matches`];
   let current = "";
   for (const match of matches) {
@@ -75,32 +84,32 @@ var toModelContent = (matches, truncated = false) => {
   return lines.join(`
 `);
 };
-var Plugin = {
+var Plugin3 = {
   id: "opencode.tool.grep",
   effect: Effect.fn("GrepTool.Plugin")(function* (ctx) {
-    const environment = yield* exports_environment.Service;
-    const ripgrep = yield* exports_ripgrep.Service;
-    const location = yield* exports_location.Service;
-    const mutation = yield* exports_location_mutation.Service;
-    const permission = yield* exports_permission.Service;
+    const environment = yield* Service66;
+    const ripgrep = yield* Service19;
+    const location = yield* Service72;
+    const mutation = yield* Service17;
+    const permission = yield* Service53;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name3,
       options: { codemode: false },
       description: "Search file contents using ripgrep's regular expression syntax or literal text matching. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
-      input: Input,
-      output: Output,
+      input: Input3,
+      output: Output2,
       execute: (input, context) => Effect.gen(function* () {
         const source = { type: "tool", messageID: context.messageID, id: context.id };
         const target = yield* mutation.resolve({ path: input.path ?? "." });
         if (target.externalDirectory)
           yield* permission.assert({
-            ...exports_location_mutation.externalDirectoryPermission(target.externalDirectory),
+            ...externalDirectoryPermission2(target.externalDirectory),
             sessionID: context.sessionID,
             agent: context.agent,
             source
           });
         yield* permission.assert({
-          action: name,
+          action: name3,
           resources: [input.pattern],
           save: ["*"],
           metadata: {
@@ -116,9 +125,9 @@ var Plugin = {
           source
         });
         const root = target.absolute;
-        const type = yield* exports_environment.typeFollowing(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
+        const type = yield* typeFollowing2(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
         const cwd = type === "directory" ? root : path.dirname(root);
-        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
         const matches = yield* ripgrep.grep({
           cwd,
           pattern: input.pattern,
@@ -128,28 +137,28 @@ var Plugin = {
           caseSensitive: input.caseSensitive,
           limit: limit + 1
         }).pipe(Effect.timeoutOrElse({
-          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
           orElse: () => Effect.fail(new ToolFailure({
-            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
           }))
-        }), Effect.map((result) => result.map((match) => exports_filesystem.Match.make({
+        }), Effect.map((result) => result.map((match) => Match2.make({
           ...match,
-          entry: exports_filesystem.Entry.make({
+          entry: Entry2.make({
             ...match.entry,
-            path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
+            path: RelativePath2.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
           })
         }))));
         return { matches: matches.slice(0, limit), truncated: matches.length > limit };
       }).pipe(Effect.map((result) => ({
         output: result.matches,
-        content: toModelContent(result.matches.map((match) => ({
+        content: toModelContent2(result.matches.map((match) => ({
           ...match,
           entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) }
         })), result.truncated),
         metadata: { matches: result.matches.length, truncated: result.truncated }
-      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof exports_ripgrep.InvalidPatternError ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof InvalidPatternError2 ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
     })).pipe(Effect.orDie);
   })
 };
 
-export { name, Input, Output, toModelContent, Plugin, exports_grep };
+export { name3, Input3, Output2, toModelContent2, Plugin3, exports_grep };

package/dist/chunks/pty-kk3rr3qh.js

@@ -0,0 +1,386 @@
+import {
+  SessionMessage2
+} from "./pty-982e01ww.js";
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/session/message-updater.ts
+var exports_message_updater = {};
+__export(exports_message_updater, {
+  SessionMessageUpdater: () => exports_message_updater,
+  update: () => update3
+});
+import { castDraft, produce } from "immer";
+import { DateTime, Effect, Match, pipe, Schema } from "effect";
+var projectTerminalSnapshot = (draft, event) => {
+  if (event.data.snapshot || event.data.files)
+    draft.snapshot = {
+      ...draft.snapshot,
+      end: event.data.snapshot,
+      files: event.data.files ? Array.from(event.data.files) : undefined
+    };
+};
+function update3(adapter, event) {
+  const created = DateTime.makeUnsafe(event.created);
+  const latestTool = (assistant, id) => assistant.content.findLast((item) => item.type === "tool" && item.id === id);
+  const latestText = (assistant) => assistant.content.findLast((item) => item.type === "text");
+  const latestReasoning = (assistant) => assistant.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
+  const updateOwnedAssistant = (messageID, recipe) => Effect.gen(function* () {
+    const assistant = yield* adapter.getAssistant(messageID);
+    if (!assistant)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, recipe));
+  });
+  const clearCurrentRetry = Effect.gen(function* () {
+    const assistant = yield* adapter.getCurrentAssistant();
+    if (!assistant?.retry)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, (draft) => {
+      draft.retry = undefined;
+    }));
+  });
+  const project = pipe(Match.type(), Match.discriminatorsExhaustive("type")({
+    "session.created": () => Effect.void,
+    "session.viewed": () => Effect.void,
+    "session.message.content.updated": (event) => updateOwnedAssistant(event.data.messageID, (draft) => {
+      draft.content = castDraft(Schema.decodeUnknownSync(Schema.Array(SessionMessage2.AssistantContent))(event.data.content));
+    }),
+    "session.usage.recorded": () => Effect.void,
+    "session.agent.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getAgent());
+      yield* adapter.appendMessage(SessionMessage2.AgentSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "agent-switched",
+        metadata: event.metadata,
+        agent: event.data.agent,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.model.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getModel());
+      yield* adapter.appendMessage(SessionMessage2.ModelSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "model-switched",
+        metadata: event.metadata,
+        model: event.data.model,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.moved": (event) => Effect.gen(function* () {
+      yield* adapter.appendMessage(SessionMessage2.LocationSwitched.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "location-switched",
+        metadata: event.metadata,
+        location: event.data.location,
+        projectID: event.data.projectID,
+        subpath: event.data.subpath,
+        previous: yield* adapter.getLocation(),
+        time: { created }
+      }));
+    }),
+    "session.renamed": () => Effect.void,
+    "session.deleted": () => Effect.void,
+    "session.forked": () => Effect.void,
+    "session.inbox.delivered": () => Effect.void,
+    "session.inbox.enqueued": () => Effect.void,
+    "session.inbox.cancelled": () => Effect.void,
+    "session.inbox.delivery.changed": () => Effect.void,
+    "session.execution.started": () => Effect.void,
+    "session.execution.succeeded": () => clearCurrentRetry,
+    "session.execution.failed": () => clearCurrentRetry,
+    "session.execution.interrupted": () => clearCurrentRetry,
+    "session.instructions.updated": (event) => {
+      if (event.data.text === undefined)
+        return Effect.void;
+      return adapter.appendMessage(SessionMessage2.System.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "system",
+        text: event.data.text,
+        description: `Instructions updated: ${Object.keys(event.data.delta).join(", ")}`,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.synthetic": (event) => {
+      return adapter.appendMessage(SessionMessage2.Synthetic.make({
+        text: event.data.text,
+        description: event.data.description,
+        metadata: event.data.metadata,
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "synthetic",
+        time: { created }
+      }));
+    },
+    "session.skill.activated": (event) => {
+      return adapter.appendMessage(SessionMessage2.Skill.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "skill",
+        skill: event.data.id,
+        name: event.data.name,
+        text: event.data.text,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.shell.started": (event) => {
+      return adapter.appendMessage(SessionMessage2.Shell.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "shell",
+        metadata: event.data.shell.metadata.background === true ? { ...event.metadata, background: true } : event.metadata,
+        shellID: event.data.shell.id,
+        command: event.data.shell.command,
+        status: event.data.shell.status,
+        time: { created }
+      }));
+    },
+    "session.shell.ended": (event) => Effect.gen(function* () {
+      const currentShell = yield* adapter.getShell(event.data.shell.id);
+      if (currentShell) {
+        yield* adapter.updateShell(produce(currentShell, (draft) => {
+          draft.status = event.data.shell.status;
+          draft.exit = event.data.shell.exit;
+          draft.output = event.data.output;
+          draft.time.completed = created;
+        }));
+      }
+    }),
+    "session.step.started": (event) => Effect.gen(function* () {
+      const existing = yield* adapter.getAssistant(event.data.assistantMessageID);
+      if (existing) {
+        yield* adapter.updateAssistant(produce(existing, (draft) => {
+          draft.agent = event.data.agent;
+          draft.model = castDraft(event.data.model);
+          draft.retry = undefined;
+          draft.error = undefined;
+          draft.finish = undefined;
+          draft.rawFinish = undefined;
+          draft.providerState = undefined;
+          draft.time.streamed = undefined;
+          draft.time.completed = undefined;
+          if (event.data.snapshot)
+            draft.snapshot = { ...draft.snapshot, start: event.data.snapshot };
+        }));
+        return;
+      }
+      const currentAssistant = yield* adapter.getCurrentAssistant();
+      if (currentAssistant) {
+        yield* adapter.updateAssistant(produce(currentAssistant, (draft) => {
+          draft.retry = undefined;
+          draft.time.completed = created;
+        }));
+      }
+      yield* adapter.appendMessage(SessionMessage2.Assistant.make({
+        id: event.data.assistantMessageID,
+        type: "assistant",
+        agent: event.data.agent,
+        model: event.data.model,
+        metadata: event.metadata,
+        time: { created },
+        content: [],
+        snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined
+      }));
+    }),
+    "session.step.streamed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.streamed = created;
+      });
+    },
+    "session.step.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish;
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.cost = event.data.cost;
+        draft.tokens = event.data.tokens;
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.step.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish ?? "error";
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.error = castDraft(event.data.error);
+        draft.retry = undefined;
+        if (event.data.cost !== undefined && event.data.tokens !== undefined) {
+          draft.cost = event.data.cost;
+          draft.tokens = castDraft(event.data.tokens);
+        }
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.text.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantText.make({ type: "text", text: "" })));
+      });
+    },
+    "session.text.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestText(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.state = castDraft(event.data.state);
+        }
+      });
+    },
+    "session.tool.input.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantTool.make({
+          type: "tool",
+          id: event.data.id,
+          name: event.data.name,
+          time: { created },
+          state: SessionMessage2.ToolStateStreaming.make({ status: "streaming", input: "" })
+        })));
+      });
+    },
+    "session.tool.input.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "streaming")
+          match.state.input = event.data.text;
+      });
+    },
+    "session.tool.called": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match) {
+          match.executed = event.data.executed;
+          match.providerState = event.data.state;
+          match.time.ran = created;
+          match.state = castDraft(SessionMessage2.ToolStateRunning.make({
+            status: "running",
+            input: event.data.input,
+            metadata: {}
+          }));
+        }
+      });
+    },
+    "session.tool.success": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "running") {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateCompleted.make({
+            status: "completed",
+            input: match.state.input,
+            content: event.data.content,
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.tool.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && (match.state.status === "streaming" || match.state.status === "running")) {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateError.make({
+            status: "error",
+            error: event.data.error,
+            input: typeof match.state.input === "string" ? {} : match.state.input,
+            ...event.data.content === undefined ? {} : { content: event.data.content },
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.reasoning.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantReasoning.make({
+          type: "reasoning",
+          text: "",
+          state: event.data.state,
+          time: { created }
+        })));
+      });
+    },
+    "session.reasoning.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestReasoning(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.time = { created: match.time?.created ?? created, completed: created };
+          if (event.data.state !== undefined)
+            match.state = event.data.state;
+        }
+      });
+    },
+    "session.retry.scheduled": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.retry = {
+          attempt: event.data.attempt,
+          at: DateTime.makeUnsafe(event.data.at),
+          error: castDraft(event.data.error)
+        };
+      });
+    },
+    "session.compaction.started": (event) => adapter.appendMessage(SessionMessage2.CompactionRunning.make({
+      id: event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+      type: "compaction",
+      status: "running",
+      metadata: event.metadata,
+      reason: event.data.reason,
+      summary: "",
+      recent: event.data.recent ?? "",
+      time: { created }
+    })),
+    "session.compaction.ended": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      if (current?.status === "running") {
+        yield* adapter.updateCompaction({
+          ...current,
+          status: "completed",
+          reason: event.data.reason,
+          model: event.data.model,
+          providerState: event.data.providerState,
+          summary: event.data.text,
+          recent: event.data.recent
+        });
+        return;
+      }
+      yield* adapter.appendMessage(SessionMessage2.Compaction.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "completed",
+        metadata: event.metadata,
+        reason: event.data.reason,
+        model: event.data.model,
+        providerState: event.data.providerState,
+        summary: event.data.text,
+        recent: event.data.recent,
+        time: { created }
+      }));
+    }),
+    "session.compaction.failed": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      const failed = SessionMessage2.CompactionFailed.make({
+        id: current?.id ?? event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "failed",
+        metadata: current?.metadata ?? event.metadata,
+        reason: event.data.reason,
+        error: event.data.error,
+        time: current?.time ?? { created }
+      });
+      if (current?.status === "running")
+        return yield* adapter.updateCompaction(failed);
+      yield* adapter.appendMessage(failed);
+    }),
+    "session.revert.staged": () => Effect.void,
+    "session.revert.cleared": () => Effect.void,
+    "session.revert.committed": () => Effect.void
+  }));
+  return project(event);
+}
+
+export { update3, exports_message_updater };

package/dist/chunks/pty-ktgp4y5h.js

@@ -0,0 +1,87 @@
+import {
+  SessionMessage2
+} from "./pty-982e01ww.js";
+import {
+  SessionSchema2
+} from "./pty-jysfrgga.js";
+import {
+  MessageDecodeError2
+} from "./pty-3wx44s71.js";
+import {
+  InitializationBlocked2,
+  read3
+} from "./pty-6e958v7x.js";
+import {
+  SessionMessageTable2
+} from "./pty-g2dy4bvs.js";
+import {
+  initial2,
+  preview3
+} from "./pty-x5hde6ee.js";
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  SessionHistory: () => exports_history,
+  decodeMessageRow: () => decodeMessageRow2,
+  entriesForRunner: () => entriesForRunner2,
+  firstUserMessage: () => firstUserMessage2,
+  latestCompaction: () => latestCompaction2,
+  load: () => load3,
+  preview: () => preview2
+});
+import { and, asc, desc, eq, gte, sql } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var decode = Schema.decodeUnknownEffect(SessionMessage2.Info);
+var latestCompaction2 = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "compaction"), sql`json_extract(${SessionMessageTable2.data}, '$.status') = 'completed'`)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+});
+var decodeMessageRow2 = (row) => decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.mapError(() => new MessageDecodeError2({
+  sessionID: SessionSchema2.ID.make(row.session_id),
+  messageID: SessionMessage2.ID.make(row.id)
+})));
+var messageEntries = Effect.fnUntraced(function* (db, sessionID) {
+  const compaction = yield* latestCompaction2(db, sessionID);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), compaction ? gte(SessionMessageTable2.seq, compaction.seq) : undefined)).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  return yield* Effect.forEach(rows, (row) => decodeMessageRow2(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))));
+});
+var load3 = Effect.fn("SessionHistory.load")(function* (db, sessionID) {
+  return (yield* messageEntries(db, sessionID)).map((entry) => entry.message);
+});
+var entriesForRunner2 = Effect.fn("SessionHistory.entriesForRunner")(function* (db, sessionID, instructions) {
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    return {
+      initial: yield* initial2(db, sessionID, instructions),
+      entries: messages
+    };
+  })).pipe(Effect.orDie);
+});
+var preview2 = Effect.fn("SessionHistory.preview")(function* (db, sessionID, instructions) {
+  const observed = yield* read3(instructions);
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    const unsettled = messages.findIndex((entry) => entry.message.type === "assistant" && entry.message.time.completed === undefined);
+    const settled = unsettled === -1 ? messages : messages.slice(0, unsettled);
+    const assembled = yield* preview3(db, sessionID, instructions, observed);
+    return {
+      initial: assembled.initial,
+      messages: settled.map((entry) => entry.message),
+      instructionUpdate: assembled.update
+    };
+  })).pipe(Effect.catch((error) => error instanceof InitializationBlocked2 ? error : Effect.die(error)));
+});
+var firstUserMessage2 = Effect.fn("SessionHistory.firstUserMessage")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "user"))).orderBy(asc(SessionMessageTable2.seq)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const message = yield* decodeMessageRow2(row).pipe(Effect.orElseSucceed(() => {
+    return;
+  }));
+  return message?.type === "user" ? message : undefined;
+});
+
+export { latestCompaction2, decodeMessageRow2, load3, entriesForRunner2, preview2, firstUserMessage2, exports_history };