@mintlify/cli 4.0.1655 → 4.0.1657

package/bin/agent-harness/runHistory.js

@@ -1,256 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { z } from 'zod';
-import { countReport } from './countReport.js';
-const RUN_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
-const INDEX_LOCK_FILENAME = 'testRuns.lock';
-const LOCK_RETRY_MS = 20;
-const STALE_LOCK_MS = 30000;
-const LOCK_TIMEOUT_MS = STALE_LOCK_MS + 10000;
-const commandResultSchema = z
-    .object({
-    id: z.string(),
-    phase: z.enum(['setup', 'test']),
-    status: z.enum(['passed', 'failed', 'cancelled']),
-    executable: z.string(),
-    args: z.array(z.string()),
-    cwd: z.string(),
-    durationMs: z.number().nonnegative(),
-    exitCode: z.number().int().nullable(),
-    stdout: z.string(),
-    stderr: z.string(),
-    error: z.string().optional(),
-})
-    .strict();
-const taskResultSchema = z
-    .object({
-    id: z.string(),
-    agent: z.enum(['claude', 'codex']),
-    file: z.string(),
-    directory: z.string(),
-    generatedFiles: z.array(z.string()),
-    testable: z.boolean(),
-    attempts: z.number().int().nonnegative(),
-    tokens: z.number().nonnegative(),
-    status: z.enum(['passed', 'failed', 'agent_error', 'cancelled']),
-    error: z.string().optional(),
-    commands: z.array(commandResultSchema),
-})
-    .strict();
-const codeTestReportSchema = z
-    .object({
-    version: z.literal(1),
-    runId: z.string().regex(RUN_ID_PATTERN),
-    status: z.enum(['passed', 'completed', 'failed', 'cancelled']),
-    docsRoot: z.string(),
-    outputDirectory: z.string(),
-    reportPath: z.string(),
-    agents: z.array(z.enum(['claude', 'codex'])).min(1),
-    model: z.string().min(1),
-    selectedFiles: z.array(z.string()),
-    startedAt: z.string(),
-    completedAt: z.string(),
-    durationMs: z.number().nonnegative(),
-    tasks: z.array(taskResultSchema),
-    historyError: z.string().optional(),
-})
-    .strict();
-const countsSchema = z
-    .object({
-    passed: z.number().int().nonnegative(),
-    failed: z.number().int().nonnegative(),
-    cancelled: z.number().int().nonnegative(),
-    agentErrors: z.number().int().nonnegative(),
-})
-    .strict();
-const testRunSummarySchema = z
-    .object({
-    runId: z.string().regex(RUN_ID_PATTERN),
-    status: z.enum(['passed', 'completed', 'failed', 'cancelled']),
-    agents: z.array(z.enum(['claude', 'codex'])).min(1),
-    model: z.string().min(1),
-    selectedFiles: z.array(z.string()),
-    startedAt: z.string(),
-    completedAt: z.string(),
-    durationMs: z.number().nonnegative(),
-    reportPath: z.string(),
-    outputDirectory: z.string(),
-    counts: countsSchema,
-})
-    .strict();
-const testRunsIndexSchema = z
-    .object({ version: z.literal(1), runs: z.array(testRunSummarySchema) })
-    .strict();
-function historyDirectory(docsRoot) {
-    return path.join(docsRoot, '.mintlify', 'test');
-}
-function runsDirectory(docsRoot) {
-    return path.join(historyDirectory(docsRoot), 'runs');
-}
-export function testRunReportPath(docsRoot, runId) {
-    if (!RUN_ID_PATTERN.test(runId))
-        throw new Error(`Invalid mint test run ID: ${runId}`);
-    return path.join(runsDirectory(docsRoot), `${runId}.json`);
-}
-export function testRunsIndexPath(docsRoot) {
-    return path.join(historyDirectory(docsRoot), 'testRuns.json');
-}
-function summarizeReport(report) {
-    return {
-        runId: report.runId,
-        status: report.status,
-        agents: report.agents,
-        model: report.model,
-        selectedFiles: report.selectedFiles,
-        startedAt: report.startedAt,
-        completedAt: report.completedAt,
-        durationMs: report.durationMs,
-        reportPath: report.reportPath,
-        outputDirectory: report.outputDirectory,
-        counts: countReport(report.tasks),
-    };
-}
-function errorCode(error) {
-    return typeof error === 'object' && error !== null && 'code' in error
-        ? String(error.code)
-        : undefined;
-}
-function writeJsonAtomically(filePath, value) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
-        try {
-            yield fs.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
-            yield fs.rename(temporaryPath, filePath);
-        }
-        finally {
-            yield fs.unlink(temporaryPath).catch(() => undefined);
-        }
-    });
-}
-function acquireIndexLock(docsRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const lockPath = path.join(historyDirectory(docsRoot), INDEX_LOCK_FILENAME);
-        const token = `${process.pid}:${randomUUID()}`;
-        const deadline = Date.now() + LOCK_TIMEOUT_MS;
-        while (Date.now() < deadline) {
-            let lock;
-            try {
-                lock = yield fs.open(lockPath, 'wx');
-            }
-            catch (error) {
-                const code = errorCode(error);
-                // Windows can deny opening a lock while another writer's deletion is still pending.
-                if (code !== 'EEXIST' && !(process.platform === 'win32' && code === 'EPERM'))
-                    throw error;
-                const stats = yield fs.stat(lockPath).catch(() => undefined);
-                if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
-                    yield fs.unlink(lockPath).catch(() => undefined);
-                    continue;
-                }
-                yield delay(LOCK_RETRY_MS);
-                continue;
-            }
-            try {
-                yield lock.writeFile(token);
-            }
-            finally {
-                yield lock.close();
-            }
-            return () => __awaiter(this, void 0, void 0, function* () {
-                const owner = yield fs.readFile(lockPath, 'utf8').catch(() => undefined);
-                if (owner === token)
-                    yield fs.unlink(lockPath).catch(() => undefined);
-            });
-        }
-        throw new Error('Timed out updating mint test run history');
-    });
-}
-function readReport(filePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return codeTestReportSchema.parse(JSON.parse(yield fs.readFile(filePath, 'utf8')));
-        }
-        catch (_a) {
-            return null;
-        }
-    });
-}
-function rebuildIndex(docsRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const entries = yield fs
-            .readdir(runsDirectory(docsRoot), { withFileTypes: true })
-            .catch(() => []);
-        const reports = yield Promise.all(entries
-            .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-            .map((entry) => readReport(path.join(runsDirectory(docsRoot), entry.name))));
-        return {
-            version: 1,
-            runs: reports
-                .filter((report) => report !== null)
-                .map(summarizeReport)
-                .sort((left, right) => right.completedAt.localeCompare(left.completedAt)),
-        };
-    });
-}
-export function loadTestRuns(docsRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return testRunsIndexSchema.parse(JSON.parse(yield fs.readFile(testRunsIndexPath(docsRoot), 'utf8')));
-        }
-        catch (_a) {
-            return rebuildIndex(docsRoot);
-        }
-    });
-}
-export function loadLatestTestRun(docsRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const index = yield loadTestRuns(docsRoot);
-        for (const run of index.runs) {
-            const report = yield readReport(testRunReportPath(docsRoot, run.runId));
-            if (report)
-                return report;
-        }
-        return null;
-    });
-}
-export function writeTestRunHistory(docsRoot, report) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fs.mkdir(runsDirectory(docsRoot), { recursive: true });
-        yield writeJsonAtomically(report.reportPath, report);
-        const releaseLock = yield acquireIndexLock(docsRoot);
-        try {
-            yield writeJsonAtomically(testRunsIndexPath(docsRoot), yield rebuildIndex(docsRoot));
-        }
-        finally {
-            yield releaseLock();
-        }
-    });
-}
-/**
- * Saves a finished run to history without letting a history failure fail the run.
- * On failure the returned report points at `fallbackReportPath` (the report that was
- * already written) and carries the problem in `historyError`.
- */
-export function recordTestRun(docsRoot, report, fallbackReportPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield writeTestRunHistory(docsRoot, report);
-            return report;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return Object.assign(Object.assign({}, report), { reportPath: fallbackReportPath, historyError: `run history could not be saved: ${message}` });
-        }
-    });
-}

