@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-4pc93936.js

@@ -0,0 +1,334 @@
+import {
+  fileDiff
+} from "./location-mutation-c77ad0vh.js";
+import {
+  exports_formatter
+} from "./location-mutation-nhg32cj8.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_file_mutation
+} from "./location-mutation-61tdevqj.js";
+import {
+  exports_location_mutation
+} from "./location-mutation-z17t3kn2.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  Plugin: () => Plugin,
+  PatchTool: () => exports_patch,
+  Output: () => Output,
+  Input: () => Input,
+  Applied: () => Applied
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { Effect, Result, Schema } from "effect";
+import path from "path";
+import { Bom } from "@opencode-ai/util/bom";
+import { Patch } from "@opencode-ai/util/patch";
+
+// src/tool/patch.txt
+var patch_default = `Use the \`patch\` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+
+// src/tool/plugin/patch.ts
+var name = "patch";
+var Input = Schema.Struct({
+  patchText: Schema.String.annotate({
+    description: "The full patch text describing add, update, and delete operations"
+  })
+});
+var Applied = Schema.Struct({
+  type: Schema.Literals(["add", "update", "delete"]),
+  resource: Schema.String,
+  target: Schema.String
+});
+var Output = Schema.Struct({
+  applied: Schema.Array(Applied),
+  files: Schema.Array(FileDiff.Info)
+});
+var toModelOutput = (output) => [
+  "Success. Updated the following files:",
+  ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
+].join(`
+`);
+var Plugin = {
+  id: "opencode.tool.patch",
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
+    const environment = yield* exports_environment.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const fileMutation = yield* exports_file_mutation.Service;
+    const formatter = yield* exports_formatter.Service;
+    const location = yield* exports_location.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: patch_default,
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        const applied = [];
+        const parsed = Patch.parse(input.patchText);
+        const lockTargets = Result.isSuccess(parsed) ? parsed.success.flatMap((hunk) => [
+          path.resolve(location.directory, hunk.path),
+          ...hunk.type === "update" && hunk.movePath ? [path.resolve(location.directory, hunk.movePath)] : []
+        ]) : [];
+        const fail = (operation, error) => {
+          const completed = applied.map((item) => item.resource).join(", ");
+          return new ToolFailure({
+            message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`
+          });
+        };
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (!input.patchText)
+            return yield* new ToolFailure({ message: "patchText is required" });
+          const hunks = yield* Effect.fromResult(parsed).pipe(Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })));
+          if (hunks.length === 0) {
+            return yield* new ToolFailure({ message: "patch rejected: empty patch" });
+          }
+          const prepared = [];
+          const updates = new Map;
+          const resolveTarget = Effect.fnUntraced(function* (value) {
+            const target = yield* mutation.resolve({ path: value, kind: "file" });
+            if (!target.externalDirectory)
+              return target;
+            yield* permission.assert({
+              ...exports_location_mutation.externalDirectoryPermission(target.externalDirectory),
+              metadata: {
+                filepath: target.absolute,
+                parentDir: target.externalDirectory.directory
+              },
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source
+            });
+            return target;
+          });
+          for (const hunk of hunks) {
+            yield* Effect.gen(function* () {
+              const target = yield* resolveTarget(hunk.path);
+              if (hunk.type === "add") {
+                const content = hunk.contents.endsWith(`
+`) || hunk.contents === "" ? hunk.contents : `${hunk.contents}
+`;
+                prepared.push({
+                  ...hunk,
+                  target,
+                  content,
+                  before: "",
+                  after: Bom.split(content).text
+                });
+                return;
+              }
+              if (hunk.type === "delete") {
+                const content = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`
+                })));
+                prepared.push({ ...hunk, target, before: content.text, after: "" });
+                return;
+              }
+              const previous = updates.get(target.absolute);
+              const original = previous ?? (yield* Effect.gen(function* () {
+                const content = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`
+                })));
+                return Bom.join(content.text, content.bom);
+              }));
+              const before = Bom.split(original).text;
+              const update = yield* Effect.try({
+                try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` })
+              });
+              const moveTarget = hunk.movePath ? yield* resolveTarget(hunk.movePath) : undefined;
+              prepared.push({
+                ...hunk,
+                target,
+                content: Patch.joinBom(update.content, update.bom),
+                before,
+                after: update.content,
+                moveTarget
+              });
+              if (!moveTarget)
+                updates.set(target.absolute, Patch.joinBom(update.content, update.bom));
+            }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error })));
+          }
+          const patchFiles = prepared.map((change) => patchFile(change));
+          const targets = prepared.flatMap((change) => [
+            change.target,
+            ...change.type === "update" && change.moveTarget ? [change.moveTarget] : []
+          ]);
+          yield* permission.assert({
+            action: "edit",
+            resources: [...new Set(targets.map((target) => target.resource))],
+            save: ["*"],
+            metadata: {
+              filepath: targets.map((target) => target.resource).join(", "),
+              diff: patchFiles.map((file) => `${file.patch}
+`).join(""),
+              files: patchFiles
+            },
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          yield* Effect.forEach(prepared, (change) => Effect.gen(function* () {
+            if (change.type === "add") {
+              yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.type === "delete") {
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.moveTarget) {
+              const moveTarget = change.moveTarget;
+              yield* environment.files.write(moveTarget.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)));
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.moveTarget.resource,
+                target: change.moveTarget.absolute
+              });
+              return;
+            }
+            yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+            applied.push({
+              type: change.type,
+              resource: change.target.resource,
+              target: change.target.absolute
+            });
+          }), { discard: true });
+          const formatted = new Map;
+          yield* Effect.forEach([...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))], (target) => Effect.gen(function* () {
+            const current = yield* exports_file_mutation.readText(environment.files, target).pipe(Effect.mapError((error) => fail(`Failed to read ${target}`, error)));
+            formatted.set(target, (yield* formatter.file(target)) ? yield* exports_file_mutation.syncTextBom(environment.files, target, current.bom).pipe(Effect.mapError((error) => fail(`Failed to sync ${target}`, error))) : current.text);
+          }), { discard: true });
+          const files = yield* Effect.forEach(prepared, (change) => {
+            if (change.type === "delete")
+              return Effect.succeed(patchFile(change));
+            const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target;
+            return Effect.succeed(patchFile(change, formatted.get(target.absolute)));
+          });
+          return { applied, files };
+        }).pipe(fileMutation.withLock(lockTargets), Effect.map((output) => ({
+          output,
+          content: toModelOutput(output),
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
+      }
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const usePatch = event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4");
+      if (usePatch) {
+        delete event.tools.edit;
+        delete event.tools.write;
+        return;
+      }
+      delete event.tools.patch;
+    }));
+  })
+};
+function errorMessage(error) {
+  if (error instanceof exports_environment.NotFound)
+    return "file does not exist";
+  if (error instanceof exports_environment.WrongKind)
+    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`;
+  if (error instanceof exports_environment.Failed)
+    return errorMessage(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function patchFile(change, after = change.after) {
+  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource;
+  const diff = fileDiff(change.target.absolute, change.before, after, change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified");
+  return {
+    ...diff,
+    file: target,
+    patch: trimDiff(diff.patch)
+  };
+}
+function trimDiff(diff) {
+  const lines = diff.split(`
+`);
+  const content = lines.filter((line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++"));
+  if (content.length === 0)
+    return diff;
+  const indent = content.reduce((result, line) => {
+    const value = line.slice(1);
+    if (value.trim().length === 0)
+      return result;
+    return Math.min(result, value.match(/^(\s*)/)?.[1].length ?? result);
+  }, Infinity);
+  if (indent === Infinity || indent === 0)
+    return diff;
+  return lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      return line[0] + line.slice(1 + indent);
+    }
+    return line;
+  }).join(`
+`);
+}
+
+export { name, Input, Applied, Output, toModelOutput, Plugin, exports_patch };

package/dist/chunks/location-mutation-4s2xwh5d.js

@@ -0,0 +1,91 @@
+import {
+  exports_permission
+} from "./location-mutation-v9bfv94f.js";
+import {
+  PositiveInt
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  Info: () => Info,
+  ConfigAgentV1: () => exports_agent
+});
+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(PositiveInt).annotate({
+    description: "Maximum number of agentic iterations before forcing text-only response"
+  }),
+  maxSteps: Schema.optional(PositiveInt).annotate({ description: "@deprecated Use 'steps' field instead." }),
+  permission: Schema.optional(exports_permission.Info)
+}), [Schema.Record(Schema.String, Schema.Any)]);
+var KNOWN_KEYS = new Set([
+  "name",
+  "model",
+  "variant",
+  "prompt",
+  "description",
+  "temperature",
+  "top_p",
+  "mode",
+  "hidden",
+  "color",
+  "steps",
+  "maxSteps",
+  "options",
+  "permission",
+  "disable",
+  "tools"
+]);
+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 Info = AgentSchema.pipe(Schema.decodeTo(AgentSchema, {
+  decode: SchemaGetter.transform(normalize),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "AgentConfig" });
+
+export { Info, exports_agent };

package/dist/chunks/location-mutation-4zg0gww9.js

@@ -0,0 +1,55 @@
+// src/database/drizzle/up-migrations/sqlite.ts
+import { sql } from "drizzle-orm/sql/sql";
+function unmatchedMigrationError(unmatched) {
+  return new Error(`While upgrading your database migrations table we found ${unmatched.length} (${unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(", ")}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`);
+}
+function prepareSQLiteMigrationBackfill(dbRows, localMigrations) {
+  const sortedLocalMigrations = [...localMigrations].sort((a, b) => a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? "").localeCompare(b.name ?? ""));
+  const byMillis = new Map;
+  const byHash = new Map;
+  for (const migration of sortedLocalMigrations) {
+    if (!byMillis.has(migration.folderMillis)) {
+      byMillis.set(migration.folderMillis, []);
+    }
+    byMillis.get(migration.folderMillis).push(migration);
+    byHash.set(migration.hash, migration);
+  }
+  const toApply = [];
+  const unmatched = [];
+  for (const dbRow of dbRows) {
+    const stringified = String(dbRow.created_at);
+    const millis = Number(stringified.substring(0, stringified.length - 3) + "000");
+    const candidates = byMillis.get(millis);
+    const matchedByMillis = candidates?.length === 1 ? candidates[0] : undefined;
+    const matchedByCandidateHash = candidates && candidates.length > 1 ? candidates.find((candidate) => candidate.hash && dbRow.hash && candidate.hash === dbRow.hash) : undefined;
+    const matchedByHash = matchedByMillis || matchedByCandidateHash ? undefined : byHash.get(dbRow.hash);
+    const matched = matchedByMillis ?? matchedByCandidateHash ?? matchedByHash;
+    if (matched) {
+      toApply.push({
+        name: matched.name,
+        selector: dbRow.id !== null ? { column: "id", value: dbRow.id } : matchedByMillis ? { column: "created_at", value: dbRow.created_at } : { column: "hash", value: dbRow.hash }
+      });
+      continue;
+    }
+    unmatched.push(dbRow);
+  }
+  if (unmatched.length > 0) {
+    throw unmatchedMigrationError(unmatched);
+  }
+  return toApply;
+}
+function buildSQLiteMigrationBackfillStatements(migrationsTable, backfillEntries) {
+  const table = sql`${sql.identifier(migrationsTable)}`;
+  const statements = [
+    sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier("name")} text`,
+    sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier("applied_at")} TEXT`
+  ];
+  for (const backfillEntry of backfillEntries) {
+    const updateQuery = sql`UPDATE ${table} SET ${sql.identifier("name")} = ${backfillEntry.name}, ${sql.identifier("applied_at")} = NULL WHERE`;
+    updateQuery.append(sql` ${sql.identifier(backfillEntry.selector.column)} = ${backfillEntry.selector.value}`);
+    statements.push(updateQuery);
+  }
+  return statements;
+}
+
+export { prepareSQLiteMigrationBackfill, buildSQLiteMigrationBackfillStatements };

