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

package/dist/chunks/{project-r9pv5d9a.js → model-6cxkhhme.js}

@@ -1,31 +1,37 @@
 import {
   exports_environment as exports_environment2
-} from "./project-6ky7rqk7.js";
+} from "./model-6ky7rqk7.js";
 import {
   exports_hooks
-} from "./project-v2wshkax.js";
+} from "./model-v2wshkax.js";
 import {
   SessionSchema
-} from "./project-bjwj8hwv.js";
+} from "./model-bjwj8hwv.js";
 import {
-  exports_environment1 as exports_environment
-} from "./project-0xzcm754.js";
+  exports_tool_output
+} from "./model-7ccgh94t.js";
 import {
   exports_file_retention
-} from "./project-hp6rpdnc.js";
+} from "./model-hp6rpdnc.js";
 import {
-  exports_select
-} from "./project-bbhffenw.js";
+  exports_environment1 as exports_environment
+} from "./model-bach7bae.js";
+import {
+  exports_config
+} from "./model-qmpdqet2.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
+import {
+  exports_select
+} from "./model-bbhffenw.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   __export,
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/shell.ts
 var exports_shell = {};
@@ -79,49 +85,50 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
   const environment = yield* exports_environment.Service;
   const hooks = yield* exports_hooks.Service;
   const environments = yield* exports_environment2.Service;
+  const config = yield* exports_config.Service;
   const context = yield* Effect.context();
   const runFork = Effect.runForkWith(context);
