@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-vz89hfgr.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/vcs/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  splitGitPatch: () => splitGitPatch,
+  fileFromPatchChunk: () => fileFromPatchChunk,
+  emptyPatch: () => emptyPatch,
+  deletePatch: () => deletePatch,
+  countPatch: () => countPatch,
+  chunksByFile: () => chunksByFile,
+  addPatch: () => addPatch,
+  VcsPatch: () => exports_patch,
+  PATCH_CONTEXT_LINES: () => PATCH_CONTEXT_LINES,
+  MAX_TOTAL_PATCH_BYTES: () => MAX_TOTAL_PATCH_BYTES,
+  MAX_PATCH_BYTES: () => MAX_PATCH_BYTES
+});
+import { formatPatch, structuredPatch } from "diff";
+var PATCH_CONTEXT_LINES = 2147483647;
+var MAX_PATCH_BYTES = 1e7;
+var MAX_TOTAL_PATCH_BYTES = 1e7;
+var emptyPatch = (file) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }));
+var addPatch = (file, content) => formatPatch(structuredPatch(file, file, "", content, "", "", { context: 0 }));
+var deletePatch = (file, content) => formatPatch(structuredPatch(file, file, content, "", "", "", { context: 0 }));
+var countPatch = (patch) => {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      additions++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      deletions++;
+  }
+  return { additions, deletions };
+};
+var parseQuotedPath = (value) => {
+  let out = "";
+  for (let idx = 1;idx < value.length; idx++) {
+    const char = value[idx];
+    if (char === '"')
+      return { value: out, end: idx + 1 };
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = value[++idx];
+    if (next === "t")
+      out += "\t";
+    else if (next === "n")
+      out += `
+`;
+    else if (next === "r")
+      out += "\r";
+    else if (next === '"' || next === "\\")
+      out += next;
+    else
+      out += next ?? "";
+  }
+};
+var parsePathToken = (value) => {
+  if (!value.startsWith('"'))
+    return value.split("\t")[0];
+  return parseQuotedPath(value)?.value ?? value;
+};
+var fileFromDiffPath = (value) => {
+  if (!value || value === "/dev/null")
+    return;
+  const file = parsePathToken(value);
+  if (file.startsWith("a/") || file.startsWith("b/"))
+    return file.slice(2);
+  return file;
+};
+var fileFromGitHeader = (header) => {
+  if (header.startsWith('"')) {
+    const first = parseQuotedPath(header);
+    const second = first ? header.slice(first.end).trimStart() : undefined;
+    if (!second)
+      return;
+    if (!second.startsWith('"'))
+      return fileFromDiffPath(second);
+    return fileFromDiffPath(parseQuotedPath(second)?.value);
+  }
+  const separator = header.indexOf(" b/");
+  if (separator === -1)
+    return;
+  return fileFromDiffPath(header.slice(separator + 1));
+};
+var fileFromPatchChunk = (chunk) => {
+  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1];
+  const before = /^--- (.+)$/m.exec(chunk)?.[1];
+  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before);
+  if (file)
+    return file;
+  const header = /^diff --git (.+)$/m.exec(chunk)?.[1];
+  return fileFromGitHeader(header ?? "");
+};
+var splitGitPatch = (patch) => {
+  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) => match[0].startsWith(`
+`) ? match.index + 1 : match.index);
+  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length));
+  if (!patch.truncated)
+    return chunks;
+  return chunks.slice(0, -1);
+};
+var chunksByFile = (patch, fallback) => splitGitPatch(patch).reduce((acc, chunk, index) => {
+  const file = fileFromPatchChunk(chunk) ?? fallback(index);
+  if (!file)
+    return acc;
+  acc.set(file, (acc.get(file) ?? "") + chunk);
+  return acc;
+}, new Map);
+
+export { PATCH_CONTEXT_LINES, MAX_PATCH_BYTES, MAX_TOTAL_PATCH_BYTES, emptyPatch, addPatch, deletePatch, countPatch, fileFromPatchChunk, splitGitPatch, chunksByFile, exports_patch };

