@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-k996mbzp.js

@@ -0,0 +1,260 @@
+import {
+  Metadata2,
+  useragent2,
+  node56
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  provenance2,
+  compatible2
+} from "./aisdk-native-msq0jde0.js";
+import {
+  Service63,
+  node67
+} from "./aisdk-native-ra3qct3x.js";
+import {
+  DeclinedError2
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  CancelledError2
+} from "./aisdk-native-0cpfncfh.js";
+import {
+  Error2
+} from "./aisdk-native-g27wjat6.js";
+import {
+  Service26,
+  node31
+} from "./aisdk-native-a5fqa70n.js";
+import {
+  make13
+} from "./aisdk-native-e82z9tr0.js";
+import {
+  toLLMMessages2
+} from "./aisdk-native-p33ejz0k.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  Service: () => Service25,
+  SessionModelRequest: () => exports_model_request,
+  baseTranscript: () => baseTranscript2,
+  boundImages: () => boundImages2,
+  layer: () => layer9,
+  node: () => node30,
+  unsupportedParts: () => unsupportedParts2
+});
+import {
+  GenerationOptions,
+  HttpOptions,
+  LanguageModel,
+  LLM,
+  LLMRequest,
+  Message,
+  SystemPart
+} from "@opencode/ai";
+import { Cause, Context, Effect, Layer, Result, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024;
+var IMAGE_BYTES_TARGET = 15 * 1024 * 1024;
+var IMAGE_REMOVED = "[This image was removed to reduce the request size and is no longer visible. Do not make claims about its contents from memory. If needed, retrieve it again with an available tool or ask the user to attach it again.]";
+var GENERATION_KEYS = new Set(Object.keys(GenerationOptions.fields));
+var baseTranscript2 = (input) => {
+  const providerMetadataKey = input.model.model.route.providerMetadataKey ?? input.model.model.provider;
+  return {
+    providerMetadataKey,
+    system: [
+      input.agent.system ? input.agent.system : make13(input.tools.definitions.map((tool) => tool.name)),
+      input.initial
+    ].filter((part) => part.length > 0).map(SystemPart.make),
+    messages: toLLMMessages2(input.messages, input.model.ref, providerMetadataKey)
+  };
+};
+var mimeToModality = (mime) => {
+  if (mime.startsWith("image/"))
+    return "image";
+  if (mime.startsWith("audio/"))
+    return "audio";
+  if (mime.startsWith("video/"))
+    return "video";
+  if (mime === "application/pdf")
+    return "pdf";
+};
+var unsupportedMedia = (mime, name, capabilities) => {
+  const modality = mimeToModality(mime);
+  if (!modality || capabilities.input.some((item) => item.startsWith(modality)))
+    return;
+  return {
+    type: "text",
+    text: `ERROR: Cannot read ${name ? `"${name}"` : modality} (this model does not support ${modality} input). Inform the user.`
+  };
+};
+var unsupportedParts2 = (messages, capabilities) => messages.map((message) => Message.make({
+  ...message,
+  content: message.content.map((part) => {
+    if (part.type === "media") {
+      return unsupportedMedia(part.mediaType, part.filename, capabilities) ?? part;
+    }
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return part;
+    return {
+      ...part,
+      result: {
+        ...part.result,
+        value: part.result.value.map((item) => {
+          if (item.type !== "file")
+            return item;
+          return unsupportedMedia(item.mime, item.name, capabilities) ?? item;
+        })
+      }
+    };
+  })
+}));
+var boundImages2 = (messages) => {
+  const isImage = (mime) => mime.toLowerCase().startsWith("image/");
+  const size = (data) => typeof data === "string" ? Buffer.byteLength(data) : Math.ceil(data.byteLength / 3) * 4;
+  const imageBytes = messages.reduce((total, message) => total + message.content.reduce((sum, part) => {
+    if (part.type === "media" && isImage(part.mediaType))
+      return sum + size(part.data);
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return sum;
+    return sum + part.result.value.reduce((bytes, item) => bytes + (item.type === "file" && isImage(item.mime) ? Buffer.byteLength(item.uri) : 0), 0);
+  }, 0), 0);
+  if (imageBytes <= IMAGE_BYTES_TRIGGER)
+    return messages;
+  let removed = 0;
+  return messages.map((message) => Message.make({
+    ...message,
+    content: message.content.map((part) => {
+      if (part.type === "media" && isImage(part.mediaType) && imageBytes - removed > IMAGE_BYTES_TARGET) {
+        removed += size(part.data);
+        return Message.text(IMAGE_REMOVED);
+      }
+      if (part.type !== "tool-result" || part.result.type !== "content")
+        return part;
+      return {
+        ...part,
+        result: {
+          ...part.result,
+          value: part.result.value.map((item) => {
+            if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
+              return item;
+            removed += Buffer.byteLength(item.uri);
+            return { type: "text", text: IMAGE_REMOVED };
+          })
+        }
+      };
+    })
+  }));
+};
+
+class Service25 extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer9 = Layer.effect(Service25, Effect.gen(function* () {
+  const hooks = yield* Service63;
+  const transport = yield* Service26;
+  const app = yield* Metadata2;
+  const prepare = Effect.fn("SessionModelRequest.prepare")(function* (kind, input, shape) {
+    const session = input.session;
+    const model = input.model;
+    const scope = { sessionID: session.id, agent: input.agent, model: model.ref, kind };
+    const tools = input.tools ?? {
+      definitions: [],
+      execute: () => new Error2({ message: "Tools are not available for this request" })
+    };
+    const given = new Map(tools.definitions.map((t) => [{ description: t.description, input: { ...t.inputSchema } }, t]));
+    const shaped = yield* shape({ sessionID: session.id, model: model.ref, system: input.system, messages: input.messages, options: {} }, Object.fromEntries(Array.from(given, ([d, t]) => [t.name, d])));
+    const byName = new Map(tools.definitions.map((t) => [t.name, t]));
+    const hooked = new Map(Object.entries(shaped.tools ?? {}).flatMap(([name, d]) => {
+      const t = given.get(d) ?? byName.get(name);
+      return t ? [[name, { ...t, description: d.description, inputSchema: d.input }]] : [];
+    }));
+    const entries = Object.entries(shaped.options);
+    const generation = Object.fromEntries(entries.filter(([k]) => GENERATION_KEYS.has(k)));
+    const providerOptions = Object.fromEntries(entries.filter(([k]) => !GENERATION_KEYS.has(k)));
+    const root = session.fork?.sessionID ?? session.id;
+    const base = LLM.request({
+      model: model.model,
+      http: {
+        headers: {
+          "x-session-affinity": session.id,
+          "X-Session-Id": session.id,
+          ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+          "User-Agent": useragent2(app),
+          "x-opencode-project": session.projectID,
+          "x-opencode-session": session.id,
+          "x-opencode-client": app.name
+        }
+      },
+      promptCacheKey: /^ses_[0-9a-f]{64}$/.test(root) ? root.slice(4) : root,
+      system: shaped.system,
+      messages: boundImages2(unsupportedParts2(shaped.messages, model.capabilities)),
+      tools: Array.from(hooked, ([name, t]) => ({ ...t, name })),
+      toolChoice: input.toolChoice,
+      generation: Object.keys(generation).length === 0 ? undefined : generation,
+      providerOptions: Object.keys(providerOptions).length === 0 ? undefined : providerOptions
+    });
+    const baseURL = base.model.route.endpoint.baseURL;
+    const modelHook = yield* hooks.trigger("session", "model.request", {
+      ...scope,
+      baseURL: typeof baseURL === "string" ? baseURL : undefined,
+      headers: { ...base.http?.headers }
+    });
+    const route = modelHook.baseURL !== undefined && modelHook.baseURL !== baseURL ? base.model.route.with({ endpoint: { baseURL: modelHook.baseURL } }) : base.model.route;
+    const request = LLMRequest.update(base, {
+      model: route === base.model.route ? base.model : LanguageModel.update(base.model, { route }),
+      http: new HttpOptions({
+        body: base.http?.body,
+        headers: Object.keys(modelHook.headers).length === 0 ? undefined : modelHook.headers,
+        query: base.http?.query
+      })
+    });
+    const selected = provenance2(model);
+    if (selected && !compatible2(selected, provenance2({ model: request.model, ref: model.ref })) && request.messages.some((message) => message.content.some((part) => part.type === "compaction")))
+      return yield* Effect.die(new Error("Provider context is incompatible with the route selected by model request hooks"));
+    const hasHttpHooks = (yield* hooks.has("session", "http.request", model.ref.providerID)) || (yield* hooks.has("session", "http.response", model.ref.providerID));
+    const http = hasHttpHooks ? (req, handler) => Effect.gen(function* () {
+      const before = yield* hooks.trigger("session", "http.request", {
+        ...scope,
+        request: yield* HttpClientRequest.toWeb(req)
+      });
+      let sent = HttpClientRequest.fromWeb(before.request);
+      if (before.request.body)
+        sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+      const res = yield* handler(sent);
+      const after = yield* hooks.trigger("session", "http.response", {
+        ...scope,
+        request: before.request,
+        response: new Response([204, 205, 304].includes(res.status) ? null : yield* Stream.toReadableStreamEffect(res.stream), { status: res.status, headers: res.headers })
+      });
+      return HttpClientResponse.fromWeb(sent, after.response);
+    }).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause)))) : undefined;
+    const webSocket = input.webSocket === "session" && !hasHttpHooks && model.capabilities.responsesWebsockets === true && model.websocket;
+    return {
+      event: shaped,
+      request,
+      options: { ...http ? { http } : {}, ...webSocket ? { webSocket: transport.bind(session.id) } : {} },
+      retry: (event) => hooks.trigger("session", "retry", event).pipe(Effect.asVoid),
+      executeTool: (call) => tools.execute({ ...call, definitions: hooked }).pipe(Effect.catchCauseFilter((cause) => {
+        const decline = cause.reasons.flatMap((r) => Cause.isDieReason(r) && (r.defect instanceof DeclinedError2 || r.defect instanceof CancelledError2) ? [r.defect] : [])[0];
+        return decline ? Result.succeed(decline) : Result.fail(cause);
+      }, (decline) => Effect.fail(decline)))
+    };
+  });
+  const agentHook = (name, agent) => (draft, tools) => hooks.trigger("session", name, { ...draft, agent, tools });
+  return Service25.of({
+    primary: (input) => prepare("primary", input, agentHook("context", input.agent)),
+    compaction: (input) => prepare("compaction", input, agentHook("compaction", input.agent)),
+    generate: (input) => prepare("generate", input, agentHook("generate", input.agent)),
+    title: (input) => prepare("title", input, (draft) => hooks.trigger("session", "title", draft))
+  });
+}));
+var node30 = makeLocationNode({
+  service: Service25,
+  layer: layer9,
+  deps: [node67, node31, node56]
+});
+
+export { baseTranscript2, unsupportedParts2, boundImages2, Service25, layer9, node30, exports_model_request };

