@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-z0bkrqjs.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./repository-ym463w8f.js";
+
+// src/plugin/provider/cohere.ts
+var CoherePlugin2 = createProviderPlugin2({
+  id: "opencode.provider.cohere",
+  package: "@ai-sdk/cohere",
+  load: async (options) => {
+    const { createCohere } = await import("@ai-sdk/cohere");
+    return createCohere(options);
+  }
+});
+
+export { CoherePlugin2 };

package/dist/chunks/repository-z0xnky3q.js

@@ -0,0 +1,121 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  parse4,
+  parseRemote2,
+  validateBranch3,
+  isRemote2,
+  cachePath2
+} from "./repository-2402vzrj.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Service56,
+  node60
+} from "./repository-p6v0vyws.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/reference.ts
+var exports_reference2 = {};
+__export(exports_reference2, {
+  Event: () => Event12,
+  GitSource: () => GitSource2,
+  Info: () => Info19,
+  LocalSource: () => LocalSource2,
+  Reference: () => exports_reference2,
+  Service: () => Service55,
+  Source: () => Source4,
+  node: () => node59
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Scope } from "effect";
+import { Reference } from "@opencode/schema/reference";
+import { Global } from "@opencode/util/global";
+import { Event as Event12 } from "@opencode/schema/reference";
+var LocalSource2 = Reference.LocalSource;
+var GitSource2 = Reference.GitSource;
+var Source4 = Reference.Source;
+var Info19 = Reference.Info;
+
+class Service55 extends Context.Service()("@opencode/Reference") {
+}
+var layer = Layer.effect(Service55, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const bus = yield* Service78;
+  const cache = yield* Service56;
+  const scope = yield* Scope.Scope;
+  const list = () => Array.from(state.get().sources).flatMap(([name, source]) => {
+    const info = {
+      name,
+      source,
+      ...source.description === undefined ? {} : { description: source.description },
+      ...source.hidden === undefined ? {} : { hidden: source.hidden }
+    };
+    if (source.type === "local")
+      return [Info19.make({ ...info, path: source.path })];
+    const repository = parse4(source.repository);
+    if (!repository || !isRemote2(repository))
+      return [];
+    if (source.branch) {
+      try {
+        validateBranch3(source.branch);
+      } catch {
+        return [];
+      }
+    }
+    return [
+      Info19.make({
+        ...info,
+        path: AbsolutePath2.make(cachePath2(global.repos, repository, source.branch))
+      })
+    ];
+  });
+  const refresh = Effect.fn("Reference.refresh")(function* () {
+    yield* Effect.forEach(list(), (reference) => Effect.gen(function* () {
+      if (reference.source.type !== "git")
+        return;
+      yield* cache.ensure({
+        reference: parseRemote2(reference.source.repository),
+        branch: reference.source.branch,
+        refresh: "daily"
+      });
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to materialize reference", { name: reference.name, cause }))), { concurrency: 4, discard: true });
+  });
+  const state = create3({
+    name: "reference",
+    initial: () => ({ sources: new Map }),
+    editor: (editor) => ({
+      add: (name, source) => editor.sources.set(name, source),
+      remove: (name) => editor.sources.delete(name),
+      list: () => Array.from(editor.sources),
+      get: (name) => editor.sources.get(name)
+    }),
+    notify: () => Effect.gen(function* () {
+      yield* refresh().pipe(Effect.forkIn(scope));
+      yield* bus.publish(Reference.Event.Updated, {});
+    })
+  });
+  yield* Effect.sleep("1 hour").pipe(Effect.andThen(refresh()), Effect.forever, Effect.forkScoped);
+  return Service55.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Reference.list")(function* () {
+      return list();
+    })
+  });
+}));
+var node59 = makeLocationNode({
+  service: Service55,
+  layer,
+  deps: [Global.node, node83, node60]
+});
+
+export { LocalSource2, GitSource2, Source4, Info19, Service55, node59, exports_reference2, Event12 };

package/dist/chunks/repository-z63w68vq.js

