@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-72z7vvq3.js → kv-1j6eeha2.js}

@@ -1,57 +1,62 @@
 import {
-  exports_websearch
-} from "./instance-k9d5hcgq.js";
+  Service78
+} from "./kv-jnv71sbj.js";
 import {
-  exports_form
-} from "./instance-b3ba60js.js";
+  Service53
+} from "./kv-nsdz1sxb.js";
 import {
-  exports_permission
-} from "./instance-enjmckgs.js";
+  ID3,
+  Result2,
+  ProviderRequiredError2,
+  DisabledError2,
+  RequestError2,
+  Service18
+} from "./kv-n08wtfc0.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/tool/plugin/websearch.ts
-var exports_websearch2 = {};
-__export(exports_websearch2, {
-  Input: () => Input,
-  NO_RESULTS: () => NO_RESULTS,
-  Plugin: () => Plugin,
-  WebSearchTool: () => exports_websearch2,
-  description: () => description,
-  name: () => name
+var exports_websearch = {};
+__export(exports_websearch, {
+  Input: () => Input4,
+  NO_RESULTS: () => NO_RESULTS2,
+  Plugin: () => Plugin4,
+  WebSearchTool: () => exports_websearch,
+  description: () => description3,
+  name: () => name4
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema, Semaphore } from "effect";
 import { HttpClientError } from "effect/unstable/http";
-var name = "websearch";
-var NO_RESULTS = "No search results found. Please try a different query.";
+var name4 = "websearch";
+var NO_RESULTS2 = "No search results found. Please try a different query.";
 var providerSelectionLock = Semaphore.makeUnsafe(1);
-var description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+var description3 = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
 
 The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`;
-var Input = Schema.Struct({
+var Input4 = Schema.Struct({
   query: Schema.String.annotate({ description: "Websearch query" })
 });
 var Output = Schema.Struct({
-  provider: exports_websearch.ID,
-  results: Schema.Array(exports_websearch.Result)
+  provider: ID3,
+  results: Schema.Array(Result2)
 });
-var Plugin = {
+var Plugin4 = {
   id: "opencode.tool.websearch",
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
-    const permission = yield* exports_permission.Service;
-    const forms = yield* exports_form.Service;
-    const websearch = yield* exports_websearch.Service;
+    const permission = yield* Service53;
+    const forms = yield* Service78;
+    const websearch = yield* Service18;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name4,
       options: { codemode: false },
-      description,
-      input: Input,
+      description: description3,
+      input: Input4,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
         yield* permission.assert({
-          action: name,
+          action: name4,
           resources: [input.query],
           save: ["*"],
           metadata: input,
@@ -64,7 +69,7 @@ var Plugin = {
             return ctx.websearch.query(input);
           return context.progress({ provider: provider.id }).pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID: provider.id })));
         }), Effect.catch((error) => {
-          if (!Schema.is(exports_websearch.ProviderRequiredError)(error))
+          if (!Schema.is(ProviderRequiredError2)(error))
             return Effect.fail(error);
           return providerSelectionLock.withPermit(Effect.gen(function* () {
             if (yield* websearch.default())
@@ -72,7 +77,7 @@ var Plugin = {
             const providers = (yield* ctx.websearch.providers()).data;
             const defaultProvider = providers[0];
             if (!defaultProvider)
-              return yield* new exports_websearch.ProviderRequiredError;
+              return yield* new ProviderRequiredError2;
             const response = yield* forms.ask({
               sessionID: context.sessionID,
               title: "Web Search",
@@ -102,7 +107,7 @@ var Plugin = {
               return yield* Effect.fail(new Error("Web search cancelled"));
             if (response.answer.choice === "disable") {
               yield* websearch.select(false);
-              return yield* new exports_websearch.DisabledError;
+              return yield* new DisabledError2;
             }
             const selection = response.answer.choice === "choose" ? yield* forms.ask({
               sessionID: context.sessionID,
@@ -126,10 +131,10 @@ var Plugin = {
               return yield* Effect.fail(new Error("Web search cancelled"));
             const providerID = selection?.answer.provider ?? "random";
             if (typeof providerID !== "string" || providerID !== "random" && !providers.some((provider) => provider.id === providerID))
-              return yield* new exports_websearch.ProviderRequiredError;
-            yield* websearch.select(providerID === "random" ? "random" : exports_websearch.ID.make(providerID));
+              return yield* new ProviderRequiredError2;
+            yield* websearch.select(providerID === "random" ? "random" : ID3.make(providerID));
             if (providerID !== "random")
-              return exports_websearch.ID.make(providerID);
+              return ID3.make(providerID);
             return providers[Math.floor(Math.random() * providers.length)]?.id;
           })).pipe(Effect.timeoutOrElse({
             duration: "1 minute",
@@ -145,20 +150,20 @@ var Plugin = {
           provider: result.data.providerID,
           results: result.data.results
         };
-        const content = output.results.length ? output.results.map((result2) => {
-          const title = result2.title ?? result2.url;
-          const published = result2.time.published ? `
-Published: ${new Date(result2.time.published).toISOString()}` : "";
-          return `## [${title}](${result2.url})${published}${result2.content ? `
+        const content = output.results.length ? output.results.map((result) => {
+          const title = result.title ?? result.url;
+          const published = result.time.published ? `
+Published: ${new Date(result.time.published).toISOString()}` : "";
+          return `## [${title}](${result.url})${published}${result.content ? `
 
-${result2.content}` : ""}`;
+${result.content}` : ""}`;
         }).join(`
 
-`) : NO_RESULTS;
+`) : NO_RESULTS2;
         return { output, content, metadata: { provider: output.provider } };
       }).pipe(Effect.mapError((error) => {
         const fallback = `Unable to search the web for ${input.query}`;
-        if (!Schema.is(exports_websearch.RequestError)(error))
+        if (!Schema.is(RequestError2)(error))
           return new ToolFailure({ message: fallback, error });
         const status = HttpClientError.isHttpClientError(error.cause) ? error.cause.response?.status : undefined;
         switch (status) {
@@ -188,9 +193,9 @@ ${result2.content}` : ""}`;
     yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
       const disabled = yield* websearch.default().pipe(Effect.as(false), Effect.catchTag("WebSearch.Disabled", () => Effect.succeed(true)));
       if (disabled)
-        delete event.tools[name];
+        delete event.tools[name4];
     }));
   })
 };
 
-export { name, NO_RESULTS, description, Input, Plugin, exports_websearch2 as exports_websearch };
+export { name4, NO_RESULTS2, description3, Input4, Plugin4, exports_websearch };

package/dist/chunks/kv-1kg9ymc8.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife2(fn) {
+  return fn();
+}
+
+export { iife2 };

package/dist/chunks/{instance-ngzr6ypz.js → kv-1ydgq2r4.js}

@@ -1,34 +1,34 @@
 import {
-  PositiveInt
-} from "./instance-j07kk359.js";
+  PositiveInt2
+} from "./kv-p8qxwesx.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/v1/config/attachment.ts
 var exports_attachment = {};
 __export(exports_attachment, {
   ConfigAttachmentV1: () => exports_attachment,
-  Image: () => Image,
-  Info: () => Info
+  Image: () => Image2,
+  Info: () => Info18
 });
 import { Schema } from "effect";
-var Image = Schema.Struct({
+var Image2 = Schema.Struct({
   auto_resize: Schema.optional(Schema.Boolean).annotate({
     description: "Resize images before sending them to the model when they exceed configured limits (default: true)"
   }),
-  max_width: Schema.optional(PositiveInt).annotate({
+  max_width: Schema.optional(PositiveInt2).annotate({
     description: "Maximum image width before resizing or rejecting the attachment (default: 2000)"
   }),
-  max_height: Schema.optional(PositiveInt).annotate({
+  max_height: Schema.optional(PositiveInt2).annotate({
     description: "Maximum image height before resizing or rejecting the attachment (default: 2000)"
   }),
-  max_base64_bytes: Schema.optional(PositiveInt).annotate({
+  max_base64_bytes: Schema.optional(PositiveInt2).annotate({
     description: "Maximum base64 payload bytes for an image attachment (default: 5242880)"
   })
 }).annotate({ identifier: "ImageAttachmentConfig" });
-var Info = Schema.Struct({
-  image: Schema.optional(Image).annotate({ description: "Image attachment configuration" })
+var Info18 = Schema.Struct({
+  image: Schema.optional(Image2).annotate({ description: "Image attachment configuration" })
 }).annotate({ identifier: "AttachmentConfig" });
 
-export { Image, Info, exports_attachment };
+export { Image2, Info18, exports_attachment };

package/dist/chunks/kv-21r38tys.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/v1/config/layout.ts
+var exports_layout = {};
+__export(exports_layout, {
+  ConfigLayoutV1: () => exports_layout,
+  Layout: () => Layout2
+});
+import { Schema } from "effect";
+var Layout2 = Schema.Literals(["auto", "stretch"]).annotate({ identifier: "LayoutConfig" });
+
+export { Layout2, exports_layout };

package/dist/chunks/{instance-s32nnj3r.js → kv-2402vzrj.js}

@@ -1,45 +1,45 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/repository.ts
 var exports_repository = {};
 __export(exports_repository, {
-  InvalidBranchError: () => InvalidBranchError,
-  InvalidReferenceError: () => InvalidReferenceError,
+  InvalidBranchError: () => InvalidBranchError3,
+  InvalidReferenceError: () => InvalidReferenceError2,
   Repository: () => exports_repository,
-  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError,
-  cacheIdentity: () => cacheIdentity,
-  cachePath: () => cachePath,
-  isFile: () => isFile,
-  isRemote: () => isRemote,
-  parse: () => parse,
-  parseRemote: () => parseRemote,
-  same: () => same,
-  validateBranch: () => validateBranch
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError2,
+  cacheIdentity: () => cacheIdentity2,
+  cachePath: () => cachePath2,
+  isFile: () => isFile2,
+  isRemote: () => isRemote2,
+  parse: () => parse4,
+  parseRemote: () => parseRemote2,
+  same: () => same2,
+  validateBranch: () => validateBranch3
 });
 import path from "path";
 import { fileURLToPath } from "url";
 import { Schema } from "effect";
 
-class InvalidReferenceError extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
+class InvalidReferenceError2 extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class UnsupportedLocalRepositoryError extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
+class UnsupportedLocalRepositoryError2 extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class InvalidBranchError extends Schema.TaggedError()("RepositoryInvalidBranchError", {
+class InvalidBranchError3 extends Schema.TaggedError()("RepositoryInvalidBranchError", {
   branch: Schema.String,
   message: Schema.String
 }) {
 }
-function parse(input) {
+function parse4(input) {
   const cleaned = normalizeInput(input);
   if (!cleaned)
     return;
@@ -71,45 +71,45 @@ function parse(input) {
     return;
   }
 }
-function parseRemote(input) {
-  const reference = parse(input);
+function parseRemote2(input) {
+  const reference = parse4(input);
   if (!reference) {
-    throw new InvalidReferenceError({
+    throw new InvalidReferenceError2({
       repository: input,
       message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
     });
   }
-  if (!isRemote(reference)) {
-    throw new UnsupportedLocalRepositoryError({
+  if (!isRemote2(reference)) {
+    throw new UnsupportedLocalRepositoryError2({
       repository: input,
       message: "Local file repositories are not supported"
     });
   }
   return reference;
 }
-function validateBranch(branch) {
+function validateBranch3(branch) {
   if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
     return;
-  throw new InvalidBranchError({
+  throw new InvalidBranchError3({
     branch,
     message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
   });
 }
-function isFile(reference) {
+function isFile2(reference) {
   return reference.protocol === "file:";
 }
-function isRemote(reference) {
-  return !isFile(reference);
+function isRemote2(reference) {
+  return !isFile2(reference);
 }
-function cachePath(root, reference, branch) {
+function cachePath2(root, reference, branch) {
   const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
   return branch ? `${base}@${encodeURIComponent(branch)}` : base;
 }
-function cacheIdentity(reference) {
+function cacheIdentity2(reference) {
   return `${reference.host}/${reference.path}`;
 }
-function same(left, right) {
-  return cacheIdentity(left) === cacheIdentity(right);
+function same2(left, right) {
+  return cacheIdentity2(left) === cacheIdentity2(right);
 }
 function normalizeInput(input) {
   return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
@@ -172,4 +172,4 @@ function buildFile(input) {
   };
 }
 
-export { InvalidReferenceError, UnsupportedLocalRepositoryError, InvalidBranchError, parse, parseRemote, validateBranch, isFile, isRemote, cachePath, cacheIdentity, same, exports_repository };
+export { InvalidReferenceError2, UnsupportedLocalRepositoryError2, InvalidBranchError3, parse4, parseRemote2, validateBranch3, isFile2, isRemote2, cachePath2, cacheIdentity2, same2, exports_repository };

package/dist/chunks/{instance-zsf8rs93.js → kv-2710q6r3.js}

@@ -1,13 +1,13 @@
 // src/event/sql.ts
 import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
-var EventSequenceTable = sqliteTable("event_sequence", {
+var EventSequenceTable2 = sqliteTable("event_sequence", {
   aggregate_id: text().notNull().primaryKey(),
   seq: integer().notNull(),
   owner_id: text()
 });
-var EventTable = sqliteTable("event", {
+var EventTable2 = sqliteTable("event", {
   id: text().$type().primaryKey(),
-  aggregate_id: text().notNull().references(() => EventSequenceTable.aggregate_id, { onDelete: "cascade" }),
+  aggregate_id: text().notNull().references(() => EventSequenceTable2.aggregate_id, { onDelete: "cascade" }),
   seq: integer().notNull(),
   created: integer().notNull().default(0),
   type: text().notNull(),
@@ -17,4 +17,4 @@ var EventTable = sqliteTable("event", {
   index("event_aggregate_type_seq_idx").on(table.aggregate_id, table.type, table.seq)
 ]);
 
-export { EventSequenceTable, EventTable };
+export { EventSequenceTable2, EventTable2 };

package/dist/chunks/kv-284xm0g3.js

@@ -0,0 +1,35 @@
+import {
+  latest2,
+  Service50
+} from "./kv-7m27rx9w.js";
+import {
+  observe2
+} from "./kv-qsdy395h.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/config/plugin/websearch.ts
+var exports_websearch2 = {};
+__export(exports_websearch2, {
+  ConfigWebSearchPlugin: () => exports_websearch2,
+  Plugin: () => Plugin18
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin18 = define({
+  id: "opencode.config.websearch",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service50;
+    const loaded = yield* observe2(config, ctx.event, ctx.websearch.reload());
+    yield* ctx.websearch.transform((websearch) => {
+      const selection = latest2(loaded.entries, "websearch");
+      if (selection === false)
+        websearch.default.set(false);
+      if (selection)
+        websearch.default.set(selection.provider);
+    });
+  })
+});
+
+export { Plugin18, exports_websearch2 };

package/dist/chunks/kv-2a5m3afh.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/environment/files.ts
+var exports_files = {};
+__export(exports_files, {
+  EnvironmentFiles: () => exports_files,
+  Failed: () => Failed2,
+  FileType: () => FileType2,
+  NotFound: () => NotFound2,
+  WrongKind: () => WrongKind2,
+  typeFollowing: () => typeFollowing2
+});
+import { Effect, Schema } from "effect";
+var FileType2 = Schema.Literals(["file", "directory", "symlink", "other"]);
+
+class NotFound2 extends Schema.TaggedError()("Environment.NotFound", {
+  path: Schema.String
+}) {
+}
+
+class WrongKind2 extends Schema.TaggedError()("Environment.WrongKind", {
+  path: Schema.String,
+  actual: FileType2
+}) {
+}
+
+class Failed2 extends Schema.TaggedError()("Environment.Failed", {
+  path: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var typeFollowing2 = (files, path) => files.stat(path).pipe(Effect.flatMap((info) => info.type === "symlink" ? files.read(path, { offset: 0, length: 0 }).pipe(Effect.map((result) => result.info.type), Effect.catchTag("Environment.WrongKind", (error) => Effect.succeed(error.actual))) : Effect.succeed(info.type)));
+
+export { FileType2, NotFound2, WrongKind2, Failed2, typeFollowing2, exports_files };

package/dist/chunks/{instance-hzeg9cfr.js → kv-2axfhc9x.js}

@@ -1,31 +1,31 @@
 // src/util/error.ts
 import { Schema } from "effect";
 
-class NamedError extends Error {
+class NamedError2 extends Error {
   static hasName(error, name) {
     return typeof error === "object" && error !== null && "name" in error && error.name === name;
   }
   static create(name, data) {
-    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
+    return NamedError2.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
   }
   static createSchemaClass(name, data) {
     const schema = Schema.Struct({
       name: Schema.Literal(name),
       data
     }).annotate({ identifier: name });
-    const result = class extends NamedError {
+    const result = class extends NamedError2 {
       data;
       static Schema = schema;
       static EffectSchema = schema;
       static tag = name;
       name = name;
-      constructor(data2, options) {
+      constructor(data, options) {
         super(name, options);
-        this.data = data2;
+        this.data = data;
         this.name = name;
       }
       static isInstance(input) {
-        return NamedError.hasName(input, name);
+        return NamedError2.hasName(input, name);
       }
       schema() {
         return schema;
@@ -40,10 +40,10 @@ class NamedError extends Error {
     Object.defineProperty(result, "name", { value: name });
     return result;
   }
-  static Unknown = NamedError.create("UnknownError", {
+  static Unknown = NamedError2.create("UnknownError", {
     message: Schema.String,
     ref: Schema.optional(Schema.String)
   });
 }
 
-export { NamedError };
+export { NamedError2 };

package/dist/chunks/kv-2exvmxnk.js

@@ -0,0 +1,87 @@
+import {
+  SessionMessage2
+} from "./kv-982e01ww.js";
+import {
+  SessionSchema2
+} from "./kv-cq35m6me.js";
+import {
+  MessageDecodeError2
+} from "./kv-aw8agfgj.js";
+import {
+  InitializationBlocked2,
+  read3
+} from "./kv-6e958v7x.js";
+import {
+  SessionMessageTable2
+} from "./kv-hrvm11jt.js";
+import {
+  initial2,
+  preview3
+} from "./kv-zqg3qsz2.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  SessionHistory: () => exports_history,
+  decodeMessageRow: () => decodeMessageRow2,
+  entriesForRunner: () => entriesForRunner2,
+  firstUserMessage: () => firstUserMessage2,
+  latestCompaction: () => latestCompaction2,
+  load: () => load4,
+  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 load4 = 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, load4, entriesForRunner2, preview2, firstUserMessage2, exports_history };

package/dist/chunks/{instance-k7hkdbw5.js → kv-2ht70gj7.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./instance-0zz82cjq.js";
-import {
-  __require
-} from "./instance-vpjkya7h.js";
+  createProviderPlugin2
+} from "./kv-se0s1eqw.js";
 
 // src/plugin/provider/venice.ts
-var VenicePlugin = createProviderPlugin({
+var VenicePlugin2 = createProviderPlugin2({
   id: "opencode.provider.venice",
   package: "venice-ai-sdk-provider",
   load: async (options) => {
@@ -15,4 +12,4 @@ var VenicePlugin = createProviderPlugin({
   }
 });
 
-export { VenicePlugin };
+export { VenicePlugin2 };