@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-470a55pw.js

@@ -0,0 +1,91 @@
+import {
+  exports_markdown
+} from "./permission-7wcmqxrc.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  Plugin: () => Plugin,
+  ConfigCommandPlugin: () => exports_command
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode-ai/schema/config/command";
+import path from "path";
+import { Effect, Option, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const fs = yield* FSUtil.Service;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), (entry) => {
+        if (entry.type === "document")
+          return Effect.succeed([{ commands: entry.info.commands }]);
+        if (entry.type !== "directory")
+          return Effect.succeed([]);
+        return loadDirectory(fs, entry.path).pipe(Effect.map((commands) => [
+          { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }
+        ]));
+      }).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 sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))));
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"));
+    yield* Stream.merge(sourceChanges, configUpdates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((draft) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          draft.update(name, (item) => {
+            item.template = command.template;
+            if (command.description !== undefined)
+              item.description = command.description;
+            if (command.agent !== undefined)
+              item.agent = command.agent;
+            if (command.model !== undefined)
+              item.model = {
+                id: command.model.model,
+                providerID: command.model.providerID,
+                ...command.model.variant === undefined ? {} : { variant: command.model.variant }
+              };
+            if (command.subtask !== undefined)
+              item.subtask = command.subtask;
+          });
+        }
+      }
+    });
+  })
+});
+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.catch(() => Effect.succeed([])));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.catch(() => Effect.succeed(undefined)))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(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
+  };
+}
+
+export { Plugin, exports_command };

package/dist/chunks/permission-476jw5d9.js

@@ -0,0 +1,65 @@
+import {
+  exports_models_dev
+} from "./permission-1zxa6y0n.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+
+// src/plugin/models-dev.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Integration } from "@opencode-ai/schema/integration";
+import { Effect, Stream } from "effect";
+var ModelsDevPlugin = define({
+  id: "opencode.models-dev",
+  effect: Effect.fn(function* (ctx) {
+    const modelsDev = yield* exports_models_dev.Service;
+    const bus = yield* exports_bus.Service;
+    const loaded = { data: snapshots(yield* modelsDev.get()) };
+    yield* ctx.integration.transform((integrations) => {
+      for (const provider of loaded.data) {
+        if (provider.environment.length === 0)
+          continue;
+        const integrationID = provider.info.id;
+        integrations.update(integrationID, (integration) => integration.name = provider.info.name);
+        integrations.method.update({
+          integrationID,
+          method: { type: "key" }
+        });
+        integrations.method.update({
+          integrationID,
+          method: {
+            type: "env",
+            names: environmentNames(provider)
+          }
+        });
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      for (const provider of loaded.data) {
+        catalog.provider.update(provider.info.id, (draft) => {
+          Object.assign(draft, provider.info);
+          draft.integrationID = Integration.ID.make(provider.info.id);
+        });
+        for (const model of provider.models) {
+          if (model.status === "deprecated")
+            continue;
+          catalog.model.update(provider.info.id, model.id, (draft) => Object.assign(draft, model));
+        }
+      }
+    });
+    yield* bus.subscribe(exports_models_dev.Event.Refreshed).pipe(Stream.runForEach(() => modelsDev.get().pipe(Effect.tap((data) => Effect.sync(() => loaded.data = snapshots(data))), Effect.andThen(ctx.integration.reload()), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function environmentNames(provider) {
+  if (provider.info.id !== exports_provider.ID.azure)
+    return [...provider.environment];
+  return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"];
+}
+function snapshots(data) {
+  return structuredClone(data).filter((provider) => provider.info.id !== "azure-cognitive-services" && provider.info.id !== "google-vertex-anthropic");
+}
+
+export { ModelsDevPlugin };

package/dist/chunks/permission-47rh966y.js

@@ -0,0 +1,194 @@
+import {
+  exports_layout
+} from "./permission-gcay93cp.js";
+import {
+  exports_command
+} from "./permission-thstd87d.js";
+import {
+  exports_agent
+} from "./permission-4s2xwh5d.js";
+import {
+  exports_provider
+} from "./permission-18pv8fg3.js";
+import {
+  exports_skills
+} from "./permission-nzrjycs5.js";
+import {
+  exports_server
+} from "./permission-pq4b4pqk.js";
+import {
+  exports_plugin
+} from "./permission-9f0rnpkn.js";
+import {
+  exports_mcp
+} from "./permission-e1z9a0ts.js";
+import {
+  exports_attachment
+} from "./permission-r3k9abhd.js";
+import {
+  exports_formatter
+} from "./permission-2nmyybe0.js";
+import {
+  exports_lsp
+} from "./permission-999qd968.js";
+import {
+  exports_permission
+} from "./permission-v9bfv94f.js";
+import {
+  NonNegativeInt,
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-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/permission-47ty4mvs.js

@@ -0,0 +1,18 @@
+// src/database/migration/20260511000411_data_migration_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260511000411_data_migration_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`data_migration\` (
+          \`name\` text PRIMARY KEY,
+          \`time_completed\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260511000411_data_migration_state_default = migration;
+
+export { _20260511000411_data_migration_state_default };

package/dist/chunks/permission-4b2tz2m9.js

@@ -0,0 +1,22 @@
+// src/github-copilot/responses/tool/image-generation.ts
+import { z } from "zod/v4";
+var imageGenerationArgsSchema = z.object({
+  background: z.enum(["auto", "opaque", "transparent"]).optional(),
+  inputFidelity: z.enum(["low", "high"]).optional(),
+  inputImageMask: z.object({
+    fileId: z.string().optional(),
+    imageUrl: z.string().optional()
+  }).optional(),
+  model: z.string().optional(),
+  moderation: z.enum(["auto"]).optional(),
+  outputCompression: z.number().int().min(0).max(100).optional(),
+  outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+  partialImages: z.number().int().min(0).max(3).optional(),
+  quality: z.enum(["auto", "low", "medium", "high"]).optional(),
+  size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+}).strict();
+var imageGenerationOutputSchema = z.object({
+  result: z.string()
+});
+
+export { imageGenerationArgsSchema, imageGenerationOutputSchema };