package/dist/chunks/aisdk-native-kg06axw8.js

@@ -0,0 +1,162 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/state.ts
+var exports_state = {};
+__export(exports_state, {
+  State: () => exports_state,
+  batch: () => batch2,
+  create: () => create3,
+  group: () => group2,
+  inherit: () => inherit2,
+  reconcile: () => reconcile2,
+  shutdown: () => shutdown2
+});
+import { Cause, Context, Effect, Exit, Fiber, Scope } from "effect";
+var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
+  defaultValue: () => {
+    return;
+  }
+});
+function group2(report) {
+  const group = { failed: false, registrations: new Set, report };
+  return (effect) => Effect.provideService(effect, CurrentGroup, group);
+}
+function disable(group, failure) {
+  if (group.failed)
+    return;
+  group.failed = true;
+  const notifications = new Set;
+  for (const registration of group.registrations) {
+    registration.remove();
+    notifications.add(registration.notify);
+  }
+  group.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
+}
+var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
+  defaultValue: () => {
+    return;
+  }
+});
+function batch2(effect) {
+  return run(effect, false);
+}
+function shutdown2(effect) {
+  return run(effect, true);
+}
+function run(effect, shutdown) {
+  return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const current = yield* CurrentBatch;
+    if (current?.active && !shutdown)
+      return yield* restore(effect);
+    const batch = { active: true, shutdown, notifications: new Set };
+    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch))).pipe(Effect.exit);
+    batch.active = false;
+    const notifications = yield* Effect.forEach(batch.notifications, (notify) => restore(notify).pipe(Effect.exit));
+    yield* Exit.asVoidAll([exit, ...notifications]);
+    return yield* exit;
+  }));
+}
+function reconcile2(root, fork, work) {
+  return Effect.gen(function* () {
+    const exit = yield* Fiber.await(fork(work()));
+    if (Exit.isFailure(exit) && root.state._tag === "Closed" && Cause.hasInterruptsOnly(exit.cause))
+      return;
+    yield* exit;
+  });
+}
+var inherit2 = Effect.fnUntraced(function* () {
+  const batch = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch);
+});
+function create3(options) {
+  let state = options.initial();
+  const transforms = new Set;
+  let dirty = false;
+  let closed = false;
+  let version = 0;
+  const invalidate = () => {
+    dirty = true;
+    version++;
+  };
+  const get = () => {
+    if (closed || !dirty)
+      return state;
+    while (true) {
+      const started = version;
+      const next = options.initial();
+      const editor = options.editor(next);
+      for (const transform of transforms) {
+        try {
+          transform.run(editor);
+        } catch (cause) {
+          if (!transform.group)
+            throw cause;
+          disable(transform.group, { state: options.name ?? "anonymous", cause });
+        }
+        if (version !== started)
+          break;
+      }
+      if (version !== started)
+        continue;
+      state = next;
+      dirty = false;
+      return state;
+    }
+  };
+  const notify = Effect.gen(function* () {
+    if (closed)
+      return;
+    const value = get();
+    if (options.notify)
+      yield* options.notify(value);
+  }).pipe(Effect.withSpan("State.notify"));
+  const changed = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    if (closed)
+      return;
+    invalidate();
+    const batch = yield* CurrentBatch;
+    if (batch?.active) {
+      if (batch.shutdown) {
+        closed = true;
+        return;
+      }
+      batch.notifications.add(notify);
+      return;
+    }
+    yield* restore(notify);
+  }));
+  return {
+    get,
+    transform: Effect.fn("State.transform")(function* (update) {
+      yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
+      const scope = yield* Scope.Scope;
+      const group = yield* CurrentGroup;
+      if (group?.failed)
+        return { dispose: Effect.void };
+      return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const transform = { run: update, group };
+        const registration = {
+          remove: () => {
+            if (!transforms.delete(transform))
+              return false;
+            group?.registrations.delete(registration);
+            invalidate();
+            return true;
+          },
+          notify: changed
+        };
+        const dispose = Effect.uninterruptible(Effect.suspend(() => registration.remove() ? changed : Effect.void));
+        transforms.add(transform);
+        group?.registrations.add(registration);
+        yield* Scope.addFinalizer(scope, dispose);
+        yield* changed;
+        return { dispose };
+      }));
+    }),
+    reload: () => changed
+  };
+}
+
+export { group2, batch2, shutdown2, reconcile2, inherit2, create3, exports_state };

