donobu 5.56.0 → 5.57.0

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

@@ -1,7 +1,11 @@
 import type { InteractionTrackingHost } from '../bindings/PageInteractionTracker';
+import type { ToolOption } from '../clients/GptClient';
 import type { FlowMetadata } from '../models/FlowMetadata';
 import type { FocusedTarget } from '../models/FocusedTarget';
+import type { GptMessage, ProposedToolCallsMessage } from '../models/GptMessage';
 import type { InteractableElement } from '../models/InteractableElement';
+import type { ProposedToolCall } from '../models/ProposedToolCall';
+import type { ToolCall } from '../models/ToolCall';
 import type { FlowsPersistence } from '../persistence/flows/FlowsPersistence';
 /**
  * Abstraction over screen/page inspection for LLM-driven flows.
@@ -91,13 +95,6 @@ export interface TargetInspectorBase {
      * Returns a fallback string if the target is disconnected.
      */
     getCurrentLocation(): string;
-    /**
-     * Platform-specific text fragments used when constructing LLM prompts.
-     *
-     * Returning a single object avoids scattering many one-liner methods
-     * across every inspector implementation.
-     */
-    getPlatformPromptInfo(): PlatformPromptInfo;
     /**
      * Context description for the LLM user message (e.g. browser tabs list
      * for web, or a generic description for mobile).
@@ -121,25 +118,6 @@ export interface TargetInspectorBase {
      */
     persistSessionState(persistence: FlowsPersistence, flowId: string): Promise<void>;
 }
-/**
- * Platform-specific text fragments for LLM prompt construction.
- *
- * Each inspector implementation returns a static instance of this.
- */
-export interface PlatformPromptInfo {
-    /** Opening paragraph(s) of the LLM system message. */
-    readonly systemPreamble: string;
-    /** e.g. "a webpage" or "a mobile app screen" — used after "two images of". */
-    readonly screenshotSubject: string;
-    /** e.g. "web page (i.e. the current viewport)" or "mobile app screen". */
-    readonly currentViewDescription: string;
-    /** e.g. "viewport of the web page" or "mobile app screen". */
-    readonly annotatedViewDescription: string;
-    /** e.g. "website" or "mobile app" — used in "interact with the {x}". */
-    readonly interactionTarget: string;
-    /** e.g. "webpage" or "app" — short noun for the target. */
-    readonly targetNoun: string;
-}
 /**
  * Callbacks provided by the flow engine during {@link TargetInspectorBase.initialize}.
  *
@@ -150,15 +128,15 @@ export interface TargetInitCallbacks {
     /** Flow metadata (mutable reference — used to read `runMode` etc.). */
     readonly metadata: FlowMetadata;
     /**
-     * Handler for platform dialog events (e.g. browser alert/confirm/prompt).
+     * Flow-engine collaborators a provider needs to handle platform dialog
+     * events (e.g. browser alert/confirm/prompt). The provider owns the dialog
+     * handling logic and wires it to its own platform event; this shim gives it
+     * the narrow slice of engine state it needs, without depending on
+     * `DonobuFlow` directly (same inversion as {@link InteractionTrackingHost}).
      *
-     * The inspector wires this to the appropriate platform event. The parameter
-     * is the platform-specific dialog object (e.g. Playwright `Dialog`), typed
-     * as `unknown` to keep this interface platform-agnostic.
-     *
-     * Only used by web targets. Mobile targets ignore this.
+     * Only consumed by web targets. Other targets ignore it.
      */
-    readonly dialogHandler?: (dialog: unknown) => Promise<void>;
+    readonly dialogHost?: DialogHost;
     /**
      * Flow-engine state needed for interaction tracking registration.
      *
@@ -169,6 +147,23 @@ export interface TargetInitCallbacks {
      */
     readonly interactionTrackingHost?: InteractionTrackingHost;
 }