@@ -0,0 +1,46 @@
+import {
+  NamedError2
+} from "./repository-2axfhc9x.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/error.ts
+var exports_error = {};
+__export(exports_error, {
+  ConfigErrorV1: () => exports_error,
+  DirectoryTypoError: () => DirectoryTypoError2,
+  FrontmatterError: () => FrontmatterError2,
+  InvalidError: () => InvalidError2,
+  JsonError: () => JsonError2,
+  RemoteAuthError: () => RemoteAuthError2
+});
+import { Schema } from "effect";
+var Issue = Schema.StructWithRest(Schema.Struct({
+  message: Schema.String,
+  path: Schema.Array(Schema.String)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+var JsonError2 = NamedError2.create("ConfigJsonError", {
+  path: Schema.String,
+  message: Schema.optional(Schema.String)
+});
+var InvalidError2 = NamedError2.create("ConfigInvalidError", {
+  path: Schema.String,
+  issues: Schema.optional(Schema.Array(Issue)),
+  message: Schema.optional(Schema.String)
+});
+var FrontmatterError2 = NamedError2.create("ConfigFrontmatterError", {
+  path: Schema.String,
+  message: Schema.String
+});
+var DirectoryTypoError2 = NamedError2.create("ConfigDirectoryTypoError", {
+  path: Schema.String,
+  dir: Schema.String,
+  suggestion: Schema.String
+});
+var RemoteAuthError2 = NamedError2.create("ConfigRemoteAuthError", {
+  url: Schema.String,
+  remote: Schema.String
+});
+
+export { JsonError2, InvalidError2, FrontmatterError2, DirectoryTypoError2, RemoteAuthError2, exports_error };

package/dist/chunks/repository-z9919s4g.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260423070820_add_icon_url_override.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260423070820_add_icon_url_override",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        ALTER TABLE \`project\` ADD \`icon_url_override\` text;
+        UPDATE \`project\` SET \`icon_url_override\` = \`icon_url\` WHERE \`icon_url\` IS NOT NULL;
+      `);
+    });
+  }
+};
+var _20260423070820_add_icon_url_override_default = migration;
+
+export { _20260423070820_add_icon_url_override_default };

package/dist/chunks/repository-za4pw5w1.js

