donobu 5.26.0 → 5.27.0

package/dist/esm/reporter/reportWalk.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Shared helpers for walking a `DonobuReport` and classifying
+ * the tests inside it. Used by every renderer (HTML, Markdown, Slack) so they
+ * all agree on "what counts as self-healed" and how suites nest.
+ */
+/**
+ * Recursively collect all specs from a suite and its nested sub-suites. The
+ * Playwright JSON report nests suites (e.g. describe blocks), so a flat view
+ * is what every renderer actually wants.
+ */
+export declare function collectSpecs(suite: any): any[];
+/**
+ * A test is "self-healed" when either:
+ * - it carries a `self-healed` annotation (set by the merge step when a
+ *   failing test flipped to passing on the heal rerun), or
+ * - its `donobuStatus` field has been set to `'healed'` (same signal, via
+ *   the merged report's per-test metadata).
+ */
+export declare function isSelfHealed(test: any): boolean;
+/** Normalized test-status the renderers use for counts and labels. */
+export type NormalizedStatus = 'passed' | 'failed' | 'healed' | 'timedOut' | 'skipped' | 'interrupted' | 'unknown';
+/**
+ * Derive the display status for a test. Prefers the final attempt's result
+ * status; bumps to `'healed'` when the self-heal signal is present; falls
+ * back to `'skipped'` when Playwright didn't emit a result.
+ */
+export declare function statusOf(test: any): NormalizedStatus;
+//# sourceMappingURL=reportWalk.d.ts.map

package/dist/esm/reporter/reportWalk.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * @fileoverview Shared helpers for walking a `DonobuReport` and classifying
+ * the tests inside it. Used by every renderer (HTML, Markdown, Slack) so they
+ * all agree on "what counts as self-healed" and how suites nest.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSpecs = collectSpecs;
+exports.isSelfHealed = isSelfHealed;
+exports.statusOf = statusOf;
+/**
+ * Recursively collect all specs from a suite and its nested sub-suites. The
+ * Playwright JSON report nests suites (e.g. describe blocks), so a flat view
+ * is what every renderer actually wants.
+ */
+function collectSpecs(suite) {
+    const specs = [...(suite.specs ?? [])];
+    for (const child of suite.suites ?? []) {
+        specs.push(...collectSpecs(child));
+    }
+    return specs;
+}
+/**
+ * A test is "self-healed" when either:
+ * - it carries a `self-healed` annotation (set by the merge step when a
+ *   failing test flipped to passing on the heal rerun), or
+ * - its `donobuStatus` field has been set to `'healed'` (same signal, via
+ *   the merged report's per-test metadata).
+ */
+function isSelfHealed(test) {
+    const annotations = test?.annotations ?? [];
+    const hasAnnotation = annotations.some((a) => a?.type === 'self-healed');
+    return hasAnnotation || test?.donobuStatus === 'healed';
+}
+/**
+ * Derive the display status for a test. Prefers the final attempt's result
+ * status; bumps to `'healed'` when the self-heal signal is present; falls
+ * back to `'skipped'` when Playwright didn't emit a result.
+ */
+function statusOf(test) {
+    const lastResult = test?.results?.at?.(-1);
+    if (test?.status === 'skipped' ||
+        (!lastResult && test?.status === undefined)) {
+        return 'skipped';
+    }
+    if (isSelfHealed(test)) {
+        return 'healed';
+    }
+    const status = lastResult?.status ?? 'unknown';
+    switch (status) {
+        case 'passed':
+        case 'failed':
+        case 'timedOut':
+        case 'skipped':
+        case 'interrupted':
+            return status;
+        default:
+            return 'unknown';
+    }
+}
+//# sourceMappingURL=reportWalk.js.map

