@2kw/ai 6.2.0-dev.23 → 6.2.0-dev.25

package/dist/agent-config/template.js

@@ -0,0 +1,59 @@
+import { stringify } from "yaml";
+import { AGENT_SCHEMA_ID } from "./schema.js";
+/**
+ * Commented starter file. Prose comments start with "# " + an uppercase letter; YAML
+ * examples start with "# " + a lowercase key, a space or "-" (the template test relies on it).
+ */
+export function agentTemplate(name) {
+    const nameLine = stringify({ name }, { lineWidth: 0 }).trimEnd();
+    return `# yaml-language-server: $schema=${AGENT_SCHEMA_ID}
+# Apply with: 2kw agents apply -f <this file> --dry-run, then without --dry-run.
+# A change to model, instructions, tools, hitlPolicy, options or skills publishes a new version and moves the latest label.
+# Full reference: 2kw agents schema
+${nameLine}
+description: What this agent is for.
+# List models with: 2kw ai models
+model: provider/model-name
+# Or an ordered list: the first entry is the default, pick another per run with 2kw agents run <agent> --model <entry>.
+# models:
+#   - provider/model-name
+#   - provider/other-model
+instructions: |
+  Describe the agent's job, its inputs, and what a good answer looks like.
+tools: []
+# Uncomment the tools this agent may use and delete the empty list above.
+# tools:
+#   - type: file_search
+#     config:
+#       knowledgeBaseIds: [kb_id]
+#   - type: backbone.extraction
+#     config:
+#       schemaIds: [schema_id]
+#   - type: backbone.document_convert
+#   - type: backbone.todo
+#   - type: backbone.skill
+#     skills: [skill-name@latest]
+#   - type: function
+#     name: lookup_order
+#     description: Look up an order by number
+#     endpoint: https://example.com/hooks/lookup-order
+#     secret: \${AGENT_LOOKUP_ORDER_SECRET}
+#     parameters:
+#       type: object
+#       properties:
+#         order: { type: string }
+#       required: [order]
+#     annotations: { readOnlyHint: true, destructiveHint: false }
+# Approval policy. Defaults: read allow, write approve, destructive block. Rules can only tighten.
+# hitlPolicy:
+#   version: 1
+#   classes: { read: allow, write: approve, destructive: block }
+#   tools:
+#     "lookup_*": read
+# Skill bindings, at most 20. Ref is a label or version number; default latest.
+# skills:
+#   - name: skill-name
+#     ref: latest
+`;
+}
+//# sourceMappingURL=template.js.map

package/dist/agent-config/validate.d.ts

