@nodetool-ai/agents 0.7.0-rc.23 → 0.8.2

package/dist/evals/codeact-api-core.js

@@ -0,0 +1,1411 @@
+/**
+ * CodeAct eval cases for the CORE `nodetool.*` namespaces — workflows, nodes,
+ * models, media, jobs, assets, agents (plus `batch`).
+ *
+ * The two graph-authoring cases build with `@nodetool-ai/sandbox-dsl`, so the
+ * world's node types are the ones that pack really exports. The exception is
+ * `nodetool.text.Uppercase`, which only ever appears inside pre-built
+ * workflows a case runs by id.
+ *
+ * The belt below is a set of fakes named exactly like the real tools, so the
+ * executor lights up the object model, its prompt section, and the guest
+ * prelude. Behind them sits one deterministic in-memory world: a node catalog
+ * a three-type interpreter can actually execute, workflows saved through
+ * `create_workflow` and runnable by the id it hands back, a background job
+ * that settles on its second poll, an interactive run that escalates once, a
+ * ranked model catalog the media tools validate against, and an asset store.
+ * No DB, no network, no clock beyond the sandbox's own `sleep`.
+ */
+import { GRAPH_DSL_PACKAGE } from "../codeact/graph-dsl-package.js";
+import { RecordingTool } from "./codeact-cases.js";
+import { isNumber, isObjectLike, isRecord, isString } from "../utils/type-guards.js";
+const str = (value) => value === undefined || value === null ? "" : String(value);
+const record = (value) => isRecord(value)
+    ? value
+    : {};
+/** Words a critique judges a brief by — short ones carry no signal. */
+const briefTerms = (brief) => Array.from(new Set(brief.toLowerCase().match(/[a-z0-9]{4,}/g) ?? []));
+const prop = (name, type, required, description) => ({ name, type, required, description });
+const OUT_STR = [{ name: "output", type: "str" }];
+const NODE_CATALOG = [
+    {
+        type: "nodetool.input.StringInput",
+        description: "A string workflow input, addressed by name at run time.",
+        keywords: ["input", "string", "text", "parameter", "entry"],
+        properties: [
+            prop("name", "str", true, "Run parameter this input reads."),
+            prop("value", "str", false, "Default when the run passes nothing.")
+        ],
+        outputs: OUT_STR,
+        evaluate: (props) => str(props["value"])
+    },
+    {
+        type: "nodetool.text.Concat",
+        description: "Join two strings, a followed by b.",
+        keywords: ["concat", "join", "append", "combine", "text"],
+        properties: [
+            prop("a", "str", true, "First string."),
+            prop("b", "str", true, "Second string.")
+        ],
+        outputs: OUT_STR,
+        evaluate: (props) => str(props["a"]) + str(props["b"])
+    },
+    {
+        // The one type here that NodeTool does not really ship. It is the middle
+        // node of the world's pre-built workflows, which cases run by id; nothing
+        // authors it, so the DSL pack never needs a wrapper for it.
+        type: "nodetool.text.Uppercase",
+        description: "Uppercase a string.",
+        keywords: ["uppercase", "shout", "case", "text"],
+        properties: [prop("text", "str", true, "String to uppercase.")],
+        outputs: OUT_STR,
+        evaluate: (props) => str(props["text"]).toUpperCase()
+    },
+    {
+        type: "nodetool.text.Template",
+        // Every other spec here takes fixed properties. This one takes a template
+        // plus whatever slots the template names, so a case that wires it has to
+        // read what the node reports rather than assume a signature.
+        description: "Render a template, substituting {{slot}} from its inputs.",
+        keywords: ["template", "render", "substitute", "format", "text"],
+        properties: [prop("string", "str", true, "Template text.")],
+        dynamicInputs: true,
+        outputs: OUT_STR,
+        evaluate: (props) => str(props["string"]).replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_, slot) => str(props[String(slot)]))
+    },
+    {
+        type: "nodetool.output.Output",
+        description: "A named output of the workflow.",
+        keywords: ["output", "result", "string", "return"],
+        properties: [
+            prop("name", "str", true, "Name this output is reported under."),
+            prop("value", "str", true, "Value to report.")
+        ],
+        outputs: OUT_STR,
+        evaluate: (props) => str(props["value"])
+    }
+];
+const nodeSpec = (type) => NODE_CATALOG.find((spec) => spec.type === type);
+const cloneGraph = (graph) => JSON.parse(JSON.stringify(graph));
+/** Ranked: `find_model` answers in this order, so `pick` is deterministic. */
+const MODEL_CATALOG = [
+    {
+        provider: "fal_ai",
+        model_id: "fal-ai/flux/schnell",
+        type: "image",
+        capabilities: ["text_to_image", "image_to_image"]
+    },
+    {
+        provider: "fal_ai",
+        model_id: "fal-ai/flux/dev",
+        type: "image",
+        capabilities: ["text_to_image"]
+    },
+    {
+        provider: "openai",
+        model_id: "gpt-image-2",
+        type: "image",
+        capabilities: ["text_to_image", "image_to_image"]
+    },
+    {
+        provider: "openai",
+        model_id: "gpt-5.4-mini",
+        type: "language",
+        capabilities: ["generate_message", "vision"]
+    },
+    {
+        provider: "anthropic",
+        model_id: "claude-sonnet-5",
+        type: "language",
+        capabilities: ["generate_message", "vision"]
+    },
+    {
+        provider: "fal_ai",
+        model_id: "fal-ai/ltx-video",
+        type: "video",
+        capabilities: ["text_to_video", "image_to_video", "reference_to_video"]
+    },
+    {
+        provider: "openai",
+        model_id: "tts-1",
+        type: "tts",
+        capabilities: ["text_to_speech"]
+    },
+    {
+        provider: "openai",
+        model_id: "whisper-1",
+        type: "asr",
+        capabilities: ["transcribe_audio"]
+    },
+    {
+        provider: "openai",
+        model_id: "text-embedding-3-small",
+        type: "embedding",
+        capabilities: ["embed_text"]
+    }
+];
+const stringInputGraph = (inputName, middleType, middleProps, outputName) => ({
+    nodes: [
+        {
+            id: "in_1",
+            type: "nodetool.input.StringInput",
+            properties: { name: inputName }
+        },
+        { id: "mid_1", type: middleType, properties: middleProps },
+        {
+            id: "out_1",
+            type: "nodetool.output.Output",
+            properties: { name: outputName }
+        }
+    ],
+    edges: [
+        {
+            source: "in_1",
+            sourceHandle: "output",
+            target: "mid_1",
+            targetHandle: middleType === "nodetool.text.Concat" ? "a" : "text"
+        },
+        {
+            source: "mid_1",
+            sourceHandle: "output",
+            target: "out_1",
+            targetHandle: "value"
+        }
+    ]
+});
+class CoreWorld {
+    workflows = new Map();
+    versions = new Map();
+    assets = new Map();
+    jobs = new Map();
+    sessions = new Map();
+    seq = 0;
+    constructor() {
+        this.workflows.set("wf_greet", {
+            id: "wf_greet",
+            name: "Greeting Builder",
+            description: "Greets whoever the run names.",
+            tags: ["demo"],
+            graph: stringInputGraph("name", "nodetool.text.Concat", { b: ", welcome aboard!" }, "greeting")
+        });
+        this.workflows.set("wf_shout", {
+            id: "wf_shout",
+            name: "Shout Line",
+            description: "Uppercases one line.",
+            tags: ["demo"],
+            graph: stringInputGraph("line", "nodetool.text.Uppercase", {}, "shout")
+        });
+    }
+    id(prefix) {
+        this.seq += 1;
+        return `${prefix}_${this.seq}`;
+    }
+    workflow(id) {
+        const found = this.workflows.get(str(id));
+        if (!found) {
+            throw new Error(`No workflow "${str(id)}". list_workflows reports what exists.`);
+        }
+        return found;
+    }
+    model(provider, model, capability) {
+        const entry = MODEL_CATALOG.find((m) => m.provider === str(provider) && m.model_id === str(model));
+        if (!entry) {
+            throw new Error(`No model "${str(provider)}/${str(model)}" in the catalog — ` +
+                `resolve one with find_model(${capability}).`);
+        }
+        if (!entry.capabilities.includes(capability)) {
+            throw new Error(`Model "${entry.provider}/${entry.model_id}" does not offer ` +
+                `"${capability}" (it offers ${entry.capabilities.join(", ")}).`);
+        }
+        return entry;
+    }
+    asset(ref) {
+        const key = str(ref);
+        const direct = this.assets.get(key) ?? this.assets.get(key.replace(/^asset:\/\//, ""));
+        if (direct)
+            return direct;
+        for (const asset of this.assets.values()) {
+            if (asset.name === key || asset.uri === key)
+                return asset;
+        }
+        throw new Error(`No asset "${key}" — list_assets or asset_search finds one.`);
+    }
+    saveAsset(name, content, contentType, prompt) {
+        const id = this.id("asset");
+        const asset = {
+            id,
+            name,
+            content,
+            content_type: contentType,
+            uri: `asset://${id}`
+        };
+        if (prompt !== undefined)
+            asset.prompt = prompt;
+        this.assets.set(id, asset);
+        return asset;
+    }
+}
+function validateGraph(graph) {
+    const errors = [];
+    const warnings = [];
+    const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+    const fed = new Map();
+    for (const edge of graph.edges) {
+        const source = byId.get(edge.source);
+        const target = byId.get(edge.target);
+        if (!source)
+            errors.push(`Edge from unknown node "${edge.source}"`);
+        if (!target) {
+            errors.push(`Edge to unknown node "${edge.target}"`);
+            continue;
+        }
+        const spec = nodeSpec(target.type);
+        const handle = str(edge.targetHandle);
+        if (spec &&
+            spec.dynamicInputs !== true &&
+            !spec.properties.some((p) => p.name === handle)) {
+            errors.push(`Node "${target.id}" (${target.type}) has no input "${handle}"`);
+        }
+        const set = fed.get(target.id) ?? new Set();
+        set.add(handle);
+        fed.set(target.id, set);
+    }
+    for (const node of graph.nodes) {
+        const spec = nodeSpec(node.type);
+        if (!spec) {
+            errors.push(`Unknown node type "${node.type}" on node "${node.id}"`);
+            continue;
+        }
+        for (const p of spec.properties) {
+            if (!p.required)
+                continue;
+            const wired = fed.get(node.id)?.has(p.name) === true;
+            const set = str(node.properties[p.name]).length > 0;
+            if (!wired && !set) {
+                errors.push(`Node "${node.id}" (${node.type}) is missing "${p.name}"`);
+            }
+        }
+    }
+    if (!graph.nodes.some((n) => n.type === "nodetool.output.Output")) {
+        warnings.push("Graph has no output node, so a run reports nothing.");
+    }
+    const issues = [
+        ...errors.map((message) => ({ severity: "error", message })),
+        ...warnings.map((message) => ({ severity: "warning", message }))
+    ];
+    return {
+        ok: errors.length === 0,
+        counts: { errors: errors.length, warnings: warnings.length, info: 0 },
+        issues
+    };
+}
+/** Evaluate the graph. `skipNodeId` yields "" for that node (escalation skip). */
+function runGraph(graph, params, skipNodeId) {
+    const values = new Map();
+    const remaining = [...graph.nodes];
+    const outputs = {};
+    while (remaining.length > 0) {
+        const ready = remaining.filter((node) => graph.edges
+            .filter((e) => e.target === node.id)
+            .every((e) => values.has(e.source)));
+        if (ready.length === 0) {
+            throw new Error("Graph has a cycle or an edge from a missing node.");
+        }
+        for (const node of ready) {
+            const spec = nodeSpec(node.type);
+            if (!spec)
+                throw new Error(`Unknown node type "${node.type}"`);
+            const props = { ...node.properties };
+            for (const edge of graph.edges.filter((e) => e.target === node.id)) {
+                props[str(edge.targetHandle)] = values.get(edge.source) ?? "";
+            }
+            if (node.type === "nodetool.input.StringInput") {
+                const key = str(props["name"]);
+                if (params[key] !== undefined)
+                    props["value"] = params[key];
+            }
+            const value = node.id === skipNodeId ? "" : spec.evaluate(props);
+            values.set(node.id, value);
+            if (node.type === "nodetool.output.Output") {
+                outputs[str(props["name"])] = value;
+            }
+            remaining.splice(remaining.indexOf(node), 1);
+        }
+    }
+    return outputs;
+}
+/** The node an interactive run parks on: the first non-input node. */
+function escalationNode(graph) {
+    const node = graph.nodes.find((n) => n.type !== "nodetool.input.StringInput") ??
+        graph.nodes[0];
+    if (!node)
+        throw new Error("Graph has no nodes to run.");
+    return node;
+}
+function toGraph(value) {
+    const raw = record(value);
+    const nodes = Array.isArray(raw["nodes"]) ? raw["nodes"] : [];
+    const edges = Array.isArray(raw["edges"]) ? raw["edges"] : [];
+    return {
+        nodes: nodes.map((n) => {
+            const node = record(n);
+            return {
+                id: str(node["id"]),
+                type: str(node["type"]),
+                properties: record(node["properties"])
+            };
+        }),
+        edges: edges.map((e) => {
+            const edge = record(e);
+            return {
+                source: str(edge["source"]),
+                sourceHandle: str(edge["sourceHandle"] ?? "output"),
+                target: str(edge["target"]),
+                targetHandle: str(edge["targetHandle"])
+            };
+        })
+    };
+}
+const summarize = (workflow) => ({
+    id: workflow.id,
+    name: workflow.name,
+    description: workflow.description,
+    tags: workflow.tags
+});
+const EXAMPLE_WORKFLOWS = [
+    {
+        id: "example_shout",
+        name: "shout-line",
+        description: "Uppercase one line — the smallest useful graph.",
+        tags: ["example"],
+        graph: stringInputGraph("line", "nodetool.text.Uppercase", {}, "shout")
+    }
+];
+/**
+ * The core-namespace toolbelt. Every call builds a fresh world, so cases never
+ * see each other's workflows, assets, or jobs.
+ */
+/** Two ledger rows: one settled render with a price, one still at the provider. */
+const FAKE_GENERATIONS = [
+    {
+        generation_id: "gen-1",
+        status: "completed",
+        provider: "fal",
+        model: "fal-ai/flux/schnell",
+        capability: "text_to_image",
+        cost: 0.04,
+        currency: "USD",
+        price_source: "model-catalog",
+        asset_ids: ["asset-gen-1"],
+        asset_uris: ["asset://asset-gen-1"],
+        parameters: { prompt: "a fox in snow" }
+    },
+    {
+        generation_id: "gen-2",
+        status: "running",
+        provider: "fal",
+        model: "fal-ai/veo",
+        capability: "text_to_video",
+        cost: null,
+        currency: null,
+        price_source: null,
+        asset_ids: [],
+        asset_uris: [],
+        parameters: { prompt: "a fox running" }
+    }
+];
+export function createCoreApiTools(recorder) {
+    const world = new CoreWorld();
+    const pendingBg = new Map();
+    const tool = (name, description, properties, impl) => new RecordingTool(name, description, { type: "object", properties }, recorder, impl);
+    const s = { type: "string" };
+    const o = { type: "object" };
+    const runSaved = (params) => {
+        const workflow = world.workflow(params["workflow_id"]);
+        return {
+            workflow,
+            outputs: runGraph(workflow.graph, record(params["params"]))
+        };
+    };
+    const generate = (params, capability, contentType, prefix) => {
+        const model = world.model(params["provider"], params["model"], capability);
+        const prompt = str(params["prompt"]);
+        const asset = world.saveAsset(`${prefix}-${str(world.assets.size + 1)}`, prompt, contentType, prompt);
+        return {
+            asset_uri: asset.uri,
+            asset_id: asset.id,
+            provider: model.provider,
+            model: model.model_id,
+            prompt
+        };
+    };
+    const adherence = (image, brief) => {
+        const asset = world.asset(image);
+        const prompt = (asset.prompt ?? asset.content).toLowerCase();
+        const terms = briefTerms(str(brief));
+        const missing = terms.filter((term) => !prompt.includes(term));
+        const score = terms.length === 0
+            ? 1
+            : Math.round(((terms.length - missing.length) / terms.length) * 100) /
+                100;
+        return { asset, score, missing };
+    };
+    return [
+        tool("list_workflows", "List saved workflows.", { limit: { type: "number" }, workflow_type: s }, (params) => {
+            if (str(params["workflow_type"]) === "example") {
+                return { workflows: EXAMPLE_WORKFLOWS.map(summarize) };
+            }
+            return {
+                workflows: [...world.workflows.values()].map(summarize)
+            };
+        }),
+        tool("get_workflow", "Get one workflow with its graph.", { workflow_id: s }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            return { ...summarize(workflow), graph: workflow.graph };
+        }),
+        tool("create_workflow", "Save a graph as a workflow.", { name: s, graph: o, tags: { type: "array" }, description: s }, (params) => {
+            const graph = toGraph(params["graph"]);
+            const check = validateGraph(graph);
+            if (!check.ok) {
+                throw new Error(`Refusing to save an invalid graph: ${check.issues
+                    .map((i) => i.message)
+                    .join("; ")}`);
+            }
+            const id = world.id("wf");
+            const workflow = {
+                id,
+                name: str(params["name"]) || id,
+                description: str(params["description"]),
+                tags: Array.isArray(params["tags"])
+                    ? params["tags"]
+                    : [],
+                graph
+            };
+            world.workflows.set(id, workflow);
+            return summarize(workflow);
+        }),
+        tool("list_workflow_versions", "List a workflow's snapshots, newest first.", { workflow_id: s, limit: { type: "number" } }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            const versions = [...(world.versions.get(workflow.id) ?? [])].reverse();
+            const limit = Number(params["limit"]) || versions.length;
+            return {
+                workflow_id: workflow.id,
+                versions: versions.slice(0, limit).map((v) => ({
+                    version: v.version,
+                    name: v.name,
+                    save_type: v.save_type
+                }))
+            };
+        }),
+        tool("get_workflow_version", "Read one snapshot without restoring it.", { workflow_id: s, version: { type: "number" } }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            const version = Number(params["version"]);
+            const found = (world.versions.get(workflow.id) ?? []).find((v) => v.version === version);
+            if (!found) {
+                throw new Error(`Workflow ${workflow.id} has no version ${version}.`);
+            }
+            return {
+                workflow_id: workflow.id,
+                version: found.version,
+                name: found.name,
+                save_type: found.save_type,
+                graph: cloneGraph(found.graph)
+            };
+        }),
+        tool("create_workflow_version", "Snapshot a workflow's current graph.", { workflow_id: s, name: s, description: s }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            const list = world.versions.get(workflow.id) ?? [];
+            const entry = {
+                version: list.length + 1,
+                name: str(params["name"]) || null,
+                save_type: "manual",
+                graph: cloneGraph(workflow.graph)
+            };
+            list.push(entry);
+            world.versions.set(workflow.id, list);
+            return {
+                ok: true,
+                workflow_id: workflow.id,
+                version: entry.version,
+                name: entry.name,
+                save_type: entry.save_type
+            };
+        }),
+        tool("restore_workflow_version", "Restore a snapshot, snapshotting the current graph first.", { workflow_id: s, version: { type: "number" } }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            const version = Number(params["version"]);
+            const found = (world.versions.get(workflow.id) ?? []).find((v) => v.version === version);
+            if (!found) {
+                throw new Error(`Workflow ${workflow.id} has no version ${version}.`);
+            }
+            const list = world.versions.get(workflow.id) ?? [];
+            const undo = {
+                version: list.length + 1,
+                name: `Before restore to v${version}`,
+                save_type: "restore",
+                graph: cloneGraph(workflow.graph)
+            };
+            list.push(undo);
+            world.versions.set(workflow.id, list);
+            workflow.graph = cloneGraph(found.graph);
+            return {
+                ok: true,
+                workflow_id: workflow.id,
+                restored_version: version,
+                undo_version: undo.version
+            };
+        }),
+        tool("delete_workflow_version", "Delete one snapshot. The live graph is not changed.", { workflow_id: s, version: { type: "number" } }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            const version = Number(params["version"]);
+            const list = world.versions.get(workflow.id) ?? [];
+            const idx = list.findIndex((v) => v.version === version);
+            if (idx < 0) {
+                throw new Error(`Workflow ${workflow.id} has no version ${version}.`);
+            }
+            list.splice(idx, 1);
+            world.versions.set(workflow.id, list);
+            return { ok: true, workflow_id: workflow.id, deleted_version: version };
+        }),
+        tool("run_workflow", "Run a saved workflow. With interactive:true a failing node escalates.", { workflow_id: s, params: o, interactive: { type: "boolean" } }, (params) => {
+            const workflow = world.workflow(params["workflow_id"]);
+            if (params["interactive"] === true) {
+                const node = escalationNode(workflow.graph);
+                const session = {
+                    id: world.id("session"),
+                    workflow_id: workflow.id,
+                    params: record(params["params"]),
+                    escalation_id: world.id("esc"),
+                    node_id: node.id
+                };
+                world.sessions.set(session.id, session);
+                return {
+                    status: "escalated",
+                    session_id: session.id,
+                    escalation: {
+                        id: session.escalation_id,
+                        node_id: node.id,
+                        node_type: node.type,
+                        error: "Transient failure while processing the node.",
+                        allowedActions: ["retry", "substitute", "skip", "fail"]
+                    }
+                };
+            }
+            return {
+                status: "completed",
+                workflow_id: workflow.id,
+                outputs: runGraph(workflow.graph, record(params["params"]))
+            };
+        }),
+        tool("start_background_job", "Start a workflow as a background job and return its id.", { workflow_id: s, params: o }, (params) => {
+            const { workflow, outputs } = runSaved(params);
+            const id = world.id("job");
+            world.jobs.set(id, {
+                id,
+                workflow_id: workflow.id,
+                params: record(params["params"]),
+                polls: 0,
+                outputs
+            });
+            return { id, job_id: id, status: "running", workflow_id: workflow.id };
+        }),
+        tool("debug_workflow", "Run a workflow and report a per-node verdict.", { workflow_id: s, params: o }, (params) => {
+            const { workflow, outputs } = runSaved(params);
+            return {
+                verdict: { ok: true, issues: [] },
+                outputs,
+                nodes: workflow.graph.nodes.map((n) => ({
+                    id: n.id,
+                    type: n.type,
+                    status: "completed"
+                }))
+            };
+        }),
+        tool("validate_workflow", "Statically check a graph or a saved workflow.", { graph: o, workflow_id: s }, (params) => {
+            const graph = params["graph"] === undefined
+                ? world.workflow(params["workflow_id"]).graph
+                : toGraph(params["graph"]);
+            return validateGraph(graph);
+        }),
+        tool("resolve_workflow_escalation", "Answer an escalation from an interactive run.", { session_id: s, escalation_id: s, action: s, outputs: o, reason: s }, (params) => {
+            const session = world.sessions.get(str(params["session_id"]));
+            if (!session)
+                throw new Error(`No debug session "${str(params["session_id"])}"`);
+            if (str(params["escalation_id"]) !== session.escalation_id) {
+                throw new Error(`Escalation "${str(params["escalation_id"])}" is not open on this session.`);
+            }
+            const action = str(params["action"]);
+            const workflow = world.workflow(session.workflow_id);
+            const intervention = { escalation_id: session.escalation_id, action };
+            world.sessions.delete(session.id);
+            if (action === "fail") {
+                return {
+                    status: "failed",
+                    error: str(params["reason"]) || "Run failed by supervisor verdict.",
+                    interventions: [intervention]
+                };
+            }
+            if (action === "substitute") {
+                return {
+                    status: "completed",
+                    outputs: record(params["outputs"]),
+                    interventions: [intervention]
+                };
+            }
+            const outputs = runGraph(workflow.graph, session.params, action === "skip" ? session.node_id : undefined);
+            return { status: "completed", outputs, interventions: [intervention] };
+        }),
+        tool("get_example_workflow", "Load one shipped example workflow with its graph.", { package_name: s, example_name: s }, (params) => {
+            const name = str(params["example_name"]);
+            const example = EXAMPLE_WORKFLOWS.find((e) => e.name === name);
+            if (!example) {
+                throw new Error(`No example "${name}" in package "${str(params["package_name"])}".`);
+            }
+            return { ...summarize(example), graph: example.graph };
+        }),
+        tool("search_nodes", "Search the node catalog by keyword.", { query: { type: "array" }, n_results: { type: "number" } }, (params) => {
+            const queries = (Array.isArray(params["query"]) ? params["query"] : [params["query"]]).map((q) => str(q).toLowerCase());
+            const hits = NODE_CATALOG.filter((spec) => queries.some((query) => query
+                .split(/\s+/)
+                .filter((word) => word.length > 2)
+                .some((word) => spec.type.toLowerCase().includes(word) ||
+                spec.keywords.some((k) => k.includes(word) || word.includes(k)))));
+            const results = (hits.length > 0 ? hits : NODE_CATALOG).slice(0, Number(params["n_results"] ?? 10));
+            return {
+                results: results.map((spec) => ({
+                    node_type: spec.type,
+                    description: spec.description
+                }))
+            };
+        }),
+        tool("get_node_info", "Full metadata for one node type.", { node_type: s }, (params) => {
+            const spec = nodeSpec(str(params["node_type"]));
+            if (!spec) {
+                throw new Error(`Unknown node type "${str(params["node_type"])}" — search_nodes lists them.`);
+            }
+            return {
+                node_type: spec.type,
+                description: spec.description,
+                properties: spec.properties,
+                dynamic_inputs: spec.dynamicInputs === true,
+                outputs: spec.outputs
+            };
+        }),
+        tool("list_nodes", "Browse the node catalog, optionally by namespace.", { namespace: s, limit: { type: "number" } }, (params) => {
+            const namespace = str(params["namespace"]);
+            const nodes = NODE_CATALOG.filter((spec) => namespace === "" || spec.type.startsWith(namespace));
+            return {
+                nodes: nodes.map((spec) => ({
+                    node_type: spec.type,
+                    description: spec.description
+                }))
+            };
+        }),
+        tool("run_node", "Run ONE node with a property bag — the single-node harness.", { node_type: s, inputs: o }, (params) => {
+            const spec = nodeSpec(str(params["node_type"]));
+            if (!spec)
+                throw new Error(`Unknown node type "${str(params["node_type"])}"`);
+            const inputs = record(params["inputs"]);
+            const missing = spec.properties
+                .filter((p) => p.required && str(inputs[p.name]).length === 0)
+                .map((p) => p.name);
+            if (missing.length > 0) {
+                throw new Error(`${spec.type} needs ${missing.join(", ")} — get_node_info lists its properties.`);
+            }
+            return { node_type: spec.type, output: spec.evaluate(inputs) };
+        }),
+        tool("find_model", "Rank the configured models offering a capability.", { capability: s, limit: { type: "number" }, provider_hint: s }, (params) => {
+            const capability = str(params["capability"]);
+            const hint = str(params["provider_hint"]);
+            const matches = MODEL_CATALOG.filter((m) => m.capabilities.includes(capability) &&
+                (hint === "" || m.provider === hint));
+            const limit = Number(params["limit"] ?? 5);
+            return {
+                capability,
+                results: matches.slice(0, limit).map((m) => ({
+                    provider: m.provider,
+                    model_id: m.model_id,
+                    type: m.type,
+                    capabilities: m.capabilities
+                })),
+                note: matches.length === 0
+                    ? `No configured model offers "${capability}".`
+                    : undefined
+            };
+        }),
+        tool("list_models", "Browse the model catalog.", { provider: s, model_type: s, limit: { type: "number" } }, (params) => {
+            const provider = str(params["provider"]);
+            const type = str(params["model_type"]);
+            return {
+                results: MODEL_CATALOG.filter((m) => (provider === "" || m.provider === provider) &&
+                    (type === "" || m.type === type)).map((m) => ({
+                    provider: m.provider,
+                    model_id: m.model_id,
+                    id: m.model_id,
+                    type: m.type
+                }))
+            };
+        }),
+        tool("list_provider_models", "One provider's catalog.", { provider: s }, (params) => {
+            const provider = str(params["provider"]);
+            return {
+                provider,
+                results: MODEL_CATALOG.filter((m) => m.provider === provider).map((m) => ({
+                    provider: m.provider,
+                    model_id: m.model_id,
+                    type: m.type
+                }))
+            };
+        }),
+        tool("generate_text", "Run one language-model roundtrip.", {
+            provider: s,
+            model: s,
+            prompt: s,
+            system: s,
+            images: { type: "array", items: s },
+            max_tokens: { type: "number" },
+            temperature: { type: "number" }
+        }, (params) => {
+            const model = world.model(params["provider"], params["model"], "generate_message");
+            return {
+                type: "text",
+                provider: model.provider,
+                model: model.model_id,
+                text: `Draft: ${str(params["prompt"])}`
+            };
+        }),
+        tool("generate_image", "Generate an image and save it as an asset.", {
+            provider: s,
+            model: s,
+            prompt: s,
+            width: { type: "number" },
+            height: { type: "number" }
+        }, (params) => generate(params, "text_to_image", "image/png", "image")),
+        tool("read_media_bytes", "Read the bytes behind a media reference (asset:// URI or asset id).", { uri: s }, (params) => {
+            const asset = world.asset(params["uri"]);
+            const content_base64 = Buffer.from(asset.content, "utf8").toString("base64");
+            return {
+                uri: asset.uri,
+                size: content_base64.length,
+                mime_type: asset.content_type,
+                content_base64
+            };
+        }),
+        tool("edit_image", "Edit an existing image asset.", { provider: s, model: s, prompt: s, input_file: s }, (params) => {
+            const model = world.model(params["provider"], params["model"], "image_to_image");
+            const source = world.asset(params["input_file"]);
+            const prompt = `${source.prompt ?? source.content} | ${str(params["prompt"])}`;
+            const asset = world.saveAsset(`edit-${source.name}`, prompt, "image/png", prompt);
+            return {
+                asset_uri: asset.uri,
+                asset_id: asset.id,
+                provider: model.provider,
+                model: model.model_id
+            };
+        }),
+        tool("generate_video", "Generate a video and save it as an asset.", { provider: s, model: s, prompt: s }, (params) => generate(params, "text_to_video", "video/mp4", "video")),
+        tool("animate_image", "Animate an image asset into a video.", { provider: s, model: s, input_file: s }, (params) => {
+            const model = world.model(params["provider"], params["model"], "image_to_video");
+            const source = world.asset(params["input_file"]);
+            const asset = world.saveAsset(`clip-${source.name}`, source.prompt ?? source.content, "video/mp4", source.prompt ?? source.content);
+            return {
+                asset_uri: asset.uri,
+                provider: model.provider,
+                model: model.model_id
+            };
+        }),
+        tool("generate_video_from_references", "Generate a video conditioned on a set of image/video references.", { provider: s, model: s, reference_files: { type: "array" }, prompt: s }, (params) => {
+            const model = world.model(params["provider"], params["model"], "reference_to_video");
+            const files = Array.isArray(params["reference_files"])
+                ? params["reference_files"]
+                : [];
+            if (files.length === 0) {
+                throw new Error("reference_files must name at least one image or video reference.");
+            }
+            // Every reference contributes to the clip, so the saved content carries
+            // all of them plus the prompt — that is what the adherence checks read.
+            const sources = files.map((file) => world.asset(file));
+            const prompt = str(params["prompt"]);
+            const content = [
+                ...sources.map((a) => a.prompt ?? a.content),
+                prompt
+            ]
+                .filter((part) => part.length > 0)
+                .join(" ");
+            const asset = world.saveAsset(`reference-clip-${str(world.assets.size + 1)}`, content, "video/mp4", content);
+            return {
+                asset_uri: asset.uri,
+                asset_id: asset.id,
+                provider: model.provider,
+                model: model.model_id
+            };
+        }),
+        tool("generate_speech", "Synthesize speech and save it as an asset.", { provider: s, model: s, text: s, voice: s }, (params) => {
+            world.model(params["provider"], params["model"], "text_to_speech");
+            const text = str(params["text"]);
+            const asset = world.saveAsset(`speech-${str(world.assets.size + 1)}`, text, "audio/mpeg");
+            return {
+                asset_uri: asset.uri,
+                duration_seconds: Math.round((text.length / 15) * 10) / 10
+            };
+        }),
+        tool("generate_music", "Generate music from a prompt and save it as an asset.", { provider: s, model: s, prompt: s, duration_seconds: { type: "number" } }, (params) => {
+            world.model(params["provider"], params["model"], "text_to_music");
+            const asset = world.saveAsset(`music-${str(world.assets.size + 1)}`, str(params["prompt"]), "audio/mpeg");
+            return {
+                asset_uri: asset.uri,
+                duration_seconds: Number(params["duration_seconds"]) || 30
+            };
+        }),
+        tool("transcribe_audio", "Transcribe an audio asset.", { provider: s, model: s, input_file: s }, (params) => {
+            world.model(params["provider"], params["model"], "transcribe_audio");
+            const asset = world.asset(params["input_file"]);
+            return { text: asset.content };
+        }),
+        tool("embed_text", "Embed text as a vector.", { provider: s, model: s, text: s }, (params) => {
+            world.model(params["provider"], params["model"], "embed_text");
+            const text = str(params["text"]);
+            const embedding = [0, 1, 2, 3].map((slot) => {
+                let sum = 0;
+                for (let i = slot; i < text.length; i += 4)
+                    sum += text.charCodeAt(i);
+                return Math.round((sum % 1000) / 10) / 100;
+            });
+            return { embedding, dimensions: embedding.length };
+        }),
+        tool("critique_image", "Judge one image against a brief with a vision model.", { provider: s, model: s, image: s, brief: s, taste_profile: s }, (params) => {
+            world.model(params["provider"], params["model"], "vision");
+            const { score, missing } = adherence(params["image"], params["brief"]);
+            return {
+                verdict: score >= 0.75 ? "pass" : "revise",
+                score,
+                defects: missing.map((term) => `the brief asks for "${term}"; the image does not show it`)
+            };
+        }),
+        tool("compare_images", "Rank 2-8 candidates against a brief.", {
+            provider: s,
+            model: s,
+            images: { type: "array" },
+            brief: s,
+            taste_profile: s
+        }, (params) => {
+            world.model(params["provider"], params["model"], "vision");
+            const images = Array.isArray(params["images"]) ? params["images"] : [];
+            const ranked = images
+                .map((image, index) => ({
+                image: str(image),
+                index,
+                score: adherence(image, params["brief"]).score
+            }))
+                .sort((a, b) => b.score - a.score || a.index - b.index);
+            return { winner: ranked[0]?.image, ranking: ranked };
+        }),
+        tool("score_image_adherence", "Score an image against the brief as yes/no checks.", { provider: s, model: s, image: s, brief: s }, (params) => {
+            world.model(params["provider"], params["model"], "vision");
+            const { score, missing } = adherence(params["image"], params["brief"]);
+            return {
+                score,
+                checks: briefTerms(str(params["brief"])).map((term) => ({
+                    question: `Does the image show "${term}"?`,
+                    pass: !missing.includes(term)
+                }))
+            };
+        }),
+        tool("understand_video", "Read a video with a multimodal chat model.", { provider: s, model: s, video: s, prompt: s }, (params) => {
+            world.model(params["provider"], params["model"], "vision");
+            const asset = world.asset(params["video"]);
+            const prompt = str(params["prompt"]) || "Describe this video in detail.";
+            return {
+                text: `${prompt} — ${asset.name} shows ${asset.prompt ?? asset.content}`,
+                provider: str(params["provider"]),
+                model: str(params["model"])
+            };
+        }),
+        tool("ffmpeg", "Run ffmpeg on workspace files.", {
+            args: { type: "array" },
+            output_file: s,
+            timeout_seconds: { type: "number" }
+        }, (params) => {
+            const output = isString(params["output_file"]) && params["output_file"]
+                ? params["output_file"]
+                : "out.mp4";
+            const asset = world.saveAsset(output, "ffmpeg", "video/mp4");
+            return { success: true, output_file: output, asset_uri: asset.uri };
+        }),
+        tool("ffprobe", "Read a media file's format and streams with ffprobe.", { path: s, timeout_seconds: { type: "number" } }, (params) => {
+            const target = str(params["path"]);
+            return {
+                path: target,
+                format: {
+                    filename: target,
+                    format_name: "mov,mp4,m4a",
+                    duration: "12.500000",
+                    size: "1048576"
+                },
+                streams: [
+                    {
+                        codec_type: "video",
+                        codec_name: "h264",
+                        width: 1920,
+                        height: 1080,
+                        r_frame_rate: "30/1"
+                    },
+                    { codec_type: "audio", codec_name: "aac", channels: 2 }
+                ]
+            };
+        }),
+        tool("yt_dlp", "Download a video with yt-dlp.", {
+            url: s,
+            output_file: s,
+            format: s,
+            timeout_seconds: { type: "number" }
+        }, (params) => {
+            const url = str(params["url"]);
+            const output = isString(params["output_file"]) && params["output_file"]
+                ? params["output_file"]
+                : "download.mp4";
+            const asset = world.saveAsset(output, url, "video/mp4");
+            return {
+                success: true,
+                url,
+                output_file: output,
+                asset_uri: asset.uri
+            };
+        }),
+        tool("list_generations", "List this account's media generations, newest first, with status, cost and assets.", { status: s, limit: { type: "number" } }, (params) => {
+            const status = str(params["status"]);
+            return {
+                generations: FAKE_GENERATIONS.filter((g) => status === "" || g.status === status).map(({ parameters: _p, ...summary }) => summary),
+                next: null
+            };
+        }),
+        tool("get_generation", "Read one generation in full: cost, how it was priced, assets, parameters.", { generation_id: s }, (params) => {
+            const id = str(params["generation_id"]);
+            const found = FAKE_GENERATIONS.find((g) => g.generation_id === id);
+            if (!found)
+                return { error: `Generation ${id} was not found.` };
+            return found;
+        }),
+        tool("list_jobs", "List background jobs.", { workflow_id: s, limit: { type: "number" } }, (params) => {
+            const workflowId = str(params["workflow_id"]);
+            return {
+                jobs: [...world.jobs.values()]
+                    .filter((job) => workflowId === "" || job.workflow_id === workflowId)
+                    .map((job) => ({
+                    id: job.id,
+                    workflow_id: job.workflow_id,
+                    status: job.polls > 1 ? "completed" : "running"
+                }))
+            };
+        }),
+        tool("get_job", "Get one job. It reports running on the first poll, completed after.", { job_id: s }, (params) => {
+            const job = world.jobs.get(str(params["job_id"]));
+            if (!job)
+                throw new Error(`No job "${str(params["job_id"])}"`);
+            job.polls += 1;
+            const done = job.polls > 1;
+            // Same shape `jobRecord` reports: outputs on the settled job, null
+            // while it runs. The fake carried them under `result` and the real
+            // tool carried them nowhere, so an agent taught here found neither.
+            return {
+                id: job.id,
+                workflow_id: job.workflow_id,
+                status: done ? "completed" : "running",
+                polls: job.polls,
+                outputs: done ? job.outputs : null
+            };
+        }),
+        tool("get_job_logs", "Read a job's logs.", { job_id: s }, (params) => {
+            const job = world.jobs.get(str(params["job_id"]));
+            if (!job)
+                throw new Error(`No job "${str(params["job_id"])}"`);
+            return {
+                job_id: job.id,
+                logs: [`job ${job.id} started`, `workflow ${job.workflow_id} scheduled`]
+            };
+        }),
+        tool("list_assets", "List assets.", { content_type: s, query: s, limit: { type: "number" } }, (params) => {
+            const contentType = str(params["content_type"]);
+            const query = str(params["query"]).toLowerCase();
+            return {
+                assets: [...world.assets.values()]
+                    .filter((a) => (contentType === "" ||
+                    a.content_type.startsWith(contentType)) &&
+                    (query === "" || a.name.toLowerCase().includes(query)))
+                    .map((a) => ({
+                    id: a.id,
+                    name: a.name,
+                    uri: a.uri,
+                    content_type: a.content_type
+                }))
+            };
+        }),
+        tool("get_asset", "Get one asset record.", { asset_id: s }, (params) => {
+            const asset = world.asset(params["asset_id"]);
+            return {
+                id: asset.id,
+                name: asset.name,
+                uri: asset.uri,
+                content_type: asset.content_type
+            };
+        }),
+        tool("asset_search", "Search assets by name or content.", { query: s, limit: { type: "number" } }, (params) => {
+            const query = str(params["query"]).toLowerCase();
+            return {
+                results: [...world.assets.values()]
+                    .filter((a) => a.name.toLowerCase().includes(query) ||
+                    a.content.toLowerCase().includes(query))
+                    .map((a) => ({
+                    id: a.id,
+                    name: a.name,
+                    uri: a.uri,
+                    content_type: a.content_type
+                }))
+            };
+        }),
+        tool("save_asset", "Save content as a named asset.", { name: s, content: s, content_type: s }, (params) => {
+            const asset = world.saveAsset(str(params["name"]), str(params["content"]), str(params["content_type"]) || "text/plain");
+            return { id: asset.id, name: asset.name, uri: asset.uri };
+        }),
+        tool("read_asset", "Read a saved asset's content.", { name: s }, (params) => {
+            const asset = world.asset(params["name"]);
+            return {
+                id: asset.id,
+                name: asset.name,
+                content: asset.content,
+                content_type: asset.content_type
+            };
+        }),
+        tool("list_images", "List image assets as handles.", { query: s, limit: { type: "number" } }, () => ({
+            images: [...world.assets.values()]
+                .filter((a) => a.content_type.startsWith("image/"))
+                .map((a) => ({ id: a.id, name: a.name, uri: a.uri }))
+        })),
+        tool("run_subtask", "Run a sub-agent on a self-contained prompt.", { description: s, prompt: s }, (params) => {
+            const prompt = str(params["prompt"]);
+            const numbers = (prompt.match(/\d+(?:\.\d+)?/g) ?? []).map(Number);
+            return {
+                description: str(params["description"]),
+                result: {
+                    sum: numbers.reduce((total, n) => total + n, 0),
+                    numbers,
+                    words: prompt.split(/\s+/).filter((w) => w.length > 0).length
+                }
+            };
+        }),
+        tool("start_subtask", "Start a background sub-agent and return a receipt immediately.", { description: s, prompt: s }, (params) => {
+            const prompt = str(params["prompt"]);
+            const numbers = (prompt.match(/\d+(?:\.\d+)?/g) ?? []).map(Number);
+            const id = `bg-${world.assets.size + 1}`;
+            const result = {
+                sum: numbers.reduce((total, n) => total + n, 0),
+                numbers,
+                words: prompt.split(/\s+/).filter((w) => w.length > 0).length
+            };
+            pendingBg.set(id, { description: str(params["description"]), result });
+            return { subtask_id: id, description: str(params["description"]), status: "running" };
+        }),
+        tool("wait_subtasks", "Collect background sub-agent results.", {
+            ids: { type: "array", items: s },
+            timeout_ms: { type: "number" }
+        }, (params) => {
+            const ids = Array.isArray(params["ids"])
+                ? params["ids"].map(String)
+                : [...pendingBg.keys()];
+            const subtasks = ids.map((id) => {
+                const entry = pendingBg.get(id);
+                return entry
+                    ? {
+                        subtask_id: id,
+                        description: entry.description,
+                        status: "completed",
+                        result: entry.result
+                    }
+                    : { subtask_id: id, status: "unknown" };
+            });
+            return { subtasks, all_settled: true };
+        })
+    ];
+}
+const asObject = (value) => isObjectLike(value) ? value : {};
+const isAssetUri = (value) => isString(value) && value.startsWith("asset://");
+export const CODEACT_API_CORE_CASES = [
+    {
+        id: "api-graph-build-and-run",
+        description: "Discover node types, then build, validate and run a graph",
+        objective: "Build a workflow that takes a string input named `name` and reports an " +
+            "output named `greeting` reading `<name>, welcome aboard!`. " +
+            "Discover the node types from the catalog — never guess a type. " +
+            'Validate the graph before running it, then run it with name = "Ada" ' +
+            "and finish with {greeting: <the run's greeting output>}.",
+        outputSchema: {
+            type: "object",
+            properties: { greeting: { type: "string" } },
+            required: ["greeting"]
+        },
+        createTools: createCoreApiTools,
+        sandboxPackages: [GRAPH_DSL_PACKAGE],
+        namespaces: ["nodes", "workflows"],
+        expect: {
+            requiredTools: ["search_nodes", "validate_workflow", "run_workflow"],
+            maxActions: 5,
+            resultCheck: (r) => asObject(r)["greeting"] === "Ada, welcome aboard!",
+            resultCheckLabel: 'greeting="Ada, welcome aboard!"'
+        }
+    },
+    {
+        id: "api-probe-node-then-wire",
+        description: "Probe a node with the single-node harness before wiring it",
+        objective: "Find the node that renders a text template. Probe it on its own with " +
+            'the template "{{title}} — a field report" and title "Hello World" so ' +
+            "you know exactly what it emits, then build and run a workflow that " +
+            "renders that same template from a `title` input, using " +
+            '"Fox In Snow" as the title. Report the rendered line as an output ' +
+            "named `line`. Finish with {probe: <the probe output>, " +
+            "line: <the run's line output>}.",
+        outputSchema: {
+            type: "object",
+            properties: { probe: { type: "string" }, line: { type: "string" } },
+            required: ["probe", "line"]
+        },
+        createTools: createCoreApiTools,
+        sandboxPackages: [GRAPH_DSL_PACKAGE],
+        namespaces: ["nodes", "workflows"],
+        expect: {
+            requiredTools: ["run_node", "run_workflow"],
+            maxActions: 5,
+            resultCheck: (r) => asObject(r)["probe"] === "Hello World — a field report" &&
+                asObject(r)["line"] === "Fox In Snow — a field report",
+            resultCheckLabel: 'probe="Hello World — a field report", line="Fox In Snow — a field report"'
+        }
+    },
+    {
+        id: "api-pick-model-and-batch-images",
+        description: "Survey providers, pick a model, batch-generate images",
+        objective: 'Three shots need rendering: "a red fox in snow", "a fox by a river", ' +
+            'and "a fox on a rooftop". Report which providers this workspace has ' +
+            "models from, resolve one text-to-image model from the ranked catalog " +
+            "(never guess an id), generate all three images, and finish with " +
+            "{provider, model, uris} where uris holds the three asset URIs in the " +
+            "order the shots were listed.",
+        outputSchema: {
+            type: "object",
+            properties: {
+                provider: { type: "string" },
+                model: { type: "string" },
+                uris: { type: "array", items: { type: "string" } }
+            },
+            required: ["provider", "model", "uris"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["models", "media"],
+        expect: {
+            requiredTools: ["list_models", "find_model", "generate_image"],
+            maxActions: 5,
+            minToolCalls: 5,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                const uris = result["uris"];
+                return (result["provider"] === "fal_ai" &&
+                    result["model"] === "fal-ai/flux/schnell" &&
+                    Array.isArray(uris) &&
+                    uris.length === 3 &&
+                    new Set(uris).size === 3 &&
+                    uris.every(isAssetUri));
+            },
+            resultCheckLabel: "fal_ai/fal-ai/flux/schnell + 3 distinct asset URIs"
+        }
+    },
+    {
+        id: "api-generate-then-critique",
+        description: "Generate an image, then judge it against the brief",
+        objective: 'Render the brief "a red fox in deep snow" with a text-to-image model, ' +
+            "then have a vision chat model critique the result against that same " +
+            "brief using the critique judge (not the adherence scorer). Finish " +
+            "with {asset_uri, verdict, score} — verdict is the critique's own " +
+            "verdict string, not a serialized report.",
+        outputSchema: {
+            type: "object",
+            properties: {
+                asset_uri: { type: "string" },
+                verdict: { type: "string" },
+                score: { type: "number" }
+            },
+            required: ["asset_uri", "verdict", "score"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["models", "media"],
+        expect: {
+            requiredTools: ["find_model", "generate_image", "critique_image"],
+            maxActions: 5,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                return (isAssetUri(result["asset_uri"]) &&
+                    result["verdict"] === "pass" &&
+                    isNumber(result["score"]) &&
+                    result["score"] >= 0.75);
+            },
+            resultCheckLabel: "verdict=pass, score>=0.75, asset:// uri"
+        }
+    },
+    {
+        id: "api-background-job-wait",
+        description: "Start a workflow as a background job and wait for it",
+        objective: 'Find the saved workflow called "Shout Line", start it as a background ' +
+            'job with line = "ship it", and wait for the job to settle rather than ' +
+            "polling by hand. Finish with {status: <the settled job's status>, " +
+            "shout: <the shout output's plain string value — the uppercased line " +
+            "itself, not JSON and not a status>}.",
+        outputSchema: {
+            type: "object",
+            properties: { status: { type: "string" }, shout: { type: "string" } },
+            required: ["status", "shout"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["workflows", "jobs"],
+        expect: {
+            requiredTools: ["list_workflows", "start_background_job", "get_job"],
+            maxActions: 4,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                return (result["status"] === "completed" && result["shout"] === "SHIP IT");
+            },
+            resultCheckLabel: 'status=completed, shout="SHIP IT"'
+        }
+    },
+    {
+        id: "api-generation-cost",
+        description: "Read what a finished media generation cost and where its asset is",
+        objective: "Find the most recent completed image generation in this account's " +
+            "generation record and report what it cost. Finish with " +
+            "{generation_id: <its id>, cost: <its cost in USD as a number>, " +
+            "asset_id: <the id of the asset it produced>}.",
+        outputSchema: {
+            type: "object",
+            properties: {
+                generation_id: { type: "string" },
+                cost: { type: "number" },
+                asset_id: { type: "string" }
+            },
+            required: ["generation_id", "cost", "asset_id"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["generations"],
+        expect: {
+            requiredTools: ["list_generations"],
+            maxActions: 3,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                return (result["generation_id"] === "gen-1" &&
+                    result["cost"] === 0.04 &&
+                    result["asset_id"] === "asset-gen-1");
+            },
+            resultCheckLabel: "generation_id=gen-1, cost=0.04, asset_id=asset-gen-1"
+        }
+    },
+    {
+        id: "api-batch-existing-workflow",
+        description: "Run one saved workflow over several inputs with bounded fan-out",
+        objective: 'Find the saved workflow called "Shout Line" and run it once per line ' +
+            'for "alpha", "beta" and "gamma", with bounded concurrency rather than ' +
+            "one action per line. Finish with {shouts: [...]} holding each run's " +
+            "shout output value — the uppercased lines themselves, not run " +
+            "statuses — in the order the lines were listed.",
+        outputSchema: {
+            type: "object",
+            properties: { shouts: { type: "array", items: { type: "string" } } },
+            required: ["shouts"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["workflows"],
+        expect: {
+            requiredTools: ["list_workflows", "run_workflow"],
+            maxActions: 4,
+            minToolCalls: 4,
+            resultCheck: (r) => {
+                const shouts = asObject(r)["shouts"];
+                return (Array.isArray(shouts) &&
+                    shouts.length === 3 &&
+                    shouts[0] === "ALPHA" &&
+                    shouts[1] === "BETA" &&
+                    shouts[2] === "GAMMA");
+            },
+            resultCheckLabel: "shouts=[ALPHA, BETA, GAMMA]"
+        }
+    },
+    {
+        id: "api-interactive-escalation",
+        description: "Answer an escalation from an interactive run",
+        objective: 'Run the saved workflow called "Greeting Builder" interactively with ' +
+            'name = "Ada". It parks on a node that failed transiently and hands ' +
+            "you an escalation: have that node tried again so the run finishes " +
+            "with its real output. Finish with {greeting: <the run's greeting " +
+            "output>, action: <the action you answered with>}.",
+        outputSchema: {
+            type: "object",
+            properties: { greeting: { type: "string" }, action: { type: "string" } },
+            required: ["greeting", "action"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["workflows"],
+        expect: {
+            requiredTools: ["run_workflow", "resolve_workflow_escalation"],
+            maxActions: 4,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                return (result["greeting"] === "Ada, welcome aboard!" &&
+                    result["action"] === "retry");
+            },
+            resultCheckLabel: 'greeting="Ada, welcome aboard!", action=retry'
+        }
+    },
+    {
+        id: "api-delegate-subtask",
+        description: "Delegate a self-contained subtask to a sub-agent",
+        objective: "You cannot do arithmetic yourself here: delegate it. Spawn a " +
+            "sub-agent with a self-contained prompt asking for the sum of the " +
+            "numbers 12, 30 and 5 (it sees none of this conversation), and finish " +
+            "with {sum: <the number it comes back with>}.",
+        outputSchema: {
+            type: "object",
+            properties: { sum: { type: "number" } },
+            required: ["sum"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["agents"],
+        expect: {
+            requiredTools: ["run_subtask"],
+            maxActions: 4,
+            resultCheck: (r) => asObject(r)["sum"] === 47,
+            resultCheckLabel: "sum=47"
+        }
+    },
+    {
+        id: "api-asset-round-trip",
+        description: "Save an asset, find it again, read it back",
+        objective: 'Save a note asset named "run-notes.txt" whose content is exactly ' +
+            '"fox: ok". Then find that asset again by searching for "run-notes" ' +
+            "and read its content back. Finish with {asset_id: <the saved " +
+            "asset's id>, content: <the text stored in the asset — the file body " +
+            "you read back, not the asset record>}.",
+        outputSchema: {
+            type: "object",
+            properties: { asset_id: { type: "string" }, content: { type: "string" } },
+            required: ["asset_id", "content"]
+        },
+        createTools: createCoreApiTools,
+        namespaces: ["assets"],
+        expect: {
+            requiredTools: ["save_asset", "read_asset"],
+            maxActions: 4,
+            resultCheck: (r) => {
+                const result = asObject(r);
+                return (result["content"] === "fox: ok" &&
+                    isString(result["asset_id"]) &&
+                    result["asset_id"].startsWith("asset_"));
+            },
+            resultCheckLabel: 'content="fox: ok", asset_id=asset_*'
+        }
+    }
+];
+//# sourceMappingURL=codeact-api-core.js.map