package/dist/chunks/aisdk-native-km19zyfq.js

@@ -0,0 +1,207 @@
+import {
+  ID9,
+  Service62
+} from "./aisdk-native-x0v86zgp.js";
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  Service78,
+  args2
+} from "./aisdk-native-qx0n0hnh.js";
+import {
+  Service19
+} from "./aisdk-native-rqysayyh.js";
+import {
+  make10
+} from "./aisdk-native-fex1jrgj.js";
+import {
+  parseOption2
+} from "./aisdk-native-5daktx2q.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  ConfigCommandPlugin: () => exports_command,
+  Plugin: () => Plugin11
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode/schema/config/command";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { AppProcess } from "@opencode/util/process";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin11 = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const fs = yield* FSUtil.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [{ commands: entry.info.commands }];
+      if (entry.type !== "directory")
+        return [];
+      const commands = yield* loadDirectory(fs, entry.path);
+      return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }];
+    });
+    const location = yield* Service73;
+    const processes = yield* AppProcess.Service;
+    const shell = yield* Service78;
+    const sessions = yield* Service19;
+    const agents = yield* Service62;
+    const subagents = yield* make10;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((editor) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          const subagent = command.subagent ?? command.subtask;
+          editor.add({
+            name,
+            description: command.description,
+            execute: (input) => Effect.gen(function* () {
+              const agent = command.agent === undefined ? undefined : ID9.make(command.agent);
+              const commandAgent = agent === undefined ? undefined : (yield* ctx.agent.get({ agentID: agent })).data;
+              const model = command.model === undefined ? commandAgent?.model : {
+                id: Model.ID.make(command.model.model),
+                providerID: Provider.ID.make(command.model.providerID),
+                ...command.model.variant === undefined ? {} : { variant: Model.VariantID.make(command.model.variant) }
+              };
+              const text = yield* evaluateTemplate(command.template, input.prompt.text, {
+                location,
+                processes,
+                shell
+              });
+              if (subagent ?? commandAgent?.mode === "subagent") {
+                const parent = yield* sessions.get(input.sessionID);
+                const selected = yield* agents.select(agent ?? parent.agent);
+                const child = yield* sessions.create({
+                  parentID: parent.id,
+                  title: command.description ?? name,
+                  agent: selected.id,
+                  model: model ?? selected.info?.model ?? parent.model
+                });
+                yield* sessions.prompt({
+                  ...input.prompt,
+                  sessionID: child.id,
+                  text: ["You are a subagent spawned by another session.", text].join(`
+`),
+                  resume: false
+                });
+                const recovery = {
+                  kind: "subagent",
+                  parentSessionID: parent.id,
+                  childSessionID: child.id,
+                  agent: selected.id,
+                  description: command.description ?? name
+                };
+                yield* subagents.start(recovery);
+                yield* subagents.background(recovery);
+                return;
+              }
+              if (agent !== undefined) {
+                const session = yield* ctx.session.get({ sessionID: input.sessionID });
+                if (session.agent !== agent)
+                  yield* ctx.session.switchAgent({ sessionID: input.sessionID, agent });
+              }
+              if (model !== undefined)
+                yield* ctx.session.switchModel({ sessionID: input.sessionID, model });
+              yield* ctx.session.prompt({
+                ...input.prompt,
+                sessionID: input.sessionID,
+                text,
+                delivery: input.delivery
+              });
+            }).pipe(Effect.asVoid)
+          });
+        }
+      }
+    });
+  })
+});
+var sourceDirectories = ["command", "commands"];
+function isCommandSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function loadDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const files = yield* fs.scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.orElseSucceed(() => []));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.orElseSucceed(() => {
+      return;
+    }))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
+  if (!info)
+    return;
+  return {
+    name: path.relative(directory, filepath).replaceAll("\\", "/").replace(/^(command|commands)\//, "").replace(/\.md$/, ""),
+    info
+  };
+}
+function evaluateTemplate(template, input, services) {
+  return Effect.gen(function* () {
+    const args = parseArguments(input);
+    const placeholders = template.match(placeholderRegex) ?? [];
+    const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+    const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+      const position = Number(index);
+      const argIndex = position - 1;
+      if (argIndex >= args.length)
+        return "";
+      if (position === last)
+        return args.slice(argIndex).join(" ");
+      return args[argIndex];
+    });
+    const withArguments = expanded.replaceAll("$ARGUMENTS", () => input);
+    const text = placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim() ? `${withArguments}
+
+${input}`.trim() : withArguments.trim();
+    const matches = Array.from(text.matchAll(shellRegex));
+    if (matches.length === 0)
+      return text;
+    const shell = yield* services.shell.resolve({ priority: "config" });
+    const outputs = yield* Effect.forEach(matches, (match) => {
+      const source = match[1] ?? "";
+      return services.processes.run(ChildProcess.make(shell, args2(shell, source), {
+        cwd: services.location.directory,
+        stdin: "ignore"
+      }), { combineOutput: true }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`)));
+    }, { concurrency: 2 });
+    const iterator = outputs[Symbol.iterator]();
+    return text.replace(shellRegex, () => iterator.next().value ?? "");
+  });
+}
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+
+export { Plugin11, exports_command };

package/dist/chunks/aisdk-native-kns4vs3f.js

@@ -0,0 +1,49 @@
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  Service31
+} from "./aisdk-native-es98n7aa.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  ConfigMcpPlugin: () => exports_mcp,
+  Plugin: () => Plugin15,
+  register: () => register2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin15 = define({
+  id: "opencode.config.mcp",
+  effect: Effect.fn(function* (ctx) {
+    yield* register2(ctx.event.subscribe());
+  })
+});
+var register2 = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
+  const config = yield* Service35;
+  const mcp = yield* Service31;
+  const loaded = { entries: [] };
+  yield* events.pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(mcp.reload()), Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.ignore, Effect.forkScoped({ startImmediately: true }));
+  loaded.entries = yield* config.entries();
+  yield* mcp.transform((editor) => {
+    const documents = loaded.entries.filter((entry) => entry.type === "document");
+    const timeout = Object.assign({}, ...documents.flatMap((entry) => entry.info.mcp?.timeout ? [entry.info.mcp.timeout] : []));
+    const servers = new Map;
+    for (const document of documents) {
+      for (const [name, server] of Object.entries(document.info.mcp?.servers ?? {})) {
+        servers.set(name, server);
+      }
+    }
+    for (const [name, server] of servers) {
+      if (editor.get(name))
+        continue;
+      editor.set(name, { ...server, timeout: { ...timeout, ...server.timeout } });
+    }
+  });
+});
+
+export { Plugin15, register2, exports_mcp };