@@ -0,0 +1,29 @@
+export interface ConfigIssue {
+    pointer: string;
+    message: string;
+}
+export interface AgentConfig {
+    name: string;
+    description?: string;
+    /** One model; with `models`, equal to its first entry. At least one of the two is present. */
+    model?: string;
+    /** Ordered model list (#591): first = default. */
+    models?: string[];
+    instructions?: string;
+    tools?: Record<string, unknown>[];
+    hitlPolicy?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+    skills?: {
+        name: string;
+        ref?: string;
+    }[];
+}
+/**
+ * A deep copy of `doc` in the form the backend actually checks: explicit nulls it treats as absent
+ * are dropped, and the parts of hitlPolicy it matches case-insensitively are lowercased
+ * (HitlPolicy.java parseClasses/action/parseTools). The structure is unchanged, so issue pointers
+ * still address the author's file. Only for validation: callers send the raw document.
+ */
+export declare function normalizeForValidation(doc: unknown): unknown;
+export declare function validateAgentConfig(raw: unknown): ConfigIssue[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/agent-config/validate.js

@@ -0,0 +1,123 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { agentSchema, NON_AUTHORABLE_TOOL_TYPES } from "./schema.js";
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+const validate = ajv.compile(agentSchema);
+/** Top-level keys whose explicit `null` the backend reads as absent. */
+const NULLABLE_KEYS = ["description", "models", "instructions", "tools", "hitlPolicy", "options", "skills"];
+/** Tool-rule values the backend matches case-insensitively; the actions (approve, auto, deny) are exact. */
+const TOOL_RULE_CLASSES = new Set(["read", "write", "destructive"]);
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/**
+ * A deep copy of `doc` in the form the backend actually checks: explicit nulls it treats as absent
+ * are dropped, and the parts of hitlPolicy it matches case-insensitively are lowercased
+ * (HitlPolicy.java parseClasses/action/parseTools). The structure is unchanged, so issue pointers
+ * still address the author's file. Only for validation: callers send the raw document.
+ */
+export function normalizeForValidation(doc) {
+    if (!isPlainObject(doc))
+        return doc;
+    const copy = structuredClone(doc);
+    for (const key of NULLABLE_KEYS) {
+        if (copy[key] === null)
+            delete copy[key];
+    }
+    if (Array.isArray(copy.skills)) {
+        for (const skill of copy.skills) {
+            if (isPlainObject(skill) && skill.ref === null)
+                delete skill.ref;
+        }
+    }
+    if (Array.isArray(copy.tools)) {
+        for (const tool of copy.tools) {
+            if (isPlainObject(tool) && tool.annotations === null)
+                delete tool.annotations;
+        }
+    }
+    const policy = copy.hitlPolicy;
+    if (isPlainObject(policy)) {
+        const lower = (v) => (typeof v === "string" ? v.toLowerCase() : v);
+        if ("default" in policy)
+            policy.default = lower(policy.default);
+        if (isPlainObject(policy.classes)) {
+            policy.classes = Object.fromEntries(Object.entries(policy.classes).map(([k, v]) => [k.toLowerCase(), lower(v)]));
+        }
+        if (isPlainObject(policy.tools)) {
+            policy.tools = Object.fromEntries(Object.entries(policy.tools).map(([pattern, v]) => {
+                const folded = lower(v);
+                return [pattern, typeof folded === "string" && TOOL_RULE_CLASSES.has(folded) ? folded : v];
+            }));
+        }
+    }
+    return copy;
+}
+function describe(e) {
+    // if/then wrappers restate the real error one level up; drop them. `not` only marks
+    // non-authorable tool types, which validateAgentConfig reports with the reason.
+    if (e.keyword === "if" || e.keyword === "false schema" || e.keyword === "not")
+        return undefined;
+    const pointer = e.instancePath || "/";
+    const params = e.params;
+    // The root anyOf is "model or models"; its two branch errors restate the one message below.
+    if (e.schemaPath.startsWith("#/anyOf/"))
+        return undefined;
+    if (e.schemaPath === "#/anyOf")
+        return { pointer, message: 'missing required key "model" (or "models")' };
+    if (e.keyword === "additionalProperties") {
+        return { pointer, message: `unknown key "${params.additionalProperty}"` };
+    }
+    if (e.keyword === "required") {
+        return { pointer, message: `missing required key "${params.missingProperty}"` };
+    }
+    if (e.keyword === "enum") {
+        const allowed = params.allowedValues.filter((v) => typeof v !== "string" || v === v.toLowerCase());
+        return { pointer, message: `must be one of the allowed values: ${allowed.join(", ")}` };
+    }
+    if (e.keyword === "const") {
+        return { pointer, message: `must be ${JSON.stringify(params.allowedValue)}` };
+    }
+    return { pointer, message: e.message ?? e.keyword };
+}
+export function validateAgentConfig(raw) {
+    const doc = normalizeForValidation(raw);
+    const issues = [];
+    if (!validate(doc)) {
+        for (const e of validate.errors ?? []) {
+            const issue = describe(e);
+            if (issue)
+                issues.push(issue);
+        }
+    }
+    const record = (doc ?? {});
+    // The backend derives model := models[0] and refuses a different explicit model (400).
+    if (typeof record.model === "string" && Array.isArray(record.models) && typeof record.models[0] === "string") {
+        if (record.model !== record.models[0]) {
+            issues.push({
+                pointer: "/model",
+                message: `must equal the first entry of models ("${record.models[0]}"), the default; or drop model`,
+            });
+        }
+    }
+    if (Array.isArray(record.tools)) {
+        record.tools.forEach((tool, i) => {
+            const type = tool?.type;
+            if (typeof type === "string" && Object.hasOwn(NON_AUTHORABLE_TOOL_TYPES, type)) {
+                issues.push({ pointer: `/tools/${i}/type`, message: `type "${type}" cannot be authored: ${NON_AUTHORABLE_TOOL_TYPES[type]}` });
+            }
+        });
+    }
+    if (Array.isArray(record.skills)) {
+        const seen = new Set();
+        record.skills.forEach((skill, i) => {
+            const name = skill?.name;
+            if (typeof name !== "string")
+                return;
+            if (seen.has(name))
+                issues.push({ pointer: `/skills/${i}/name`, message: `duplicate skill "${name}"` });
+            seen.add(name);
+        });
+    }
+    // Dedupe on the (pointer, message) pair; JSON keeps the key unambiguous without a control-character separator.
+    const unique = new Map(issues.map((i) => [JSON.stringify([i.pointer, i.message]), i]));
+    return [...unique.values()];
+}
+//# sourceMappingURL=validate.js.map

package/dist/commands/agent-apply.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { components } from "../generated/openapi.js";
+import { type ApiClient } from "../lib/agent-lookup.js";
+import type { AgentConfig } from "../agent-config/validate.js";
+export type AgentVersionDTO = components["schemas"]["AgentVersionDTO"];
+export declare function getLatestVersion(client: ApiClient, agentId: string): Promise<AgentVersionDTO | undefined>;
+export declare function versionBody(config: AgentConfig, changeDescription: string): Record<string, unknown>;
+export declare function makeAgentApplyCommand(): Command;
+//# sourceMappingURL=agent-apply.d.ts.map

package/dist/commands/agent-apply.js

@@ -0,0 +1,176 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { BackboneApiError, CliUsageError } from "../lib/errors.js";
+import { findAgentByName } from "../lib/agent-lookup.js";
+import { loadAgentConfig, maskSecrets } from "../agent-config/file.js";
+import { CONFIG_FIELDS, planApply } from "../agent-config/plan.js";
+export async function getLatestVersion(client, agentId) {
+    try {
+        const { data } = await client.GET("/v1/agents/{agentId}/versions/latest", { params: { path: { agentId } } });
+        return data;
+    }
+    catch (err) {
+        if (err instanceof BackboneApiError && err.status === 404)
+            return undefined;
+        throw err;
+    }
+}
+export function versionBody(config, changeDescription) {
+    const body = {};
+    const source = config;
+    for (const field of CONFIG_FIELDS) {
+        if (source[field] !== undefined)
+            body[field] = source[field];
+    }
+    body.changeDescription = changeDescription;
+    return body;
+}
+/**
+ * The complete agent DTO for POST /v1/agents and PUT /v1/agents/{id}. The backend's PUT maps every DTO field
+ * onto the row without skipping nulls (#624), so an absent key clears the column: `skills` (NOT NULL) must
+ * always be sent, and a PUT must carry `latestVersionId` or the agent loses its head pointer. Nullable
+ * columns (instructions, options, hitl_policy) are omitted when the file omits them, which clears them to
+ * SQL NULL exactly as createVersion does; an explicit JSON null would arrive as a NullNode instead.
+ */
+function agentBody(config, latestVersionId) {
+    const body = {
+        name: config.name,
+        description: config.description ?? "",
+    };
+    // `!= null`: the config is the raw file, which may spell an absent value as `null`.
+    // The backend derives model := models[0], so the list alone is a complete pair (#591).
+    if (config.model != null)
+        body.model = config.model;
+    if (config.models != null)
+        body.models = config.models;
+    if (config.instructions != null)
+        body.instructions = config.instructions;
+    body.tools = config.tools ?? [];
+    if (config.hitlPolicy != null)
+        body.hitlPolicy = config.hitlPolicy;
+    if (config.options != null)
+        body.options = config.options;
+    body.skills = config.skills ?? [];
+    if (latestVersionId !== undefined)
+        body.latestVersionId = latestVersionId;
+    return body;
+}
+async function moveLabel(client, agentId, label, versionId) {
+    const { data: labels } = await client.GET("/v1/agents/{agentId}/labels", { params: { path: { agentId } } });
+    if ((labels ?? []).some((l) => l.name === label)) {
+        await client.PUT("/v1/agents/{agentId}/labels/{labelName}", {
+            params: { path: { agentId, labelName: label } },
+            body: { agentVersionId: versionId },
+        });
+    }
+    else {
+        await client.POST("/v1/agents/{agentId}/labels", {
+            params: { path: { agentId } },
+            body: { name: label, agentVersionId: versionId },
+        });
+    }
+}
+function printText(result) {
+    const verb = result.dryRun ? `would be ${result.action}` : result.action;
+    const version = result.version !== null
+        ? ` (version ${result.version}; ${result.labels.join(", ")})`
+        : result.dryRun
+            ? ` (${result.labels.join(", ")})`
+            : "";
+    console.log(`${chalk.bold(result.agent)} ${verb}${version}`);
+    for (const c of result.changes) {
+        const mark = c.from === undefined ? chalk.green("+") : c.to === undefined ? chalk.red("-") : chalk.yellow("~");
+        console.log(`  ${mark} ${c.field}`);
+    }
+}
+export function makeAgentApplyCommand() {
+    return new Command("apply")
+        .description("Create or update an agent from agent.yaml; a changed config publishes a new version")
+        .requiredOption("-f, --file <path>", "Agent file (.yaml, .yml or .json; - for stdin)")
+        .option("--label <name>", "Also point this label at the resulting version")
+        .option("-m, --message <text>", "Change description for a new version", "2kw agents apply")
+        .option("--dry-run", "Validate and show the plan without writing")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            if (opts.label === "latest") {
+                throw new CliUsageError("The latest label moves automatically; choose another label name.");
+            }
+            const { config, secrets } = loadAgentConfig(opts.file, process.env);
+            const client = getClient(command);
+            const agent = await findAgentByName(client, config.name);
+            const latest = agent ? await getLatestVersion(client, String(agent.id)) : undefined;
+            const plan = planApply(config, agent ? { agent, latest: latest } : undefined);
+            let agentId = agent?.id ? String(agent.id) : null;
+            let version = null;
+            // A dry run reports the labels that would apply; a real run only those it actually set.
+            const labels = opts.label && opts.dryRun ? ["latest", opts.label] : ["latest"];
+            if (!opts.dryRun) {
+                let versionId = latest?.id;
+                version = latest?.versionNumber ?? null;
+                if (plan.action === "created") {
+                    let created;
+                    try {
+                        ({ data: created } = await client.POST("/v1/agents", {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            body: agentBody(config),
+                        }));
+                    }
+                    catch (err) {
+                        if (err instanceof BackboneApiError && err.status === 500) {
+                            throw new BackboneApiError({
+                                status: err.status,
+                                error: err.errorType,
+                                message: `${err.message} — an agent named "${config.name}" may already exist`,
+                                timestamp: err.timestamp,
+                                code: err.code,
+                            });
+                        }
+                        throw err;
+                    }
+                    if (!created?.id)
+                        throw new Error("Agent was created but the response has no id");
+                    agentId = String(created.id);
+                }
+                if (plan.action === "created" || plan.action === "versioned") {
+                    const { data: v } = await client.POST("/v1/agents/{agentId}/versions", {
+                        params: { path: { agentId: agentId } },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        body: versionBody(config, opts.message),
+                    });
+                    versionId = v?.id;
+                    version = v?.versionNumber ?? null;
+                }
+                if ((plan.action === "versioned" && plan.descriptionChanged) || plan.action === "updated") {
+                    // PUT replaces the whole agent row: send the file's config (never the fetched agent's, which is
+                    // stale after a new version) and the head pointer, the new version's id when one was just published.
+                    const head = plan.action === "versioned" ? versionId : agent?.latestVersionId;
+                    await client.PUT("/v1/agents/{id}", {
+                        params: { path: { id: agentId } },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        body: agentBody(config, head),
+                    });
+                }
+                if (opts.label && versionId) {
+                    await moveLabel(client, agentId, opts.label, versionId);
+                    labels.push(opts.label);
+                }
+            }
+            const result = maskSecrets({
+                agent: config.name,
+                agentId,
+                action: plan.action,
+                dryRun: !!opts.dryRun,
+                version,
+                labels,
+                changes: plan.changes,
+            }, secrets);
+            if (isJsonOutput(command))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                printText(result);
+        });
+    });
+}
+//# sourceMappingURL=agent-apply.js.map

