@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-a02svayp.js

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

package/dist/chunks/ripgrep-a65h300v.js

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  node: () => node,
+  SkillDiscovery: () => exports_discovery,
+  Service: () => Service
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+import { Hash } from "@opencode-ai/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      const decoded = decodeURIComponent(segment);
+      return decoded.length > 0 && decoded !== "." && decoded !== ".." && !decoded.includes("/") && !decoded.includes("\\") && !decoded.includes("\x00");
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (files.some((file) => file === undefined)) {
+          return [];
+        }
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.catch(() => Effect.succeed(undefined)));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists2 = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists2)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service, node, exports_discovery };

package/dist/chunks/ripgrep-a6wxg7ch.js

@@ -0,0 +1,139 @@
+import {
+  exports_promise
+} from "./ripgrep-5vcssjzn.js";
+import {
+  exports_internal
+} from "./ripgrep-t0azhkhn.js";
+import {
+  exports_sdk
+} from "./ripgrep-k1qrb68g.js";
+import {
+  exports_source
+} from "./ripgrep-pn1rs1sd.js";
+import {
+  exports_plugin
+} from "./ripgrep-vee0pxvg.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  node: () => node,
+  layer: () => layer,
+  Service: () => Service,
+  PluginSupervisor: () => exports_supervisor
+});
+import { Event } from "@opencode-ai/schema/config";
+import { Context, Deferred, Effect, Layer, Schema, Stream } from "effect";
+import path from "path";
+import { pathToFileURL } from "url";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Npm } from "@opencode-ai/util/npm";
+import { importModule } from "@opencode-ai/util/runtime-import";
+var PluginModule = Schema.Struct({
+  default: Schema.Union([
+    Schema.Struct({
+      id: Schema.String,
+      effect: Schema.declare((input) => typeof input === "function")
+    }),
+    Schema.Struct({
+      id: Schema.String,
+      setup: Schema.declare((input) => typeof input === "function")
+    })
+  ])
+});
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (pre, post, operations) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      plugins().filter((plugin2) => matches(operation.target, plugin2.id)).forEach((plugin2) => enabled.delete(plugin2.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin2) => matches(operation.target, plugin2.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin2) => enabled.add(plugin2.id));
+      continue;
+    }
+    const plugin = yield* load(operation).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(Effect.as(undefined))));
+    if (!plugin)
+      continue;
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  return [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...Array.from(packages.values()).filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id))
+  ];
+});
+var load = Effect.fn("PluginSupervisor.load")(function* (operation) {
+  const npm = yield* Npm.Service;
+  const entrypoint = path.isAbsolute(operation.target) ? pathToFileURL(operation.target).href : (yield* npm.add(operation.target, { subpaths: ["server", ""] })).entrypoint;
+  if (!entrypoint)
+    return;
+  const source = operation.mtime === undefined ? entrypoint : typeof Bun !== "undefined" ? `${operation.target.replaceAll("\\", "/")}?mtime=${operation.mtime}` : `${entrypoint}?mtime=${operation.mtime}`;
+  yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source });
+  const mod = yield* Effect.promise(() => importModule(source));
+  const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default;
+  const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  return {
+    id: plugin.id,
+    version: JSON.stringify(operation),
+    effect: (host) => plugin.effect({ ...host, options: operation.options })
+  };
+});
+
+class Service extends Context.Service()("@opencode/PluginSupervisor") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const registry = yield* exports_plugin.Service;
+  const sdk = yield* exports_sdk.Service;
+  const sources = yield* exports_source.Service;
+  const bus = yield* exports_bus.Service;
+  const ready = { current: yield* Deferred.make() };
+  let observed = 0;
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const internal = yield* exports_internal.list();
+    const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()];
+    const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }));
+    const operations = yield* sources.operations();
+    const plugins = yield* resolve(pre, post, operations);
+    yield* registry.activate(plugins);
+  });
+  const updates = Stream.merge(sources.changes(), bus.subscribe([Event.Updated, exports_sdk.Updated])).pipe(Stream.mapEffect(() => Effect.gen(function* () {
+    observed++;
+    if (yield* Deferred.isDone(ready.current))
+      ready.current = yield* Deferred.make();
+    return observed;
+  })));
+  yield* Stream.concat(Stream.succeed(0), updates).pipe(Stream.buffer({ capacity: 1, strategy: "sliding" }), Stream.debounce("100 millis"), Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate();
+    if (observed === target)
+      yield* Deferred.succeed(ready.current, undefined);
+  }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  return Service.of({ flush: Effect.suspend(() => Deferred.await(ready.current)) });
+}));
+var nodeDeps = [
+  exports_plugin.node,
+  exports_sdk.node,
+  exports_source.node,
+  exports_bus.node,
+  Npm.node,
+  exports_internal.requirements
+];
+var node = makeLocationNode({ service: Service, layer, deps: nodeDeps });
+
+export { Service, layer, node, exports_supervisor };

