donobu 5.23.0 → 5.24.0

package/dist/esm/managers/DonobuFlowsManager.js

@@ -159,11 +159,13 @@ class DonobuFlowsManager {
                 const allowedEnvVarsByName = distillAllowedEnvVariableNames(flowParams.overallObjective, flowParams.envVars);
                 const flowMetadata = {
                     id: flowId,
+                    target: flowParams.target,
                     metadataVersion: 1,
                     createdWithDonobuVersion: MiscUtils_1.MiscUtils.DONOBU_VERSION,
                     name: flowParams.name || null,
                     envVars: allowedEnvVarsByName,
                     runMode: initialRunMode,
+                    isControlPanelEnabled: flowParams.isControlPanelEnabled ?? true,
                     gptConfigName: gptClientData.gptConfigName,
                     hasGptConfigNameOverride: !gptClientData.agentName,
                     customTools: flowParams.customTools ?? null,
@@ -181,6 +183,7 @@ class DonobuFlowsManager {
                     state: 'UNSTARTED',
                     nextState: null,
                     videoDisabled: flowParams.videoDisabled,
+                    testId: flowParams.testId ?? null,
                     // Target-specific fields (browser, targetWebsite, isControlPanelEnabled, etc.)
                     ...targetRuntime.getMetadataFields(),
                 };
@@ -277,45 +280,73 @@ class DonobuFlowsManager {
         throw FlowNotFoundException_1.FlowNotFoundException.forId(flowId);
     }
     /**
-     * Loads the given flow by ID and returns a `CreateDonobuFlow` object that can be passed to `createFlow`
-     * as to execute the flow as a rerun (i.e. without agentic decisioning).
+     * Converts a prior flow's tool calls into a list of tool calls to invoke when
+     * starting a new flow as a rerun (i.e. without agentic decisioning).
      *
-     * @param flowId The ID of the flow to prepare as a rerun.
-     * @returns Parameters that can be passed to createFlow to execute the flow as a rerun.
+     * @param priorFlowMetadata The metadata of the flow to prepare as a rerun.
+     * @param options           The code generation options to use for the rerun.
+     *
+     * @returns A list of tool calls to invoke when starting the flow.
      */
-    async getFlowAsRerun(flowId, options) {
-        const priorFlowMetadata = await this.getFlowById(flowId);
-        const originalToolCalls = await this.getToolCalls(flowId);
+    async getToolCallsForRerun(priorFlowMetadata, options) {
+        const originalToolCalls = await this.getToolCalls(priorFlowMetadata.id);
         // Delegate tool call preparation to the target runtime plugin so that
         // rerun logic is fully target-agnostic.
         const plugin = this.targetRuntimePlugins.get(priorFlowMetadata.target);
-        const toolCallsOnStart = plugin
+        return plugin
             ? await plugin.prepareToolCallsForRerun(originalToolCalls, options)
             : await prepareToolCallsForRerun(originalToolCalls, options);
-        const allowedTools = priorFlowMetadata.allowedTools ?? [];
-        // Build target-specific config from the prior flow metadata.
+    }
+    /**
+     * Loads the given flow by ID and returns a `CreateDonobuFlow` object that can be passed to `createFlow`
+     * to execute the flow as a rerun (i.e. without agentic decisioning).
+     *
+     * @param flowId The ID of the flow to prepare as a rerun.
+     * @returns Parameters that can be passed to createFlow to execute the flow as a rerun.
+     */
+    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);
+    }
+    /**
+     * Takes a RunConfig object, or anything derived from it (FlowMetadata,
+     * TestMetadata), plus some additional parameters, and returns a
+     * CreateDonobuFlow object that can be passed to `createFlow` to execute the
+     * flow.
+     *
+     * @param name             The name for the new flow
+     * @param runMode          The run mode to be used for the flow
+     * @param config           The RunConfig object
+     * @param toolCallsOnStart An ordered series of tool calls to invoke when
+     *                         starting the flow
+     *
+     * @returns A CreateDonobuFlow object that can be passed to createFlow to
+     * execute the flow.
+     */
+    getFlowFromConfigAndToolCalls(name, runMode, config, toolCallsOnStart) {
+        // Build target-specific config from the config object.
         const targetConfig = {};
-        const targetKey = priorFlowMetadata.target;
-        if (targetKey && targetKey in priorFlowMetadata) {
-            targetConfig[targetKey] = priorFlowMetadata[targetKey];
+        const targetKey = config.target;
+        if (targetKey && targetKey in config) {
+            targetConfig[targetKey] = config[targetKey];
         }
         return {
-            target: priorFlowMetadata.target,
+            target: config.target,
             ...targetConfig,
-            overallObjective: priorFlowMetadata.overallObjective ?? undefined,
-            name: priorFlowMetadata.name ?? undefined,
-            callbackUrl: priorFlowMetadata.callbackUrl ?? undefined,
-            customTools: priorFlowMetadata.customTools ?? undefined,
-            maxToolCalls: priorFlowMetadata.maxToolCalls,
-            gptConfigNameOverride: priorFlowMetadata.gptConfigName ?? undefined,
-            defaultMessageDuration: 0,
-            initialRunMode: 'DETERMINISTIC',
-            isControlPanelEnabled: false,
-            allowedTools: allowedTools,
-            toolCallsOnStart: toolCallsOnStart,
-            envVars: priorFlowMetadata.envVars ?? undefined,
-            resultJsonSchema: priorFlowMetadata.resultJsonSchema ?? undefined,
-            videoDisabled: priorFlowMetadata.videoDisabled,
+            overallObjective: config.overallObjective ?? undefined,
+            name,
+            callbackUrl: config.callbackUrl ?? undefined,
+            customTools: config.customTools ?? undefined,
+            maxToolCalls: config.maxToolCalls,
+            defaultMessageDuration: runMode === 'DETERMINISTIC' ? 1000 : undefined,
+            initialRunMode: runMode,
+            isControlPanelEnabled: true,
+            allowedTools: config.allowedTools ?? [],
+            toolCallsOnStart,
+            envVars: config.envVars ?? undefined,
+            resultJsonSchema: config.resultJsonSchema ?? undefined,
+            videoDisabled: config.videoDisabled,
         };
     }
     /** Add a proposed tool call the tool call queue for the given flow by ID. */
@@ -605,6 +636,21 @@ class DonobuFlowsManager {
             case 'name':
                 flowMetadata = await this.getFlowByName(browserStateRef.value);
                 break;
+            case 'testId': {
+                // Resolve the test ID to its most recent successful flow.
+                const { items } = await this.getFlows({
+                    testId: browserStateRef.value,
+                    state: 'SUCCESS',
+                    sortBy: 'created_at',
+                    sortOrder: 'desc',
+                    limit: 1,
+                });
+                if (items.length === 0) {
+                    throw new BrowserStateNotFoundException_1.BrowserStateNotFoundException(`test:${browserStateRef.value}`);
+                }
+                flowMetadata = items[0];
+                break;
+            }
             case 'json':
                 return browserStateRef.value;
             default:

package/dist/esm/managers/DonobuStack.js

@@ -50,7 +50,7 @@ async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory
     const envDataManager = new EnvDataManager_1.EnvDataManager(envPersistenceFactory);
     const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, resolvedToolRegistry, targetRuntimePlugins);
     const testsPersistenceRegistry = await TestsPersistenceRegistry_1.TestsPersistenceRegistryImpl.fromEnvironment(environ);
-    const testsManager = new TestsManager_1.TestsManager(testsPersistenceRegistry, flowsPersistenceRegistry);
+    const testsManager = new TestsManager_1.TestsManager(testsPersistenceRegistry, flowsManager);
     const suitesPersistenceRegistry = await SuitesPersistenceRegistry_1.SuitesPersistenceRegistryImpl.fromEnvironment(environ);
     const suitesManager = new SuitesManager_1.SuitesManager(suitesPersistenceRegistry, testsPersistenceRegistry);
     return {

package/dist/esm/managers/FederatedPagination.js

@@ -33,6 +33,7 @@ async function federatedList(layers, query, comparator) {
     const paginationState = parseCompositePageToken(query.pageToken);
     const requestedLimit = Math.min(Math.max(1, query.limit ?? 100), 100);
     const combinedResults = [];
+    let layersThatReturnedResults = 0;
     for (let i = 0; i < layers.length; i++) {
         if (paginationState.exhaustedSources.includes(i)) {
             continue;
@@ -44,6 +45,9 @@ async function federatedList(layers, query, comparator) {
             pageToken: paginationState.sourceTokens[i],
         };
         const sourceResult = await layers[i].getItems(sourceQuery);
+        if (sourceResult.items.length > 0) {
+            layersThatReturnedResults++;
+        }
         combinedResults.push(...sourceResult.items);
         if (sourceResult.nextPageToken) {
             paginationState.sourceTokens[i] = sourceResult.nextPageToken;
@@ -52,7 +56,12 @@ async function federatedList(layers, query, comparator) {
             paginationState.exhaustedSources.push(i);
         }
     }
-    combinedResults.sort(comparator);
+    // Only re-sort when results came from multiple layers; a single layer's
+    // results are already in the order it returned them, and re-sorting can
+    // disturb fields the comparator can't fully account for.
+    if (layersThatReturnedResults > 1) {
+        combinedResults.sort(comparator);
+    }
     const limitedResults = combinedResults.slice(0, requestedLimit);
     const hasMore = combinedResults.length > requestedLimit ||
         paginationState.exhaustedSources.length < layers.length;

package/dist/esm/managers/FlowCatalog.js

@@ -113,47 +113,39 @@ class FlowCatalog {
         return null;
     }
     async getFlows(query) {
-        const paginationState = (0, FederatedPagination_1.parseCompositePageToken)(query.pageToken);
-        const requestedLimit = Math.min(Math.max(1, query.limit || 100), 100);
-        const combinedResults = [];
-        const persistenceLayers = await this.flowsPersistenceRegistry.getAll();
-        for (let i = 0; i < persistenceLayers.length; i++) {
-            if (paginationState.exhaustedSources.includes(i)) {
-                continue;
-            }
-            const sourceLimit = Math.min(requestedLimit * 2, 100);
-            const sourceQuery = {
-                ...query,
-                limit: sourceLimit,
-                pageToken: paginationState.sourceTokens[i],
-            };
-            const sourceResult = await persistenceLayers[i].getFlowsMetadata(sourceQuery);
-            const itemsWithSource = sourceResult.items.map((flow) => ({
-                flow,
-                sourceIndex: i,
-            }));
-            combinedResults.push(...itemsWithSource);
-            if (sourceResult.nextPageToken) {
-                paginationState.sourceTokens[i] = sourceResult.nextPageToken;
-            }
-            else {
-                paginationState.exhaustedSources.push(i);
+        const layers = (await this.flowsPersistenceRegistry.getAll()).map((persistence) => ({
+            getItems: (q) => persistence.getFlowsMetadata(q),
+        }));
+        const sortBy = query.sortBy ?? 'created_at';
+        const desc = (query.sortOrder ?? 'desc') === 'desc';
+        // For `created_at` we don't have a real field on FlowMetadata; use
+        // `startedAt` as a close-enough proxy, falling back to "now" when
+        // null so unstarted flows sort to the most-recent end.
+        const fieldFor = (flow) => {
+            switch (sortBy) {
+                case 'created_at':
+                    return flow.startedAt ?? Date.now();
+                case 'name':
+                    return flow.name ?? '';
+                case 'run_mode':
+                    return flow.runMode;
+                case 'state':
+                    return flow.state;
+                default:
+                    return '';
             }
-        }
-        combinedResults.sort((a, b) => (b.flow.startedAt || 0) - (a.flow.startedAt || 0));
-        const limitedResults = combinedResults.slice(0, requestedLimit);
-        const lastTimestamp = limitedResults.length > 0
-            ? limitedResults[limitedResults.length - 1].flow.startedAt
-            : null;
-        paginationState.cursorTimestamp = lastTimestamp;
-        const hasMore = combinedResults.length > requestedLimit ||
-            paginationState.exhaustedSources.length < persistenceLayers.length;
-        return {
-            items: limitedResults.map((item) => item.flow),
-            nextPageToken: hasMore
-                ? (0, FederatedPagination_1.createCompositePageToken)(paginationState)
-                : undefined,
         };
+        return (0, FederatedPagination_1.federatedList)(layers, query, (a, b) => {
+            const aKey = fieldFor(a);
+            const bKey = fieldFor(b);
+            if (aKey < bKey) {
+                return desc ? 1 : -1;
+            }
+            if (aKey > bKey) {
+                return desc ? -1 : 1;
+            }
+            return 0;
+        });
     }
     isLocal() {
         return this.deploymentEnvironment === 'LOCAL';

package/dist/esm/managers/FlowDependencyAnalyzer.js

@@ -83,6 +83,18 @@ class FlowDependencyAnalyzer {
                     return [flowId];
                 }
                 throw new Error(`Flow dependency not found: flow with name "${initialState.value}" does not exist`);
+            case 'testId': {
+                // Resolve the test ID to its most recent successful flow within the
+                // input set. Ordering matches DonobuFlowsManager.getBrowserStorageState,
+                // which sorts SUCCESS flows by startedAt desc.
+                const candidates = [...flowsMap.values()]
+                    .filter((f) => f.testId === initialState.value && f.state === 'SUCCESS')
+                    .sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
+                if (candidates.length > 0) {
+                    return [candidates[0].id];
+                }
+                throw new Error(`Flow dependency not found: no successful flow exists for test "${initialState.value}"`);
+            }
             case 'json':
                 // Direct JSON state - no dependencies
                 return [];

package/dist/esm/managers/SuitesManager.js

@@ -53,13 +53,30 @@ class SuitesManager {
         const layers = (await this.suitesPersistenceRegistry.getAll()).map((persistence) => ({
             getItems: (q) => persistence.getSuites(q),
         }));
-        const sortAsc = query.sortOrder === 'asc';
-        const sortCol = query.sortBy ?? 'created_at';
+        const sortBy = query.sortBy ?? 'created_at';
+        const desc = (query.sortOrder ?? 'desc') === 'desc';
+        // SuiteMetadata has no `created_at` field — fall back to "now" so newly
+        // returned items sort to the most-recent end.
+        const fieldFor = (suite) => {
+            switch (sortBy) {
+                case 'created_at':
+                    return Date.now();
+                case 'name':
+                    return suite.name ?? '';
+                default:
+                    return '';
+            }
+        };
         return (0, FederatedPagination_1.federatedList)(layers, query, (a, b) => {
-            const aVal = String(a[sortCol] ?? '');
-            const bVal = String(b[sortCol] ?? '');
-            const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-            return sortAsc ? cmp : -cmp;
+            const aKey = fieldFor(a);
+            const bKey = fieldFor(b);
+            if (aKey < bKey) {
+                return desc ? 1 : -1;
+            }
+            if (aKey > bKey) {
+                return desc ? -1 : 1;
+            }
+            return 0;
         });
     }
     /**

package/dist/esm/managers/TestsManager.d.ts

@@ -1,12 +1,13 @@
+import type { CreateDonobuFlow } from '../models/CreateDonobuFlow';
 import type { CreateTest } from '../models/CreateTest';
 import type { PaginatedResult } from '../models/PaginatedResult';
 import type { TestMetadata, TestsQuery } from '../models/TestMetadata';
-import type { FlowsPersistenceRegistry } from '../persistence/flows/FlowsPersistenceRegistry';
 import type { TestsPersistenceRegistry } from '../persistence/tests/TestsPersistenceRegistry';
+import type { DonobuFlowsManager } from './DonobuFlowsManager';
 export declare class TestsManager {
     private readonly testsPersistenceRegistry;
-    private readonly flowsPersistenceRegistry;
-    constructor(testsPersistenceRegistry: TestsPersistenceRegistry, flowsPersistenceRegistry: FlowsPersistenceRegistry);
+    private readonly flowsManager;
+    constructor(testsPersistenceRegistry: TestsPersistenceRegistry, flowsManager: DonobuFlowsManager);
     createTest(params: CreateTest): Promise<TestMetadata>;
     getTestById(testId: string): Promise<TestMetadata>;
     getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
@@ -24,5 +25,25 @@ export declare class TestsManager {
      * layers (Volatile, S3, GCS).
      */
     deleteTest(testId: string): Promise<void>;
+    /**
+     * Gets the list of tool calls to invoke when starting a new flow for the
+     * given test, based on the most recent successful flow for the test.
+     *
+     * @param test - The test to get the tool calls for
+     *
+     * @returns      The tool calls to use when executing the test
+     *
+     * @throws {Error} if no previous successful flow is found
+     */
+    private getTestToolCalls;
+    /**
+     * Creates a new flow (config) for the given test, which should be passed to
+     * `flowsManager.createFlow` to execute the test.
+     *
+     * @param testId - The ID of the test to create a new flow for
+     *
+     * @returns        A new flow configuration
+     */
+    getNewFlowFromTest(testId: string): Promise<CreateDonobuFlow>;
 }
 //# sourceMappingURL=TestsManager.d.ts.map

package/dist/esm/managers/TestsManager.js

@@ -2,28 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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 FederatedPagination_1 = require("./FederatedPagination");
 class TestsManager {
-    constructor(testsPersistenceRegistry, flowsPersistenceRegistry) {
+    constructor(testsPersistenceRegistry, flowsManager) {
         this.testsPersistenceRegistry = testsPersistenceRegistry;
-        this.flowsPersistenceRegistry = flowsPersistenceRegistry;
+        this.flowsManager = flowsManager;
     }
     async createTest(params) {
         const testId = (0, crypto_1.randomUUID)();
+        const web = params.web
+            ? {
+                browser: params.web.browser ?? { using: { type: 'device' } },
+                targetWebsite: params.web.targetWebsite,
+            }
+            : undefined;
         const testMetadata = {
             id: testId,
             metadataVersion: 1,
-            name: params.name ?? null,
+            name: MiscUtils_1.MiscUtils.getDisplayName({ name: params.name ?? null, web }),
             suiteId: params.suiteId ?? null,
             nextRunMode: params.nextRunMode ?? 'AUTONOMOUS',
             target: params.target,
-            web: params.web
-                ? {
-                    browser: params.web.browser ?? { using: { type: 'device' } },
-                    targetWebsite: params.web.targetWebsite,
-                }
-                : undefined,
+            web,
             envVars: params.envVars ?? null,
             customTools: params.customTools ?? null,
             overallObjective: params.overallObjective ?? null,
@@ -55,13 +58,35 @@ class TestsManager {
         const layers = (await this.testsPersistenceRegistry.getAll()).map((persistence) => ({
             getItems: (q) => persistence.getTests(q),
         }));
-        const sortAsc = query.sortOrder === 'asc';
-        const sortCol = query.sortBy ?? 'created_at';
+        const sortBy = query.sortBy ?? 'created_at';
+        const desc = (query.sortOrder ?? 'desc') === 'desc';
+        // TestMetadata has no `created_at` field — fall back to "now" so newly
+        // returned items sort to the most-recent end. For other sort columns,
+        // map the snake_case API name to the camelCase JS field.
+        const fieldFor = (test) => {
+            switch (sortBy) {
+                case 'created_at':
+                    return Date.now();
+                case 'name':
+                    return test.name ?? '';
+                case 'suite_id':
+                    return test.suiteId ?? '';
+                case 'next_run_mode':
+                    return test.nextRunMode;
+                default:
+                    return '';
+            }
+        };
         return (0, FederatedPagination_1.federatedList)(layers, query, (a, b) => {
-            const aVal = String(a[sortCol] ?? '');
-            const bVal = String(b[sortCol] ?? '');
-            const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-            return sortAsc ? cmp : -cmp;
+            const aKey = fieldFor(a);
+            const bKey = fieldFor(b);
+            if (aKey < bKey) {
+                return desc ? 1 : -1;
+            }
+            if (aKey > bKey) {
+                return desc ? -1 : 1;
+            }
+            return 0;
         });
     }
     /**
@@ -91,25 +116,95 @@ class TestsManager {
      * layers (Volatile, S3, GCS).
      */
     async deleteTest(testId) {
-        const testLayers = await this.testsPersistenceRegistry.getAll();
-        const flowLayers = await this.flowsPersistenceRegistry.getAll();
-        for (let i = 0; i < testLayers.length; i++) {
+        for (const persistence of await this.testsPersistenceRegistry.getAll()) {
             try {
-                await testLayers[i].deleteTest(testId);
-                // Cascade-delete flows in this layer after successfully deleting
-                // the test. This mirrors the DB-level ON DELETE CASCADE for
-                // non-DB layers.
-                const flowsResult = await flowLayers[i].getFlowsMetadata({
-                    testId,
-                });
-                for (const flow of flowsResult.items) {
-                    await flowLayers[i].deleteFlow(flow.id);
-                }
+                await persistence.deleteTest(testId);
             }
             catch {
                 // Ignore errors from layers that don't have this test.
             }
         }
+        // Cascade-delete flows belonging to this test. Paginate through all flows
+        // since `getFlows` caps each page at 100.
+        const flowsNotDeleted = [];
+        let pageToken = undefined;
+        do {
+            const { items, nextPageToken } = await this.flowsManager.getFlows({
+                testId,
+                pageToken,
+            });
+            for (const flow of items) {
+                try {
+                    await this.flowsManager.deleteFlowById(flow.id);
+                }
+                catch (error) {
+                    if (!(error instanceof CannotDeleteRunningFlowException_1.CannotDeleteRunningFlowException)) {
+                        throw error;
+                    }
+                    flowsNotDeleted.push(flow);
+                }
+            }
+            pageToken = nextPageToken;
+        } while (pageToken);
+        if (flowsNotDeleted.length > 0) {
+            // TODO: Just warn here? There will be orphaned flows.
+            console.warn(`Failed to delete ${flowsNotDeleted.length} flows belonging to test ${testId}: ${flowsNotDeleted.map((f) => f.id).join(', ')}`);
+        }
+    }
+    /**
+     * Gets the list of tool calls to invoke when starting a new flow for the
+     * given test, based on the most recent successful flow for the test.
+     *
+     * @param test - The test to get the tool calls for
+     *
+     * @returns      The tool calls to use when executing the test
+     *
+     * @throws {Error} if no previous successful flow is found
+     */
+    async getTestToolCalls(test) {
+        let previousSuccesfulFlow = undefined;
+        let pageToken = undefined;
+        while (!previousSuccesfulFlow) {
+            const { items: previousFlows, nextPageToken } = await this.flowsManager.getFlows({
+                testId: test.id,
+                sortBy: 'created_at',
+                sortOrder: 'desc',
+                pageToken,
+            });
+            previousSuccesfulFlow = previousFlows.find((f) => f.state === 'SUCCESS');
+            if (!previousSuccesfulFlow && !nextPageToken) {
+                throw new Error(`No previous successful flow found for test ${test.id}`);
+            }
+            pageToken = nextPageToken;
+        }
+        return this.flowsManager.getToolCallsForRerun(previousSuccesfulFlow, {
+            areElementIdsVolatile: false,
+            disableSelectorFailover: false,
+        });
+    }
+    /**
+     * Creates a new flow (config) for the given test, which should be passed to
+     * `flowsManager.createFlow` to execute the test.
+     *
+     * @param testId - The ID of the test to create a new flow for
+     *
+     * @returns        A new flow configuration
+     */
+    async getNewFlowFromTest(testId) {
+        const test = await this.getTestById(testId);
+        let toolCallsOnStart = [];
+        let runMode = test.nextRunMode;
+        if (runMode === 'DETERMINISTIC') {
+            try {
+                toolCallsOnStart = await this.getTestToolCalls(test);
+            }
+            catch {
+                runMode = 'AUTONOMOUS';
+            }
+        }
+        const newFlowConfig = this.flowsManager.getFlowFromConfigAndToolCalls(test.name ?? `Flow for test ${test.id}`, runMode, test, toolCallsOnStart);
+        newFlowConfig.testId = test.id;
+        return newFlowConfig;
     }
 }
 exports.TestsManager = TestsManager;

package/dist/esm/models/BrowserConfig.d.ts

@@ -46,6 +46,9 @@ export declare const BrowserConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"name">;
         value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"testId">;
+        value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"json">;
         value: z.ZodObject<{

package/dist/esm/models/BrowserStateFlowReference.d.ts

@@ -5,6 +5,9 @@ export declare const BrowserStateReferenceSchema: z.ZodDiscriminatedUnion<[z.Zod
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"name">;
     value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"testId">;
+    value: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"json">;
     value: z.ZodObject<{

package/dist/esm/models/BrowserStateFlowReference.js

@@ -8,11 +8,22 @@ exports.BrowserStateReferenceSchema = v4_1.z
     .discriminatedUnion('type', [
     v4_1.z.object({
         type: v4_1.z.literal('id'),
-        value: v4_1.z.string(),
+        value: v4_1.z
+            .string()
+            .describe('A specific flow ID to restore browser state from.'),
     }),
     v4_1.z.object({
         type: v4_1.z.literal('name'),
-        value: v4_1.z.string(),
+        value: v4_1.z
+            .string()
+            .describe('The name of a flow to restore browser state from.'),
+    }),
+    v4_1.z.object({
+        type: v4_1.z.literal('testId'),
+        value: v4_1.z
+            .string()
+            .describe('A test ID. The browser state will be restored from the most ' +
+            'recent successful flow belonging to this test.'),
     }),
     v4_1.z.object({
         type: v4_1.z.literal('json'),

package/dist/esm/models/CreateDonobuFlow.d.ts

@@ -9,6 +9,9 @@ export declare const CreateDonobuFlowSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"name">;
                 value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"testId">;
+                value: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"json">;
                 value: z.ZodObject<{
@@ -139,6 +142,7 @@ export declare const CreateDonobuFlowSchema: z.ZodObject<{
         parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         toolCallId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>>>>;
+    testId: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type CreateDonobuFlow = z.infer<typeof CreateDonobuFlowSchema>;
 //# sourceMappingURL=CreateDonobuFlow.d.ts.map

package/dist/esm/models/CreateDonobuFlow.js

@@ -64,6 +64,10 @@ is not defined or unresolvable, the default flow agent configuration will be use
         .nullable()
         .optional()
         .describe('An ordered series of tool calls to invoke when starting the flow'),
+    testId: v4_1.z
+        .string()
+        .optional()
+        .describe('The ID of the test that this flow is associated with. Only optional to support legacy flow creation scenarios.'),
 })
     .passthrough()
     .describe('This is the expected payload for a request to create a new Donobu flow');

package/dist/esm/models/CreateSuite.d.ts

@@ -28,6 +28,9 @@ export declare const CreateSuiteSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"name">;
                 value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"testId">;
+                value: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"json">;
                 value: z.ZodObject<{