package/dist/esm/reporter/slack.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Donobu Slack Reporter for Playwright.
+ *
+ * Writes a Slack Block Kit payload to disk and, when configured, POSTs it
+ * directly to a Slack Incoming Webhook. During auto-heal the POST is deferred
+ * to the orchestrator so the user sees exactly one message per run reflecting
+ * the final (merged, possibly healed) outcome — not an initial failure
+ * message followed by a healed one.
+ *
+ * @usage
+ * The reporter takes no Slack-related options. All Slack configuration is
+ * driven by environment variables (see below) — typically populated from CI
+ * secrets and contextual run metadata. Wire it up in `playwright.config.ts`
+ * with no arguments:
+ *
+ * ```ts
+ * reporter: [
+ *   ['donobu/reporter/slack'],
+ * ],
+ * ```
+ *
+ * Optionally set `outputFile` to control the on-disk payload path:
+ *
+ * ```ts
+ * reporter: [
+ *   ['donobu/reporter/slack', { outputFile: 'test-results/slack-payload.json' }],
+ * ],
+ * ```
+ *
+ * @env Configuration
+ *
+ * **`DONOBU_SLACK_WEBHOOK_URL`** *(required for posting; secret)* — the Slack
+ * Incoming Webhook URL to POST the payload to. When unset, the reporter still
+ * writes the payload file but performs no network call (the file is then
+ * useful as a CI artifact or for piping to `curl` manually). This is treated
+ * as a secret and is read only from the environment — never as a reporter
+ * option — so it cannot accidentally end up checked into a config file.
+ *
+ * **`DONOBU_REPORT_URL`** *(optional; not secret)* — a URL to embed in the
+ * Slack message that links back to the full report (e.g. the GitHub Actions
+ * run URL, or a published HTML report). When unset, the message simply omits
+ * the link section. Read from the environment for symmetry with the webhook
+ * URL: both come from CI context, and a single configuration story keeps the
+ * mental model simple. To override per-suite, set the env var differently
+ * before invoking `donobu test`.
+ *
+ * **`DONOBU_AUTO_HEAL_ACTIVE`** / **`DONOBU_AUTO_HEAL_ORCHESTRATED`**
+ * *(set internally; not user-facing)* — coordination flags the donobu CLI
+ * sets so the reporter knows when to defer Slack posting to the orchestrator.
+ * Users should never set these themselves.
+ *
+ * @CI A typical GitHub Actions wiring:
+ *
+ * ```yaml
+ * env:
+ *   DONOBU_SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+ *   DONOBU_REPORT_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+ * run: npx donobu test --auto-heal
+ * ```
+ *
+ * @auto-heal Per-run delivery semantics
+ *
+ * Every Donobu run produces exactly one Slack POST when a webhook is
+ * configured, regardless of whether auto-heal triggers:
+ * - **No auto-heal configured:** the reporter posts directly during `onEnd`.
+ * - **Auto-heal configured, tests pass:** the reporter defers; the
+ *   orchestrator posts the initial payload after the early-return.
+ * - **Auto-heal configured, no eligible plans:** same — orchestrator posts
+ *   the initial payload via the fallback path.
+ * - **Auto-heal configured, heal runs and merges:** the reporter defers in
+ *   both the initial run and the heal rerun; the orchestrator posts the
+ *   merged payload after re-rendering.
+ */
+import type { FullResult, Reporter, TestCase, TestResult } from '@playwright/test/reporter';
+import { type SlackBlockPayload } from './renderSlack';
+export interface DonobuSlackReporterOptions {
+    /** Path to write the Slack payload. Defaults to `test-results/slack-payload.json`. */
+    outputFile?: string;
+}
+/**
+ * POST a Slack Block Kit payload to an Incoming Webhook URL. Logs failures but
+ * never throws — Slack delivery is a nice-to-have, not a test-run blocker.
+ */
+export declare function postSlackPayload(webhookUrl: string, payload: SlackBlockPayload): Promise<void>;
+export default class DonobuSlackReporter implements Reporter {
+    private readonly options;
+    private readonly resultsByTest;
+    constructor(options?: DonobuSlackReporterOptions);
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(_result: FullResult): Promise<void>;
+    printsToStdio(): boolean;
+}
+//# sourceMappingURL=slack.d.ts.map