package/dist/commands/agent-export.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeAgentExportCommand(): Command;
+//# sourceMappingURL=agent-export.d.ts.map

package/dist/commands/agent-export.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { CliUsageError } from "../lib/errors.js";
+import { resolveAgent, splitAgentRef } from "../lib/agent-lookup.js";
+import { dropInertTools, escapePlaceholders, redactSecrets, toAgentYaml, versionToConfig, } from "../agent-config/export.js";
+import { getLatestVersion } from "./agent-apply.js";
+/**
+ * Exclusive create unless forced: the early existence check runs before any request, so a file
+ * created while the export was fetching must still not be overwritten.
+ */
+function writeOutput(file, text, force) {
+    try {
+        writeFileSync(file, text, { flag: force ? "w" : "wx" });
+    }
+    catch (err) {
+        const code = err.code;
+        // "wx" reports an existing directory as EEXIST too, where --force would not help.
+        const isDirectory = code === "EEXIST" && (statSync(file, { throwIfNoEntry: false })?.isDirectory() ?? false);
+        if (code === "EEXIST" && !isDirectory) {
+            throw new CliUsageError(`${file} exists. Pass --force to overwrite.`);
+        }
+        const reason = isDirectory ? "EISDIR" : (code ?? err.message);
+        throw new CliUsageError(`${file}: cannot write file (${reason})`);
+    }
+}
+export function makeAgentExportCommand() {
+    return new Command("export")
+        .description("Write an agent version as agent.yaml (webhook secrets become ${ENV} placeholders)")
+        .argument("<agent>", "Agent name or id, optionally with @label (default latest)")
+        .option("-o, --output <file>", "Write to a file instead of stdout")
+        .option("--force", "Overwrite an existing output file")
+        .option("--include-secrets", "Write webhook secrets in plaintext")
+        .action(async (ref, opts, command) => {
+        await runAction(command, async () => {
+            const { name, label = "latest", model } = splitAgentRef(ref);
+            if (model !== undefined) {
+                throw new CliUsageError("export takes <agent>[@label]; a #model override has no meaning here.");
+            }
+            if (opts.output && existsSync(opts.output) && !opts.force) {
+                throw new CliUsageError(`${opts.output} exists. Pass --force to overwrite.`);
+            }
+            const client = getClient(command);
+            const agent = await resolveAgent(client, name);
+            const agentId = String(agent.id);
+            let version;
+            if (label === "latest") {
+                version = await getLatestVersion(client, agentId);
+            }
+            else {
+                const { data: labels } = await client.GET("/v1/agents/{agentId}/labels", { params: { path: { agentId } } });
+                const hit = (labels ?? []).find((l) => l.name === label);
+                if (!hit?.agentVersionId) {
+                    const known = (labels ?? []).map((l) => l.name).join(", ") || "none";
+                    throw new CliUsageError(`Label '${label}' not found on ${agent.name}. Labels: ${known}`);
+                }
+                ({ data: version } = await client.GET("/v1/agents/{agentId}/versions/{versionId}", {
+                    params: { path: { agentId, versionId: hit.agentVersionId } },
+                }));
+            }
+            if (!version)
+                throw new CliUsageError(`${agent.name} has no published version.`);
+            const config = escapePlaceholders(versionToConfig(agent, version));
+            const inert = dropInertTools(config.tools);
+            if (inert.tools)
+                config.tools = inert.tools;
+            else
+                delete config.tools;
+            if (inert.dropped.length) {
+                console.error(`Dropped tool entries that have no effect at run time: ${inert.dropped.join(", ")}`);
+            }
+            let envNames = [];
+            if (!opts.includeSecrets) {
+                const redacted = redactSecrets(config.tools);
+                if (redacted.tools)
+                    config.tools = redacted.tools;
+                envNames = redacted.envNames;
+            }
+            const text = isJsonOutput(command)
+                ? `${JSON.stringify(config, null, 2)}\n`
+                : toAgentYaml(config, {
+                    agent: agent.name,
+                    label,
+                    versionNumber: version.versionNumber ?? null,
+                    date: new Date().toISOString().slice(0, 10),
+                });
+            if (opts.output) {
+                writeOutput(opts.output, text, Boolean(opts.force));
+            }
+            else {
+                process.stdout.write(text);
+            }
+            if (envNames.length) {
+                console.error(`Secrets replaced by placeholders; set before apply: ${envNames.join(", ")}`);
+            }
+        });
+    });
+}
+//# sourceMappingURL=agent-export.js.map

