@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,130 @@
+import {
+  Key3,
+  removed2,
+  make20,
+  diffByKey2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  Summary2,
+  summarize2,
+  namespaceLine2
+} from "./aisdk-native-3fc6dm20.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/codemode/instructions.ts
+var exports_instructions3 = {};
+__export(exports_instructions3, {
+  CodeModeInstructions: () => exports_instructions3,
+  make: () => make14,
+  render: () => render3,
+  update: () => update3
+});
+import { searchSignature, toolExpression } from "@opencode/codemode";
+import { Effect, Schema } from "effect";
+var prompt = (hasMoreTools) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.
+
+${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools callable inside \`execute\`. It does not affect tools exposed directly outside Code Mode.${hasMoreTools ? `
+
+## Search
+
+Call \`search(...)\` to discover exact paths and signatures for additional tools:
+
+- ${searchSignature}` : ""}
+
+## Available tools`;
+function render3(catalog) {
+  if (catalog.total === 0)
+    return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.";
+  const tools = catalog.namespaces.flatMap((namespace) => {
+    return [namespaceLine2(namespace), ...namespace.entries.map((entry) => entry.line)];
+  });
+  return `${prompt(catalog.shown < catalog.total)}
+
+${tools.join(`
+`)}`;
+}
+function update3(previous, current) {
+  const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
+
+${render3(current)}`;
+  if (current.total === 0)
+    return replacement;
+  const previousComplete = previous.shown === previous.total;
+  const currentComplete = current.shown === current.total;
+  if (previousComplete !== currentComplete)
+    return replacement;
+  const descriptions = diffByKey2(previous.namespaces.filter((namespace) => namespace.description !== undefined), current.namespaces.filter((namespace) => namespace.description !== undefined), (namespace) => namespace.name, (before, after) => before.description !== after.description);
+  if (descriptions.added.length > 0 || descriptions.removed.length > 0 || descriptions.changed.length > 0)
+    return replacement;
+  const diff = diffByKey2(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
+  const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+  if (!currentComplete) {
+    if (entriesChanged)
+      return replacement;
+    const namespaces = diffByKey2(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
+    const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0;
+    if (!changed)
+      return replacement;
+    const parts = ["The Code Mode tool catalog has changed."];
+    if (namespaces.added.length > 0) {
+      parts.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
+    }
+    if (namespaces.changed.length > 0) {
+      parts.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
+    }
+    if (namespaces.removed.length > 0) {
+      parts.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
+    }
+    const delta = parts.join(`
+
+`);
+    if (delta.length < replacement.length)
+      return delta;
+    return replacement;
+  }
+  if (!entriesChanged)
+    return replacement;
+  const parts = ["The Code Mode tool catalog has changed."];
+  if (diff.added.length > 0) {
+    parts.push([
+      "New tools are available in addition to those previously listed:",
+      ...diff.added.map((entry) => entry.line)
+    ].join(`
+`));
+  }
+  if (diff.changed.length > 0) {
+    parts.push([
+      "Changed tool listings supersede the previously listed ones:",
+      ...diff.changed.map((change) => change.current.line)
+    ].join(`
+`));
+  }
+  if (diff.removed.length > 0) {
+    parts.push(`The following tools are no longer available and must not be called: ${diff.removed.map((entry) => toolExpression(entry.path)).join(", ")}.`);
+  }
+  const delta = parts.join(`
+
+`);
+  if (delta.length < replacement.length)
+    return delta;
+  return replacement;
+}
+var key = Key3.make("core/codemode");
+var codec = Schema.toCodecJson(Summary2);
+var make14 = (inventory) => {
+  const catalog = inventory === undefined ? removed2 : summarize2(inventory);
+  return make20({
+    key,
+    codec,
+    read: Effect.succeed(catalog),
+    render: {
+      initial: render3,
+      changed: update3,
+      removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools."
+    }
+  });
+};
+
+export { render3, update3, make14, exports_instructions3 };

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

@@ -0,0 +1,330 @@
+import {
+  ID10,
+  Info23,
+  SessionSchema2
+} from "./aisdk-native-y6f0p4jw.js";
+import {
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  isSynced2,
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service74,
+  node79
+} from "./aisdk-native-ykq8g6tf.js";
+import {
+  Service42,
+  node45
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  SessionMessageTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  node43
+} from "./aisdk-native-0fm13a2s.js";
+import {
+  current2
+} from "./aisdk-native-cq37gk0t.js";
+import {
+  snapshot2
+} from "./aisdk-native-3175eqdp.js";
+import {
+  Slug2
+} from "./aisdk-native-gebd4c9n.js";
+import {
+  SessionAlreadyProjected2,
+  node25
+} from "./aisdk-native-xrekznn2.js";
+import {
+  Metadata2,
+  node56
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  NotFoundError7,
+  MessageNotFoundError2,
+  ForkEmptyError2,
+  MessageDecodeError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  AttachmentError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2,
+  SkillNotFoundError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  ListInput5,
+  Service61,
+  node65
+} from "./aisdk-native-smbad60v.js";
+import {
+  Service46,
+  node49
+} from "./aisdk-native-n09f2zd2.js";
+import {
+  Service38,
+  node42
+} from "./aisdk-native-ynnjbwyb.js";
+import {
+  llmClient2
+} from "./aisdk-native-5t3nmthw.js";
+import {
+  Service26,
+  node31
+} from "./aisdk-native-a5fqa70n.js";
+import {
+  generate3
+} from "./aisdk-native-v5dw3fed.js";
+import {
+  execute2
+} from "./aisdk-native-0nzv5c2w.js";
+import {
+  DestinationNotFoundError2,
+  DestinationNotDirectoryError2,
+  DestinationUnavailableError2,
+  Service20,
+  node24
+} from "./aisdk-native-dk95gbn1.js";
+import {
+  Service33,
+  node37
+} from "./aisdk-native-23279rje.js";
+import {
+  make12
+} from "./aisdk-native-qv308p2a.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session.ts
+var exports_session = {};
+__export(exports_session, {
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  ID: () => ID10,
+  InboxConflictError: () => InboxConflictError2,
+  Info: () => Info23,
+  ListAnchor: () => ListAnchor2,
+  ListInput: () => ListInput3,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  NotFoundError: () => NotFoundError7,
+  PromptConflictError: () => PromptConflictError2,
+  Service: () => Service19,
+  Session: () => exports_session,
+  SessionSchema: () => SessionSchema2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  node: () => node23
+});
+import { Effect, Layer, Schema, Context, Stream } from "effect";
+import { LLMClient } from "@opencode/ai";
+import { ListAnchor as ListAnchor2 } from "@opencode/schema/session";
+import { and, desc, eq } from "drizzle-orm";
+import { Model } from "@opencode/schema/model";
+import path from "path";
+import { Node } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+var ListInput3 = ListInput5;
+class Service19 extends Context.Service()("@opencode/Session") {
+}
+var layer = Layer.effect(Service19, Effect.gen(function* () {
+  const app = yield* Metadata2;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const projects = yield* Service74;
+  const execution = yield* Service38;
+  const llm = yield* LLMClient.Service;
+  const transport = yield* Service26;
+  const store = yield* Service61;
+  const instances = yield* Service42;
+  const moves = yield* Service20;
+  const jobs = yield* Service46;
+  const environments = yield* Service33;
+  const sessions = yield* make12();
+  const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
+  const result = Service19.of({
+    create: Effect.fn("Session.create")(function* (input) {
+      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 NotFoundError7({ 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(SessionEvent2.Created, {
+        sessionID,
+        slug: Slug2.create(),
+        version: app.version,
+        projectID: project.id,
+        parentID: input.parentID,
+        location,
+        subpath: RelativePath2.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        title: input.title,
+        agent: input.agent,
+        metadata: input.metadata ?? parent?.metadata,
+        permissions: input.permissions ?? parent?.permissions,
+        model: input.model ? {
+          id: Model.ID.make(input.model.id),
+          providerID: input.model.providerID,
+          variant: input.model.variant
+        } : undefined
+      }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
+        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)));
+      }));
+      if (projected.type === "existing")
+        return projected.session;
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    fork: Effect.fn("Session.fork")(function* (input) {
+      const parent = yield* result.get(input.sessionID);
+      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 MessageNotFoundError2({
+          sessionID: input.sessionID,
+          messageID: input.boundary.messageID
+        });
+      if (!boundary)
+        return yield* new ForkEmptyError2({ sessionID: input.sessionID });
+      const sessionID = SessionSchema2.ID.create();
+      const inherited = yield* db.transaction(() => Effect.all({
+        instructions: current2(db, parent.id),
+        instructionEntries: snapshot2(db, parent.id)
+      })).pipe(Effect.orDie);
+      yield* bus.publish(SessionEvent2.Forked, {
+        sessionID,
+        parentID: parent.id,
+        boundary: { ...input.boundary, messageID: boundary.id },
+        ...inherited
+      });
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    get: (sessionID) => sessions.forSession(sessionID).get(),
+    environment: Effect.fn("Session.environment")(function* (input) {
+      yield* result.get(input.sessionID);
+      if (input.variables !== undefined)
+        yield* environments.set(input.sessionID, input.variables);
+      return yield* environments.get(input.sessionID);
+    }),
+    view: (input) => sessions.forSession(input.sessionID).view(input),
+    remove: Effect.fn("Session.remove")(function* (sessionID) {
+      yield* result.get(sessionID);
+      yield* execution.interrupt(sessionID);
+      yield* execution.awaitIdle(sessionID);
+      yield* transport.close(sessionID);
+      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(SessionEvent2.Deleted, { sessionID });
+      yield* bus.remove(sessionID);
+    }),
+    list: Effect.fn("Session.list")(function* (input) {
+      return { data: yield* store.list(input) };
+    }),
+    messages: Effect.fn("Session.messages")(function* (input) {
+      yield* result.get(input.sessionID);
+      return yield* store.messages(input);
+    }),
+    message: (input) => sessions.forSession(input.sessionID).message(input.messageID),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
+    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) => 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* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service42, 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* execute2({ ...input, session }).pipe(Effect.provideService(Service42, instances));
+    }),
+    shell: (input) => sessions.forSession(input.sessionID).shell(input),
+    skill: (input) => sessions.forSession(input.sessionID).skill(input),
+    switchAgent: (input) => sessions.forSession(input.sessionID).switchAgent(input),
+    switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
+    rename: (input) => sessions.forSession(input.sessionID).rename(input),
+    setPermissions: (input) => sessions.forSession(input.sessionID).setPermissions(input),
+    move: moves.move,
+    compact: (input) => sessions.forSession(input.sessionID).compact(input),
+    wait: (sessionID) => sessions.forSession(sessionID).wait(),
+    active: execution.active,
+    background: Effect.fn("Session.background")(function* (sessionID) {
+      yield* result.get(sessionID);
+      const backgrounded = yield* jobs.backgroundAll({ sessionID });
+      if (backgrounded.length === 0)
+        return;
+      yield* result.synthetic({
+        sessionID,
+        text: [
+          "User requested that active blocking work be moved to the background.",
+          "",
+          "Backgrounded work:",
+          ...backgrounded.map((job) => `- ${job.type}: ${job.title && job.title.length > 0 ? job.title : job.id}`),
+          "",
+          "The backgrounded work is still unfinished. Move on to other work if you can. If there is nothing else useful to do, finish your response. Do not wait, sleep, poll, or report the backgrounded work as complete until a later completion notification is added to the conversation."
+        ].join(`
+`)
+      }).pipe(Effect.catchTag("Session.SyntheticConflictError", Effect.die));
+    }),
+    resume: (sessionID) => sessions.forSession(sessionID).resume(),
+    synthetic: (input) => sessions.forSession(input.sessionID).synthetic(input),
+    interrupt: (sessionID, options) => sessions.forSession(sessionID).interrupt(options),
+    revert: {
+      stage: (input) => sessions.forSession(input.sessionID).revert.stage(input),
+      clear: (sessionID) => sessions.forSession(sessionID).revert.clear(),
+      commit: (sessionID) => sessions.forSession(sessionID).revert.commit()
+    }
+  });
+  return result;
+}));
+var node23 = Node.makeGlobalNode({
+  service: Service19,
+  layer,
+  deps: [
+    node49,
+    node37,
+    node85,
+    node84,
+    node79,
+    node42,
+    node31,
+    llmClient2,
+    node65,
+    node45,
+    node43,
+    node24,
+    node25,
+    FSUtil.node,
+    node56
+  ]
+});
+
+export { ListAnchor2, ListInput3, Service19, node23, exports_session };

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

@@ -0,0 +1,77 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/opencode.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  MoveInput: () => MoveInput2,
+  OpenCodeTools: () => exports_opencode,
+  Plugin: () => Plugin35,
+  RenameInput: () => RenameInput2
+});
+import { SystemPart, ToolFailure } from "@opencode/ai";
+import { AbsolutePath } from "@opencode/schema/schema";
+import { Session } from "@opencode/schema/session";
+import { Effect, Schema } from "effect";
+var RenameInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to rename the current session." }),
+  title: Schema.String.check(Schema.isMinLength(1)).annotate({ description: "New session title." })
+});
+var RenameOutput = Schema.Struct({ sessionID: Session.ID, title: Schema.String });
+var MoveInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to move the current session." }),
+  directory: AbsolutePath.check(Schema.isMinLength(1)).annotate({
+    description: "Destination directory, relative to the target session's directory or absolute. Supports ~."
+  })
+});
+var MoveOutput = Schema.Struct({ sessionID: Session.ID, directory: AbsolutePath });
+var Plugin35 = {
+  id: "opencode.tools",
+  effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      event.system.push(SystemPart.make("When you create a worktree outside the current working directory and intend to use it as your primary working directory, consider using `execute` to call `tools.opencode.session_move` and make the worktree the session's working directory."));
+    }));
+    yield* ctx.tool.transform((draft) => {
+      draft.namespace({ name: "opencode", description: "OpenCode session and runtime tools." });
+      draft.add({
+        name: "session_rename",
+        description: "Rename a session, or omit sessionID to rename the current session. Use a short, specific title that summarizes the work being done.",
+        input: RenameInput2,
+        output: RenameOutput,
+        options: { namespace: "opencode", codemode: true },
+        execute: (input, context) => {
+          const sessionID = input.sessionID ?? context.sessionID;
+          const title = input.title.trim();
+          if (!title)
+            return Effect.fail(new ToolFailure({ message: "Session title must not be empty" }));
+          return ctx.session.rename({ sessionID, title }).pipe(Effect.as({
+            output: { sessionID, title },
+            content: `Renamed session ${sessionID} to ${title}.`
+          }), Effect.mapError((error) => new ToolFailure({ message: `Unable to rename session ${sessionID}`, error })));
+        }
+      });
+      draft.add({
+        name: "session_move",
+        description: "Move a session to another directory, or omit sessionID to move the current session. The current session moves at the next safe boundary; do not run destination-dependent tools in the same execute call.",
+        input: MoveInput2,
+        output: MoveOutput,
+        options: { namespace: "opencode", codemode: true, pinned: true },
+        execute: (input, context) => Effect.gen(function* () {
+          const sessionID = input.sessionID ?? context.sessionID;
+          yield* ctx.session.move({
+            sessionID,
+            directory: input.directory,
+            delivery: "steer"
+          });
+          return {
+            output: { sessionID, directory: input.directory },
+            content: `Moved session ${sessionID} to ${input.directory}.`
+          };
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to move session to ${input.directory}`, error })))
+      });
+    }).pipe(Effect.orDie);
+  })
+};
+
+export { RenameInput2, MoveInput2, Plugin35, exports_opencode };

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

