@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-d6vvk673.js

@@ -0,0 +1,149 @@
+import {
+  __export,
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  packageName: () => packageName,
+  mergeOverlay: () => mergeOverlay,
+  mergeHeaders: () => mergeHeaders,
+  loadPackage: () => loadPackage,
+  isAISDK: () => isAISDK,
+  aisdk: () => aisdk,
+  Settings: () => Settings,
+  Request: () => Request,
+  Provider: () => exports_provider,
+  LoadError: () => LoadError,
+  Info: () => Info,
+  ID: () => ID,
+  AISDK_PREFIX: () => AISDK_PREFIX
+});
+import { Effect, Schema } from "effect";
+import { Provider } from "@opencode-ai/schema/provider";
+import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
+var ID = Provider.ID;
+var AISDK_PREFIX = "aisdk:";
+var isAISDK = (value) => value?.startsWith(AISDK_PREFIX) ?? false;
+var aisdk = (value) => isAISDK(value) ? value : `${AISDK_PREFIX}${value}`;
+function packageName(value) {
+  if (value === undefined || !isAISDK(value))
+    return value;
+  return value.slice(AISDK_PREFIX.length);
+}
+var JsonRecord = Schema.Record(Schema.String, Schema.Json);
+var decodeJsonRecord = Schema.decodeUnknownSync(JsonRecord);
+
+class LoadError extends Schema.TaggedErrorClass()("Provider.LoadError", {
+  package: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var packages = new Map;
+var builtins = new Map([
+  ["@opencode-ai/ai/providers/amazon-bedrock", () => import("@opencode-ai/ai/providers/amazon-bedrock")],
+  ["@opencode-ai/ai/providers/amazon-bedrock/mantle", () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle")],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/chat",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/chat")
+  ],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/responses",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/responses")
+  ],
+  ["@opencode-ai/ai/providers/anthropic", () => import("@opencode-ai/ai/providers/anthropic")],
+  ["@opencode-ai/ai/providers/azure", () => import("@opencode-ai/ai/providers/azure")],
+  ["@opencode-ai/ai/providers/azure/chat", () => import("@opencode-ai/ai/providers/azure/chat")],
+  ["@opencode-ai/ai/providers/azure/responses", () => import("@opencode-ai/ai/providers/azure/responses")],
+  ["@opencode-ai/ai/providers/google", () => import("@opencode-ai/ai/providers/google")],
+  ["@opencode-ai/ai/providers/openai", () => import("@opencode-ai/ai/providers/openai")],
+  ["@opencode-ai/ai/providers/openai/chat", () => import("@opencode-ai/ai/providers/openai/chat")],
+  ["@opencode-ai/ai/providers/openai/responses", () => import("@opencode-ai/ai/providers/openai/responses")],
+  ["@opencode-ai/ai/providers/openai-compatible", () => import("@opencode-ai/ai/providers/openai-compatible")],
+  ["@opencode-ai/ai/providers/openrouter", () => import("@opencode-ai/ai/providers/openrouter")],
+  ["@opencode-ai/ai/providers/xai", () => import("@opencode-ai/ai/providers/xai")]
+]);
+var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
+  const builtin = builtins.get(specifier);
+  if (builtin)
+    return yield* importPackage(specifier, specifier, builtin);
+  const resolved = yield* Effect.sync(() => {
+    if (specifier.startsWith("file://") || specifier.startsWith("@opencode-ai/ai/"))
+      return specifier;
+    try {
+      return import.meta.resolve(specifier);
+    } catch {
+      return;
+    }
+  });
+  if (resolved)
+    return yield* importPackage(specifier, resolved);
+  if (!npm) {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} is not installed`)
+    });
+  }
+  const parts = specifier.split("/");
+  const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError({ package: specifier, cause })));
+  const entrypoint = yield* Effect.try({
+    try: () => specifier === root && installed.entrypoint ? installed.entrypoint : resolveModule(specifier, installed.directory),
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  return yield* importPackage(specifier, entrypoint);
+});
+function mergeOverlay(base, overlay) {
+  if (base === undefined)
+    return overlay && decodeJsonRecord({ ...overlay });
+  if (overlay === undefined)
+    return decodeJsonRecord({ ...base });
+  return decodeJsonRecord(Object.fromEntries(new Set([...Object.keys(base), ...Object.keys(overlay)]).values().map((key) => {
+    const left = base[key];
+    const right = overlay[key];
+    if (right === undefined)
+      return [key, left];
+    if (typeof left === "object" && left !== null && !Array.isArray(left) && typeof right === "object" && right !== null && !Array.isArray(right))
+      return [
+        key,
+        mergeOverlay(left, right) ?? {}
+      ];
+    return [key, right];
+  })));
+}
+function mergeHeaders(base, overlay) {
+  if (base === undefined)
+    return overlay && { ...overlay };
+  if (overlay === undefined)
+    return { ...base };
+  return Object.fromEntries([...Object.entries(base), ...Object.entries(overlay)].reduce((result, entry) => {
+    result.set(entry[0].toLowerCase(), entry);
+    return result;
+  }, new Map).values());
+}
+var Request = Provider.Request;
+var Settings = Provider.Settings;
+var Info = Provider.Info;
+var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, entrypoint, load = () => importModule(entrypoint)) {
+  const module = yield* Effect.tryPromise({
+    try: () => {
+      const existing = packages.get(entrypoint);
+      if (existing)
+        return existing;
+      const loaded = load();
+      packages.set(entrypoint, loaded);
+      return loaded;
+    },
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  if (typeof module !== "object" || module === null || typeof module.model !== "function") {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} does not export model(modelID, settings)`)
+    });
+  }
+  return module;
+});
+
+export { ID, AISDK_PREFIX, isAISDK, aisdk, packageName, LoadError, loadPackage, mergeOverlay, mergeHeaders, Request, Settings, Info, exports_provider };