-  const sessions = new Map;
+  const commands = new Map;
   const exitOrder = [];
   const outputDir = path.join(global.data, DIRECTORY, location.project.id);
   const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"));
   const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"));
   yield* Effect.promise(() => mkdir(outputDir, { recursive: true }));
   yield* Effect.addFinalizer(() => Effect.gen(function* () {
-    for (const session of sessions.values()) {
-      if (session.timeoutFiber)
-        yield* Fiber.interrupt(session.timeoutFiber);
-      yield* Deferred.interrupt(session.done);
+    for (const command of commands.values()) {
+      if (command.timeoutFiber)
+        yield* Fiber.interrupt(command.timeoutFiber);
+      yield* Deferred.interrupt(command.done);
     }
-    sessions.clear();
+    commands.clear();
     exitOrder.length = 0;
   }));
   const require2 = Effect.fnUntraced(function* (id) {
-    const session = sessions.get(id);
-    if (!session)
+    const command = commands.get(id);
+    if (!command)
       return yield* new NotFoundError({ id });
-    return session;
+    return command;
   });
-  const removeSession = Effect.fnUntraced(function* (id) {
-    const session = sessions.get(id);
+  const removeCommand = Effect.fnUntraced(function* (id) {
+    const command = commands.get(id);
     const index = exitOrder.indexOf(id);
     if (index !== -1)
       exitOrder.splice(index, 1);
-    if (!session)
+    if (!command)
       return;
-    sessions.delete(id);
-    if (session.timeoutFiber)
-      yield* Fiber.interrupt(session.timeoutFiber);
-    yield* Deferred.fail(session.done, new NotFoundError({ id }));
-    yield* Effect.promise(() => unlink(session.file).catch(() => {}));
+    commands.delete(id);
+    if (command.timeoutFiber)
+      yield* Fiber.interrupt(command.timeoutFiber);
+    yield* Deferred.fail(command.done, new NotFoundError({ id }));
+    yield* Effect.promise(() => unlink(command.file).catch(() => {}));
     yield* bus.publish(Shell.Event.Deleted, { id });
   });
   const remove = Effect.fn("Shell.remove")(function* (id) {
     yield* require2(id);
-    yield* removeSession(id);
+    yield* removeCommand(id);
   });
   const list = Effect.fn("Shell.list")(function* () {
-    return Array.from(sessions.values()).filter((session) => session.info.status === "running").map((session) => session.info);
+    return Array.from(commands.values()).filter((command) => command.info.status === "running").map((command) => command.info);
   });
   const get = Effect.fn("Shell.get")(function* (id) {
     return (yield* require2(id)).info;
@@ -130,23 +137,23 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
     return yield* Deferred.await((yield* require2(id)).done);
   });
   const timeout = Effect.fn("Shell.timeout")(function* (id, duration) {
-    const session = yield* require2(id);
-    if (session.info.status !== "running" || !session.timeout)
-      return session.info;
-    yield* session.timeout(duration);
-    return session.info;
+    const command = yield* require2(id);
+    if (command.info.status !== "running" || !command.timeout)
+      return command.info;
+    yield* command.timeout(duration);
+    return command.info;
   });
   const output = Effect.fnUntraced(function* (id, input) {
-    const session = yield* require2(id);
+    const command = yield* require2(id);
     const cursor = input?.cursor ?? 0;
     const limit = input?.limit ?? 65536;
-    if (cursor >= session.size)
-      return { output: "", cursor: session.size, size: session.size, truncated: false };
+    if (cursor >= command.size)
+      return { output: "", cursor: command.size, size: command.size, truncated: false };
     const start = Math.max(0, cursor);
-    const length = Math.min(limit, session.size - start);
+    const length = Math.min(limit, command.size - start);
     const buffer = Buffer.alloc(length);
     const bytesRead = yield* Effect.promise(() => new Promise((resolve) => {
-      const stream = createReadStream(session.file, { start, end: start + length - 1 });
+      const stream = createReadStream(command.file, { start, end: start + length - 1 });
       let offset = 0;
       stream.on("data", (chunk) => {
         const bytes = Buffer.from(chunk);
@@ -159,10 +166,33 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
     return {
       output: buffer.subarray(0, bytesRead).toString("utf8"),
       cursor: start + bytesRead,
-      size: session.size,
+      size: command.size,
       truncated: false
     };
   });
+  const result = Effect.fn("Shell.result")(function* (started) {
+    const info = yield* wait(started.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed({ ...started, status: "killed", time: { ...started.time, completed: Date.now() } })));
+    const capture = yield* Effect.gen(function* () {
+      const limits = exports_config.latest(yield* config.entries(), "tool_output");
+      const maxLines = limits?.max_lines ?? exports_tool_output.MAX_LINES;
+      const maxBytes = limits?.max_bytes ?? exports_tool_output.MAX_BYTES;
+      const latest = yield* output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
+      const page = yield* output(info.id, { cursor: Math.max(0, latest.size - maxBytes), limit: maxBytes });
+      const lines = page.output.split(`
+`);
+      if (page.output.endsWith(`
+`))
+        lines.pop();
+      const truncated = latest.size > maxBytes || lines.length > maxLines;
+      const text = lines.length > maxLines ? lines.slice(-maxLines).join(`
+`) : page.output;
+      const notice = truncated ? `
+
+[output truncated; full output saved to: ${info.file}]` : "";
+      return { output: `${text || "(no output)"}${notice}`, truncated };
+    }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(undefined)));
+    return { info, capture };
+  });
   const create = Effect.fn("Shell.create")(function* (input, before) {
     const sessionID = input.metadata?.sessionID;
     const sessionEnvironment = location.workspaceID === undefined && Schema.is(SessionSchema.ID)(sessionID) ? yield* environments.get(sessionID) : undefined;
@@ -202,7 +232,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         detached: process.platform !== "win32",
         forceKillAfter: Duration.seconds(3)
       })).pipe(Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })));
-      const session2 = {
+      const command2 = {
         info: produce(info, (draft) => {
           draft.pid = handle.pid;
         }),
@@ -210,12 +240,12 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         size: 0,
         done: Deferred.makeUnsafe()
       };
-      sessions.set(id, session2);
+      commands.set(id, command2);
       const stream = createWriteStream(file);
       const outputDone = Latch.makeUnsafe();
       const pump = handle.all.pipe(Stream.runForEach((chunk) => Effect.sync(() => {
         stream.write(chunk);
-        session2.size += chunk.length;
+        command2.size += chunk.length;
       })));
       runFork(Effect.gen(function* () {
         yield* pump.pipe(Effect.catch(() => Effect.void));
@@ -229,9 +259,9 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         stream.once("error", () => resolve());
       }));
       const finish = (status, exit, beforeWait = Effect.void) => Effect.gen(function* () {
-        if (session2.info.status !== "running")
+        if (command2.info.status !== "running")
           return;
-        session2.info = produce(session2.info, (draft) => {
+        command2.info = produce(command2.info, (draft) => {
           draft.status = status;
           if (exit !== undefined)
             draft.exit = exit;
@@ -239,7 +269,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         });
         yield* beforeWait;
         yield* outputDone.await;
-        yield* Deferred.succeed(session2.done, session2.info);
+        yield* Deferred.succeed(command2.done, command2.info);
         yield* bus.publish(Shell.Event.Exited, {
           id,
           ...exit !== undefined ? { exit } : {},
@@ -250,29 +280,32 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
           const oldest = exitOrder[0];
           if (!oldest)
             break;
-          yield* removeSession(Shell.ID.make(oldest));
+          yield* removeCommand(oldest);
         }
-        if (session2.timeoutFiber)
-          yield* Fiber.interrupt(session2.timeoutFiber);
+        const timeoutFiber = command2.timeoutFiber;
+        command2.timeout = undefined;
+        command2.timeoutFiber = undefined;
+        if (timeoutFiber)
+          yield* Fiber.interrupt(timeoutFiber);
       });
-      session2.timeout = (duration) => Effect.gen(function* () {
-        if (session2.timeoutFiber)
-          yield* Fiber.interrupt(session2.timeoutFiber);
-        session2.timeoutFiber = undefined;
-        if (duration === 0 || session2.info.status !== "running")
+      command2.timeout = (duration) => Effect.gen(function* () {
+        if (command2.timeoutFiber)
+          yield* Fiber.interrupt(command2.timeoutFiber);
+        command2.timeoutFiber = undefined;
+        if (duration === 0 || command2.info.status !== "running")
           return;
-        session2.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))))));
+        command2.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void))))));
       });
