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

package/dist/chunks/{integration-bybkghrn.js → kv-a1tpkmh4.js}

@@ -21,9 +21,9 @@ var blocks = new Set([
   "section",
   "summary"
 ]);
-var MAX_MARKDOWN_BYTES = 5 * 1024 * 1024;
-var CONTENT_BYTES = MAX_MARKDOWN_BYTES - 64 * 1024;
-function convertHTMLToMarkdown(html) {
+var MAX_MARKDOWN_BYTES2 = 5 * 1024 * 1024;
+var CONTENT_BYTES = MAX_MARKDOWN_BYTES2 - 64 * 1024;
+function convertHTMLToMarkdown2(html) {
   const output = [];
   const stack = [];
   const encoder = new TextEncoder;
@@ -64,7 +64,7 @@ function convertHTMLToMarkdown(html) {
     return characters.slice(0, low).join("");
   };
   const append = (value, content = false) => {
-    const limit = content ? CONTENT_BYTES : MAX_MARKDOWN_BYTES;
+    const limit = content ? CONTENT_BYTES : MAX_MARKDOWN_BYTES2;
     if (!value || outputBytes >= limit)
       return;
     const bytes = encoder.encode(value);
@@ -198,12 +198,12 @@ function convertHTMLToMarkdown(html) {
       tildes = Math.max(tildes, currentTildes);
     }
     if (code.inline) {
-      const fence2 = "`".repeat(Math.max(1, backticks + 1));
+      const fence = "`".repeat(Math.max(1, backticks + 1));
       const padding = /^ | $/.test(code.text) && !/^ +$/.test(code.text) ? " " : "";
       flushSpace();
       prefixQuote();
-      const wrapper = encoder.encode(`${fence2}${padding}${padding}${fence2}`).byteLength;
-      appendRaw(`${fence2}${padding}${sliceBytes(code.text, Math.max(0, CONTENT_BYTES - outputBytes - wrapper))}${padding}${fence2}`);
+      const wrapper = encoder.encode(`${fence}${padding}${padding}${fence}`).byteLength;
+      appendRaw(`${fence}${padding}${sliceBytes(code.text, Math.max(0, CONTENT_BYTES - outputBytes - wrapper))}${padding}${fence}`);
       return;
     }
     if (activeCell) {
@@ -238,7 +238,7 @@ function convertHTMLToMarkdown(html) {
       depth++;
       if (depth > 1e4) {
         if (stack.at(-1)?.suppressed) {
-          const visibleParent = stack.findLastIndex((frame2) => !frame2.suppressed);
+          const visibleParent = stack.findLastIndex((frame) => !frame.suppressed);
           fallbackSuppressedDepth = visibleParent + 2;
         }
         activeCode = undefined;
@@ -395,8 +395,8 @@ function convertHTMLToMarkdown(html) {
         const value = Number.parseInt(attributes.value ?? "");
         if (activeList?.ordered && !Number.isNaN(value))
           activeList.next = value;
-        const marker2 = activeList?.ordered ? `${activeList.next++}.` : "-";
-        const prefix = `${(activeItem?.indent ?? "").slice(0, 24)}${marker2} `;
+        const marker = activeList?.ordered ? `${activeList.next++}.` : "-";
+        const prefix = `${(activeItem?.indent ?? "").slice(0, 24)}${marker} `;
         frame.item = { indent: " ".repeat(prefix.length), previous: activeItem };
         activeItem = frame.item;
         pendingIndent = "";
@@ -662,7 +662,7 @@ ${prefix}| ${row.join(" | ")} |`);
     pendingText += chunk;
   }
   flushText();
-  return sliceBytes(normalized.join("").trim(), MAX_MARKDOWN_BYTES);
+  return sliceBytes(normalized.join("").trim(), MAX_MARKDOWN_BYTES2);
 }
 
-export { MAX_MARKDOWN_BYTES, convertHTMLToMarkdown };
+export { MAX_MARKDOWN_BYTES2, convertHTMLToMarkdown2 };

package/dist/chunks/{integration-pj7nypz0.js → kv-a3mv2pdz.js}

@@ -1,176 +1,190 @@
 import {
-  exports_command
-} from "./integration-fn8qccm8.js";
+  ID9,
+  Info22,
+  SessionSchema2
+} from "./kv-cq35m6me.js";
 import {
-  exports_session
-} from "./integration-pn89kfvv.js";
+  RelativePath2
+} from "./kv-p8qxwesx.js";
 import {
-  DestinationNotDirectoryError,
-  DestinationNotFoundError,
-  DestinationUnavailableError,
-  exports_move
-} from "./integration-d6yxznb3.js";
+  Service80,
+  node84
+} from "./kv-3rps85z5.js";
 import {
-  exports_generate
-} from "./integration-w2nd9bs6.js";
+  isSynced2,
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_projector
-} from "./integration-a2y4sq9c.js";
+  Service71,
+  node75
+} from "./kv-wywtm3b4.js";
 import {
-  exports_execution
-} from "./integration-nh84sznz.js";
+  Service40,
+  node42
+} from "./kv-sp5wnj6d.js";
 import {
-  exports_inbox
-} from "./integration-d9nzfyee.js";
+  SessionEvent2
+} from "./kv-mntxs535.js";
 import {
-  exports_instruction_entry
-} from "./integration-6yzp77jc.js";
+  SessionMessageTable2
+} from "./kv-hrvm11jt.js";
 import {
-  exports_model_transport
-} from "./integration-rpa95wsa.js";
+  node28
+} from "./kv-6c7eyv5g.js";
 import {
-  exports_service
-} from "./integration-6bxzghb6.js";
+  current2
+} from "./kv-zqg3qsz2.js";
 import {
-  Slug
-} from "./integration-df3v2q6j.js";
+  snapshot2
+} from "./kv-csjjrfxs.js";
 import {
-  exports_job
-} from "./integration-bymgjy4k.js";
+  Slug2
+} from "./kv-gebd4c9n.js";
 import {
-  llmClient
-} from "./integration-326j4s6w.js";
+  SessionAlreadyProjected2,
+  node26
+} from "./kv-qvs4vh02.js";
 import {
-  exports_store
-} from "./integration-jwp0b78z.js";
+  Metadata2,
+  node45
+} from "./kv-y0bse006.js";
 import {
-  exports_instruction_state
-} from "./integration-m3k5wttq.js";
+  NotFoundError6,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  ForkEmptyError2,
+  MessageDecodeError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  AttachmentError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2,
+  SkillNotFoundError2
+} from "./kv-aw8agfgj.js";
 import {
-  AttachmentError,
-  BusyError,
-  CompactionConflictError,
-  ForkEmptyError,
-  InboxConflictError,
-  MessageDecodeError,
-  MessageIncompleteError,
-  MessageNotAssistantError,
-  MessageNotFoundError,
-  MessageToolIncompleteError,
-  NotFoundError,
-  PromptConflictError,
-  SkillNotFoundError,
-  SyntheticConflictError
-} from "./integration-2sqw2jjm.js";
+  ListInput5,
+  Service55,
+  node58
+} from "./kv-0c2smd8y.js";
 import {
-  SessionMessageTable
-} from "./integration-q606pcse.js";
+  Service42,
+  node44
+} from "./kv-rszjw5nd.js";
 import {
-  exports_environment
-} from "./integration-zn935gjz.js";
+  Service23,
+  node27
+} from "./kv-hbhn1exa.js";
 import {
-  ID,
-  Info,
-  SessionSchema
-} from "./integration-bjwj8hwv.js";
+  llmClient2
+} from "./kv-0e0xafbb.js";
 import {
-  exports_app
-} from "./integration-hs51b0fc.js";
+  Service32,
+  node35
+} from "./kv-z0r88r3d.js";
 import {
-  SessionEvent
-} from "./integration-a83yvq99.js";
+  generate3
+} from "./kv-rr97n57r.js";
 import {
-  exports_project
-} from "./integration-a7rjzrqs.js";
+  execute2
+} from "./kv-n4qddg0w.js";
 import {
-  RelativePath
-} from "./integration-j07kk359.js";
+  DestinationNotFoundError2,
+  DestinationNotDirectoryError2,
+  DestinationUnavailableError2,
+  Service22,
+  node25
+} from "./kv-gva7hxj4.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  Service39,
+  node41
+} from "./kv-8npyp30c.js";
 import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
+  make12
+} from "./kv-9rjp7yvj.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/session.ts
-var exports_session2 = {};
-__export(exports_session2, {
-  AttachmentError: () => AttachmentError,
-  BusyError: () => BusyError,
-  CompactionConflictError: () => CompactionConflictError,
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  ID: () => ID,
-  InboxConflictError: () => InboxConflictError,
-  Info: () => Info,
-  ListAnchor: () => ListAnchor,
-  ListInput: () => ListInput,
-  MessageDecodeError: () => MessageDecodeError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  NotFoundError: () => NotFoundError,
-  PromptConflictError: () => PromptConflictError,
-  Service: () => Service,
-  Session: () => exports_session2,
-  SessionSchema: () => SessionSchema,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SyntheticConflictError: () => SyntheticConflictError,
-  node: () => node
+var exports_session = {};
+__export(exports_session, {
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  ID: () => ID9,
+  InboxConflictError: () => InboxConflictError2,
+  Info: () => Info22,
+  ListAnchor: () => ListAnchor2,
+  ListInput: () => ListInput3,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError6,
+  PromptConflictError: () => PromptConflictError2,
+  Service: () => Service21,
+  Session: () => exports_session,
+  SessionSchema: () => SessionSchema2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  node: () => node24
 });
 import { Effect, Layer, Schema, Context, Stream } from "effect";
 import { LLMClient } from "@opencode-ai/ai";
-import { ListAnchor } from "@opencode-ai/schema/session";
+import { ListAnchor as ListAnchor2 } from "@opencode-ai/schema/session";
 import { and, desc, eq } from "drizzle-orm";
 import { Model } from "@opencode-ai/schema/model";
 import path from "path";
 import { Node } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var ListInput = exports_store.ListInput;
-class Service extends Context.Service()("@opencode/Session") {
+var ListInput3 = ListInput5;
+class Service21 extends Context.Service()("@opencode/Session") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const app = yield* exports_app.Metadata;
-  const database = yield* exports_database.Service;
+var layer = Layer.effect(Service21, Effect.gen(function* () {
+  const app = yield* Metadata2;
+  const database = yield* Service80;
   const db = database.db;
-  const bus = yield* exports_bus.Service;
-  const projects = yield* exports_project.Service;
-  const execution = yield* exports_execution.Service;
+  const bus = yield* Service79;
+  const projects = yield* Service71;
+  const execution = yield* Service23;
   const llm = yield* LLMClient.Service;
-  const transport = yield* exports_model_transport.Service;
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const moves = yield* exports_move.Service;
-  const jobs = yield* exports_job.Service;
-  const environments = yield* exports_environment.Service;
-  const sessions = yield* exports_session.make();
-  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
-  const result = Service.of({
+  const transport = yield* Service32;
+  const store = yield* Service55;
+  const instances = yield* Service40;
+  const moves = yield* Service22;
+  const jobs = yield* Service42;
+  const environments = yield* Service39;
+  const sessions = yield* make12();
+  const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
+  const result = Service21.of({
     create: Effect.fn("Session.create")(function* (input) {
-      const sessionID = input.id ?? SessionSchema.ID.create();
+      const sessionID = input.id ?? SessionSchema2.ID.create();
       const recorded = yield* store.get(sessionID);
       if (recorded)
         return recorded;
       const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
       if (input.parentID && parent === undefined)
-        return yield* new NotFoundError({ sessionID: input.parentID });
+        return yield* new NotFoundError6({ sessionID: input.parentID });
       const location = parent?.location ?? input.location;
       if (location === undefined)
         return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
       const project = yield* projects.resolve(location.directory);
-      const projected = yield* bus.publish(SessionEvent.Created, {
+      const projected = yield* bus.publish(SessionEvent2.Created, {
         sessionID,
-        slug: Slug.create(),
+        slug: Slug2.create(),
         version: app.version,
         projectID: project.id,
         parentID: input.parentID,
         location,
-        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        subpath: RelativePath2.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
         title: input.title,
         agent: input.agent,
         metadata: input.metadata ?? parent?.metadata,
@@ -180,7 +194,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           variant: input.model.variant
         } : undefined
       }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
-        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
+        if (!(defect instanceof SessionAlreadyProjected2)) {
           return Effect.die(defect);
         }
         return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
@@ -191,20 +205,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     fork: Effect.fn("Session.fork")(function* (input) {
       const parent = yield* result.get(input.sessionID);
-      const boundary = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+      const boundary = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable2.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
       if (!boundary && input.boundary.type === "before")
-        return yield* new MessageNotFoundError({
+        return yield* new MessageNotFoundError2({
           sessionID: input.sessionID,
           messageID: input.boundary.messageID
         });
       if (!boundary)
-        return yield* new ForkEmptyError({ sessionID: input.sessionID });
-      const sessionID = SessionSchema.ID.create();
+        return yield* new ForkEmptyError2({ sessionID: input.sessionID });
+      const sessionID = SessionSchema2.ID.create();
       const inherited = yield* db.transaction(() => Effect.all({
-        instructions: exports_instruction_state.current(db, parent.id),
-        instructionEntries: exports_instruction_entry.snapshot(db, parent.id)
+        instructions: current2(db, parent.id),
+        instructionEntries: snapshot2(db, parent.id)
       })).pipe(Effect.orDie);
-      yield* bus.publish(SessionEvent.Forked, {
+      yield* bus.publish(SessionEvent2.Forked, {
         sessionID,
         parentID: parent.id,
         boundary: { ...input.boundary, messageID: boundary.id },
@@ -228,7 +242,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const children = yield* result.list({ parentID: sessionID });
       yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
       yield* environments.clear(sessionID);
-      yield* bus.publish(SessionEvent.Deleted, { sessionID });
+      yield* bus.publish(SessionEvent2.Deleted, { sessionID });
       yield* bus.remove(sessionID);
     }),
     list: Effect.fn("Session.list")(function* (input) {
@@ -248,15 +262,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
     steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
     queueInbox: (input) => sessions.forSession(input.sessionID).queueInbox(input.inboxID),
-    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => exports_bus.isSynced(item) || isDurableSessionEvent(item))),
+    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => isSynced2(item) || isDurableSessionEvent(item))),
     prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
     generate: Effect.fn("Session.generate")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_generate.generate({ session, prompt: input.prompt }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(LLMClient.Service, llm));
+      return yield* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service40, instances), Effect.provideService(Service80, database), Effect.provideService(LLMClient.Service, llm));
     }),
     command: Effect.fn("Session.command")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_command.execute({ ...input, session }).pipe(Effect.provideService(exports_service.Service, instances));
+      return yield* execute2({ ...input, session }).pipe(Effect.provideService(Service40, instances));
     }),
     shell: (input) => sessions.forSession(input.sessionID).shell(input),
     skill: (input) => sessions.forSession(input.sessionID).skill(input),
@@ -296,26 +310,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return result;
 }));
-var node = Node.makeGlobalNode({
-  service: Service,
+var node24 = Node.makeGlobalNode({
+  service: Service21,
   layer,
   deps: [
-    exports_job.node,
-    exports_environment.node,
-    exports_database.node,
-    exports_bus.node,
-    exports_project.node,
-    exports_execution.node,
-    exports_model_transport.node,
-    llmClient,
-    exports_store.node,
-    exports_service.node,
-    exports_inbox.node,
-    exports_move.node,
-    exports_projector.node,
+    node44,
+    node41,
+    node84,
+    node83,
+    node75,
+    node27,
+    node35,
+    llmClient2,
+    node58,
+    node42,
+    node28,
+    node25,
+    node26,
     FSUtil.node,
-    exports_app.node
+    node45
   ]
 });
 
-export { ListAnchor, ListInput, Service, node, exports_session2 as exports_session };
+export { ListAnchor2, ListInput3, Service21, node24, exports_session };

package/dist/chunks/{integration-jqhp3fpz.js → kv-aaet6srn.js}

@@ -1,22 +1,22 @@
 import {
-  Failed,
-  NotFound,
-  WrongKind
-} from "./integration-vynk8zbr.js";
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./kv-2a5m3afh.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/environment/memory.ts
 var exports_memory = {};
 __export(exports_memory, {
   EnvironmentMemory: () => exports_memory,
-  makeMemoryDriver: () => makeMemoryDriver
+  makeMemoryDriver: () => makeMemoryDriver2
 });
 import path from "node:path";
 import { Effect, PlatformError } from "effect";
 import { make } from "effect/unstable/process/ChildProcessSpawner";
-var makeMemoryDriver = () => {
+var makeMemoryDriver2 = () => {
   const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
   const key = (value) => path.posix.resolve("/", value);
   const info = (node) => ({
@@ -65,24 +65,24 @@ var makeMemoryDriver = () => {
       mkdirSync(parent);
     nodes.set(target, { type: "directory", mtimeMs: Date.now() });
   };
-  const failed = (value, cause) => new Failed({ path: value, cause });
+  const failed = (value, cause) => new Failed2({ path: value, cause });
   const overrides = {
     stat: (value) => Effect.suspend(() => {
       const node = lookup(value);
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }));
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound2({ path: value }));
     }),
     read: (value, range) => Effect.gen(function* () {
       const original = lookup(value);
       if (!original)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (original.type === "directory")
-        return yield* new WrongKind({ path: value, actual: "directory" });
+        return yield* new WrongKind2({ path: value, actual: "directory" });
       const resolved = resolveKey(value, true);
       const node = resolved === undefined ? undefined : nodes.get(resolved);
       if (!node)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (node.type !== "file")
-        return yield* new WrongKind({ path: value, actual: node.type });
+        return yield* new WrongKind2({ path: value, actual: node.type });
       const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
       return { info: info(node), bytes: bytes.slice() };
     }),
@@ -104,9 +104,9 @@ var makeMemoryDriver = () => {
       const target = resolveKey(value, true) ?? key(value);
       const node = nodes.get(target);
       if (!node)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (node.type !== "directory")
-        return yield* new WrongKind({ path: value, actual: node.type });
+        return yield* new WrongKind2({ path: value, actual: node.type });
       return [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
     }),
     remove: (value) => Effect.sync(() => {
@@ -120,7 +120,7 @@ var makeMemoryDriver = () => {
       const source = resolveKey(from, false) ?? key(from);
       const node = nodes.get(source);
       if (!node)
-        return yield* new NotFound({ path: from });
+        return yield* new NotFound2({ path: from });
       yield* Effect.try({
         try: () => {
           const requested = resolveKey(to, false) ?? key(to);
@@ -167,4 +167,4 @@ var makeMemoryDriver = () => {
   };
 };
 
-export { makeMemoryDriver, exports_memory };
+export { makeMemoryDriver2, exports_memory };

package/dist/chunks/{integration-a02svayp.js → kv-af5trqkr.js}

@@ -1,10 +1,10 @@
 // src/github-copilot/chat/openai-compatible-chat-options.ts
 import { z } from "zod/v4";
-var openaiCompatibleProviderOptions = z.object({
+var openaiCompatibleProviderOptions2 = z.object({
   user: z.string().optional(),
   reasoningEffort: z.string().optional(),
   textVerbosity: z.string().optional(),
   thinking_budget: z.number().optional()
 });
 
-export { openaiCompatibleProviderOptions };
+export { openaiCompatibleProviderOptions2 };

package/dist/chunks/{integration-1wcz8fvj.js → kv-afrmfg78.js}

@@ -1,6 +1,6 @@
 // src/github-copilot/openai-compatible-error.ts
 import { z } from "zod/v4";
-var openaiCompatibleErrorDataSchema = z.object({
+var openaiCompatibleErrorDataSchema2 = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
@@ -8,9 +8,9 @@ var openaiCompatibleErrorDataSchema = z.object({
     code: z.union([z.string(), z.number()]).nullish()
   })
 });
-var defaultOpenAICompatibleErrorStructure = {
-  errorSchema: openaiCompatibleErrorDataSchema,
+var defaultOpenAICompatibleErrorStructure2 = {
+  errorSchema: openaiCompatibleErrorDataSchema2,
   errorToMessage: (data) => data.error.message
 };
 
-export { openaiCompatibleErrorDataSchema, defaultOpenAICompatibleErrorStructure };
+export { openaiCompatibleErrorDataSchema2, defaultOpenAICompatibleErrorStructure2 };

package/dist/chunks/{integration-gb1z7yet.js → kv-ajtjthsy.js}

@@ -1,17 +1,17 @@
 import {
-  ProjectTable
-} from "./integration-c8ya26sa.js";
+  absoluteColumn2
+} from "./kv-r8dhm0tv.js";
 import {
-  absoluteColumn
-} from "./integration-zbqqnp0n.js";
+  ProjectTable2
+} from "./kv-9qm9egsn.js";
 
 // src/worktree/sql.ts
 import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var WorktreeTable = sqliteTable("worktree", {
-  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
-  directory: absoluteColumn().notNull(),
+var WorktreeTable2 = sqliteTable("worktree", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
   strategy: text(),
   time_created: integer().notNull().$default(() => Date.now())
 }, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
 
-export { WorktreeTable };
+export { WorktreeTable2 };