package/dist/chunks/location-mutation-4zzdwbaz.js

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

package/dist/chunks/location-mutation-50jxp3hw.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  useragent: () => useragent,
+  node: () => node,
+  make: () => make,
+  layer: () => layer,
+  configured: () => configured,
+  Metadata: () => Metadata,
+  App: () => exports_app
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Metadata = Context.Reference("@opencode/App", {
+  defaultValue: () => make()
+});
+function make(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer = (input) => Layer.succeed(Metadata, make(input));
+var configured = (input) => makeGlobalNode({ service: Metadata, layer: layer(input), deps: [] });
+var node = configured();
+
+export { Metadata, make, useragent, layer, configured, node, exports_app };

package/dist/chunks/location-mutation-52jzav25.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/prompt-cache-key.ts
+var exports_prompt_cache_key = {};
+__export(exports_prompt_cache_key, {
+  make: () => make,
+  SessionPromptCacheKey: () => exports_prompt_cache_key
+});
+var make = (sessionID) => /^ses_[0-9a-f]{64}$/.test(sessionID) ? sessionID.slice(4) : sessionID;
+
+export { make, exports_prompt_cache_key };

package/dist/chunks/location-mutation-530z90jy.js

@@ -0,0 +1,81 @@
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/skill/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  SkillInstructions: () => exports_instructions2,
+  Service: () => Service
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  id: exports_skill.ID,
+  name: exports_skill.Name,
+  description: Schema.String
+});
+var entries = (skills) => skills.flatMap((skill) => [
+  "  <skill>",
+  `    <id>${skill.id}</id>`,
+  `    <name>${skill.name}</name>`,
+  `    <description>${skill.description}</description>`,
+  "  </skill>"
+]);
+var render = (skills) => [
+  "Skills provide specialized instructions and workflows for specific tasks.",
+  "Use the skill tool to load a skill when a task matches its description.",
+  ...skills.length === 0 ? ["No skills are currently available."] : ["<available_skills>", ...entries(skills), "</available_skills>"]
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = exports_instructions.diffByKey(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available skills have changed. This list supersedes the previous available skills list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New skills are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following skill IDs are no longer available and must not be used: ${diff.removed.map((skill) => skill.id).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/SkillInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const skills = yield* exports_skill.Service;
+  return Service.of({
+    load: Effect.fn("SkillInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return exports_instructions.empty;
+      const permitted = exports_skill.available(yield* skills.list(), agent);
+      const available = permitted.flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
+      return exports_instructions.make({
+        key: exports_instructions.Key.make("core/skill-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Skill guidance is no longer available. Do not use any previously listed skill."
+        }
+      });
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_skill.node] });
+
+export { Service, node, exports_instructions2 as exports_instructions };

package/dist/chunks/location-mutation-56p2m126.js

@@ -0,0 +1,31 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+
+// src/plugin/provider/zenmux.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var ZenmuxPlugin = define({
+  id: "opencode.provider.zenmux",
+  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://zenmux.ai/api/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            ...provider.headers
+          };
+        });
+      }
+    });
+  })
+});
+
+export { ZenmuxPlugin };