+/**
+ * Narrow view of the flow engine that a provider's dialog handler needs.
+ * `DonobuFlow` structurally satisfies this. All array/metadata members are
+ * live references the handler may read and mutate (e.g. shifting a queued
+ * tool call, flipping `metadata.state`).
+ */
+export interface DialogHost {
+    readonly proposedToolCalls: ProposedToolCall[];
+    readonly invokedToolCalls: ToolCall[];
+    readonly gptMessages: GptMessage[];
+    readonly metadata: FlowMetadata;
+    readonly persistence: FlowsPersistence;
+    /** Query the LLM with a one-off tool set (used to decide a dialog response). */
+    queryGpt(messages: GptMessage[], tools: ToolOption[]): Promise<ProposedToolCallsMessage>;
+    /** Size-optimize the message history before a one-off query. */
+    optimizeHistory(history: GptMessage[]): GptMessage[];
+}
 /**
  * Union of all target inspector implementations.
  *

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

@@ -12,20 +12,6 @@ export declare class TestsManager {
     constructor(testsPersistenceRegistry: TestsPersistenceRegistry, suitesPersistenceRegistry: SuitesPersistenceRegistry, flowsManager: DonobuFlowsManager);
     createTest(params: CreateTest): Promise<TestMetadata>;
     getTestById(testId: string): Promise<TestMetadata>;
-    /**
-     * Picks the tests persistence layer to use when creating a new test.
-     *
-     * - If `suiteId` is null/undefined: use the primary tests layer.
-     * - If `suiteId` is set: look up the suite's layer key and use the matching
-     *   tests layer. If no tests layer matches the suite's key (rare — would
-     *   require asymmetric registry config), fall back to the primary tests
-     *   layer; the FK won't hold but at least the test is persisted somewhere.
-     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
-     *   to the primary tests layer (the SQLite FK will reject if applicable;
-     *   non-DB layers will accept the dangling reference).
-     */
-    private resolveLayerForTestCreate;
-    private findSuiteLayerKey;
     getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     /**
      * Update a test in the persistence layer where it exists.
@@ -41,17 +27,6 @@ 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. The returned config's
@@ -63,5 +38,30 @@ export declare class TestsManager {
      * @returns        A new flow configuration
      */
     getNewFlowFromTest(testId: string): Promise<CreateDonobuFlow>;