package/dist/chunks/ripgrep-w3m7zc1r.js

@@ -0,0 +1,73 @@
+import {
+  exports_model
+} from "./ripgrep-h90v6ecj.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  AgentNotFoundError,
+  StepFailedError,
+  UserInterruptedError
+} from "./ripgrep-s6by3cc4.js";
+import {
+  exports_integration
+} from "./ripgrep-qrmb8ve0.js";
+
+// src/session/to-session-error.ts
+import { AIError, ToolFailure } from "@opencode-ai/ai";
+import { Tool } from "@opencode-ai/schema/tool";
+function toSessionError(cause) {
+  if (cause instanceof AIError) {
+    switch (cause.reason._tag) {
+      case "RateLimit":
+        return providerError("provider.rate-limit", cause.reason);
+      case "Authentication":
+        return providerError("provider.auth", cause.reason);
+      case "QuotaExceeded":
+        return providerError("provider.quota", cause.reason);
+      case "ContentPolicy":
+        return providerError("provider.content-filter", cause.reason);
+      case "Transport":
+        return providerError("provider.transport", cause.reason);
+      case "ProviderInternal":
+        return providerError("provider.internal", cause.reason);
+      case "InvalidProviderOutput":
+        return providerError("provider.invalid-output", cause.reason);
+      case "InvalidRequest":
+        return providerError("provider.invalid-request", cause.reason);
+      case "NoRoute":
+        return providerError("provider.no-route", cause.reason);
+      case "UnknownProvider":
+        return providerError("provider.unknown", cause.reason);
+      default: {
+        const exhaustive = cause.reason;
+        return exhaustive;
+      }
+    }
+  }
+  if (cause instanceof exports_permission.BlockedError)
+    return { type: "permission.rejected", message: cause.message };
+  if (cause instanceof ToolFailure || cause instanceof Tool.Error) {
+    if (cause.error === undefined)
+      return { type: "tool.execution", message: cause.message };
+    const unwrapped = toSessionError(cause.error);
+    return unwrapped.message === "" ? { ...unwrapped, type: "tool.execution", message: cause.message } : unwrapped;
+  }
+  if (cause instanceof StepFailedError)
+    return cause.error;
+  if (cause instanceof AgentNotFoundError)
+    return { type: "unknown", message: cause.message };
+  if (cause instanceof UserInterruptedError)
+    return { type: "aborted", message: cause.message };
+  if (cause instanceof exports_model.ModelNotSelectedError || cause instanceof exports_model.ModelUnavailableError || cause instanceof exports_model.VariantUnavailableError || cause instanceof exports_model.UnsupportedPackageError || cause instanceof exports_model.UnresolvedProviderVariablesError)
+    return { type: "provider.no-route", message: cause.message };
+  if (cause instanceof exports_integration.AuthorizationError)
+    return { type: "provider.auth", message: cause.message };
+  return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) };
+}
+function providerError(type, reason) {
+  const status = ("http" in reason ? reason.http?.response?.status : undefined) ?? ("status" in reason ? reason.status : undefined);
+  return { type, message: reason.message, ...status === undefined ? {} : { status } };
+}
+
+export { toSessionError };

package/dist/chunks/ripgrep-w5d5n64x.js