package/dist/chunks/ripgrep-a83yvq99.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode-ai/schema/session-event";
+import * as SessionEvent from "@opencode-ai/schema/session-event";
+
+export { SessionEvent };

package/dist/chunks/ripgrep-aen2vrbj.js

@@ -0,0 +1,75 @@
+import {
+  exports_reference
+} from "./ripgrep-77qdnkw9.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/reference.ts
+var exports_reference2 = {};
+__export(exports_reference2, {
+  Plugin: () => Plugin,
+  ConfigReferencePlugin: () => exports_reference2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import path from "path";
+import { Effect, Stream } from "effect";
+import { Global } from "@opencode-ai/util/global";
+var Plugin = define({
+  id: "opencode.config.reference",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const location = yield* exports_location.Service;
+    const global = yield* Global.Service;
+    const loaded = { entries: yield* config.entries() };
+    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 ?? {})) {
+          if (!validAlias(name))
+            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({
+            type: "local",
+            path: AbsolutePath.make(localPath(directory, global.home, typeof entry === "string" ? entry : entry.path)),
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }) : exports_reference.GitSource.make({
+            type: "git",
+            repository: typeof entry === "string" ? entry : entry.repository,
+            ...entry.branch === undefined ? {} : { branch: entry.branch },
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }));
+        }
+      }
+      for (const [name, source] of entries)
+        draft.add(name, source);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.reference.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function validAlias(name) {
+  return name.length > 0 && !/[\/\s`,]/.test(name);
+}
+function local(entry) {
+  return typeof entry === "string" ? entry.startsWith(".") || entry.startsWith("/") || entry.startsWith("~") : ("path" in entry);
+}
+function localPath(directory, home, value) {
+  if (value.startsWith("~/"))
+    return path.join(home, value.slice(2));
+  return path.isAbsolute(value) ? value : path.resolve(directory, value);
+}
+
+export { Plugin, exports_reference2 as exports_reference };

package/dist/chunks/ripgrep-aw3m7sv3.js

@@ -0,0 +1,194 @@
+import {
+  exports_formatter
+} from "./ripgrep-2nmyybe0.js";
+import {
+  exports_lsp
+} from "./ripgrep-999qd968.js";
+import {
+  exports_skills
+} from "./ripgrep-nzrjycs5.js";
+import {
+  exports_layout
+} from "./ripgrep-gcay93cp.js";
+import {
+  exports_agent
+} from "./ripgrep-4s2xwh5d.js";
+import {
+  exports_permission
+} from "./ripgrep-v9bfv94f.js";
+import {
+  exports_attachment
+} from "./ripgrep-r3k9abhd.js";
+import {
+  exports_provider
+} from "./ripgrep-18pv8fg3.js";
+import {
+  exports_server
+} from "./ripgrep-pq4b4pqk.js";
+import {
+  exports_mcp
+} from "./ripgrep-e1z9a0ts.js";
+import {
+  exports_command
+} from "./ripgrep-thstd87d.js";
+import {
+  exports_plugin
+} from "./ripgrep-9f0rnpkn.js";
+import {
+  NonNegativeInt,
+  PositiveInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/config.ts
+var exports_config = {};
+__export(exports_config, {
+  WellKnown: () => WellKnown,
+  Info: () => Info,
+  ConfigV1: () => exports_config
+});
+import { Schema } from "effect";
+import { ConfigReference } from "@opencode-ai/schema/config/reference";
+var WellKnown = Schema.Struct({
+  config: Schema.optional(Schema.Json),
+  remote_config: Schema.optional(Schema.Json)
+});
+var LogLevelRef = Schema.Literals(["DEBUG", "INFO", "WARN", "ERROR"]).annotate({
+  identifier: "LogLevel",
+  description: "Log level"
+});
+var Info = Schema.Struct({
+  $schema: Schema.optional(Schema.String).annotate({
+    description: "JSON schema reference for configuration validation"
+  }),
+  shell: Schema.optional(Schema.String).annotate({ description: "Default shell to use for terminal and bash tool" }),
+  logLevel: Schema.optional(LogLevelRef).annotate({ description: "Log level" }),
+  server: Schema.optional(exports_server.Server).annotate({
+    description: "Server configuration for opencode serve and web commands"
+  }),
+  command: Schema.optional(Schema.Record(Schema.String, exports_command.Info)).annotate({
+    description: "Command configuration, see https://opencode.ai/docs/commands"
+  }),
+  skills: Schema.optional(exports_skills.Info).annotate({ description: "Additional skill folder paths" }),
+  references: Schema.optional(ConfigReference.Info).annotate({
+    description: "Named git or local directory references"
+  }),
+  reference: Schema.optional(ConfigReference.Info).annotate({
+    description: "@deprecated Use 'references' field instead. Named git or local directory references"
+  }),
+  watcher: Schema.optional(Schema.Struct({ ignore: Schema.optional(Schema.mutable(Schema.Array(Schema.String))) })),
+  snapshot: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable snapshot tracking. When false, filesystem snapshots are not recorded and undoing or reverting will not undo/redo file changes. Defaults to true."
+  }),
+  plugin: Schema.optional(Schema.mutable(Schema.Array(exports_plugin.Spec))),
+  share: Schema.optional(Schema.Literals(["manual", "auto", "disabled"])).annotate({
+    description: "Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing"
+  }),
+  autoshare: Schema.optional(Schema.Boolean).annotate({
+    description: "@deprecated Use 'share' field instead. Share newly created sessions automatically"
+  }),
+  autoupdate: Schema.optional(Schema.Union([Schema.Boolean, Schema.Literal("notify")])).annotate({
+    description: "Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications"
+  }),
+  disabled_providers: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Disable providers that are loaded automatically"
+  }),
+  enabled_providers: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "When set, ONLY these providers will be enabled. All other providers will be ignored"
+  }),
+  model: Schema.optional(Schema.String).annotate({
+    description: "Model to use in the format of provider/model, eg anthropic/claude-2"
+  }),
+  small_model: Schema.optional(Schema.String).annotate({
+    description: "Small model to use for tasks like title generation in the format of provider/model"
+  }),
+  default_agent: Schema.optional(Schema.String).annotate({
+    description: "Default agent to use when none is specified. Must be a primary agent. Falls back to 'build' if not set or if the specified agent is invalid."
+  }),
+  subagent_depth: Schema.optional(NonNegativeInt).annotate({
+    description: "Maximum subagent nesting depth. Defaults to 1, which prevents subagents from launching subagents."
+  }),
+  username: Schema.optional(Schema.String).annotate({
+    description: "Custom username to display in conversations instead of system username"
+  }),
+  mode: Schema.optional(Schema.StructWithRest(Schema.Struct({ build: Schema.optional(exports_agent.Info), plan: Schema.optional(exports_agent.Info) }), [Schema.Record(Schema.String, exports_agent.Info)])).annotate({ description: "@deprecated Use `agent` field instead." }),
+  agent: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    plan: Schema.optional(exports_agent.Info),
+    build: Schema.optional(exports_agent.Info),
+    general: Schema.optional(exports_agent.Info),
+    explore: Schema.optional(exports_agent.Info),
+    title: Schema.optional(exports_agent.Info),
+    summary: Schema.optional(exports_agent.Info),
+    compaction: Schema.optional(exports_agent.Info)
+  }), [Schema.Record(Schema.String, exports_agent.Info)])).annotate({ description: "Agent configuration, see https://opencode.ai/docs/agents" }),
+  provider: Schema.optional(Schema.Record(Schema.String, exports_provider.Info)).annotate({
+    description: "Custom provider configurations and model overrides"
+  }),
+  mcp: Schema.optional(Schema.Record(Schema.String, Schema.Union([exports_mcp.Info, Schema.Struct({ enabled: Schema.Boolean })]))).annotate({ description: "MCP (Model Context Protocol) server configurations" }),
+  formatter: Schema.optional(exports_formatter.Info).annotate({
+    description: "Enable or configure formatters. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides."
+  }),
+  lsp: Schema.optional(exports_lsp.Info).annotate({
+    description: "Enable or configure LSP servers. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides."
+  }),
+  instructions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional instruction files or patterns to include"
+  }),
+  layout: Schema.optional(exports_layout.Layout).annotate({ description: "@deprecated Always uses stretch layout." }),
+  permission: Schema.optional(exports_permission.Info),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+  attachment: Schema.optional(exports_attachment.Info).annotate({
+    description: "Attachment processing configuration, including image size limits and resizing behavior"
+  }),
+  enterprise: Schema.optional(Schema.Struct({ url: Schema.optional(Schema.String).annotate({ description: "Enterprise URL" }) })),
+  tool_output: Schema.optional(Schema.Struct({
+    max_lines: Schema.optional(PositiveInt).annotate({
+      description: "Maximum lines of tool output before it is truncated and saved to disk (default: 2000)"
+    }),
+    max_bytes: Schema.optional(PositiveInt).annotate({
+      description: "Maximum bytes of tool output before it is truncated and saved to disk (default: 51200)"
+    })
+  })).annotate({
+    description: "Thresholds for truncating tool output. When output exceeds either limit, the full text is written to the truncation directory and a preview is returned."
+  }),
+  compaction: Schema.optional(Schema.Struct({
+    auto: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable automatic compaction when context is full (default: true)"
+    }),
+    prune: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable pruning of old tool outputs (default: false)"
+    }),
+    tail_turns: Schema.optional(NonNegativeInt).annotate({
+      description: "Number of recent user turns, including their following assistant/tool responses, to keep verbatim during compaction (default: 2)"
+    }),
+    preserve_recent_tokens: Schema.optional(NonNegativeInt).annotate({
+      description: "Maximum number of tokens from recent turns to preserve verbatim after compaction"
+    }),
+    reserved: Schema.optional(NonNegativeInt).annotate({
+      description: "Token buffer for compaction. Leaves enough window to avoid overflow during compaction."
+    })
+  })),
+  experimental: Schema.optional(Schema.Struct({
+    disable_paste_summary: Schema.optional(Schema.Boolean),
+    batch_tool: Schema.optional(Schema.Boolean).annotate({ description: "Enable the batch tool" }),
+    openTelemetry: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable OpenTelemetry spans for AI SDK calls (using the 'experimental_telemetry' flag)"
+    }),
+    primary_tools: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+      description: "Tools that should only be available to primary agents."
+    }),
+    subagent_depth: Schema.optional(NonNegativeInt).annotate({
+      description: "Maximum subagent nesting depth. Defaults to 1."
+    }),
+    continue_loop_on_deny: Schema.optional(Schema.Boolean).annotate({
+      description: "Continue the agent loop when a tool call is denied"
+    }),
+    mcp_timeout: Schema.optional(PositiveInt).annotate({
+      description: "Timeout in milliseconds for model context protocol (MCP) requests"
+    })
+  }))
+}).annotate({ identifier: "Config" });
+
+export { WellKnown, Info, exports_config };

package/dist/chunks/ripgrep-ayevdmef.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260611035744_credential.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611035744_credential",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`connector_id\` text NOT NULL,
+          \`method_id\` text NOT NULL,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`active\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`credential_connector_active_idx\` ON \`credential\` (\`connector_id\`) WHERE "credential"."active" = 1;`);
+    });
+  }
+};
+var _20260611035744_credential_default = migration;
+
+export { _20260611035744_credential_default };

package/dist/chunks/ripgrep-ayfwnm78.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./ripgrep-0zz82cjq.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/groq.ts
+var GroqPlugin = createProviderPlugin({
+  id: "opencode.provider.groq",
+  package: "@ai-sdk/groq",
+  load: async (options) => {
+    const { createGroq } = await import("@ai-sdk/groq");
+    return createGroq(options);
+  }
+});
+
+export { GroqPlugin };

package/dist/chunks/ripgrep-b02txbh8.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260602182828_add_project_directories.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602182828_add_project_directories",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260602182828_add_project_directories_default = migration;
+
+export { _20260602182828_add_project_directories_default };