package/dist/esm/reporter/slack.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * @fileoverview Donobu Slack Reporter for Playwright.
+ *
+ * Writes a Slack Block Kit payload to disk and, when configured, POSTs it
+ * directly to a Slack Incoming Webhook. During auto-heal the POST is deferred
+ * to the orchestrator so the user sees exactly one message per run reflecting
+ * the final (merged, possibly healed) outcome — not an initial failure
+ * message followed by a healed one.
+ *
+ * @usage
+ * The reporter takes no Slack-related options. All Slack configuration is
+ * driven by environment variables (see below) — typically populated from CI
+ * secrets and contextual run metadata. Wire it up in `playwright.config.ts`
+ * with no arguments:
+ *
+ * ```ts
+ * reporter: [
+ *   ['donobu/reporter/slack'],
+ * ],
+ * ```
+ *
+ * Optionally set `outputFile` to control the on-disk payload path:
+ *
+ * ```ts
+ * reporter: [
+ *   ['donobu/reporter/slack', { outputFile: 'test-results/slack-payload.json' }],
+ * ],
+ * ```
+ *
+ * @env Configuration
+ *
+ * **`DONOBU_SLACK_WEBHOOK_URL`** *(required for posting; secret)* — the Slack
+ * Incoming Webhook URL to POST the payload to. When unset, the reporter still
+ * writes the payload file but performs no network call (the file is then
+ * useful as a CI artifact or for piping to `curl` manually). This is treated
+ * as a secret and is read only from the environment — never as a reporter
+ * option — so it cannot accidentally end up checked into a config file.
+ *
+ * **`DONOBU_REPORT_URL`** *(optional; not secret)* — a URL to embed in the
+ * Slack message that links back to the full report (e.g. the GitHub Actions
+ * run URL, or a published HTML report). When unset, the message simply omits
+ * the link section. Read from the environment for symmetry with the webhook
+ * URL: both come from CI context, and a single configuration story keeps the
+ * mental model simple. To override per-suite, set the env var differently
+ * before invoking `donobu test`.
+ *
+ * **`DONOBU_AUTO_HEAL_ACTIVE`** / **`DONOBU_AUTO_HEAL_ORCHESTRATED`**
+ * *(set internally; not user-facing)* — coordination flags the donobu CLI
+ * sets so the reporter knows when to defer Slack posting to the orchestrator.
+ * Users should never set these themselves.
+ *
+ * @CI A typical GitHub Actions wiring:
+ *
+ * ```yaml
+ * env:
+ *   DONOBU_SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+ *   DONOBU_REPORT_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+ * run: npx donobu test --auto-heal
+ * ```
+ *
+ * @auto-heal Per-run delivery semantics
+ *
+ * Every Donobu run produces exactly one Slack POST when a webhook is
+ * configured, regardless of whether auto-heal triggers:
+ * - **No auto-heal configured:** the reporter posts directly during `onEnd`.
+ * - **Auto-heal configured, tests pass:** the reporter defers; the
+ *   orchestrator posts the initial payload after the early-return.
+ * - **Auto-heal configured, no eligible plans:** same — orchestrator posts
+ *   the initial payload via the fallback path.
+ * - **Auto-heal configured, heal runs and merges:** the reporter defers in
+ *   both the initial run and the heal rerun; the orchestrator posts the
+ *   merged payload after re-rendering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postSlackPayload = postSlackPayload;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const buildReport_1 = require("./buildReport");
+const renderSlack_1 = require("./renderSlack");
+const stateFile_1 = require("./stateFile");
+/**
+ * POST a Slack Block Kit payload to an Incoming Webhook URL. Logs failures but
+ * never throws — Slack delivery is a nice-to-have, not a test-run blocker.
+ */
+async function postSlackPayload(webhookUrl, payload) {
+    try {
+        const response = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            console.error(`Donobu Slack POST returned ${response.status}: ${await response.text().catch(() => '<no body>')}`);
+        }
+    }
+    catch (error) {
+        console.error(`Donobu Slack POST failed: ${error.message ?? error}`);
+    }
+}
+class DonobuSlackReporter {
+    constructor(options = {}) {
+        this.resultsByTest = new Map();
+        this.options = options;
+    }
+    onTestEnd(test, result) {
+        const existing = this.resultsByTest.get(test);
+        if (existing) {
+            existing.push(result);
+        }
+        else {
+            this.resultsByTest.set(test, [result]);
+        }
+    }
+    async onEnd(_result) {
+        const outputFile = (0, path_1.resolve)(this.options.outputFile ?? 'test-results/slack-payload.json');
+        const outputDir = (0, path_1.dirname)(outputFile);
+        const autoHealActive = process.env.DONOBU_AUTO_HEAL_ACTIVE === '1';
+        const autoHealOrchestrated = process.env.DONOBU_AUTO_HEAL_ORCHESTRATED === '1';
+        const reportUrl = process.env.DONOBU_REPORT_URL;
+        const report = (0, buildReport_1.buildDonobuReport)(this.resultsByTest);
+        (0, stateFile_1.mergeStateFileEntry)(process.env.PLAYWRIGHT_JSON_OUTPUT_DIR, report, {
+            slack: { outputFile },
+        });
+        // Payload file is always written — even during a heal rerun — so the
+        // auto-heal orchestrator and any CI artifact upload can see the final state.
+        const payload = (0, renderSlack_1.renderSlack)(report, { reportUrl });
+        (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+        (0, fs_1.writeFileSync)(outputFile, JSON.stringify(payload, null, 2), 'utf8');
+        console.error(`Donobu Slack payload written to ${outputFile}`);
+        // Defer Slack POST to the orchestrator when either:
+        // - this is the auto-heal rerun (orchestrator will re-render and post the
+        //   merged result itself), OR
+        // - the outer `donobu test` invocation enabled auto-heal (orchestrator will
+        //   decide whether to post the pre-heal or merged payload once it knows
+        //   whether auto-heal actually triggered).
+        if (autoHealActive || autoHealOrchestrated) {
+            return;
+        }
+        const webhookUrl = process.env.DONOBU_SLACK_WEBHOOK_URL;
+        if (webhookUrl) {
+            await postSlackPayload(webhookUrl, payload);
+        }
+    }
+    printsToStdio() {
+        return false;
+    }
+}
+exports.default = DonobuSlackReporter;
+//# sourceMappingURL=slack.js.map

package/dist/esm/reporter/stateFile.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Shared state-file helper for Donobu reporters.
+ *
+ * Each Donobu reporter (HTML, Markdown, Slack) records its intended output
+ * path into a single state file that the auto-heal orchestrator reads after
+ * merging two runs, so it can re-render every configured format at the same
+ * path the reporter originally chose.
+ *
+ * When multiple reporters run in the same Playwright process, each one calls
+ * {@link mergeStateFileEntry} in its `onEnd` hook. The helper is
+ * read-modify-write: it loads any previously-written state, merges this
+ * reporter's `donobuOutputs` entry in without clobbering sibling entries, and
+ * writes the result back. Synchronous fs I/O is sufficient — Playwright runs
+ * reporter hooks sequentially within a single JS event loop.
+ */
+import { type DonobuReport, type DonobuReportOutputs } from './model';
+/**
+ * Merge a single reporter's `donobuOutputs` entry into the shared state file.
+ * Safe to call from multiple reporters in the same run — each reporter's
+ * entry is merged alongside any siblings already written.
+ *
+ * @param playwrightOutputDir - the Playwright JSON output dir (passed via
+ *   `PLAYWRIGHT_JSON_OUTPUT_DIR`). When unset, the call is a no-op because
+ *   we have nowhere canonical to land the state file.
+ * @param report - the fresh `DonobuReport` this reporter built from live events.
+ *   Its `suites` overwrite any previous state (they're identical across
+ *   reporters running the same test run, so either is fine).
+ * @param outputsEntry - the format-keyed entry this reporter is contributing.
+ */
+export declare function mergeStateFileEntry(playwrightOutputDir: string | undefined, report: DonobuReport, outputsEntry: DonobuReportOutputs): void;
+//# sourceMappingURL=stateFile.d.ts.map

package/dist/esm/reporter/stateFile.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * @fileoverview Shared state-file helper for Donobu reporters.
+ *
+ * Each Donobu reporter (HTML, Markdown, Slack) records its intended output
+ * path into a single state file that the auto-heal orchestrator reads after
+ * merging two runs, so it can re-render every configured format at the same
+ * path the reporter originally chose.
+ *
+ * When multiple reporters run in the same Playwright process, each one calls
+ * {@link mergeStateFileEntry} in its `onEnd` hook. The helper is
+ * read-modify-write: it loads any previously-written state, merges this
+ * reporter's `donobuOutputs` entry in without clobbering sibling entries, and
+ * writes the result back. Synchronous fs I/O is sufficient — Playwright runs
+ * reporter hooks sequentially within a single JS event loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeStateFileEntry = mergeStateFileEntry;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const model_1 = require("./model");
+/**
+ * Merge a single reporter's `donobuOutputs` entry into the shared state file.
+ * Safe to call from multiple reporters in the same run — each reporter's
+ * entry is merged alongside any siblings already written.
+ *
+ * @param playwrightOutputDir - the Playwright JSON output dir (passed via
+ *   `PLAYWRIGHT_JSON_OUTPUT_DIR`). When unset, the call is a no-op because
+ *   we have nowhere canonical to land the state file.
+ * @param report - the fresh `DonobuReport` this reporter built from live events.
+ *   Its `suites` overwrite any previous state (they're identical across
+ *   reporters running the same test run, so either is fine).
+ * @param outputsEntry - the format-keyed entry this reporter is contributing.
+ */
+function mergeStateFileEntry(playwrightOutputDir, report, outputsEntry) {
+    if (!playwrightOutputDir) {
+        return;
+    }
+    const statePath = (0, path_1.join)(playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME);
+    let existing = null;
+    if ((0, fs_1.existsSync)(statePath)) {
+        try {
+            existing = JSON.parse((0, fs_1.readFileSync)(statePath, 'utf8'));
+        }
+        catch {
+            // Corrupt state file — start fresh rather than failing the reporter.
+        }
+    }
+    const merged = {
+        ...(existing ?? {}),
+        ...report,
+        metadata: {
+            ...(existing?.metadata ?? {}),
+            ...(report.metadata ?? {}),
+            donobuOutputs: {
+                ...(existing?.metadata?.donobuOutputs ?? {}),
+                ...(report.metadata?.donobuOutputs ?? {}),
+                ...outputsEntry,
+            },
+        },
+    };
+    try {
+        (0, fs_1.mkdirSync)(playwrightOutputDir, { recursive: true });
+        (0, fs_1.writeFileSync)(statePath, JSON.stringify(merged), 'utf8');
+    }
+    catch {
+        // Non-fatal — worst case the orchestrator falls back to no re-rendering.
+    }
+}
+//# sourceMappingURL=stateFile.js.map

package/dist/esm/tools/AssertPageTool.d.ts

@@ -4,18 +4,18 @@ import { ToolCallResult } from '../models/ToolCallResult';
 import { Tool } from './Tool';
 export declare const AssertPageCoreSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        content: "content";
         title: "title";
         url: "url";
-        content: "content";
     }>;
     expected: z.ZodString;
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
 export declare const AssertPageToolGptSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        content: "content";
         title: "title";
         url: "url";