@@ -0,0 +1,286 @@
+import {
+  ID
+} from "./ripgrep-tvmhrvfj.js";
+import {
+  exports_select
+} from "./ripgrep-04kwjb53.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  lazy
+} from "./ripgrep-8w9tzfz1.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export,
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/pty.ts
+var exports_pty = {};
+__export(exports_pty, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  UpdateInput: () => UpdateInput,
+  Service: () => Service,
+  Pty: () => exports_pty,
+  NotFoundError: () => NotFoundError,
+  Info: () => Info,
+  ExitedError: () => ExitedError,
+  Event: () => Event,
+  CreateInput: () => CreateInput
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Pty } from "@opencode-ai/schema/pty";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/pty";
+var BUFFER_LIMIT = 1024 * 1024 * 2;
+var EXITED_LIMIT = 25;
+var pty = lazy(() => import("#pty"));
+var Info = Pty.Info;
+var CreateInput = Pty.CreateInput;
+var UpdateInput = Pty.UpdateInput;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Pty.NotFoundError", {
+  ptyID: ID
+}) {
+}
+
+class ExitedError extends Schema.TaggedErrorClass()("Pty.ExitedError", {
+  ptyID: ID
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Pty") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const location = yield* exports_location.Service;
+  const config = yield* exports_config.Service;
+  const global = yield* Global.Service;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const sessions = new Map;
+  const exitOrder = [];
+  function notifyEnd(session, event) {
+    for (const subscriber of session.subscribers.values()) {
+      if (!subscriber.active) {
+        subscriber.end = event;
+        continue;
+      }
+      try {
+        subscriber.onEnd(event);
+      } catch {}
+    }
+    session.subscribers.clear();
+  }
+  function teardown(session) {
+    for (const listener of session.listeners)
+      listener.dispose();
+    session.listeners.length = 0;
+    if (session.info.status === "running") {
+      try {
+        session.process.kill();
+      } catch {}
+    }
+    notifyEnd(session, {});
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    for (const session of sessions.values())
+      teardown(session);
+    sessions.clear();
+    exitOrder.length = 0;
+  }));
+  const requireSession = Effect.fn("Pty.requireSession")(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return yield* new NotFoundError({ ptyID: id });
+    return session;
+  });
+  const removeSession = Effect.fnUntraced(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return;
+    sessions.delete(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    yield* Effect.logInfo("removing session", { id });
+    teardown(session);
+    yield* bus.publish(Pty.Event.Deleted, { id: session.info.id });
+  });
+  const remove = Effect.fn("Pty.remove")(function* (id) {
+    yield* requireSession(id);
+    yield* removeSession(id);
+  });
+  const list = Effect.fn("Pty.list")(function* () {
+    return Array.from(sessions.values()).map((session) => session.info);
+  });
+  const get = Effect.fn("Pty.get")(function* (id) {
+    return (yield* requireSession(id)).info;
+  });
+  const create = Effect.fn("Pty.create")(function* (input) {
+    const id = ID.ascending();
+    const command = input.command || exports_select.preferred(exports_config.latest(yield* config.entries(), "shell"), options, global.bin);
+    const args = exports_select.login(command) ? [...input.args ?? [], "-l"] : [...input.args ?? []];
+    const cwd = input.cwd || location.directory;
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      OPENCODE_TERMINAL: "1"
+    };
+    if (process.platform === "win32") {
+      env.LC_ALL = "C.UTF-8";
+      env.LC_CTYPE = "C.UTF-8";
+      env.LANG = "C.UTF-8";
+    }
+    yield* Effect.logInfo("creating session", { id, cmd: command, args, cwd });
+    const { spawn } = yield* Effect.promise(() => pty());
+    const proc = yield* Effect.sync(() => spawn(command, args, { name: "xterm-256color", cwd, env }));
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: proc.pid
+    };
+    const session = {
+      info,
+      process: proc,
+      buffer: "",
+      bufferCursor: 0,
+      cursor: 0,
+      subscribers: new Map,
+      listeners: []
+    };
+    sessions.set(id, session);
+    session.listeners.push(proc.onData((chunk) => {
+      session.cursor += chunk.length;
+      for (const [token, subscriber] of session.subscribers.entries()) {
+        if (!subscriber.active) {
+          subscriber.pending.push(chunk);
+          continue;
+        }
+        try {
+          subscriber.onData(chunk);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      }
+      session.buffer += chunk;
+      if (session.buffer.length <= BUFFER_LIMIT)
+        return;
+      const excess = session.buffer.length - BUFFER_LIMIT;
+      session.buffer = session.buffer.slice(excess);
+      session.bufferCursor += excess;
+    }), proc.onExit(({ exitCode }) => {
+      if (session.info.status === "exited")
+        return;
+      session.info.status = "exited";
+      session.info.exitCode = exitCode;
+      notifyEnd(session, { exitCode });
+      exitOrder.push(id);
+      runFork(Effect.gen(function* () {
+        yield* Effect.logInfo("session exited", { id, exitCode });
+        yield* bus.publish(Pty.Event.Exited, { id, exitCode });
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeSession(oldest);
+        }
+      }));
+    }));
+    yield* bus.publish(Pty.Event.Created, { info });
+    return info;
+  });
+  const update = Effect.fn("Pty.update")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (input.title)
+      session.info.title = input.title;
+    if (input.size && session.info.status === "running")
+      session.process.resize(input.size.cols, input.size.rows);
+    yield* bus.publish(Pty.Event.Updated, { info: session.info });
+    return session.info;
+  });
+  const write = Effect.fn("Pty.write")(function* (id, data) {
+    const session = yield* requireSession(id);
+    if (session.info.status === "running")
+      session.process.write(data);
+  });
+  const attach = Effect.fn("Pty.attach")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (session.info.status !== "running")
+      return yield* new ExitedError({ ptyID: id });
+    yield* Effect.logInfo("client attached to session", { id, directory: location.directory });
+    const token = {};
+    const subscriber = {
+      onData: input.onData,
+      onEnd: input.onEnd,
+      active: false,
+      detached: false,
+      pending: []
+    };
+    session.subscribers.set(token, subscriber);
+    const start = session.bufferCursor;
+    const end = session.cursor;
+    const from = input.cursor === -1 ? end : typeof input.cursor === "number" && Number.isSafeInteger(input.cursor) ? Math.max(0, input.cursor) : 0;
+    const replay = (() => {
+      if (!session.buffer || from >= end)
+        return "";
+      const offset = Math.max(0, from - start);
+      if (offset >= session.buffer.length)
+        return "";
+      return session.buffer.slice(offset);
+    })();
+    return {
+      replay,
+      cursor: end,
+      write: (data) => {
+        if (session.info.status === "running")
+          session.process.write(data);
+      },
+      activate: () => {
+        if (subscriber.active || subscriber.detached)
+          return;
+        subscriber.active = true;
+        try {
+          for (const chunk of subscriber.pending)
+            subscriber.onData(chunk);
+          subscriber.pending.length = 0;
+          if (subscriber.end)
+            subscriber.onEnd(subscriber.end);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      },
+      detach: () => {
+        subscriber.detached = true;
+        subscriber.pending.length = 0;
+        subscriber.end = undefined;
+        session.subscribers.delete(token);
+      }
+    };
+  });
+  return Service.of({ list, get, create, update, remove, write, attach });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_bus.node, exports_location.node, exports_config.node, Global.node]
+  });
+}
+var node = configured();
+
+export { Info, CreateInput, UpdateInput, NotFoundError, ExitedError, Service, layer, configured, node, exports_pty, Event };

