rovecode 0.4.0-beta.2 → 0.4.0

package/src/tools/provider.ts

@@ -0,0 +1,149 @@
+/** provider_list / provider_edit — the agent's window onto the provider registry (providers/registry.ts).
+ *
+ *  Split like task/task_status (port #26): provider_list is kind "read" (policy action file.read →
+ *  auto-allowed under gated rules and in plan mode; it never mutates and never prompts), provider_edit
+ *  is kind "custom" → action tool.provider_edit, PROMPT under gated rules (cli/runtime.ts buildCfg),
+ *  denied in plan mode by the blanket tool.* rule, allowed under yolo. Children (task tool) get neither.
+ *
+ *  Secrets: NEITHER tool accepts, returns or echoes an API key. provider_list prints key SOURCES
+ *  (stored / env NAME / none); provider_edit refuses any key-shaped argument (looksLikeSecret) and
+ *  tells the model how the human sets one — `rovecode auth set <id>` (masked prompt), `/provider key`
+ *  in the TUI, or the env var named by keyEnv. A key the model was given would otherwise sit in the
+ *  transcript and in the provider's logs forever.
+ *
+ *  Effects are live: the registry re-reads its files, so the run that follows an add/use — and the
+ *  TUI, through registry.onChange — sees the new provider without a restart. */
+
+import type { Tool, ToolOutput } from "../core/types.ts";
+import { inferProtocol, isConfigured } from "../providers/provider-config.ts";
+import { formatProviderList, type ProviderRegistry } from "../providers/registry.ts";
+
+const SECRET_FIELD_RE = /^(api[_-]?key|key|secret|token|password|auth(orization)?|bearer)$/i;
+/** common key prefixes — a value that starts like this is a secret whatever the field is called */
+const SECRET_VALUE_RE = /^(sk-|sk_|key-|xai-|gsk_|AKIA|Bearer\s|ghp_)/;
+
+/** The argument name that carries something key-shaped, or null. `keyEnv`/`noKey` are legitimate. */
+export function looksLikeSecret(args: unknown): string | null {
+  if (typeof args !== "object" || args === null) return null;
+  for (const [k, v] of Object.entries(args as Record<string, unknown>)) {
+    if (k === "keyEnv" || k === "noKey") continue;
+    if (typeof v !== "string" || v.trim().length === 0) continue;
+    if (SECRET_FIELD_RE.test(k)) return k;
+    if (SECRET_VALUE_RE.test(v.trim())) return k;
+  }
+  return null;
+}
+
+const refusal = (field: string): string =>
+  `provider_edit never accepts API keys (argument "${field}" looks like one) — nothing was stored. Keys stay with the human: ask them to run \`rovecode auth set <id>\` (masked prompt) or \`/provider key <id> <key>\` in the TUI, or to set the env var you name in keyEnv. Then retry without the key.`;
+
+export function providerListTool(reg: ProviderRegistry): Tool {
+  return {
+    schema: {
+      name: "provider_list",
+      description: "Inspect model providers (never prompts, never mutates, never shows a key). `list` shows the configured providers, the default provider/model and where each key comes from (stored / env NAME / none; `all` adds keyless built-ins); `models` lists the model ids a provider offers (its providers.json entry or its /models endpoint); `test` makes one tiny real call to a provider (optionally a specific model) and reports ok or the error. Use it before switching models, or when a run ends with a `config:` error.",
+      args: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["list", "models", "test"] },
+          id: { type: "string", description: "provider id (models / test)" },
+          model: { type: "string", description: "model id to test (default: the provider's default model)" },
+          all: { type: "boolean", description: "list: include built-in providers that have no key yet" },
+        },
+        required: ["action"],
+      },
+    },
+    kind: "read",
+    sequential: false,
+    async execute(args): Promise<ToolOutput> {
+      const a = (args && typeof args === "object" ? args : {}) as { action?: string; id?: string; model?: string; all?: boolean };
+      switch (a.action) {
+        case "list":
+          return { ok: true, output: formatProviderList(reg, { all: a.all === true }) };
+        case "models": {
+          if (!a.id) return { ok: false, output: "models needs `id`" };
+          const r = await reg.models(a.id);
+          if (!r.ok) return { ok: false, output: r.error };
+          return r.models.length > 0
+            ? { ok: true, output: `${a.id} models (${r.source}, ${r.models.length}):\n${r.models.join("\n")}` }
+            : { ok: true, output: `${a.id}: the endpoint listed no models (it may not implement /models — try a model id directly with test)` };
+        }
+        case "test": {
+          if (!a.id) return { ok: false, output: "test needs `id`" };
+          const r = await reg.probe(a.id, a.model);
+          return { ok: r.ok, output: `${a.id}/${r.model}: ${r.detail}` };
+        }
+        default:
+          return { ok: false, output: "action must be list | models | test" };
+      }
+    },
+  };
+}
+
+export function providerEditTool(reg: ProviderRegistry): Tool {
+  return {
+    schema: {
+      name: "provider_edit",
+      description: "Add, remove or select model providers; the human approves each call. `add` registers an endpoint {id, baseUrl, protocol? (openai|anthropic — inferred from the URL), keyEnv? (env var holding the key), defaultModel?, noKey? (local servers), scope? (user|project)} in providers.json. `remove` deletes a file-defined provider. `use` sets the default provider/model (`selector` = \"provider/model\" or a provider id) and takes effect immediately: the TUI switches now, the next run uses it, no restart. NEVER pass an API key here — the call is refused and nothing is stored. After `add`, tell the user to run `rovecode auth set <id>` (or `/provider key <id> <key>` in the TUI), or to set the keyEnv variable; the key is picked up live.",
+      args: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["add", "remove", "use"] },
+          id: { type: "string" },
+          baseUrl: { type: "string", description: "http(s) endpoint root, e.g. https://llm.example.com/v1" },
+          protocol: { type: "string", enum: ["openai", "anthropic"] },
+          keyEnv: { type: "string", description: "env var that holds the key (default <ID>_API_KEY)" },
+          defaultModel: { type: "string" },
+          noKey: { type: "boolean", description: "local server: no key required" },
+          scope: { type: "string", enum: ["user", "project"], description: "which providers.json: ~/.rovecode (default) or ./.rovecode" },
+          selector: { type: "string", description: "use: provider/model" },
+        },
+        required: ["action"],
+      },
+    },
+    kind: "custom",
+    sequential: true,
+    async execute(args): Promise<ToolOutput> {
+      const leaked = looksLikeSecret(args);
+      if (leaked !== null) return { ok: false, output: refusal(leaked) };
+      const a = (args && typeof args === "object" ? args : {}) as {
+        action?: string; id?: string; baseUrl?: string; protocol?: "openai" | "anthropic"; keyEnv?: string;
+        defaultModel?: string; noKey?: boolean; scope?: "user" | "project"; selector?: string;
+      };
+      const scope = a.scope === "project" ? "project" : "user";
+      switch (a.action) {
+        case "add": {
+          if (!a.id || !a.baseUrl) return { ok: false, output: "add needs `id` and `baseUrl`" };
+          const r = reg.add({
+            id: a.id, baseUrl: a.baseUrl, protocol: a.protocol ?? inferProtocol(a.baseUrl),
+            ...(a.keyEnv !== undefined ? { keyEnv: a.keyEnv } : {}),
+            ...(a.defaultModel !== undefined ? { defaultModel: a.defaultModel } : {}),
+            ...(a.noKey === true ? { noKey: true } : {}),
+          }, scope);
+          if ("error" in r) return { ok: false, output: r.error };
+          const key = !isConfigured(r)
+            ? `key: NOT SET — the user must run \`rovecode auth set ${r.id}\` (or \`/provider key ${r.id} <key>\` in the TUI), or set ${r.keyEnv}; it is picked up immediately, no restart`
+            : r.keySource === "stored" ? "key: stored credential" : r.keySource === "env" ? `key: env ${r.keyEnv} (present)` : "key: not needed";
+          return { ok: true, output: `added provider "${r.id}" (${r.protocol}, ${r.baseUrl}) to the ${scope} providers.json\n${key}${r.defaultModel !== undefined ? `\ndefault model: ${r.defaultModel}` : ""}\nselect it with provider_edit use ${r.id}/<model>` };
+        }
+        case "remove": {
+          if (!a.id) return { ok: false, output: "remove needs `id`" };
+          const r = reg.remove(a.id);
+          if ("error" in r) return { ok: false, output: r.error };
+          return { ok: true, output: r.removed.length > 0 ? `removed provider "${a.id}" from the ${r.removed.join(" and ")} providers.json` : `provider "${a.id}" was not in any providers.json` };
+        }
+        case "use": {
+          const sel = a.selector ?? a.id;
+          if (!sel) return { ok: false, output: "use needs `selector` (provider/model)" };
+          const r = reg.setDefault(sel, scope);
+          if ("error" in r) return { ok: false, output: r.error };
+          const p = reg.get(r.provider);
+          const note = p !== undefined && !isConfigured(p) ? `\nnote: ${reg.keyHint(p)}` : "";
+          return { ok: true, output: `default → ${r.provider}/${r.model} (saved to the ${scope} providers.json; the TUI switches now, headless runs use it from the next run)${note}` };
+        }
+        default:
+          return { ok: false, output: "action must be add | remove | use" };
+      }
+    },
+  };
+}