+    /**
+     * Picks the tests persistence layer to use when creating a new test.
+     *
+     * - If `suiteId` is null/undefined: use the primary tests layer.
+     * - If `suiteId` is set: look up the suite's layer key and use the matching
+     *   tests layer. If no tests layer matches the suite's key (rare — would
+     *   require asymmetric registry config), fall back to the primary tests
+     *   layer; the FK won't hold but at least the test is persisted somewhere.
+     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
+     *   to the primary tests layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    private resolveLayerForTestCreate;
+    private findSuiteLayerKey;
+    /**
+     * 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;
 }
 //# sourceMappingURL=TestsManager.d.ts.map

package/dist/esm/managers/TestsManager.js

@@ -63,49 +63,6 @@ class TestsManager {
         }
         throw TestNotFoundException_1.TestNotFoundException.forId(testId);
     }
-    /**
-     * Picks the tests persistence layer to use when creating a new test.
-     *
-     * - If `suiteId` is null/undefined: use the primary tests layer.
-     * - If `suiteId` is set: look up the suite's layer key and use the matching
-     *   tests layer. If no tests layer matches the suite's key (rare — would
-     *   require asymmetric registry config), fall back to the primary tests
-     *   layer; the FK won't hold but at least the test is persisted somewhere.
-     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
-     *   to the primary tests layer (the SQLite FK will reject if applicable;
-     *   non-DB layers will accept the dangling reference).
-     */
-    async resolveLayerForTestCreate(suiteId) {
-        if (!suiteId) {
-            return this.testsPersistenceRegistry.get();
-        }
-        let suiteLayerKey;
-        try {
-            suiteLayerKey = await this.findSuiteLayerKey(suiteId);
-        }
-        catch (error) {
-            if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
-                throw error;
-            }
-            return this.testsPersistenceRegistry.get();
-        }
-        const matched = await this.testsPersistenceRegistry.getByKey(suiteLayerKey);
-        return matched ?? (await this.testsPersistenceRegistry.get());
-    }
-    async findSuiteLayerKey(suiteId) {
-        for (const { key, persistence, } of await this.suitesPersistenceRegistry.getEntries()) {
-            try {
-                await persistence.getSuiteById(suiteId);
-                return key;
-            }
-            catch (error) {
-                if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
-                    throw error;
-                }
-            }
-        }
-        throw SuiteNotFoundException_1.SuiteNotFoundException.forId(suiteId);
-    }
     async getTests(query) {
         const layers = (await this.testsPersistenceRegistry.getAll()).map((persistence) => ({
             getItems: (q) => persistence.getTests(q),
@@ -210,37 +167,6 @@ class TestsManager {
             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. The returned config's
@@ -276,6 +202,80 @@ class TestsManager {
         newFlowConfig.testId = test.id;
         return newFlowConfig;
     }
+    /**
+     * Picks the tests persistence layer to use when creating a new test.
+     *
+     * - If `suiteId` is null/undefined: use the primary tests layer.
+     * - If `suiteId` is set: look up the suite's layer key and use the matching
+     *   tests layer. If no tests layer matches the suite's key (rare — would
+     *   require asymmetric registry config), fall back to the primary tests
+     *   layer; the FK won't hold but at least the test is persisted somewhere.
+     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
+     *   to the primary tests layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    async resolveLayerForTestCreate(suiteId) {
+        if (!suiteId) {
+            return this.testsPersistenceRegistry.get();
+        }
+        let suiteLayerKey;
+        try {
+            suiteLayerKey = await this.findSuiteLayerKey(suiteId);
+        }
+        catch (error) {
+            if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
+                throw error;
+            }
+            return this.testsPersistenceRegistry.get();
+        }
+        const matched = await this.testsPersistenceRegistry.getByKey(suiteLayerKey);
+        return matched ?? (await this.testsPersistenceRegistry.get());
+    }
+    async findSuiteLayerKey(suiteId) {
+        for (const { key, persistence, } of await this.suitesPersistenceRegistry.getEntries()) {
+            try {
+                await persistence.getSuiteById(suiteId);
+                return key;
+            }
+            catch (error) {
+                if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
+                    throw error;
+                }
+            }
+        }
+        throw SuiteNotFoundException_1.SuiteNotFoundException.forId(suiteId);
+    }
+    /**
+     * 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,
+        });
+    }
 }
 exports.TestsManager = TestsManager;
 //# sourceMappingURL=TestsManager.js.map

package/dist/esm/managers/ToolManager.js

@@ -5,6 +5,7 @@ exports.buildToolInterpolationDataSource = buildToolInterpolationDataSource;
 const v4_1 = require("zod/v4");
 const PageClosedException_1 = require("../exceptions/PageClosedException");
 const ToolRequiresGptException_1 = require("../exceptions/ToolRequiresGptException");
+const TargetProvider_1 = require("../targets/TargetProvider");
 const JsonUtils_1 = require("../utils/JsonUtils");
 const Logger_1 = require("../utils/Logger");
 const PlaywrightUtils_1 = require("../utils/PlaywrightUtils");
@@ -39,9 +40,8 @@ class ToolManager {
      * @returns A Promise resolving to a ToolCall object containing execution details and results
      */
     async invokeTool(context, toolName, toolParameters, isFromGpt) {
-        const target = context.targetInspector.target;
         const startedAt = new Date().getTime();
-        const initialPageUrl = target.type === 'web' ? target.current?.url() : undefined;
+        const initialPageUrl = (0, TargetProvider_1.currentLocation)(context.provider);
         Logger_1.appLogger.info(`Taking action: ${toolName}`, {
             toolName,
             parameters: toolParameters,
@@ -83,7 +83,7 @@ class ToolManager {
                     parameters: toolParameters,
                     outcome: null,
                     postCallImageId: null,
-                    page: initialPageUrl ?? '',
+                    page: initialPageUrl,
                     startedAt: startedAt,
                     completedAt: null,
                 });
@@ -127,8 +127,10 @@ class ToolManager {
         }
         if (toolCallResult.metadata?.exception !== new PageClosedException_1.PageClosedException().name) {
             try {
-                if (context.targetInspector.connected) {
-                    const postCallImage = await context.targetInspector.captureScreenshot();
+                // captureSnapshot returns null when nothing is capturable (no target,
+                // disconnected, or no visual snapshot), so no connectivity guard here.
+                const postCallImage = await (0, TargetProvider_1.captureSnapshot)(context.provider);
+                if (postCallImage) {
                     postCallImageId = await context.persistence.saveScreenShot(context.metadata.id, postCallImage);
                 }
             }

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

@@ -18,7 +18,11 @@ export interface ToolRegistry {
     defaultTools(): Tool<z.ZodObject, z.ZodObject>[];
     /** Every available tool: prepackaged + plugins, with plugin overrides applied. */
     allTools(): Tool<z.ZodObject, z.ZodObject>[];
-    /** All tools compatible with the given target type (e.g. `'web'`, `'mobile'`). */
+    /**
+     * All tools compatible with the given target type (e.g. `'web'`, `'mobile'`):
+     * a tool is included if it is universal (no declared targets) or supports the
+     * type.
+     */
     toolsForTarget(targetType: string): Tool<z.ZodObject, z.ZodObject>[];
 }
 /**

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

@@ -4,7 +4,7 @@ import type { InteractableElement } from '../models/InteractableElement';
 import type { FlowsPersistence } from '../persistence/flows/FlowsPersistence';
 import type { InteractionVisualizer } from './InteractionVisualizer';
 import { PageInspector } from './PageInspector';
-import type { PlatformPromptInfo, TargetInitCallbacks, TargetInspectorBase } from './TargetInspector';
+import type { TargetInitCallbacks, TargetInspectorBase } from './TargetInspector';
 /**
  * Web implementation of {@link TargetInspectorBase}.
  *
@@ -27,12 +27,10 @@ export declare class WebTargetInspector implements TargetInspectorBase {
     private readonly _interactionVisualizer;
     readonly type: "web";
     readonly pageInspector: PageInspector;
-    private static readonly PROMPT_INFO;
-    constructor(_target: WebTarget, _browserContext: BrowserContext, _interactionVisualizer: InteractionVisualizer);
     get target(): WebTarget;
     get connected(): boolean;
     get interactableElementAttribute(): string;
-    private requirePage;
+    constructor(_target: WebTarget, _browserContext: BrowserContext, _interactionVisualizer: InteractionVisualizer);
     attributeInteractableElements(): Promise<void>;
     getAttributedInteractableElements(): Promise<InteractableElement[]>;
     annotateInteractableElements(): Promise<void>;
@@ -51,11 +49,17 @@ export declare class WebTargetInspector implements TargetInspectorBase {
     }>;
     showInteractionCursor(): Promise<void>;
     hideInteractionCursor(): Promise<void>;
+    /**
+     * Close the browser context to interrupt any in-flight Playwright call so a
+     * cancelled flow's run loop unblocks at once. This only interrupts — it does
+     * not tear down the browser.
+     */
+    interrupt(): Promise<void>;
     getCurrentLocation(): string;
-    getPlatformPromptInfo(): PlatformPromptInfo;
     getContextDescription(): string;
     initialize(callbacks: TargetInitCallbacks): Promise<void>;
     persistSessionState(persistence: FlowsPersistence, flowId: string): Promise<void>;
+    private requirePage;
     private handleNewPage;
 }
 //# sourceMappingURL=WebTargetInspector.d.ts.map

package/dist/esm/managers/WebTargetInspector.js

@@ -4,6 +4,7 @@ exports.WebTargetInspector = void 0;
 const PageInteractionTracker_1 = require("../bindings/PageInteractionTracker");
 const SetDonobuAnnotations_1 = require("../bindings/SetDonobuAnnotations");
 const PageClosedException_1 = require("../exceptions/PageClosedException");
+const WebDialogHandler_1 = require("../targets/WebDialogHandler");
 const BrowserUtils_1 = require("../utils/BrowserUtils");
 const Logger_1 = require("../utils/Logger");
 const PageLogListeners_1 = require("../utils/PageLogListeners");
@@ -26,37 +27,31 @@ const PageInspector_1 = require("./PageInspector");
  * Page-specific helpers like `getHtmlSnippet`.
  */
 class WebTargetInspector {
-    constructor(_target, _browserContext, _interactionVisualizer) {
-        this._target = _target;
-        this._browserContext = _browserContext;
-        this._interactionVisualizer = _interactionVisualizer;
-        this.type = 'web';
-        this.pageInspector = new PageInspector_1.PageInspector();
+    get target() {
+        return this._target;
     }
     /* ------------------------------------------------------------------ */
     /*  Target accessors                                                  */
     /* ------------------------------------------------------------------ */
-    get target() {
-        return this._target;
-    }
     get connected() {
         return this._target.current !== null;
     }
     get interactableElementAttribute() {
         return this.pageInspector.interactableElementAttribute;
     }
-    requirePage() {
-        if (!this._target.current) {
-            throw new PageClosedException_1.PageClosedException();
-        }
-        return this._target.current;
+    constructor(_target, _browserContext, _interactionVisualizer) {
+        this._target = _target;
+        this._browserContext = _browserContext;
+        this._interactionVisualizer = _interactionVisualizer;
+        this.type = 'web';
+        this.pageInspector = new PageInspector_1.PageInspector();
     }
-    /* ------------------------------------------------------------------ */
-    /*  Element inspection                                                */
-    /* ------------------------------------------------------------------ */
     async attributeInteractableElements() {
         await this.pageInspector.attributeInteractableElements(this.requirePage());
     }
+    /* ------------------------------------------------------------------ */
+    /*  Element inspection                                                */
+    /* ------------------------------------------------------------------ */
     async getAttributedInteractableElements() {
         return this.pageInspector.getAttributedInteractableElements(this.requirePage());
     }
@@ -66,26 +61,26 @@ class WebTargetInspector {
     async removeAnnotations() {
         await this.pageInspector.removeDonobuAnnotations(this.requirePage());
     }
-    /* ------------------------------------------------------------------ */
-    /*  Screenshots                                                       */
-    /* ------------------------------------------------------------------ */
     async takeCleanScreenshot() {
         return PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(this.requirePage());
     }
+    /* ------------------------------------------------------------------ */
+    /*  Screenshots                                                       */
+    /* ------------------------------------------------------------------ */
     async takeAnnotatedScreenshot() {
         return PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(this.requirePage());
     }
     async captureScreenshot() {
         return PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(this.requirePage());
     }
-    /* ------------------------------------------------------------------ */
-    /*  Connection lifecycle                                              */
-    /* ------------------------------------------------------------------ */
     checkConnectedOrThrow() {
         if (!this._target.current) {
             throw new PageClosedException_1.PageClosedException();
         }
     }
+    /* ------------------------------------------------------------------ */
+    /*  Connection lifecycle                                              */
+    /* ------------------------------------------------------------------ */
     checkTargetAliveOrThrow() {
         if (this._target.current?.isClosed()) {
             throw new PageClosedException_1.PageClosedException();
@@ -106,28 +101,35 @@ class WebTargetInspector {
         this._target.current = allPages[0];
         return { recovered: true };
     }
-    /* ------------------------------------------------------------------ */
-    /*  Interaction cursor                                                */
-    /* ------------------------------------------------------------------ */
     async showInteractionCursor() {
         if (this._target.current) {
             await this._interactionVisualizer.showMouse(this._target.current);
         }
     }
+    /* ------------------------------------------------------------------ */
+    /*  Interaction cursor                                                */
+    /* ------------------------------------------------------------------ */
     async hideInteractionCursor() {
         if (this._target.current) {
             await this._interactionVisualizer.hideMouse(this._target.current);
         }
     }
-    /* ------------------------------------------------------------------ */
-    /*  Location & platform identity                                      */
-    /* ------------------------------------------------------------------ */
+    /**
+     * Close the browser context to interrupt any in-flight Playwright call so a
+     * cancelled flow's run loop unblocks at once. This only interrupts — it does
+     * not tear down the browser.
+     */
+    async interrupt() {
+        if (this._target.current) {
+            await this._browserContext.close();
+        }
+    }
     getCurrentLocation() {
         return this._target.current?.url() ?? 'about:blank';
     }
-    getPlatformPromptInfo() {
-        return WebTargetInspector.PROMPT_INFO;
-    }
+    /* ------------------------------------------------------------------ */
+    /*  Location & platform identity                                      */
+    /* ------------------------------------------------------------------ */
     getContextDescription() {
         if (!this._target.current) {
             return 'The web browser has no open pages.';
@@ -141,9 +143,6 @@ class WebTargetInspector {
 
 The active (i.e. in focus) tab is ${this._target.current.url()}`;
     }
-    /* ------------------------------------------------------------------ */
-    /*  Initialization & session state                                    */
-    /* ------------------------------------------------------------------ */
     async initialize(callbacks) {
         const browserContext = this._browserContext;
         // Register page handler — assigns new tabs/popups as the focused page
@@ -151,8 +150,8 @@ The active (i.e. in focus) tab is ${this._target.current.url()}`;
         browserContext.on('page', (page) => this.handleNewPage(page, callbacks));
         await PlaywrightUtils_1.PlaywrightUtils.setupBasicBrowserContext(browserContext);
         // Wire flow-engine handlers onto the browser context.
-        if (callbacks.dialogHandler) {
-            browserContext.on('dialog', callbacks.dialogHandler);
+        if (callbacks.dialogHost) {
+            browserContext.on('dialog', (0, WebDialogHandler_1.createWebDialogHandler)(callbacks.dialogHost));
         }
         if (callbacks.interactionTrackingHost) {
             await PageInteractionTracker_1.PageInteractionTracker.register(callbacks.interactionTrackingHost, browserContext);
@@ -172,6 +171,9 @@ The active (i.e. in focus) tab is ${this._target.current.url()}`;
             }
         }
     }
+    /* ------------------------------------------------------------------ */
+    /*  Initialization & session state                                    */
+    /* ------------------------------------------------------------------ */
     async persistSessionState(persistence, flowId) {
         try {
             const browserState = await BrowserUtils_1.BrowserUtils.getBrowserStorageState(this._browserContext);
@@ -181,6 +183,12 @@ The active (i.e. in focus) tab is ${this._target.current.url()}`;
             Logger_1.appLogger.error('Failed to persist browser state when completing flow', error);
         }
     }
+    requirePage() {
+        if (!this._target.current) {
+            throw new PageClosedException_1.PageClosedException();
+        }
+        return this._target.current;
+    }
     /* ------------------------------------------------------------------ */
     /*  Internal helpers                                                  */
     /* ------------------------------------------------------------------ */
@@ -195,14 +203,4 @@ The active (i.e. in focus) tab is ${this._target.current.url()}`;
     }
 }
 exports.WebTargetInspector = WebTargetInspector;
-WebTargetInspector.PROMPT_INFO = {
-    systemPreamble: `You are a web browser automation agent to help people navigate webpages to
-accomplish an OVERALL OBJECTIVE. These webpages are being rendered in a web
-browser and are powered using the Microsoft Playwright framework.`,
-    screenshotSubject: 'a webpage',
-    currentViewDescription: 'web page (i.e. the current viewport)',
-    annotatedViewDescription: 'viewport of the web page',
-    interactionTarget: 'website',
-    targetNoun: 'webpage',
-};
 //# sourceMappingURL=WebTargetInspector.js.map