package/dist/chunks/permission-dbah77c1.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/local-shell.ts
+import { z } from "zod/v4";
+var localShellInputSchema = z.object({
+  action: z.object({
+    type: z.literal("exec"),
+    command: z.array(z.string()),
+    timeoutMs: z.number().optional(),
+    user: z.string().optional(),
+    workingDirectory: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional()
+  })
+});
+var localShellOutputSchema = z.object({
+  output: z.string()
+});
+
+export { localShellInputSchema, localShellOutputSchema };

package/dist/chunks/permission-ddn74qps.js

@@ -0,0 +1,37 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/anthropic.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var AnthropicPlugin = define({
+  id: "opencode.provider.anthropic",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/anthropic")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "anthropic-beta": "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
+          };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/anthropic")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"));
+      evt.sdk = mod.createAnthropic(evt.options);
+    }));
+  })
+});
+
+export { AnthropicPlugin };

package/dist/chunks/permission-df3v2q6j.js

@@ -0,0 +1,77 @@
+// src/util/slug.ts
+var Slug;
+((Slug) => {
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty"
+  ];
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf"
+  ];
+  function create() {
+    return [
+      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
+      NOUNS[Math.floor(Math.random() * NOUNS.length)]
+    ].join("-");
+  }
+  Slug.create = create;
+})(Slug ||= {});
+
+export { Slug };

package/dist/chunks/permission-dhcq6c44.js

@@ -0,0 +1,14 @@
+// src/database/migration/20260227213759_add_session_workspace_id.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260227213759_add_session_workspace_id",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`workspace_id\` text;`);
+      yield* tx.run(`CREATE INDEX \`session_workspace_idx\` ON \`session\` (\`workspace_id\`);`);
+    });
+  }
+};
+var _20260227213759_add_session_workspace_id_default = migration;
+
+export { _20260227213759_add_session_workspace_id_default };

package/dist/chunks/permission-dhphtf1x.js

@@ -0,0 +1,45 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/mime.ts
+var exports_mime = {};
+__export(exports_mime, {
+  detect: () => detect,
+  Mime: () => exports_mime
+});
+function detect(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10]))
+    return "image/png";
+  if (startsWith(bytes, [255, 216, 255]))
+    return "image/jpeg";
+  if (startsWith(bytes, [71, 73, 70, 56]))
+    return "image/gif";
+  if (startsWith(bytes, [66, 77]))
+    return "image/bmp";
+  if (startsWith(bytes, [37, 80, 68, 70, 45]))
+    return "application/pdf";
+  if (startsWith(bytes, [82, 73, 70, 70]) && startsWith(bytes.subarray(8), [87, 69, 66, 80]))
+    return "image/webp";
+  if (startsWith(bytes.subarray(4), [102, 116, 121, 112]) && (startsWith(bytes.subarray(8), [97, 118, 105, 102]) || startsWith(bytes.subarray(8), [97, 118, 105, 115])))
+    return "image/avif";
+  return isText(bytes) ? "text/plain" : "application/octet-stream";
+}
+function startsWith(bytes, prefix) {
+  return prefix.every((value, index) => bytes[index] === value);
+}
+function isText(bytes) {
+  if (bytes.length === 0)
+    return true;
+  if (bytes.includes(0))
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+  } catch {
+    return false;
+  }
+  const controls = bytes.reduce((count, byte) => count + Number(byte < 9 || byte > 13 && byte < 32), 0);
+  return controls / bytes.length <= 0.3;
+}
+
+export { detect, exports_mime };

