oakode 0.0.0-stage → 0.5.1

package/dist/agents/plan.js

@@ -0,0 +1,143 @@
+/**
+ * Plans: what the parent model proposes with `delegate`, normalized and checked in code before anyone approves it
+ * (docs/design/subagents.md §7). The model proposes; this decides what is allowed.
+ */
+import { accessNote, allowedModel, effectiveModel, notSupported } from "../models.js";
+import { estimablePricing, estimateAs, worstCaseUsd } from "./budget.js";
+import { EFFORT_CHOICES } from "./types.js";
+const str = (v, max) => (typeof v === "string" ? v.trim().slice(0, max) : "");
+/** The model's `none`/`minimal` become low and `xhigh` becomes high; anything else unknown is the provider's default. */
+function effortOf(v) {
+    const s = str(v, 20).toLowerCase();
+    if (!s)
+        return { effort: "default" };
+    if (EFFORT_CHOICES.includes(s))
+        return { effort: s };
+    if (s === "none" || s === "minimal")
+        return { effort: "low", mapped: s };
+    if (s === "xhigh")
+        return { effort: "high", mapped: s };
+    return { effort: "default", mapped: s };
+}
+/**
+ * The `delegate` tool's arguments as a plan. Unknown fields are ignored, ids are made safe and unique, the model
+ * defaults to `auto`, and each agent's budget is an even share of what is left of the turn's budget.
+ */
+export function parsePlan(args, remaining) {
+    const notes = [];
+    const list = Array.isArray(args?.agents) ? args.agents : [];
+    const seen = new Set();
+    const agents = list.map((a, i) => {
+        let id = str(a?.id, 24).replace(/[^A-Za-z0-9_-]/g, "") || `a${i + 1}`;
+        while (seen.has(id))
+            id = `${id}_${i + 1}`;
+        seen.add(id);
+        const { effort, mapped } = effortOf(a?.effort);
+        if (mapped)
+            notes.push({ agent: id, severity: "warn", text: `effort "${mapped}" is shown as ${effort} (the card offers default, low, medium, high)` });
+        return {
+            id,
+            role: str(a?.role, 120) || `agent ${i + 1}`,
+            task: str(a?.task, 8000),
+            model: str(a?.model, 200) || "auto",
+            effort,
+            profile: "read",
+            budgetCredits: 0,
+            dependsOn: Array.isArray(a?.dependsOn) ? a.dependsOn.map((d) => str(d, 24)).filter(Boolean) : [],
+        };
+    });
+    const share = agents.length ? Math.floor((remaining / agents.length) * 100) / 100 : 0;
+    for (const a of agents)
+        a.budgetCredits = share;
+    return { plan: { goal: str(args?.goal, 500), agents }, notes };
+}
+/** The effort actually sent for a model: nothing for `default` or a model that takes no effort setting. */
+export function effortSent(m, e) {
+    return e !== "default" && m?.oicki.capabilities.reasoning ? e : undefined;
+}
+/** Checks a plan; errors block approval until the plan is edited. */
+export function validatePlan(plan, ctx) {
+    const issues = [];
+    const err = (text, agent) => issues.push({ agent, severity: "error", text });
+    const warn = (text, agent) => issues.push({ agent, severity: "warn", text });
+    const find = (id) => ctx.catalog.find((m) => m.id === id);
+    if (!plan.agents.length)
+        err("the plan has no agents");
+    if (plan.agents.length > ctx.settings.maxAgents)
+        err(`${plan.agents.length} agents; at most ${ctx.settings.maxAgents} (subagents.maxAgents)`);
+    const ids = new Set(plan.agents.map((a) => a.id));
+    const estimate = {};
+    let sum = 0;
+    for (const a of plan.agents) {
+        if (!a.task)
+            err("no task", a.id);
+        const m = find(a.model);
+        if (!allowedModel(a.model))
+            err(notSupported(a.model), a.id);
+        else if (!m)
+            err(`"${a.model}" is not in OICKI's model list`, a.id);
+        else {
+            const served = m.oicki.resolves_to ? find(m.oicki.resolves_to) : undefined;
+            const eff = effectiveModel(m, served);
+            if (!eff.oicki.capabilities.tools)
+                err(`${a.model} cannot use tools`, a.id);
+            const note = accessNote(m);
+            if (note)
+                err(`${a.model} ${note}, so OICKI would refuse it for this sign-in`, a.id);
+            if ((eff.oicki.context_window ?? Infinity) < 32_000)
+                warn(`${a.model} has a small context window (${eff.oicki.context_window} tokens)`, a.id);
+            if (a.effort !== "default" && !eff.oicki.capabilities.reasoning)
+                warn(`${a.model} takes no effort setting; "${a.effort}" is not sent`, a.id);
+            const as = estimateAs(m, find); // a router is estimated as the model it resolves to
+            const p = estimablePricing(as);
+            if (!as || !p)
+                err(`${a.model} has no verified price in the catalog, so its cost cannot be estimated`, a.id);
+            else
+                estimate[a.id] = estimateAgent(p, ctx.rate, as.id, a.budgetCredits, ctx.settings.agentMaxRequests);
+        }
+        if (!(a.budgetCredits > 0))
+            err("budget must be more than 0 credits", a.id);
+        sum += a.budgetCredits;
+        for (const d of a.dependsOn)
+            if (!ids.has(d))
+                err(`depends on "${d}", which is not in the plan`, a.id);
+        if (a.dependsOn.includes(a.id))
+            err("depends on itself", a.id);
+    }
+    if (plan.agents.length === 1)
+        warn("one agent runs nothing in parallel; doing it yourself is usually cheaper");
+    if (sum > ctx.remaining + 1e-9)
+        warn(`the agents' budgets add up to ${sum.toFixed(2)} credits, more than the ${ctx.remaining.toFixed(2)} left this turn: they share what is left`);
+    const levels = dependencyLevels(plan.agents);
+    if (!levels)
+        err("the dependencies form a cycle");
+    else if (levels.length > 4)
+        err(`${levels.length} dependency levels; at most 4`);
+    return { plan, issues, estimate, levels: levels ?? [] };
+}
+/** Agents grouped by dependency depth (all of a level can run together), or undefined for a cycle. */
+export function dependencyLevels(agents) {
+    const known = new Set(agents.map((a) => a.id));
+    const placed = new Set();
+    const levels = [];
+    while (placed.size < agents.length) {
+        const next = agents.filter((a) => !placed.has(a.id) && a.dependsOn.every((d) => placed.has(d) || !known.has(d))).map((a) => a.id);
+        if (!next.length)
+            return undefined;
+        next.forEach((id) => placed.add(id));
+        levels.push(next);
+    }
+    return levels;
+}
+/**
+ * A rough range: low = 6 requests of an 8K-token prompt, 70% cached, 600 output tokens; high = the worst case of the
+ * agent's request limit (agentMaxRequests), never more than its budget. Both at the model's learned credits-per-USD ratio.
+ */
+function estimateAgent(p, rate, model, budget, maxRequests) {
+    const perUsd = rate.get(model);
+    const cached = p.cache_read_usd_per_million ?? p.input_usd_per_million;
+    const lowUsd = 6 * ((8000 * 0.3 * p.input_usd_per_million + 8000 * 0.7 * cached + 600 * p.output_usd_per_million) / 1e6 + (p.per_request_usd ?? 0));
+    const highUsd = maxRequests * worstCaseUsd(p, 20_000, 4096);
+    const low = lowUsd * perUsd;
+    return { low: Math.min(low, budget), high: Math.max(Math.min(highUsd * perUsd, budget), Math.min(low, budget)), firstUse: !rate.known(model) };
+}