@@ -0,0 +1,74 @@
+import {
+  PositiveInt2
+} from "./repository-922hggd3.js";
+import {
+  Info16
+} from "./repository-g190xswt.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/agent.ts
+var exports_agent3 = {};
+__export(exports_agent3, {
+  ConfigAgentV1: () => exports_agent3,
+  Info: () => Info13
+});
+import { Schema, SchemaGetter } from "effect";
+var Color = Schema.Union([
+  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"])
+]);
+var AgentSchema = Schema.StructWithRest(Schema.Struct({
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String).annotate({
+    description: "Default model variant for this agent (applies only when using the agent's configured model)."
+  }),
+  temperature: Schema.optional(Schema.Finite),
+  top_p: Schema.optional(Schema.Finite),
+  prompt: Schema.optional(Schema.String),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description: "@deprecated Use 'permission' field instead"
+  }),
+  disable: Schema.optional(Schema.Boolean),
+  description: Schema.optional(Schema.String).annotate({ description: "Description of when to use the agent" }),
+  mode: Schema.optional(Schema.Literals(["subagent", "primary", "all"])),
+  hidden: Schema.optional(Schema.Boolean).annotate({
+    description: "Hide this subagent from the @ autocomplete menu (default: false, only applies to mode: subagent)"
+  }),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  color: Schema.optional(Color).annotate({
+    description: "Hex color code (e.g., #FF5733) or theme color (e.g., primary)"
+  }),
+  steps: Schema.optional(PositiveInt2).annotate({
+    description: "Maximum number of agentic iterations before forcing text-only response"
+  }),
+  maxSteps: Schema.optional(PositiveInt2).annotate({ description: "@deprecated Use 'steps' field instead." }),
+  permission: Schema.optional(Info16)
+}), [Schema.Record(Schema.String, Schema.Any)]);
+var KNOWN_KEYS = new Set(["name", ...Object.keys(AgentSchema.schema.fields)]);
+var normalize = (agent) => {
+  const options = { ...agent.options };
+  for (const [key, value] of Object.entries(agent)) {
+    if (!KNOWN_KEYS.has(key))
+      options[key] = value;
+  }
+  const permission = {};
+  for (const [tool, enabled] of Object.entries(agent.tools ?? {})) {
+    const action = enabled ? "allow" : "deny";
+    if (tool === "write" || tool === "edit" || tool === "patch") {
+      permission.edit = action;
+      continue;
+    }
+    permission[tool] = action;
+  }
+  globalThis.Object.assign(permission, agent.permission);
+  const steps = agent.steps ?? agent.maxSteps;
+  return { ...agent, options, permission, ...steps !== undefined ? { steps } : {} };
+};
+var Info13 = AgentSchema.pipe(Schema.decodeTo(AgentSchema, {
+  decode: SchemaGetter.transform(normalize),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "AgentConfig" });
+
+export { Info13, exports_agent3 };

package/dist/chunks/repository-zc2xj3qj.js

@@ -0,0 +1,33 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/nvidia.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var NvidiaPlugin2 = define({
+  id: "opencode.provider.nvidia",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://integrate.api.nvidia.com/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-BILLING-INVOKE-ORIGIN": provider.headers?.["X-BILLING-INVOKE-ORIGIN"] ?? "OpenCode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { NvidiaPlugin2 };

package/dist/chunks/repository-zdwyj9y5.js

@@ -0,0 +1,207 @@
+import {
+  ID9,
+  Service61
+} from "./repository-b5n11jz6.js";
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  SessionSchema2
+} from "./repository-y6f0p4jw.js";
+import {
+  Service54
+} from "./repository-mw6spqsr.js";
+import {
+  evaluate2,
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service26
+} from "./repository-51cmmk6m.js";
+import {
+  NO_TEXT2
+} from "./repository-x1ezjp6w.js";
+import {
+  make10
+} from "./repository-2cgm8dc1.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/subagent.ts
+var exports_subagent = {};
+__export(exports_subagent, {
+  Input: () => Input3,
+  Output: () => Output3,
+  Plugin: () => Plugin20,
+  SubagentTool: () => exports_subagent,
+  description: () => description2,
+  name: () => name3
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+var name3 = "subagent";
+var backgroundResult = (sessionID) => ({
+  sessionID,
+  status: "running",
+  output: [
+    `The subagent is working in the background (sessionID: ${sessionID}). You will be notified automatically when it finishes.`,
+    "DO NOT sleep, poll for progress, ask the subagent for status, or duplicate this subagent's work; avoid working with the same files or topics it is using.",
+    "Work on non-overlapping tasks, or briefly tell the user what you launched and end your response."
+  ].join(`
+`)
+});
+var Input3 = Schema.Struct({
+  agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
+  description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
+  prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
+  sessionID: Schema.optionalKey(SessionSchema2.ID).annotate({
+    description: "Continue a specific previous subagent conversation by passing its sessionID. Calls without a sessionID start a new conversation."
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress."
+  })
+});
+var Output3 = Schema.Struct({
+  sessionID: SessionSchema2.ID,
+  status: Schema.Literals(["completed", "running"]),
+  output: Schema.String
+});
+var description2 = [
+  "Spawns an agent in a child session to work on the specified task.",
+  "The output includes a sessionID you can pass back later to continue that specific conversation with the subagent.",
+  "New child sessions start with fresh context, so include all relevant context and instructions when you don't pass a sessionID.",
+  "Foreground (default) runs the subagent to completion and returns its final response.",
+  "Background mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.",
+  "Use background only for independent work that can run while you continue elsewhere."
+].join(`
+`);
+var Plugin20 = {
+  id: "opencode.tool.subagent",
+  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
+    const sessions = yield* Service26;
+    const jobs = yield* Service54;
+    const agents = yield* Service61;
+    const config = yield* Service44;
+    const permission = yield* Service58;
+    const subagents = yield* make10;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name3,
+      options: { codemode: false },
+      description: description2,
+      input: Input3,
+      output: Output3,
+      execute: (input, context) => Effect.gen(function* () {
+        const parent = yield* sessions.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
+        let current = parent;
+        let depth = 0;
+        while (current.parentID) {
+          depth++;
+          current = yield* sessions.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
+        }
+        const limit = latest2(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
+        if (depth >= limit)
+          return yield* new ToolFailure({
+            message: `Subagent depth limit reached (${limit}). Increase "experimental.subagent_depth" to allow nested subagents.`
+          });
+        const agent = yield* agents.resolve(input.agent);
+        if (agent === undefined)
+          return yield* new ToolFailure({ message: `Unknown agent: ${input.agent}` });
+        if (agent.mode === "primary")
+          return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` });
+        yield* permission.assert({
+          action: name3,
+          resources: [agent.id],
+          save: [agent.id],
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          }
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent denied: ${agent.id}`, error })));
+        const existing = input.sessionID === undefined ? undefined : yield* sessions.get(input.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent session not found: ${input.sessionID}`, error })));
+        if (existing !== undefined && existing.parentID !== context.sessionID)
+          return yield* new ToolFailure({
+            message: `Session ${existing.id} is not a child of the current session`
+          });
+        if (existing !== undefined && existing.agent !== agent.id) {
+          yield* sessions.switchAgent({ sessionID: existing.id, agent: agent.id }).pipe(Effect.andThen(agent.model === undefined ? Effect.void : sessions.switchModel({ sessionID: existing.id, model: agent.model })), Effect.mapError((error) => new ToolFailure({ message: `Failed to switch subagent session agent: ${existing.id}`, error })));
+        }
+        const model = agent.model ?? parent.model;
+        const child = existing ?? (yield* sessions.create({
+          parentID: context.sessionID,
+          title: input.description,
+          agent: ID9.make(input.agent),
+          model
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }))));
+        const background = input.background === true;
+        yield* context.progress({ sessionID: child.id, status: "running" });
+        yield* sessions.prompt({
+          sessionID: child.id,
+          text: existing === undefined ? ["You are a subagent spawned by another session.", input.prompt].join(`
+`) : input.prompt,
+          ...background && existing === undefined ? { resume: false } : {}
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Failed to prompt subagent: ${child.id}`, error })));
+        const recovery = {
+          kind: "subagent",
+          parentSessionID: context.sessionID,
+          childSessionID: child.id,
+          agent: agent.name,
+          description: input.description
+        };
+        yield* subagents.start(recovery);
+        if (background) {
+          yield* subagents.background(recovery);
+          return backgroundResult(child.id);
+        }
+        const result = yield* jobs.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([sessions.interrupt(child.id), jobs.cancel(child.id)], {
+          discard: true
+        })));
+        if (result?.type === "backgrounded") {
+          yield* subagents.notify(recovery, result.info.started_at);
+          return backgroundResult(child.id);
+        }
+        if (result?.info.status === "error")
+          return yield* new ToolFailure({
+            message: `Subagent failed (sessionID: ${child.id}): ${result.info.error ?? "unknown error"}`
+          });
+        if (result?.info.status === "cancelled")
+          return yield* new ToolFailure({ message: `Subagent cancelled (sessionID: ${child.id})` });
+        return {
+          sessionID: child.id,
+          status: "completed",
+          output: result?.info.output ?? NO_TEXT2
+        };
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.status === "completed" ? `<subagent sessionID="${output.sessionID}" state="completed">
+${output.output}
+</subagent>` : output.output,
+        metadata: { sessionID: output.sessionID, status: output.status }
+      })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name3];
+      if (!tool)
+        return;
+      const selected = yield* agents.resolve(event.agent);
+      if (!selected)
+        return;
+      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && evaluate2(name3, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
+      if (available.length === 0)
+        return;
+      tool.description = [
+        tool.description,
+        "",
+        "Available subagents:",
+        ...available.map((agent) => `- ${agent.id}: ${agent.description ?? "This subagent should only be called when explicitly requested."}`)
+      ].join(`
+`);
+    }));
+  })
+};
+
+export { name3, Input3, Output3, description2, Plugin20, exports_subagent };

package/dist/chunks/repository-zeh9ct20.js

@@ -0,0 +1,29 @@
+import {
+  PositiveInt2
+} from "./repository-922hggd3.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/server.ts
+var exports_server = {};
+__export(exports_server, {
+  ConfigServerV1: () => exports_server,
+  Server: () => Server2
+});
+import { Schema } from "effect";
+var Server2 = Schema.Struct({
+  port: Schema.optional(PositiveInt2).annotate({
+    description: "Port to listen on"
+  }),
+  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
+  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
+  mdnsDomain: Schema.optional(Schema.String).annotate({
+    description: "Custom domain name for mDNS service (default: opencode.local)"
+  }),
+  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional domains to allow for CORS"
+  })
+}).annotate({ identifier: "ServerConfig" });
+
+export { Server2, exports_server };

package/dist/chunks/repository-zr2ceqn5.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/promise.ts
+var exports_promise = {};
+__export(exports_promise, {
+  PluginPromise: () => exports_promise,
+  fromPromise: () => fromPromise2
+});
+import { fromPromise as fromPromise2 } from "@opencode/plugin/promise/adapter";
+
+export { exports_promise, fromPromise2 };