package/bin/agent-harness/runSave.js

@@ -1,47 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { z } from 'zod';
-const runSaveSchema = z
-    .object({
-    version: z.literal(1),
-    runId: z.string().regex(/^[A-Za-z0-9._-]+$/),
-    agents: z.array(z.enum(['claude', 'codex'])).min(1),
-    model: z.string().min(1),
-    selectedFiles: z.array(z.string().min(1)),
-    createdAt: z.string(),
-})
-    .strict();
-function savePath(outputDirectory) {
-    return path.join(outputDirectory, 'save.json');
-}
-export function loadRunSave(outputDirectory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const content = yield fs.readFile(savePath(outputDirectory), 'utf8');
-            return runSaveSchema.parse(JSON.parse(content));
-        }
-        catch (_a) {
-            return null;
-        }
-    });
-}
-export function writeRunSave(outputDirectory, save) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fs.mkdir(outputDirectory, { recursive: true });
-        yield fs.writeFile(savePath(outputDirectory), `${JSON.stringify(save, null, 2)}\n`);
-    });
-}
-export function clearRunSave(outputDirectory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fs.unlink(savePath(outputDirectory)).catch(() => undefined);
-    });
-}

package/bin/agent-harness/setupFolders.js

@@ -1,73 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { randomBytes } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const PACKAGE_JSON = `${JSON.stringify({
-    name: 'mint-test-task',
-    private: true,
-    type: 'module',
-    // No positional path: Node 21+ treats --test arguments as globs, so a bare
-    // directory such as `tests/` fails with MODULE_NOT_FOUND. The default patterns
-    // pick up tests/*.test.js on every supported Node version.
-    scripts: { test: 'node --test' },
-}, null, 2)}\n`;
-function isExistingFile(error) {
-    return (typeof error === 'object' && error !== null && error.code === 'EEXIST');
-}
-function scaffoldTaskDirectory(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fs.mkdir(path.join(directory, 'tests'), { recursive: true });
-        try {
-            yield fs.writeFile(path.join(directory, 'package.json'), PACKAGE_JSON, { flag: 'wx' });
-        }
-        catch (error) {
-            if (!isExistingFile(error))
-                throw error;
-        }
-    });
-}
-export function scaffoldTaskDirectories(tasks) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const task of tasks)
-            yield scaffoldTaskDirectory(task.directory);
-    });
-}
-export function setupFolders(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ pages, agents, docsRoot, outputDirectory, runId: savedRunId, }) {
-        const runId = savedRunId !== null && savedRunId !== void 0 ? savedRunId : `${new Date()
-            .toISOString()
-            .replace(/[-:TZ.]/g, '')
-            .slice(0, 14)}-${randomBytes(4).toString('hex')}`;
-        const runDirectory = path.join(path.resolve(outputDirectory), runId);
-        const reportPath = path.join(runDirectory, 'report.json');
-        yield fs.mkdir(runDirectory, { recursive: true });
-        const tasks = [];
-        for (const agent of agents) {
-            for (const [pageIndex, page] of pages.entries()) {
-                const slug = page.file
-                    .replace(/\.[^.]+$/, '')
-                    .replace(/[^a-z0-9]+/gi, '-')
-                    .replace(/^-|-$/g, '')
-                    .slice(0, 56);
-                tasks.push({
-                    id: `${agent}:${page.file}`,
-                    agent,
-                    docsRoot,
-                    file: page.file,
-                    directory: path.join(runDirectory, agent, `${String(pageIndex + 1).padStart(3, '0')}-${slug || 'page'}`),
-                    attempts: 0,
-                    tokens: 0,
-                });
-            }
-        }
-        return { runId, runDirectory, reportPath, tasks };
-    });
-}