package/dist/agents/types.js

@@ -0,0 +1,20 @@
+/** Subagent types and settings (docs/design/subagents.md §3, §5). */
+import { loadConfig } from "../config.js";
+export const EFFORT_CHOICES = ["default", "low", "medium", "high"];
+/** The highest budget OAKODE accepts at all, whatever the config says. */
+export const BUDGET_CEILING = 200;
+const num = (v, def, min, max) => (typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : def);
+/** `"subagents"` in config.json, with defaults and bounds; off unless `"enabled": true`. */
+export function subagentSettings(raw = loadConfig().subagents) {
+    const c = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    const maxBudgetCredits = num(c.maxBudgetCredits, BUDGET_CEILING, 1, BUDGET_CEILING);
+    return {
+        enabled: c.enabled === true,
+        maxParallel: Math.round(num(c.maxParallel, 3, 1, 8)),
+        maxAgents: Math.round(num(c.maxAgents, 6, 1, 12)),
+        budgetCredits: num(c.budgetCredits, 40, 1, maxBudgetCredits),
+        maxBudgetCredits,
+        agentTimeoutSec: num(c.agentTimeoutSec, 600, 30, 3600),
+        agentMaxRequests: Math.round(num(c.agentMaxRequests, 30, 2, 100)),
+    };
+}