package/dist/commands/agent-init.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function makeAgentInitCommand(): Command;
+export declare function makeAgentSchemaCommand(): Command;
+//# sourceMappingURL=agent-init.d.ts.map

package/dist/commands/agent-init.js

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { statSync, writeFileSync } from "node:fs";
+import { parse } from "yaml";
+import { runAction } from "../lib/client.js";
+import { CliUsageError } from "../lib/errors.js";
+import { agentSchema } from "../agent-config/schema.js";
+import { agentTemplate } from "../agent-config/template.js";
+import { validateAgentConfig } from "../agent-config/validate.js";
+export function makeAgentInitCommand() {
+    return new Command("init")
+        .description("Write a commented agent.yaml template")
+        .argument("<name>", "Agent name")
+        .option("-o, --output <file>", "Output file", "agent.yaml")
+        .option("--force", "Overwrite an existing file")
+        .action(async (rawName, opts, command) => {
+        await runAction(command, async () => {
+            const name = rawName.trim();
+            if (!name)
+                throw new CliUsageError("Agent name must not be empty.");
+            const text = agentTemplate(name);
+            const nameIssue = validateAgentConfig(parse(text)).find((issue) => issue.pointer === "/name");
+            if (nameIssue)
+                throw new CliUsageError(`Invalid agent name: ${nameIssue.message}`);
+            writeTemplate(opts.output, text, Boolean(opts.force));
+            console.error(`Wrote ${opts.output}. Next: 2kw agents apply -f ${opts.output} --dry-run`);
+        });
+    });
+}
+/** Exclusive create unless forced, so nothing is overwritten between a check and the write. */
+function writeTemplate(file, text, force) {
+    try {
+        writeFileSync(file, text, { flag: force ? "w" : "wx" });
+    }
+    catch (err) {
+        const code = err.code;
+        // "wx" reports an existing directory as EEXIST too, where --force would not help.
+        const isDirectory = code === "EEXIST" && (statSync(file, { throwIfNoEntry: false })?.isDirectory() ?? false);
+        if (code === "EEXIST" && !isDirectory) {
+            throw new CliUsageError(`${file} exists. Pass --force to overwrite.`);
+        }
+        const reason = isDirectory ? "EISDIR" : (code ?? err.message);
+        throw new CliUsageError(`${file}: cannot write file (${reason})`);
+    }
+}
+export function makeAgentSchemaCommand() {
+    return new Command("schema")
+        .description("Print the JSON Schema for agent.yaml")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            console.log(JSON.stringify(agentSchema, null, 2));
+        });
+    });
+}
+//# sourceMappingURL=agent-init.js.map

package/dist/commands/agent-run.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export declare function resolveRunInput(arg: string | undefined, inputFile: string | undefined, readStdin?: () => string | undefined): string;
+export declare function makeAgentRunCommand(): Command;
+export declare function makeAgentDecideCommand(): Command;
+//# sourceMappingURL=agent-run.d.ts.map