-      yield* session2.timeout(invocation.timeout);
+      yield* command2.timeout(invocation.timeout);
       runFork(handle.exitCode.pipe(Effect.flatMap((code) => finish("exited", code)), Effect.catch(() => finish("exited"))));
       yield* bus.publish(Shell.Event.Created, { info });
-      yield* Deferred.succeed(ready, session2);
-      yield* Deferred.await(session2.done).pipe(Effect.catch(() => Effect.void));
+      yield* Deferred.succeed(ready, command2);
+      yield* Deferred.await(command2.done).pipe(Effect.catch(() => Effect.void));
     })).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))));
-    const session = yield* Deferred.await(ready);
-    return session.info;
+    const command = yield* Deferred.await(ready);
+    return command.info;
   });
-  return Service.of({ create, list, get, wait, timeout, output, remove });
+  return Service.of({ create, list, get, wait, result, timeout, output, remove });
 }));
 var node = makeLocationNode({
   service: Service,
@@ -285,6 +318,7 @@ var node = makeLocationNode({
     exports_environment.node,
     exports_hooks.node,
     exports_environment2.node,
+    exports_config.node,
     cleanupNode
   ]
 });

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

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/session/environment.ts
 var exports_environment = {};

package/dist/chunks/model-6tpset1y.js

@@ -0,0 +1,203 @@
+import {
+  exports_supervisor_service
+} from "./model-s33fw6zm.js";
+import {
+  exports_skill
+} from "./model-9w1y4hdv.js";
+import {
+  AttachmentError,
+  SkillNotFoundError
+} from "./model-cgqn2mrm.js";
+import {
+  exports_hooks
+} from "./model-v2wshkax.js";
+import {
+  exports_mime
+} from "./model-dhphtf1x.js";
+import {
+  exports_image
+} from "./model-qert5162.js";
+import {
+  __export
+} from "./model-rvfvac9x.js";
+
+// src/session/prompt.ts
+var exports_prompt = {};
+__export(exports_prompt, {
+  make: () => make,
+  layer: () => layer,
+  SessionPrompt: () => exports_prompt,
+  Service: () => Service
+});
+import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt";
+import { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Context, Effect, Layer } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+var make = Effect.fn("SessionPrompt.make")(function* () {
+  const fs = yield* FSUtil.Service;
+  const plugins = yield* exports_supervisor_service.Service;
+  const hooks = yield* exports_hooks.Service;
+  const image = yield* exports_image.Service;
+  const skillService = yield* exports_skill.Service;
+  const prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
+    yield* plugins.flush;
+    const event = yield* hooks.trigger("session", "prompt", {
+      sessionID: request.sessionID,
+      messageID: request.messageID,
+      prompt: structuredClone({
+        text: request.input.text,
+        files: request.input.files?.slice(),
+        agents: request.input.agents?.slice(),
+        skills: request.input.skills?.slice()
+      }),
+      metadata: structuredClone(request.input.metadata),
+      delivery: request.input.delivery ?? "steer"
+    });
+    const input = event.prompt;
+    const files = input.files ? yield* Effect.forEach(input.files, materializeAttachment, { concurrency: 8 }) : undefined;
+    const requested = input.skills;
+    const selected = yield* Effect.gen(function* () {
+      if (!requested?.length)
+        return;
+      const prepared = new Map;
+      return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
+        const name = prepared.get(attachment.id);
+        if (name !== undefined)
+          return { id: attachment.id, name, mention: attachment.mention };
+        const skill = yield* skillService.get(attachment.id);
+        if (!skill)
+          return yield* new SkillNotFoundError({ skill: attachment.id });
+        prepared.set(skill.id, skill.name);
+        return {
+          id: skill.id,
+          name: skill.name,
+          text: (yield* exports_skill.prepare(fs, skill).pipe(Effect.orDie)).output,
+          mention: attachment.mention
+        };
+      }));
+    });
+    return {
+      type: "user",
+      payload: SessionInbox.UserPayload.make({
+        ...Prompt.make({
+          text: input.text,
+          agents: input.agents,
+          files,
+          skills: selected?.length ? selected : undefined
+        }),
+        metadata: event.metadata
+      }),
+      delivery: SessionInbox.Delivery.make(event.delivery)
+    };
+  });
+  const materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(function* (input) {
+    const resolved = input.uri.startsWith("data:") ? {
+      bytes: yield* decodeDataURL(input.uri),
+      source: { type: "inline" },
+      start: undefined,
+      end: undefined,
+      name: undefined,
+      mime: undefined
+    } : yield* readFileAttachment(input.uri);
+    if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
+      return yield* new AttachmentError({
+        uri: input.uri,
+        message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
+      });
+    const mime = resolved.mime ?? exports_mime.detect(resolved.bytes);
+    const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
+`).slice(resolved.start - 1, resolved.end).join(`
+`)) : resolved.bytes;
+    const normalized = yield* normalizeImageAttachment(input, Buffer.from(content).toString("base64"), mime);
+    return FileAttachment.create({
+      data: normalized.data,
+      mime: normalized.mime,
+      source: resolved.source,
+      name: input.name ?? resolved.name,
+      description: input.description,
+      mention: input.mention
+    });
+  });
+  const normalizeImageAttachment = Effect.fn("SessionPrompt.normalizeImageAttachment")(function* (input, data, mime) {
+    if (!mime.startsWith("image/"))
+      return { data: Base64.make(data), mime };
+    const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
+    const content = { uri: label, content: data, encoding: "base64", mime };
+    const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError({ uri: label, message: error.message })));
+    return { data: Base64.make(normalized.content), mime: normalized.mime };
+  });
+  const readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function* (uri) {
+    const url = yield* Effect.try({
+      try: () => new URL(uri),
+      catch: () => new AttachmentError({ uri, message: `Invalid attachment URI: ${uri}` })
+    });
+    if (url.protocol !== "file:")
+      return yield* new AttachmentError({ uri, message: `Unsupported attachment URI: ${uri}` });
+    const start = positiveInt(url.searchParams.get("start"));
+    const end = positiveInt(url.searchParams.get("end"));
+    const target = yield* Effect.try({
+      try: () => {
+        url.search = "";
+        url.hash = "";
+        return fileURLToPath(url);
+      },
+      catch: () => new AttachmentError({ uri, message: `Invalid file URI: ${uri}` })
+    });
+    const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+    if (info.type === "Directory") {
+      const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+      return {
+        bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
+`)),
+        source: { type: "uri", uri },
+        start: undefined,
+        end: undefined,
+        name: path.basename(target),
+        mime: "application/x-directory"
+      };
+    }
+    if (info.type !== "File")
+      return yield* new AttachmentError({ uri, message: `Attachment is not a file: ${uri}` });
+    if (Number(info.size) > MAX_ATTACHMENT_BYTES)
+      return yield* new AttachmentError({
+        uri,
+        message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
+      });
+    const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+    return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
+  });
+  return { prepare };
+});
+
+class Service extends Context.Service()("@opencode/SessionPrompt") {
+}
+var layer = Layer.effect(Service, make());
+var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function decodeDataURL(uri) {
+  return Effect.try({
+    try: () => {
+      const comma = uri.indexOf(",");
+      if (comma === -1)
+        throw new Error("Invalid data URL");
+      const metadata = uri.slice(5, comma);
+      const payload = uri.slice(comma + 1);
+      if (!metadata.split(";").some((part) => part.toLowerCase() === "base64"))
+        return Buffer.from(decodeURIComponent(payload));
+      const bytes = Buffer.from(payload, "base64");
+      if (bytes.toString("base64") !== payload)
+        throw new Error("Non-canonical base64");
+      return bytes;
+    },
+    catch: () => new AttachmentError({ uri, message: "Invalid attachment data URL" })
+  });
+}
+function positiveInt(value) {
+  if (value === null)
+    return;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+export { make, Service, layer, exports_prompt };

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

@@ -1,9 +1,9 @@
 import {
   exports_state
-} from "./project-x89rah0x.js";
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/filesystem/location-watcher-policy.ts
 var exports_location_watcher_policy = {};

package/dist/chunks/{project-a0s5dkct.js → model-7afh56wg.js}

@@ -1,21 +1,21 @@
 import {
   exports_entry_observer
-} from "./project-kp1t5rcy.js";
+} from "./model-kp1t5rcy.js";
 import {
   exports_reference
-} from "./project-qxsjpy8c.js";
+} from "./model-pywyq33w.js";
 import {
   exports_config
-} from "./project-6kmefejb.js";
+} from "./model-qmpdqet2.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
 import {
   AbsolutePath
-} from "./project-j07kk359.js";
+} from "./model-j07kk359.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/config/plugin/reference.ts
 var exports_reference2 = {};