package/dist/chunks/permission-dht5baf0.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260601010001_normalize_storage_paths.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601010001_normalize_storage_paths",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`UPDATE project SET worktree = REPLACE(worktree, char(92), '/') WHERE worktree GLOB '[A-Za-z]:' || char(92) || '*' OR worktree LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE project SET sandboxes = REPLACE(sandboxes, char(92) || char(92), '/') WHERE instr(sandboxes, char(92)) > 0 AND (worktree GLOB '[A-Za-z]:*' OR worktree LIKE '//%');`);
+      yield* tx.run(`UPDATE session SET directory = REPLACE(directory, char(92), '/') WHERE directory GLOB '[A-Za-z]:' || char(92) || '*' OR directory LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE session SET path = REPLACE(path, char(92), '/') WHERE path IS NOT NULL AND instr(path, char(92)) > 0 AND (directory GLOB '[A-Za-z]:*' OR directory LIKE '//%');`);
+    });
+  }
+};
+var _20260601010001_normalize_storage_paths_default = migration;
+
+export { _20260601010001_normalize_storage_paths_default };

package/dist/chunks/permission-dppgrtwb.js

@@ -0,0 +1,126 @@
+// src/database/migration/20260804233008_loose_psylocke.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260804233008_loose_psylocke",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`kv\` (
+          \`key\` text PRIMARY KEY,
+          \`value\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_blob\` (
+          \`hash\` text PRIMARY KEY,
+          \`value\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_entry\` (
+          \`session_id\` text NOT NULL,
+          \`key\` text NOT NULL,
+          \`value\` text,
+          \`removed\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`instruction_entry_pk\` PRIMARY KEY(\`session_id\`, \`key\`),
+          CONSTRAINT \`fk_instruction_entry_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_state\` (
+          \`session_id\` text PRIMARY KEY,
+          \`epoch_start\` integer NOT NULL,
+          \`through_seq\` integer NOT NULL,
+          \`initial_values\` text NOT NULL,
+          \`current_values\` text NOT NULL,
+          CONSTRAINT \`fk_instruction_state_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`session_pending\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          \`delivery\` text,
+          \`admitted_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_pending_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`session_v2\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`workspace_id\` text,
+          \`parent_id\` text,
+          \`fork_session_id\` text,
+          \`fork_boundary\` text,
+          \`slug\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`path\` text,
+          \`title\` text,
+          \`version\` text NOT NULL,
+          \`share_url\` text,
+          \`summary_additions\` integer,
+          \`summary_deletions\` integer,
+          \`summary_files\` integer,
+          \`summary_diffs\` text,
+          \`metadata\` text,
+          \`cost\` real DEFAULT 0 NOT NULL,
+          \`tokens_input\` integer DEFAULT 0 NOT NULL,
+          \`tokens_output\` integer DEFAULT 0 NOT NULL,
+          \`tokens_reasoning\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_read\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_write\` integer DEFAULT 0 NOT NULL,
+          \`revert\` text,
+          \`permission\` text,
+          \`agent\` text,
+          \`model\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_compacting\` integer,
+          \`time_archived\` integer,
+          \`time_suspended\` integer,
+          CONSTRAINT \`fk_session_v2_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`ALTER TABLE \`event\` ADD \`created\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`__new_session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_message\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_message\` RENAME TO \`session_message\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`CREATE INDEX \`session_pending_session_delivery_seq_idx\` ON \`session_pending\` (\`session_id\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_compaction_idx\` ON \`session_pending\` (\`session_id\`) WHERE "session_pending"."type" = 'compaction';`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_admitted_seq_idx\` ON \`session_pending\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`);
+      yield* tx.run(`DROP TABLE \`data_migration\`;`);
+      yield* tx.run(`DROP TABLE \`session_context_epoch\`;`);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+    });
+  }
+};
+var _20260804233008_loose_psylocke_default = migration;
+
+export { _20260804233008_loose_psylocke_default };