package/dist/chunks/ripgrep-w8bc7ndm.js

@@ -0,0 +1,212 @@
+import {
+  exports_runtime
+} from "./ripgrep-5rzqpsek.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_schema
+} from "./ripgrep-y8rs54ne.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/subagent.ts
+var exports_subagent = {};
+__export(exports_subagent, {
+  name: () => name,
+  description: () => description,
+  SubagentTool: () => exports_subagent,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema, Scope } from "effect";
+var name = "subagent";
+var NO_TEXT = "Subagent completed without a text response.";
+var backgroundStarted = (sessionID) => [
+  `The subagent is working in the background (id: ${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 Input = 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" }),
+  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 Output = Schema.Struct({
+  sessionID: exports_schema.ID,
+  status: Schema.Literals(["completed", "running"]),
+  output: Schema.String
+});
+var description = [
+  "Spawns an agent in a child session to work on the specified task.",
+  "Include all relevant context and instructions in the prompt because the child starts with fresh context.",
+  "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 Plugin = {
+  id: "opencode.tool.subagent",
+  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
+    const runtime = yield* exports_runtime.Service;
+    const agents = yield* exports_agent.Service;
+    const config = yield* exports_config.Service;
+    const permission = yield* exports_permission.Service;
+    const scope = yield* Scope.Scope;
+    const latestAssistantText = Effect.fn("SubagentTool.latestAssistantText")(function* (sessionID) {
+      const messages = yield* runtime.session.messages({ sessionID, order: "desc", limit: 20 });
+      const assistant = messages.find((message) => message.type === "assistant" && message.time.completed !== undefined && message.error === undefined);
+      if (assistant === undefined || assistant.type !== "assistant")
+        return NO_TEXT;
+      const text = assistant.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+      return text.length > 0 ? text : NO_TEXT;
+    });
+    const injectCompletion = Effect.fn("SubagentTool.injectCompletion")(function* (parentID, childID, agent, description2, state, text) {
+      yield* runtime.session.synthetic({
+        sessionID: parentID,
+        text: `<subagent id="${childID}" state="${state}" description="${description2}">
+${text}
+</subagent>`,
+        description: description2,
+        metadata: { source: "subagent", childID, agent, state }
+      });
+    });
+    const notifyWhenDone = Effect.fn("SubagentTool.notifyWhenDone")(function* (parentID, childID, agent, description2) {
+      yield* runtime.job.wait({ id: childID }).pipe(Effect.flatMap((result) => {
+        if (result.info?.status === "completed")
+          return injectCompletion(parentID, childID, agent, description2, "completed", result.info.output ?? NO_TEXT);
+        if (result.info?.status === "error")
+          return injectCompletion(parentID, childID, agent, description2, "error", result.info.error ?? "Subagent failed");
+        if (result.info?.status === "cancelled")
+          return injectCompletion(parentID, childID, agent, description2, "cancelled", "Subagent cancelled");
+        return Effect.void;
+      }), Effect.forkIn(scope, { startImmediately: true }));
+    });
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const parent = yield* runtime.session.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* runtime.session.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
+        }
+        const limit = exports_config.latest(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: name,
+          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 model = agent.model ?? parent.model;
+        const child = yield* runtime.session.create({
+          parentID: context.sessionID,
+          title: input.description,
+          agent: exports_agent.ID.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" });
+        const run = Effect.gen(function* () {
+          yield* runtime.session.prompt({
+            sessionID: child.id,
+            text: ["You are a subagent spawned by another session.", input.prompt].join(`
+`),
+            resume: false
+          });
+          yield* runtime.session.resume(child.id);
+          return yield* latestAssistantText(child.id);
+        }).pipe(Effect.onInterrupt(() => runtime.session.interrupt(child.id)));
+        const info = yield* runtime.job.start({
+          id: child.id,
+          type: name,
+          title: input.description,
+          metadata: {},
+          run
+        });
+        if (background) {
+          yield* runtime.job.background(info.id);
+          yield* notifyWhenDone(context.sessionID, child.id, agent.name, input.description);
+          return {
+            sessionID: child.id,
+            status: "running",
+            output: backgroundStarted(child.id)
+          };
+        }
+        const result = yield* runtime.job.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([runtime.session.interrupt(child.id), runtime.job.cancel(child.id)], {
+          discard: true
+        })));
+        if (result?.type === "backgrounded") {
+          yield* notifyWhenDone(context.sessionID, child.id, agent.name, input.description);
+          return {
+            sessionID: child.id,
+            status: "running",
+            output: backgroundStarted(child.id)
+          };
+        }
+        if (result?.info.status === "error")
+          return yield* new ToolFailure({ message: result.info.error ?? "Subagent failed" });
+        if (result?.info.status === "cancelled")
+          return yield* new ToolFailure({ message: "Subagent cancelled" });
+        return { sessionID: child.id, status: "completed", output: result?.info.output ?? NO_TEXT };
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: 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[name];
+      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 && exports_permission.evaluate(name, 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 { name, Input, Output, description, Plugin, exports_subagent };