@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-cghsqmpm.js

@@ -0,0 +1,172 @@
+import {
+  exports_markdown
+} from "./location-mutation-7wcmqxrc.js";
+import {
+  exports_agent as exports_agent2
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_migrate
+} from "./location-mutation-3mfgaav1.js";
+import {
+  exports_agent
+} from "./location-mutation-4s2xwh5d.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/agent.ts
+var exports_agent3 = {};
+__export(exports_agent3, {
+  Plugin: () => Plugin,
+  ConfigAgentPlugin: () => exports_agent3
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Document, Info } from "@opencode-ai/schema/config";
+import { ConfigAgent } from "@opencode-ai/schema/config/agent";
+import path from "path";
+import { Effect, Option, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+var legacySources = [
+  { pattern: "{agent,agents}/**/*.md", primary: false },
+  { pattern: "{mode,modes}/*.md", primary: true }
+];
+var sourceDirectories = ["agent", "agents", "mode", "modes"];
+var decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info);
+var decodeLegacyAgent = Schema.decodeUnknownOption(exports_agent.Info);
+var decodeConfig = Schema.decodeUnknownOption(Info);
+var pathActions = ["external_directory", "read", "edit"];
+var agentKeys = new Set([
+  "model",
+  "variant",
+  "request",
+  "system",
+  "description",
+  "mode",
+  "hidden",
+  "color",
+  "steps",
+  "disabled",
+  "permissions"
+]);
+var Plugin = define({
+  id: "opencode.config.agent",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), (entry) => {
+        if (entry.type === "document")
+          return Effect.succeed([entry]);
+        if (entry.type !== "directory")
+          return Effect.succeed([]);
+        return Effect.gen(function* () {
+          const files = yield* discover(fs, entry.path);
+          return yield* Effect.forEach(files, (file) => fs.readFileStringSafe(file.filepath).pipe(Effect.map((content) => content ? decode(file, content) : undefined), Effect.catch(() => Effect.succeed(undefined)))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+        });
+      }).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.agent.reload()));
+    const sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(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.agent.transform((draft) => {
+      const permissions = expandPermissions(loaded.documents.flatMap((document) => document.info.permissions ?? []), global.home);
+      const configuredDefault = exports_config.latest(loaded.documents, "default_agent");
+      if (configuredDefault !== undefined)
+        draft.default(exports_agent2.ID.make(configuredDefault));
+      for (const current of draft.list()) {
+        draft.update(current.id, (agent) => agent.permissions.push(...permissions));
+      }
+      for (const document of loaded.documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = exports_agent2.ID.make(id);
+          if (item.disabled) {
+            draft.remove(agentID);
+            continue;
+          }
+          const exists = draft.get(agentID) !== undefined;
+          draft.update(agentID, (agent) => {
+            if (!exists)
+              agent.permissions.push(...permissions);
+            if (item.model !== undefined)
+              agent.model = {
+                id: item.model.model,
+                providerID: item.model.providerID,
+                ...item.model.variant === undefined ? {} : { variant: item.model.variant }
+              };
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {});
+              Object.assign(agent.request.body, item.request.body ?? {});
+            }
+            if (item.system !== undefined)
+              agent.system = item.system;
+            if (item.description !== undefined)
+              agent.description = item.description;
+            if (item.mode !== undefined)
+              agent.mode = item.mode;
+            if (item.hidden !== undefined)
+              agent.hidden = item.hidden;
+            if (item.color !== undefined)
+              agent.color = item.color;
+            if (item.steps !== undefined)
+              agent.steps = item.steps;
+            if (item.permissions !== undefined) {
+              agent.permissions.push(...expandPermissions(item.permissions, global.home));
+            }
+          });
+        }
+      }
+    });
+  })
+});
+function isAgentSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function expandPermissions(rules, home) {
+  return rules.map((rule) => isPathAction(rule.action) ? { ...rule, resource: expandHome(rule.resource, home) } : rule);
+}
+function isPathAction(action) {
+  return pathActions.some((item) => item === action);
+}
+function expandHome(resource, home) {
+  if (resource === "~")
+    return home;
+  if (resource === "$HOME")
+    return home;
+  const relative = resource.startsWith("~/") ? resource.slice(2) : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\") ? resource.slice(6) : undefined;
+  if (relative !== undefined)
+    return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative);
+  return resource;
+}
+function discover(fs, directory) {
+  return Effect.forEach(legacySources, (source) => fs.scan(source.pattern, { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.map((files) => files.toSorted().map((filepath) => ({ directory, filepath, primary: source.primary }))))).pipe(Effect.map((files) => files.flat()), Effect.catch(() => Effect.succeed([])));
+}
+function decode(file, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return;
+  const name = path.relative(file.directory, file.filepath).replaceAll("\\", "/").replace(/^(agent|agents|mode|modes)\//, "").replace(/\.md$/, "");
+  const body = markdown.content.trim();
+  const legacy = Object.keys(markdown.data).some((key) => !agentKeys.has(key));
+  const agent = legacy ? Option.getOrUndefined(Option.map(decodeLegacyAgent({ name, ...markdown.data, prompt: body }, { errors: "all", propertyOrder: "original" }), exports_migrate.migrateAgent)) : Option.getOrUndefined(decodeAgent({ ...markdown.data, system: body }, { errors: "all", propertyOrder: "original" }));
+  if (!agent)
+    return;
+  const info = Option.getOrUndefined(decodeConfig({
+    agents: { [name]: file.primary ? { ...agent, mode: "primary" } : agent }
+  }));
+  if (!info)
+    return;
+  return new Document({ type: "document", path: AbsolutePath.make(file.filepath), info });
+}
+
+export { Plugin, exports_agent3 as exports_agent };

package/dist/chunks/location-mutation-cgvnqv92.js

@@ -0,0 +1,27 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+
+// src/plugin/provider/kilo.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var KiloPlugin = define({
+  id: "opencode.provider.kilo",
+  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/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://api.kilo.ai/api/gateway")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { KiloPlugin };

package/dist/chunks/location-mutation-cm67rqy2.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260808023530_workspace_domain.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260808023530_workspace_domain",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260808023530_workspace_domain_default = migration;
+
+export { _20260808023530_workspace_domain_default };

package/dist/chunks/location-mutation-cs3a8p19.js

@@ -0,0 +1,65 @@
+import {
+  exports_models_dev
+} from "./location-mutation-2kmss6qq.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.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/location-mutation-cv3jyr2n.js

@@ -0,0 +1,87 @@
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  description: () => description,
+  SkillTool: () => exports_skill2,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import path from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var name = "skill";
+var FILE_LIMIT = 10;
+var Input = Schema.Struct({
+  id: exports_skill.ID.annotate({ description: "The ID of the skill from the available skills list" })
+});
+var Output = Schema.Struct({
+  name: exports_skill.Name,
+  directory: Schema.String,
+  output: Schema.String
+});
+var description = [
+  "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
+  "",
+  "The skill ID must match one of the available skills in the instructions."
+].join(`
+`);
+var toModelOutput = exports_skill.toModelOutput;
+var unableToLoad = (name2, error) => new ToolFailure({ message: `Unable to load skill ${name2}`, error });
+var Plugin = {
+  id: "opencode.tool.skill",
+  effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
+    const fs = yield* FSUtil.Service;
+    const skills = yield* exports_skill.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const current = yield* skills.list();
+        const skill = current.find((skill2) => skill2.id === input.id);
+        if (!skill)
+          return yield* unableToLoad(input.id);
+        return yield* Effect.gen(function* () {
+          yield* permission.assert({
+            action: name,
+            resources: [skill.id],
+            save: [skill.id],
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: { type: "tool", messageID: context.messageID, id: context.id }
+          });
+          const directory = path.dirname(skill.location);
+          const files = path.basename(skill.location) === "SKILL.md" ? (yield* fs.scan("**/*", { cwd: directory, absolute: true, include: "file", dot: true })).filter((file) => path.basename(file) !== "SKILL.md").toSorted().slice(0, FILE_LIMIT) : [];
+          return {
+            name: skill.name,
+            directory,
+            output: exports_skill.toModelOutput(skill, files)
+          };
+        }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)));
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.output,
+        metadata: { name: output.name, directory: output.directory }
+      })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, description, toModelOutput, Plugin, exports_skill2 as exports_skill };