package/dist/chunks/permission-e1z9a0ts.js

@@ -0,0 +1,69 @@
+import {
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  Remote: () => Remote,
+  OAuth: () => OAuth,
+  Local: () => Local,
+  Info: () => Info,
+  ConfigMCPV1: () => exports_mcp
+});
+import { Schema } from "effect";
+var Local = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server"
+  }),
+  cwd: Schema.optional(Schema.String).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server"
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpLocalConfig" });
+var OAuth = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)"
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  callbackPort: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))).annotate({
+    description: "Port for the local OAuth callback server (default: 19876). Shorthand for redirectUri when only the port needs changing. Ignored if redirectUri is set."
+  }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
+  })
+}).annotate({ identifier: "McpOAuthConfig" });
+var Remote = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request"
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpRemoteConfig" });
+var Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" });
+
+export { Local, OAuth, Remote, Info, exports_mcp };

package/dist/chunks/permission-e2mxwc51.js

@@ -0,0 +1,109 @@
+import {
+  exports_runner
+} from "./permission-cz3dkvcz.js";
+import {
+  toSessionError
+} from "./permission-42xz94rv.js";
+import {
+  exports_run_coordinator
+} from "./permission-xfrawapx.js";
+import {
+  exports_location_service_map
+} from "./permission-zdkg1k91.js";
+import {
+  exports_store
+} from "./permission-2zyawa45.js";
+import {
+  UserInterruptedError
+} from "./permission-s6by3cc4.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/execution.ts
+var exports_execution = {};
+__export(exports_execution, {
+  terminal: () => terminal,
+  noopLayer: () => noopLayer,
+  node: () => node,
+  layer: () => layer,
+  SessionExecution: () => exports_execution,
+  Service: () => Service
+});
+import { Cause, Context, Effect, Exit, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/SessionExecution") {
+}
+function terminal(exit, reason) {
+  if (Exit.isSuccess(exit))
+    return { type: "succeeded" };
+  if (Cause.hasInterrupts(exit.cause))
+    return { type: "interrupted", reason: reason ?? "shutdown" };
+  const failure = Cause.squash(exit.cause);
+  if (failure instanceof UserInterruptedError)
+    return { type: "interrupted", reason: "user" };
+  return { type: "failed", error: toSessionError(failure) };
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const store = yield* exports_store.Service;
+  const locations = yield* exports_location_service_map.Service;
+  const bus = yield* exports_bus.Service;
+  const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
+  const claimOnCommit = (sessionID) => ({
+    commit: () => store.claim(sessionID)
+  });
+  const releaseOnCommit = (sessionID) => ({
+    commit: () => store.release(sessionID)
+  });
+  const coordinator = yield* exports_run_coordinator.make({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+    drain: Effect.fnUntraced(function* (sessionID, force) {
+      const session = yield* store.get(sessionID);
+      if (!session)
+        return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+      return yield* exports_runner.Service.use((runner) => runner.drain({ sessionID, force })).pipe(Effect.provide(locations.get(session.location)), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+    }),
+    settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
+      const outcome = terminal(exit, reason);
+      if (outcome.type === "succeeded") {
+        yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        return;
+      }
+      if (outcome.type === "interrupted") {
+        yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        return;
+      }
+      yield* bus.publish(SessionEvent.Execution.Failed, {
+        sessionID,
+        error: outcome.error
+      }, releaseOnCommit(sessionID));
+    }))
+  });
+  return Service.of({
+    active: coordinator.active,
+    interrupt: (sessionID) => coordinator.interrupt(sessionID, "user"),
+    resume: coordinator.run,
+    wake: coordinator.wake,
+    awaitIdle: coordinator.awaitIdle
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [exports_store.node, exports_location_service_map.node, exports_bus.node]
+});
+var noopLayer = Layer.succeed(Service, Service.of({
+  active: Effect.succeed(new Set),
+  resume: () => Effect.void,
+  wake: () => Effect.void,
+  interrupt: () => Effect.void,
+  awaitIdle: () => Effect.void
+}));
+
+export { Service, terminal, layer, node, noopLayer, exports_execution };