package/bin/agent-harness/tasks/checkTestability.js

@@ -1,228 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import z from 'zod';
-import { buildCheckPrompt, CHECK_JSON_INSTRUCTION, CHECK_SYSTEM_PROMPT, CHECK_TOOL_INSTRUCTION, } from '../buildTaskPrompt.js';
-import { loadClaudeAgentSdk, loadCodexSdk } from '../loadAgentSdk.js';
-import { testCheckSchema, } from '../types.js';
-const CHECK_FILENAME = 'mint-test-check.json';
-const CHECK_MODEL = 'claude-haiku-4-5-20251001';
-function readValidCheck(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const check = testCheckSchema.parse(JSON.parse(yield fs.readFile(path.join(directory, CHECK_FILENAME), 'utf8')));
-            return validateCheck(check).length === 0 ? check : null;
-        }
-        catch (_a) {
-            return null;
-        }
-    });
-}
-function validateCheck(check) {
-    return !check.testable && !check.reason ? ['Not-testable page needs a reason'] : [];
-}
-function parseJsonReply(reply) {
-    var _a;
-    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(reply);
-    const raw = (_a = fenced === null || fenced === void 0 ? void 0 : fenced[1]) !== null && _a !== void 0 ? _a : reply;
-    const start = raw.indexOf('{');
-    const end = raw.lastIndexOf('}');
-    if (start === -1 || end === -1)
-        throw new Error('Reply contained no JSON object');
-    return JSON.parse(raw.slice(start, end + 1));
-}
-function runTestabilityCheck(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ file, content, agent, workingDirectory, signal, }) {
-        const prompt = buildCheckPrompt(file, content);
-        let tokens = 0;
-        let raw;
-        if (agent === 'claude') {
-            const reply = yield promptClaudeCheck({ prompt, workingDirectory, signal });
-            tokens = reply.tokens;
-            if (reply.captured === null)
-                throw new Error('agent never called report_testability');
-            raw = reply.captured;
-        }
-        else {
-            const reply = yield promptCodex({
-                prompt,
-                systemPrompt: CHECK_SYSTEM_PROMPT + CHECK_JSON_INSTRUCTION,
-                workingDirectory,
-                signal,
-            });
-            tokens = reply.tokens;
-            raw = parseJsonReply(reply.result);
-        }
-        const check = testCheckSchema.parse(raw);
-        const errors = validateCheck(check);
-        if (errors.length > 0)
-            throw new Error(errors.join('\n'));
-        return { tokens, check };
-    });
-}
-export const checkFileTestability = (task_1, _a) => __awaiter(void 0, [task_1, _a], void 0, function* (task, { onTaskUpdate, signal, runDirectory, }) {
-    const emit = (phase, tokens) => onTaskUpdate({
-        id: task.id,
-        agent: task.agent,
-        file: task.file,
-        directory: task.directory,
-        generatedFiles: [],
-        phase,
-        tokens,
-    });
-    let attempts = 0;
-    let tokens = 0;
-    let lastError = 'run cancelled';
-    let check = yield readValidCheck(task.directory);
-    if (!check) {
-        emit('checking', tokens);
-        const content = yield fs.readFile(path.join(task.docsRoot, task.file), 'utf8');
-        for (let attempt = 1; attempt <= 2 && !signal.aborted && !check; attempt++) {
-            attempts = attempt;
-            try {
-                const reply = yield runTestabilityCheck({
-                    file: task.file,
-                    content,
-                    agent: task.agent,
-                    workingDirectory: runDirectory,
-                    signal,
-                });
-                tokens += reply.tokens;
-                check = reply.check;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error.message : String(error);
-            }
-        }
-        if (!check) {
-            if (signal.aborted) {
-                emit('cancelled', tokens);
-                return Object.assign(Object.assign({}, task), { attempts, tokens, error: 'run cancelled' });
-            }
-            emit('agent_error', tokens);
-            return Object.assign(Object.assign({}, task), { attempts, tokens, error: lastError });
-        }
-    }
-    if (!check.testable) {
-        emit('not_testable', tokens);
-        return Object.assign(Object.assign({}, task), { attempts, tokens, testable: false });
-    }
-    yield fs.mkdir(task.directory, { recursive: true });
-    yield fs.writeFile(path.join(task.directory, CHECK_FILENAME), `${JSON.stringify(check, null, 2)}\n`);
-    emit('checked', tokens);
-    return Object.assign(Object.assign({}, task), { attempts, tokens, testable: true });
-});
-function promptClaudeCheck(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ prompt, workingDirectory, signal, }) {
-        var _b, e_1, _c, _d;
-        const { query, tool, createSdkMcpServer } = yield loadClaudeAgentSdk();
-        const abortController = new AbortController();
-        const abort = () => abortController.abort(signal.reason);
-        if (signal.aborted)
-            abort();
-        else
-            signal.addEventListener('abort', abort, { once: true });
-        let captured = null;
-        const server = createSdkMcpServer({
-            name: 'mint-test',
-            tools: [
-                tool('report_testability', 'Report whether the documentation page is testable. Call exactly once.', {
-                    version: z.literal(1),
-                    testable: z.boolean(),
-                    reason: z.string().optional(),
-                }, (input) => __awaiter(this, void 0, void 0, function* () {
-                    captured = input;
-                    return { content: [{ type: 'text', text: 'recorded' }] };
-                })),
-            ],
-        });
-        const session = query({
-            prompt,
-            options: {
-                abortController,
-                allowedTools: ['mcp__mint-test__report_testability'],
-                cwd: workingDirectory,
-                mcpServers: { 'mint-test': server },
-                model: CHECK_MODEL,
-                permissionMode: 'dontAsk',
-                persistSession: false,
-                settingSources: [],
-                strictMcpConfig: true,
-                systemPrompt: CHECK_SYSTEM_PROMPT + CHECK_TOOL_INSTRUCTION,
-                tools: [],
-            },
-        });
-        try {
-            try {
-                for (var _e = true, session_1 = __asyncValues(session), session_1_1; session_1_1 = yield session_1.next(), _b = session_1_1.done, !_b; _e = true) {
-                    _d = session_1_1.value;
-                    _e = false;
-                    const message = _d;
-                    if (message.type !== 'result')
-                        continue;
-                    if (message.subtype !== 'success' || message.is_error) {
-                        const details = message.subtype === 'success' ? message.result : message.errors.join('; ');
-                        throw new Error(details || `Claude stopped with ${message.subtype}`);
-                    }
-                    const usage = message.usage;
-                    return {
-                        tokens: usage.input_tokens +
-                            usage.output_tokens +
-                            usage.cache_creation_input_tokens +
-                            usage.cache_read_input_tokens,
-                        captured,
-                    };
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_e && !_b && (_c = session_1.return)) yield _c.call(session_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            throw new Error('Claude finished without returning a result');
-        }
-        finally {
-            signal.removeEventListener('abort', abort);
-            session.close();
-        }
-    });
-}
-function promptCodex(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ prompt, systemPrompt, workingDirectory, signal, }) {
-        const { Codex } = yield loadCodexSdk();
-        const thread = new Codex().startThread({
-            approvalPolicy: 'never',
-            networkAccessEnabled: true,
-            sandboxMode: 'workspace-write',
-            skipGitRepoCheck: true,
-            workingDirectory,
-        });
-        const result = yield thread.run(`${systemPrompt}\n\n${prompt}`, { signal });
-        const usage = result.usage;
-        const tokens = usage
-            ? usage.input_tokens +
-                usage.cached_input_tokens +
-                usage.cache_write_input_tokens +
-                usage.output_tokens +
-                usage.reasoning_output_tokens
-            : 0;
-        return { tokens, result: result.finalResponse };
-    });
-}