-        content: "content";
     }>;
     expected: z.ZodString;
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/esm/utils/MiscUtils.d.ts

@@ -1,6 +1,5 @@
 import z from 'zod/v4';
 import type { GptMessage } from '../models/GptMessage';
-import type { WebTargetConfig } from '../models/RunConfig';
 export declare class MiscUtils {
     private constructor();
     static readonly DONOBU_VERSION: string;
@@ -80,17 +79,5 @@ export declare class MiscUtils {
      * Infers a MIME type from a file ID / filename extension.
      */
     static inferMimeType(fileId: string): string;
-    /**
-     * Mirrors `getDisplayText` from frontend/src/lib/utils.ts.
-     */
-    static getDisplayText(url: string): string;
-    /**
-     * Mirrors the fallback used in frontend FlowsTable for the display name of a
-     * flow, but can also apply to tests.
-     */
-    static getDisplayName({ name, web }: {
-        name: string | null;
-        web?: WebTargetConfig;
-    }, fallbackName?: string): string;
 }
 //# sourceMappingURL=MiscUtils.d.ts.map

package/dist/esm/utils/MiscUtils.js

@@ -268,27 +268,6 @@ class MiscUtils {
                 return 'application/octet-stream';
         }
     }
-    /**
-     * Mirrors `getDisplayText` from frontend/src/lib/utils.ts.
-     */
-    static getDisplayText(url) {
-        try {
-            const parsedUrl = new URL(url);
-            return parsedUrl.protocol === 'file:'
-                ? parsedUrl.pathname.split('/').pop() || url
-                : parsedUrl.hostname;
-        }
-        catch {
-            return url;
-        }
-    }
-    /**
-     * Mirrors the fallback used in frontend FlowsTable for the display name of a
-     * flow, but can also apply to tests.
-     */
-    static getDisplayName({ name, web }, fallbackName = 'Untitled') {
-        return (name ?? MiscUtils.getDisplayText(web?.targetWebsite ?? '') ?? fallbackName);
-    }
 }
 exports.MiscUtils = MiscUtils;
 MiscUtils.DONOBU_VERSION = MiscUtils.getPackageVersion();