package/dist/chunks/location-mutation-cz3dkvcz.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/runner/index.ts
+var exports_runner = {};
+__export(exports_runner, {
+  SessionRunner: () => exports_runner,
+  Service: () => Service
+});
+import { Context } from "effect";
+
+class Service extends Context.Service()("@opencode/SessionRunner") {
+}
+
+export { Service, exports_runner };

package/dist/chunks/location-mutation-d6s8p2vk.js

@@ -0,0 +1,157 @@
+// src/tool/runtime.ts
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema } from "effect";
+var definition = (tool) => ({
+  name: effectiveName(tool),
+  description: tool.description,
+  inputSchema: inputJsonSchema(tool.input),
+  ...tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }
+});
+var execute = (tool, input, context) => Effect.gen(function* () {
+  const decoded = yield* decodeInput(tool.input, input);
+  const result = yield* tool.execute(decoded, context);
+  if (tool.output === undefined) {
+    if ("output" in result)
+      return yield* Effect.die("Tool result declared output without an output schema");
+    return {
+      output: undefined,
+      content: normalizeContent(result.content),
+      ...result.metadata === undefined ? {} : { metadata: result.metadata }
+    };
+  }
+  if (!("output" in result))
+    return yield* new Tool.Error({ message: "Tool did not return its declared output" });
+  const output = yield* encodeOutput(tool.output, result.output);
+  return {
+    output,
+    content: normalizeContent(result.content, output),
+    ...result.metadata === undefined ? {} : { metadata: result.metadata }
+  };
+});
+var decodeInput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Invalid tool input: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Invalid tool input");
+  return Effect.succeed(value);
+};
+var encodeOutput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Tool returned an invalid value for its output schema");
+  return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
+};
+var isStandardSchema = (schema) => typeof schema === "object" && schema !== null && ("~standard" in schema);
+var validateStandard = (schema, value, prefix) => Effect.gen(function* () {
+  const pending = yield* Effect.try({
+    try: () => schema["~standard"].validate(value),
+    catch: (error) => standardFailure(prefix, error)
+  });
+  const result = pending instanceof Promise ? yield* Effect.tryPromise({ try: () => pending, catch: (error) => standardFailure(prefix, error) }) : pending;
+  if (result.issues)
+    return yield* new Tool.Error({
+      message: `${prefix}: ${result.issues.map((issue) => issue.message).join(", ")}`
+    });
+  return result.value;
+});
+var standardFailure = (prefix, error) => new Tool.Error({ message: `${prefix}: ${error instanceof Error ? error.message : String(error)}` });
+var inputJsonSchema = (schema) => {
+  if (schema === undefined || schema === null)
+    return {};
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var outputJsonSchema = (schema) => {
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var toJsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema);
+  const normalized = flattenAllOf(Object.keys(document.definitions).length === 0 ? document.schema : { ...document.schema, $defs: document.definitions });
+  return dropDefinitionsIfResolved(inlineLocalReferences(normalized));
+};
+var flattenAllOf = (value) => {
+  if (Array.isArray(value))
+    return value.map(flattenAllOf);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+  if (!Array.isArray(schema.allOf) || !schema.allOf.every(isRecord) || !canFlattenAllOf(schema.allOf, schema))
+    return schema;
+  const { allOf, ...rest } = schema;
+  return flattenAllOf({ ...Object.assign({}, ...allOf), ...rest });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canFlattenAllOf = (allOf, parent) => {
+  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"));
+  return allOf.every((item) => Object.keys(item).every((key) => {
+    if (keys.has(key))
+      return false;
+    keys.add(key);
+    return true;
+  }));
+};
+var inlineLocalReferences = (value, definitions, seen = new Set) => {
+  if (Array.isArray(value))
+    return value.map((item) => inlineLocalReferences(item, definitions, seen));
+  if (!isRecord(value))
+    return value;
+  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined);
+  if (typeof value.$ref === "string" && localDefinitions) {
+    const segment = value.$ref.match(/^#\/\$defs\/([^/]+)$/)?.[1];
+    const name = segment?.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (name && !seen.has(name)) {
+      const target = localDefinitions[name];
+      if (target) {
+        const { $ref: _, ...rest } = value;
+        const resolvedTarget = inlineLocalReferences(target, localDefinitions, new Set(seen).add(name));
+        const resolvedSiblings = inlineLocalReferences(rest, localDefinitions, seen);
+        if (!isRecord(resolvedTarget) || !isRecord(resolvedSiblings))
+          return resolvedTarget;
+        if (canMergeRecords(resolvedTarget, resolvedSiblings))
+          return { ...resolvedTarget, ...resolvedSiblings };
+        return { allOf: [resolvedTarget, resolvedSiblings] };
+      }
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]));
+};
+var canMergeRecords = (left, right) => Object.keys(left).every((key) => !(key in right));
+var dropDefinitionsIfResolved = (value) => {
+  if (!isRecord(value) || hasLocalReference(value))
+    return value;
+  const { $defs: _, ...rest } = value;
+  return rest;
+};
+var hasLocalReference = (value) => {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#/$defs/"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+};
+var normalizeContent = (value, output) => {
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  if (value !== undefined && value.length > 0)
+    return [...value];
+  return [{ type: "text", text: stringify(output) }];
+};
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var normalizedName = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName = (tool) => tool.options?.namespace === undefined ? normalizedName(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`;
+
+export { definition, execute, normalizeContent };