package/bin/agent-harness/types.js

@@ -1,66 +0,0 @@
-import { z } from 'zod';
-const identifier = z.string().trim().min(1).max(120);
-const commandSchema = z
-    .object({
-    id: identifier.optional(),
-    executable: z.string().trim().min(1).max(512),
-    args: z.array(z.string().max(10000)).max(100),
-    cwd: z.string().max(1024).optional(),
-    timeoutMs: z
-        .number()
-        .int()
-        .min(1000)
-        .max(30 * 60 * 1000)
-        .optional(),
-})
-    .strict();
-const manifestFileSchema = z
-    .object({
-    version: z.literal(1),
-    generatedFiles: z.array(z.string().min(1).max(1024)).max(1000),
-    setupCommands: z.array(commandSchema).max(50),
-    testCommands: z.array(commandSchema).max(200),
-})
-    .strict();
-/**
- * Agents often copy the manifest example verbatim and omit command ids. The id only needs to be
- * unique within the manifest, so assign `setup-N` / `test-N` instead of rejecting the whole page.
- */
-export function assignCommandIds(manifest) {
-    const taken = new Set([...manifest.setupCommands, ...manifest.testCommands]
-        .map((command) => command.id)
-        .filter((id) => id !== undefined));
-    const withIds = (commands, phase) => {
-        let next = 1;
-        return commands.map((command) => {
-            if (command.id !== undefined)
-                return Object.assign(Object.assign({}, command), { id: command.id });
-            let id = `${phase}-${next}`;
-            while (taken.has(id)) {
-                next += 1;
-                id = `${phase}-${next}`;
-            }
-            taken.add(id);
-            next += 1;
-            return Object.assign(Object.assign({}, command), { id });
-        });
-    };
-    return {
-        version: manifest.version,
-        generatedFiles: manifest.generatedFiles,
-        setupCommands: withIds(manifest.setupCommands, 'setup'),
-        testCommands: withIds(manifest.testCommands, 'test'),
-    };
-}
-export const manifestSchema = manifestFileSchema.transform(assignCommandIds);
-export const testCheckSchema = z
-    .object({
-    version: z.literal(1),
-    testable: z.boolean(),
-    reason: z
-        .string()
-        .max(2000)
-        .optional()
-        .transform((value) => ((value === null || value === void 0 ? void 0 : value.trim()) ? value.trim() : undefined)),
-})
-    .strict();