package/src/tools/task.ts

@@ -0,0 +1,216 @@
+/** `task` + `task_status` tools (port #26): the model's door to background subagents over
+ *  core/tasks.ts TaskManager. Children run through orchestrator.ts runChild (the ONE
+ *  agentLoop); these tools never run a loop themselves.
+ *
+ *  Source shape: opencode packages/opencode/src/tool/task.ts (MIT, snapshot
+ *  research/source_snapshots/opencode-2026 @ ebece6e) — parameters description/prompt/
+ *  subagent_type + background flag (:43-62), "started" text that tells the model NOT to
+ *  poll and to keep working or end its turn (:31-35), depth walk refusal (:104-117),
+ *  result rendered as a tagged block with the child's final text (:64-79, :341-345).
+ *  Departures: TWO tools split by policy class instead of background:true on a foreground
+ *  tool — `task` (kind spawn: start|cancel — creating a child, or destroying its work) and
+ *  `task_status` (kind read: status|result|list — registry reads; `result` is an explicit
+ *  bounded wait). Refusals come from the orchestrator's preflight (depth cap / spawn
+ *  policy) as tool output, never exceptions.
+ *
+ *  Policy: `task` kind "spawn" → action "spawn" (core/tools.ts actionFor): the default gated
+ *  rules PROMPT for it (cli/runtime.ts buildCfg) — once per start, since "once" is never
+ *  cached — yolo allows, plan mode denies (core/modes.ts); children derive prompt→deny
+ *  (orchestrator deriveChildRules), so nested starts exist only under an allow rule.
+ *  `task_status` kind "read" → action "file.read", which the gated rules ALLOW: collecting a
+ *  result never prompts, headless surfaces (run/serve/acp) and children read it, plan mode
+ *  keeps it. Its schema declares no path/command/url, so the policy resource is the tool
+ *  NAME and a smuggled `path` cannot re-aim a `deny file.read task_status` rule (tools.ts
+ *  describeResource honors declared keys only). Fix-wave MED-2: one action-agnostic
+ *  spawn-kind tool prompted for status/result/list too (≥2 prompts per task) and failed
+ *  them closed on headless surfaces. */
+
+import type { Tool, ToolContext, ToolOutput } from "../core/types.ts";
+import { formatTaskList, isTerminal, type TaskId, type TaskInfo, type TaskManager } from "../core/tasks.ts";
+import type { SteeringQueue } from "../core/loop.ts";
+
+export const DEFAULT_WAIT_MS = 60_000;
+export const MAX_WAIT_MS = 600_000;
+
+export interface TaskToolOptions {
+  /** depth of the loop this tool serves (root = 0); children start at depth + 1 */
+  parentDepth?: number;
+  /** completion notes for tasks started here (default: the manager's attached queue) */
+  notify?: SteeringQueue;
+  /** the task id of the child this tool serves (nested); enables slot lending */
+  caller?: TaskId;
+  /** owner signal for tasks started here (nested: the serving task's own run signal, so
+   *  cancelling a task cancels its children). Root tools leave it unset — the manager's
+   *  bindRun() signal owns root tasks; ToolContext.signal is NOT usable (loop.ts:91). */
+  owner?: AbortSignal;
+  /** agent name used when `agent` is omitted */
+  defaultAgent?: string;
+}
+
+export interface TaskStatusToolOptions {
+  /** the task id of the child this tool serves (nested): a `result` wait lends its slot to
+   *  the waited-on queued task (TaskManager.result slot lending) */
+  caller?: TaskId;
+}
+
+const NOT_POLLING =
+  "You will be notified in this conversation when it finishes — do NOT poll or sleep: " +
+  "continue other non-overlapping work or end your turn. Use `task_status result` to wait for it when you need its output.";
+/** one-shot policy (cli/main.ts cmdRun exit): tasks never outlive the process that started them */
+const ONE_SHOT =
+  "In a one-shot run (`rovecode run`) background tasks do not outlive the run: collect what you need with " +
+  "`task_status result` before ending your turn.";
+
+interface Args {
+  action?: unknown; goal?: unknown; agent?: unknown; isolated?: unknown; label?: unknown; id?: unknown; timeout_ms?: unknown;
+}
+
+const err = (output: string): ToolOutput => ({ ok: false, output: `Error: ${output}` });
+const need = (tool: string, what: string): ToolOutput => err(`${tool} ${what} requires a string \`id\` (see \`task_status list\`)`);
+
+function describe(t: TaskInfo, now: number): string {
+  const secs = t.startedAt !== undefined ? Math.max(0, Math.round(((t.finishedAt ?? now) - t.startedAt) / 1000)) : 0;
+  const usage = t.usage ? `, tokens ${t.usage.input}in/${t.usage.output}out` : "";
+  return `task ${t.id} (${t.label}) ${t.status} — agent ${t.agent}, ${t.isolated ? "isolated, " : ""}${secs}s${usage}`;
+}
+
+function renderResult(t: TaskInfo, now: number): ToolOutput {
+  const head = describe(t, now);
+  if (t.status === "done") {
+    const patch = t.patchLines !== undefined ? `\n[isolated: ${t.patchLines === 0 ? "no file changes" : `patch of ${t.patchLines} lines merged back`}]` : "";
+    return { ok: true, output: `${head}${patch}\n${t.summary ?? "(no output)"}`, data: t };
+  }
+  if (t.status === "failed") return { ok: false, output: `${head}\n${t.error ?? "unknown error"}`, data: t };
+  if (t.status === "cancelled") return { ok: false, output: head, data: t };
+  return { ok: true, output: `${head}. ${NOT_POLLING}`, data: t };
+}
+
+/** `timeout_ms`: numbers and numeric strings ("5000" — models quote integers) clamp to
+ *  [0, MAX_WAIT_MS]; absent → the default; anything else is a clear error, never a silent
+ *  default (fix-wave L6: a quoted "5000" used to become the 60s default). */
+function parseTimeout(v: unknown): number | { error: string } {
+  if (v === undefined || v === null) return DEFAULT_WAIT_MS;
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+  if (!Number.isFinite(n)) return { error: `task_status result: \`timeout_ms\` must be a number of milliseconds (got ${JSON.stringify(v) ?? String(v)})` };
+  return Math.min(MAX_WAIT_MS, Math.max(0, Math.floor(n)));
+}
+
+/** kind spawn: `start` (a new child) and `cancel` (destroys the child's work) — the two
+ *  actions a gated policy should ask about. Reads live on `task_status`. */
+export function createTaskTool(tasks: TaskManager, opts: TaskToolOptions = {}): Tool {
+  const defaultAgent = opts.defaultAgent ?? "main";
+  return {
+    schema: {
+      name: "task",
+      description:
+        "Run subagents as background tasks. `start` launches a child agent session on `goal` and returns " +
+        "at once with a task id; the child works while you continue, and a note lands in this conversation " +
+        "when it finishes (do not poll). Read its state or output with the `task_status` tool (status/result/list " +
+        "— never prompts); `cancel` aborts a task. Children see only `goal` (write it self-contained). " +
+        `At most ${tasks.maxConcurrent} run concurrently; extra starts queue FIFO. ` +
+        "`isolated` runs the child in a git worktree copy and merges its file changes back as a patch on success. " +
+        "Policy: under gated rules each `start` needs approval and the child runs read-only (prompt-gated actions " +
+        "are denied for children) unless allow rules cover them; under yolo it inherits allow-all. " + ONE_SHOT,
+      args: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["start", "cancel"] },
+          goal: { type: "string", description: "start: the child's task, self-contained (it has no access to this conversation)" },
+          agent: { type: "string", description: `start: agent definition to run (default "${defaultAgent}")` },
+          isolated: { type: "boolean", description: "start: run in an isolated worktree copy; file changes merge back as a patch when the task finishes ok" },
+          label: { type: "string", description: "start: short label (3-5 words) shown in task lists and completion notes" },
+          id: { type: "string", description: "cancel: task id (e.g. t1)" },
+        },
+        required: ["action"],
+      },
+    },
+    kind: "spawn",
+    sequential: true,
+    async execute(args: unknown): Promise<ToolOutput> {
+      const a = (args ?? {}) as Args;
+      const id = typeof a.id === "string" ? a.id.trim() : "";
+      switch (a.action) {
+        case "start": {
+          if (typeof a.goal !== "string" || a.goal.trim() === "") return err("task start requires a non-empty string `goal`");
+          const agent = typeof a.agent === "string" && a.agent.trim() !== "" ? a.agent.trim() : defaultAgent;
+          const r = tasks.start(
+            { agent, goal: a.goal, isolated: a.isolated === true, background: true },
+            { label: typeof a.label === "string" ? a.label : undefined, parentDepth: opts.parentDepth ?? 0, notify: opts.notify, caller: opts.caller, owner: opts.owner },
+          );
+          if (!r.ok) return err(`task refused: ${r.reason}`);
+          const t = tasks.status(r.id)!;
+          const state = t.status === "running" ? "running" : `queued (${tasks.counts().running} running, bound ${tasks.maxConcurrent})`;
+          // the approver/model must know what the child CAN do (deriveChildRules: prompt → deny)
+          const policy = r.childPolicy === "gated"
+            ? "Policy: gated — the child runs read-only (prompt-gated actions are DENIED for children) unless allow rules cover them."
+            : "Policy: the child inherits your allow rules.";
+          return { ok: true, output: `task ${t.id} (${t.label}) started: ${state}. ${policy} ${NOT_POLLING}`, data: t };
+        }
+        case "cancel": {
+          if (id === "") return need("task", "cancel");
+          const before = tasks.status(id);
+          if (!before) return err(`unknown task '${id}'`);
+          if (isTerminal(before.status)) return { ok: true, output: `task ${id} already ${before.status}`, data: before };
+          const t = tasks.cancel(id)!;
+          return { ok: true, output: `task ${t.id} (${t.label}) cancelled`, data: t };
+        }
+        default:
+          return err(`task requires action start|cancel (got ${JSON.stringify(a.action ?? null)}); status|result|list live on task_status`);
+      }
+    },
+  };
+}
+
+/** kind read: `status` | `result` (bounded wait, aborts with the run) | `list`. Auto-allowed by
+ *  the gated rules (file.read) and plan mode; no path/command/url in the schema, so the policy
+ *  resource is always the tool name. */
+export function createTaskStatusTool(tasks: TaskManager, opts: TaskStatusToolOptions = {}): Tool {
+  return {
+    schema: {
+      name: "task_status",
+      description:
+        "Read background tasks started with `task` (never prompts, never mutates). `status` shows one task's " +
+        "state; `result` waits (bounded by `timeout_ms`, default 60s) for a task to finish and returns the " +
+        "child's final output — call it when you need the output, otherwise wait for the completion note; " +
+        "`list` shows every task. " + ONE_SHOT,
+      args: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["status", "result", "list"] },
+          id: { type: "string", description: "status/result: task id (e.g. t1)" },
+          timeout_ms: { type: "integer", description: `result: max wait in ms (default ${DEFAULT_WAIT_MS}, max ${MAX_WAIT_MS}); 0 = report the current state at once` },
+        },
+        required: ["action"],
+      },
+    },
+    kind: "read",
+    sequential: true,
+    async execute(args: unknown, ctx: ToolContext): Promise<ToolOutput> {
+      const a = (args ?? {}) as Args;
+      const now = Date.now();
+      const id = typeof a.id === "string" ? a.id.trim() : "";
+      switch (a.action) {
+        case "status": {
+          if (id === "") return need("task_status", "status");
+          const t = tasks.status(id);
+          return t ? { ok: true, output: describe(t, now), data: t } : err(`unknown task '${id}'`);
+        }
+        case "result": {
+          if (id === "") return need("task_status", "result");
+          if (!tasks.status(id)) return err(`unknown task '${id}'`);
+          const timeoutMs = parseTimeout(a.timeout_ms);
+          if (typeof timeoutMs !== "number") return err(timeoutMs.error);
+          const t = await tasks.result(id, { timeoutMs, signal: ctx.signal, caller: opts.caller });
+          if (!t) return err(`unknown task '${id}'`);
+          if (!isTerminal(t.status) && ctx.signal.aborted) return err(`wait for task ${id} aborted`);
+          if (!isTerminal(t.status)) return { ok: true, output: `${describe(t, Date.now())} — still running after ${Math.round(timeoutMs / 1000)}s. ${NOT_POLLING}`, data: t };
+          return renderResult(t, Date.now());
+        }
+        case "list":
+          return { ok: true, output: formatTaskList(tasks.list(), now), data: tasks.counts() };
+        default:
+          return err(`task_status requires action status|result|list (got ${JSON.stringify(a.action ?? null)}); start|cancel live on task`);
+      }
+    },
+  };
+}