package/dist/esm/utils/displayName.d.ts

@@ -0,0 +1,16 @@
+import type { WebTargetConfig } from '../models/RunConfig';
+/**
+ * Mirrors `getDisplayText` from frontend/src/lib/utils.ts. Returns the
+ * hostname for http(s) URLs, the final path segment for file:// URLs, or
+ * the input string unchanged if it can't be parsed as a URL.
+ */
+export declare function getDisplayText(url: string): string;
+/**
+ * Mirrors the fallback used in frontend FlowsTable for the display name of a
+ * flow, but can also apply to tests.
+ */
+export declare function getDisplayName({ name, web }: {
+    name: string | null;
+    web?: WebTargetConfig;
+}, fallbackName?: string): string;
+//# sourceMappingURL=displayName.d.ts.map

package/dist/esm/utils/displayName.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDisplayText = getDisplayText;
+exports.getDisplayName = getDisplayName;
+/**
+ * Mirrors `getDisplayText` from frontend/src/lib/utils.ts. Returns the
+ * hostname for http(s) URLs, the final path segment for file:// URLs, or
+ * the input string unchanged if it can't be parsed as a URL.
+ */
+function getDisplayText(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.protocol === 'file:'
+            ? parsedUrl.pathname.split('/').pop() || url
+            : parsedUrl.hostname;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Mirrors the fallback used in frontend FlowsTable for the display name of a
+ * flow, but can also apply to tests.
+ */
+function getDisplayName({ name, web }, fallbackName = 'Untitled') {
+    return name ?? getDisplayText(web?.targetWebsite ?? '') ?? fallbackName;
+}
+//# sourceMappingURL=displayName.js.map

package/dist/managers/DonobuFlowsManager.js

@@ -52,6 +52,7 @@ const UnknownToolException_1 = require("../exceptions/UnknownToolException");
 const GptConfig_1 = require("../models/GptConfig");
 const resolveTargetRuntime_1 = require("../targets/resolveTargetRuntime");
 const CustomToolRunnerTool_1 = require("../tools/CustomToolRunnerTool");
+const displayName_1 = require("../utils/displayName");
 const FlowLogBuffer_1 = require("../utils/FlowLogBuffer");
 const Logger_1 = require("../utils/Logger");
 const MiscUtils_1 = require("../utils/MiscUtils");
@@ -294,7 +295,7 @@ class DonobuFlowsManager {
     async getFlowAsRerun(flowId, options) {
         const priorFlowMetadata = await this.getFlowById(flowId);
         const toolCallsOnStart = await this.getToolCallsForRerun(priorFlowMetadata, options);
-        return this.getFlowFromConfigAndToolCalls(MiscUtils_1.MiscUtils.getDisplayName(priorFlowMetadata, 'Untitled Flow'), 'DETERMINISTIC', priorFlowMetadata, toolCallsOnStart);
+        return this.getFlowFromConfigAndToolCalls((0, displayName_1.getDisplayName)(priorFlowMetadata, 'Untitled Flow'), 'DETERMINISTIC', priorFlowMetadata, toolCallsOnStart);
     }
     /**
      * Takes a RunConfig object, or anything derived from it (FlowMetadata,

package/dist/managers/TestsManager.js

@@ -4,7 +4,7 @@ exports.TestsManager = void 0;
 const crypto_1 = require("crypto");
 const CannotDeleteRunningFlowException_1 = require("../exceptions/CannotDeleteRunningFlowException");
 const TestNotFoundException_1 = require("../exceptions/TestNotFoundException");
-const MiscUtils_1 = require("../utils/MiscUtils");
+const displayName_1 = require("../utils/displayName");
 const FederatedPagination_1 = require("./FederatedPagination");
 class TestsManager {
     constructor(testsPersistenceRegistry, flowsManager) {
@@ -22,7 +22,7 @@ class TestsManager {
         const testMetadata = {
             id: testId,
             metadataVersion: 1,
-            name: MiscUtils_1.MiscUtils.getDisplayName({ name: params.name ?? null, web }),
+            name: (0, displayName_1.getDisplayName)({ name: params.name ?? null, web }),
             suiteId: params.suiteId ?? null,
             nextRunMode: params.nextRunMode ?? 'AUTONOMOUS',
             target: params.target,

package/dist/models/CreateTest.d.ts

@@ -13,7 +13,6 @@ export declare const CreateTestSchema: z.ZodObject<{
         javascript: z.ZodString;
     }, z.core.$strip>>>>;
     overallObjective: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resultJsonSchema: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     callbackUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     maxToolCalls: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -140,6 +139,7 @@ export declare const CreateTestSchema: z.ZodObject<{
         INSTRUCT: "INSTRUCT";
         DETERMINISTIC: "DETERMINISTIC";
     }>>>;
+    allowedTools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
 }, z.core.$loose>;
 export type CreateTest = z.infer<typeof CreateTestSchema>;
 //# sourceMappingURL=CreateTest.d.ts.map

package/dist/models/CreateTest.js

@@ -36,6 +36,12 @@ exports.CreateTestSchema = RunConfig_1.RunConfigSchema.partial()
     nextRunMode: RunMode_1.RunModeSchema.nullable()
         .optional()
         .describe('The run mode to use when creating flows from this test. Defaults to AUTONOMOUS.'),
+    // `allowedTools` is the only field in RunConfig that isn't already
+    // nullable at the base, so `.partial()` above only adds `.optional()`
+    // (accepts `undefined`, not `null`). Manual-test creation sends `null`
+    // here — mirror the nullable override that CreateDonobuFlowSchema uses
+    // so the two creation endpoints accept the same payload shape.
+    allowedTools: RunConfig_1.RunConfigSchema.shape.allowedTools.nullable().optional(),
 })
     .loose();
 //# sourceMappingURL=CreateTest.js.map