@@ -0,0 +1,31 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/project/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  Current: () => Current3,
+  Event: () => Event20,
+  ID: () => ID17,
+  Info: () => Info32,
+  ProjectSchema: () => exports_schema,
+  UpdateInput: () => UpdateInput4,
+  Vcs: () => Vcs3
+});
+import { Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+var ID17 = Project.ID;
+var Current3 = Project.Current;
+var Info32 = Project.Info;
+var UpdateInput4 = Project.UpdateInput;
+var Event20 = Project.Event;
+var Vcs3 = Schema.Struct({
+  type: Project.Vcs,
+  store: AbsolutePath2
+});
+
+export { ID17, Current3, Info32, UpdateInput4, Event20, Vcs3, exports_schema };

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

@@ -0,0 +1,37 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/mcp-codemode-exclusion.ts
+var exports_mcp_codemode_exclusion = {};
+__export(exports_mcp_codemode_exclusion, {
+  McpCodeModeExclusionPlugin: () => exports_mcp_codemode_exclusion,
+  Plugin: () => Plugin28
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var urls = [/^https:\/\/executor\.sh\/[^/]+\/mcp$/];
+var Plugin28 = define({
+  id: "opencode.mcp.codemode.exclusion",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.mcp.transform((editor) => {
+      for (const [, server] of editor.list()) {
+        if (server.codemode !== undefined)
+          continue;
+        if (server.type === "local") {
+          if (server.command[0] === "executor" && server.command[1] === "mcp")
+            server.codemode = false;
+          continue;
+        }
+        if (!URL.canParse(server.url))
+          continue;
+        const url = new URL(server.url);
+        const endpoint = `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+        if (urls.some((pattern) => pattern.test(endpoint)))
+          server.codemode = false;
+      }
+    });
+  })
+});
+
+export { Plugin28, exports_mcp_codemode_exclusion };