package/dist/agents/verify.js

@@ -0,0 +1,94 @@
+import { posix } from "node:path";
+/** One spelling per relative path ("./a/../b.ts" and "b.ts" are the same file); absolute paths stay as they are. */
+const norm = (p) => posix.normalize(p.replace(/\\/g, "/")).replace(/^\.\//, "").replace(/\/+$/, "");
+/** For each file: the line numbers the agent's tools actually showed it (an empty set: touched, no lines seen). */
+export function seenLines(raw) {
+    const seen = new Map();
+    const add = (path, n) => {
+        const k = norm(path);
+        if (!seen.has(k))
+            seen.set(k, new Set());
+        if (n !== undefined)
+            seen.get(k).add(n);
+    };
+    const results = new Map();
+    // text, or (from an older session) a list of text parts
+    const text = (c) => (typeof c === "string" ? c : Array.isArray(c) ? c.map((p) => (p && typeof p.text === "string" ? p.text : "")).join("") : "");
+    for (const m of raw)
+        if (m.role === "tool")
+            results.set(m.tool_call_id, text(m.content));
+    for (const m of raw) {
+        if (m.role !== "assistant" || !m.tool_calls)
+            continue;
+        for (const c of m.tool_calls) {
+            const out = results.get(c.id);
+            if (!out || out.startsWith("Error:") || out.startsWith("Interrupted:"))
+                continue;
+            let args;
+            try {
+                args = JSON.parse(c.function.arguments);
+            }
+            catch {
+                continue;
+            }
+            if (c.function.name === "read") {
+                // one file: numbered lines; several: "==> path <==" sections, each of which may be an error instead
+                const single = Array.isArray(args.paths) ? (args.paths.length === 1 ? args.paths[0] : undefined) : args.path;
+                let current = typeof single === "string" ? single : undefined;
+                let fresh = false; // just after a section header: its first line decides whether the file was read
+                if (current)
+                    add(current);
+                for (const line of out.split("\n")) {
+                    const head = /^==> (.+) <==$/.exec(line);
+                    if (head) {
+                        current = head[1];
+                        fresh = true;
+                        continue;
+                    }
+                    if (fresh && current) {
+                        fresh = false;
+                        if (line.startsWith("Error:")) {
+                            current = undefined; // "No such file" and the like: not read
+                            continue;
+                        }
+                        add(current);
+                    }
+                    const num = /^\s*(\d+)\t/.exec(line);
+                    if (current && num)
+                        add(current, Number(num[1]));
+                }
+            }
+            else if (c.function.name === "grep") {
+                for (const line of out.split("\n")) {
+                    const hit = /^(.+?)[:-](\d+)[:-] /.exec(line);
+                    if (hit)
+                        add(hit[1], Number(hit[2]));
+                }
+            }
+        }
+    }
+    return seen;
+}
+export function verifyReport(report, raw) {
+    const seen = seenLines(raw);
+    const check = (f) => {
+        if (!f.evidence.length)
+            return { ...f, verified: false, why: "no evidence cited" };
+        for (const e of f.evidence) {
+            if (e.command)
+                return { ...f, verified: false, why: `cites a command (${e.command.slice(0, 60)}) it could not have run` };
+            if (!e.path)
+                return { ...f, verified: false, why: "evidence without a file" };
+            const lines = seen.get(norm(e.path));
+            if (!lines)
+                return { ...f, verified: false, why: `cites ${e.path}, which it never read` };
+            if (e.lines) {
+                for (let n = e.lines[0]; n <= e.lines[1]; n++)
+                    if (!lines.has(n))
+                        return { ...f, verified: false, why: `cites ${e.path}:${e.lines[0]}-${e.lines[1]}, but line ${n} was never shown to it` };
+            }
+        }
+        return { ...f, verified: true };
+    };
+    return { ...report, findings: report.findings.map(check) };
+}