@@ -35,7 +35,6 @@ var Plugin = define({
     const global = yield* Global.Service;
     const loaded = yield* exports_entry_observer.observe(config, ctx.event, ctx.reference.reload());
     yield* ctx.reference.transform((draft) => {
-      const entries = new Map;
       for (const doc of loaded.entries.filter((entry) => entry.type === "document")) {
         const directory = doc.path ? path.dirname(doc.path) : location.directory;
         for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
@@ -43,7 +42,7 @@ var Plugin = define({
             continue;
           const description = typeof entry === "string" ? undefined : entry.description;
           const hidden = typeof entry === "string" ? undefined : entry.hidden;
-          entries.set(name, local(entry) ? exports_reference.LocalSource.make({
+          draft.add(name, local(entry) ? exports_reference.LocalSource.make({
             type: "local",
             path: AbsolutePath.make(localPath(directory, global.home, typeof entry === "string" ? entry : entry.path)),
             ...description === undefined ? {} : { description },
@@ -57,8 +56,6 @@ var Plugin = define({
           }));
         }
       }
-      for (const [name, source] of entries)
-        draft.add(name, source);
     });
   })
 });

package/dist/chunks/{project-f7q7a28y.js → model-7ccgh94t.js}

@@ -1,15 +1,15 @@
-import {
-  exports_id
-} from "./project-58xdvehb.js";
 import {
   exports_file_retention
-} from "./project-hp6rpdnc.js";
+} from "./model-hp6rpdnc.js";
+import {
+  exports_id
+} from "./model-58xdvehb.js";
 import {
   exports_state
-} from "./project-x89rah0x.js";
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/tool-output.ts
 var exports_tool_output = {};

package/dist/chunks/{project-vqt151v9.js → model-7dhnf1ge.js}

@@ -1,12 +1,12 @@
-import {
-  exports_state
-} from "./project-x89rah0x.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
+import {
+  exports_state
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/agent.ts
 var exports_agent = {};

package/dist/chunks/{project-t16napr0.js → model-7drm3h8s.js}

@@ -1,15 +1,15 @@
-import {
-  exports_integration
-} from "./project-pm64n062.js";
 import {
   exports_app
-} from "./project-50jxp3hw.js";
+} from "./model-50jxp3hw.js";
+import {
+  exports_integration
+} from "./model-19vx63bj.js";
 import {
   exports_credential
-} from "./project-qhe68xsc.js";
+} from "./model-e6tx6p0e.js";
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./model-fex42j86.js";
 
 // src/plugin/provider/xai.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";

package/dist/chunks/{project-h2h934sz.js → model-7fr2g77j.js}

@@ -1,15 +1,15 @@
-import {
-  exports_parallel
-} from "./project-5fe026tx.js";
 import {
   exports_exa
-} from "./project-f9wt0tjw.js";
+} from "./model-f9wt0tjw.js";
 import {
   exports_tavily
-} from "./project-bh1wr8rq.js";
+} from "./model-bh1wr8rq.js";
+import {
+  exports_parallel
+} from "./model-5fe026tx.js";
 import {
   exports_firecrawl
-} from "./project-vqbmgfq1.js";
+} from "./model-vqbmgfq1.js";
 
 // src/plugin/websearch/index.ts
 var WebSearchPlugins = [

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

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/oauth/page.ts
 var exports_page = {};