donobu 5.55.0 → 5.57.0

package/dist/esm/clients/AnthropicGptClient.js

@@ -29,6 +29,83 @@ class AnthropicGptClient extends GptClient_1.GptClient {
             'Content-Type': AnthropicGptClient.CONTENT_TYPE_HEADER_VALUE,
         });
     }
+    static chatRequestMessageFromGptMessage(gptMessage) {
+        if (gptMessage.type === 'assistant') {
+            return {
+                role: 'assistant',
+                content: gptMessage.text,
+            };
+        }
+        if (gptMessage.type === 'structured_output') {
+            const output = gptMessage.output;
+            return {
+                role: 'assistant',
+                content: JSON.stringify(JsonUtils_1.JsonUtils.objectToJson(output), null, 2),
+            };
+        }
+        if (gptMessage.type === 'proposed_tool_calls') {
+            return {
+                role: 'assistant',
+                content: gptMessage.proposedToolCalls.map((tc) => ({
+                    type: 'tool_use',
+                    id: tc.toolCallId,
+                    name: tc.name,
+                    input: JsonUtils_1.JsonUtils.objectToJson(tc.parameters),
+                })),
+            };
+        }
+        if (gptMessage.type === 'system') {
+            return {
+                type: 'text',
+                text: gptMessage.text,
+            };
+        }
+        if (gptMessage.type === 'user') {
+            return {
+                role: 'user',
+                content: gptMessage.items.map((item) => {
+                    if ('bytes' in item) {
+                        const imageType = MiscUtils_1.MiscUtils.detectImageType(item.bytes);
+                        const mimeType = `image/${imageType}`;
+                        return {
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: mimeType,
+                                data: Buffer.from(item.bytes).toString('base64'),
+                            },
+                        };
+                    }
+                    else {
+                        return {
+                            type: 'text',
+                            text: item.text,
+                        };
+                    }
+                }),
+            };
+        }
+        if (gptMessage.type === 'tool_call_result') {
+            return {
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: gptMessage.toolCallId,
+                        content: gptMessage.data,
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unsupported message type: ${JsonUtils_1.JsonUtils.objectToJson(gptMessage)}`);
+    }
+    static toolChoiceFromTool(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: v4_1.z.toJSONSchema(tool.inputSchema),
+        };
+    }
     async ping(options) {
         const resp = await this.makeRequest(`/v1/models/${this.anthropicConfig.modelName}`, 'GET', undefined, undefined, options?.signal);
         if (resp.status === 404) {
@@ -216,83 +293,6 @@ class AnthropicGptClient extends GptClient_1.GptClient {
             }
         }
     }
-    static chatRequestMessageFromGptMessage(gptMessage) {
-        if (gptMessage.type === 'assistant') {
-            return {
-                role: 'assistant',
-                content: gptMessage.text,
-            };
-        }
-        if (gptMessage.type === 'structured_output') {
-            const output = gptMessage.output;
-            return {
-                role: 'assistant',
-                content: JSON.stringify(JsonUtils_1.JsonUtils.objectToJson(output), null, 2),
-            };
-        }
-        if (gptMessage.type === 'proposed_tool_calls') {
-            return {
-                role: 'assistant',
-                content: gptMessage.proposedToolCalls.map((tc) => ({
-                    type: 'tool_use',
-                    id: tc.toolCallId,
-                    name: tc.name,
-                    input: JsonUtils_1.JsonUtils.objectToJson(tc.parameters),
-                })),
-            };
-        }
-        if (gptMessage.type === 'system') {
-            return {
-                type: 'text',
-                text: gptMessage.text,
-            };
-        }
-        if (gptMessage.type === 'user') {
-            return {
-                role: 'user',
-                content: gptMessage.items.map((item) => {
-                    if ('bytes' in item) {
-                        const imageType = MiscUtils_1.MiscUtils.detectImageType(item.bytes);
-                        const mimeType = `image/${imageType}`;
-                        return {
-                            type: 'image',
-                            source: {
-                                type: 'base64',
-                                media_type: mimeType,
-                                data: Buffer.from(item.bytes).toString('base64'),
-                            },
-                        };
-                    }
-                    else {
-                        return {
-                            type: 'text',
-                            text: item.text,
-                        };
-                    }
-                }),
-            };
-        }
-        if (gptMessage.type === 'tool_call_result') {
-            return {
-                role: 'user',
-                content: [
-                    {
-                        type: 'tool_result',
-                        tool_use_id: gptMessage.toolCallId,
-                        content: gptMessage.data,
-                    },
-                ],
-            };
-        }
-        throw new Error(`Unsupported message type: ${JsonUtils_1.JsonUtils.objectToJson(gptMessage)}`);
-    }
-    static toolChoiceFromTool(tool) {
-        return {
-            name: tool.name,
-            description: tool.description,
-            input_schema: v4_1.z.toJSONSchema(tool.inputSchema),
-        };
-    }
 }
 exports.AnthropicGptClient = AnthropicGptClient;
 AnthropicGptClient.API_URL = 'https://api.anthropic.com';

package/dist/esm/clients/OpenAiGptClient.d.ts

@@ -14,6 +14,20 @@ export declare class OpenAiGptClient extends GptClient {
     private static readonly REQUEST_TIMEOUT_MILLISECONDS;
     private readonly headers;
     constructor(openAiConfig: OpenAiConfig, apiUrl?: string);
+    /**
+     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
+     * Key behaviors:
+     *  - Enforce additionalProperties:false on objects and require all defined properties.
+     *  - Remove unsupported validation keywords.
+     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
+     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
+     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
+     *
+     * Notes for optional fields:
+     *  - Since all fields must be required, emulate optionals with union types that include "null".
+     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
+     */
+    private static createOpenAiCompatibleJsonSchema;
     ping(options?: {
         signal?: AbortSignal;
     }): Promise<void>;
@@ -36,19 +50,5 @@ export declare class OpenAiGptClient extends GptClient {
      * Makes an HTTP request to the OpenAI API with standard configuration.
      */
     private makeRequest;
-    /**
-     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
-     * Key behaviors:
-     *  - Enforce additionalProperties:false on objects and require all defined properties.
-     *  - Remove unsupported validation keywords.
-     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
-     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
-     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
-     *
-     * Notes for optional fields:
-     *  - Since all fields must be required, emulate optionals with union types that include "null".
-     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
-     */
-    private static createOpenAiCompatibleJsonSchema;
 }
 //# sourceMappingURL=OpenAiGptClient.d.ts.map

package/dist/esm/clients/OpenAiGptClient.js

@@ -29,6 +29,189 @@ class OpenAiGptClient extends GptClient_1.GptClient {
             'Content-Type': 'application/json',
         });
     }
+    /**
+     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
+     * Key behaviors:
+     *  - Enforce additionalProperties:false on objects and require all defined properties.
+     *  - Remove unsupported validation keywords.
+     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
+     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
+     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
+     *
+     * Notes for optional fields:
+     *  - Since all fields must be required, emulate optionals with union types that include "null".
+     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
+     */
+    static createOpenAiCompatibleJsonSchema(schema) {
+        // Defensive deep clone to avoid mutating the caller's object.
+        const clone = (obj) => obj === null || typeof obj !== 'object'
+            ? obj
+            : Array.isArray(obj)
+                ? obj.map(clone)
+                : Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, clone(v)]));
+        // Set of keywords we will strip because they are not supported or risky per docs.
+        // (Docs list these as unsupported in Structured Outputs.)
+        const STRIP_KEYS = new Set([
+            // string
+            'minLength',
+            'maxLength',
+            'pattern',
+            'format',
+            'contentMediaType',
+            'contentEncoding',
+            'contentSchema',
+            // number
+            'minimum',
+            'maximum',
+            'exclusiveMinimum',
+            'exclusiveMaximum',
+            'multipleOf',
+            // object
+            'patternProperties',
+            'unevaluatedProperties',
+            'propertyNames',
+            'minProperties',
+            'maxProperties',
+            'dependentRequired',
+            'dependentSchemas',
+            // arrays
+            'unevaluatedItems',
+            'contains',
+            'minContains',
+            'maxContains',
+            'minItems',
+            'maxItems',
+            'uniqueItems',
+            'additionalItems',
+            'prefixItems',
+            // schema/meta rarely needed for model guidance
+            '$dynamicRef',
+            '$dynamicAnchor',
+            '$vocabulary',
+            'allOf', // conservative: remove; can be rewritten as anyOf in many cases
+            'oneOf', // conservative: remove; prefer anyOf
+            'not', // conservative: remove
+            'if',
+            'then',
+            'else',
+        ]);
+        // Normalize `items`:
+        // - if array (tuple validation), convert to anyOf branch for a simpler, supported pattern.
+        const normalizeItems = (items) => {
+            if (Array.isArray(items)) {
+                return {
+                    anyOf: items.map((s) => cleanSchema(s)),
+                };
+            }
+            return cleanSchema(items);
+        };
+        // Ensure object properties are all required and additionalProperties:false
+        const normalizeObject = (s) => {
+            const out = s;
+            if (!out.properties) {
+                out.properties = {};
+            }
+            // Enforce additionalProperties:false per docs
+            out.additionalProperties = false;
+            // Compute required = all keys in properties (OpenAI requires all params/fields required)
+            const propKeys = Object.keys(out.properties);
+            out.required = Array.from(new Set([...(out.required ?? []), ...propKeys]));
+            // Recurse into each property
+            for (const [key, subschema] of Object.entries(out.properties)) {
+                if (typeof subschema === 'boolean') {
+                    // Convert boolean schemas to permissive object (true) or impossible (false).
+                    // We'll treat `true` as `{}` and `false` as `{ "enum": [] }` which is unmatchable.
+                    out.properties[key] = subschema ? {} : { enum: [] };
+                }
+                else {
+                    out.properties[key] = cleanSchema(subschema);
+                }
+            }
+            return out;
+        };
+        // Core cleaner: strip unsupported keys, normalize arrays/objects/anyOf/$defs.
+        const cleanSchema = (input) => {
+            if (input === undefined) {
+                return {};
+            }
+            if (typeof input === 'boolean') {
+                return input ? {} : { enum: [] }; // keep shape valid; `enum: []` is unsatisfiable.
+            }
+            let s = clone(input);
+            // Remove unsupported keys at this level
+            for (const k of Object.keys(s)) {
+                if (STRIP_KEYS.has(k)) {
+                    delete s[k];
+                }
+            }
+            // Clean $defs recursively
+            if (s.$defs) {
+                for (const [defKey, defSchema] of Object.entries(s.$defs)) {
+                    s.$defs[defKey] = cleanSchema(defSchema);
+                }
+            }
+            // Handle anyOf branches
+            if (s.anyOf) {
+                s.anyOf = s.anyOf.map((branch) => cleanSchema(branch));
+            }
+            // Keep enum/const/description/title/$ref as-is.
+            // Normalize arrays
+            if (s.type === 'array') {
+                if (s.items !== undefined) {
+                    s.items = normalizeItems(s.items);
+                }
+                else {
+                    // Provide a permissive default for items to avoid undefined behavior.
+                    s.items = {};
+                }
+            }
+            // Normalize objects
+            if (s.type === 'object') {
+                s = normalizeObject(s);
+            }
+            // If `type` is a union array, keep it (this is how optionals are expressed: includes "null")
+            // Nothing to do here; we just don't strip it.
+            // If `properties` exists but `type` is missing, make it an object to be explicit
+            if (!s.type && s.properties) {
+                s.type = 'object';
+                s = normalizeObject(s);
+            }
+            // If we still have tuple constructs in "items" (e.g., array of schemas after clean), ensure we normalized
+            if (Array.isArray(s.items)) {
+                s.items = normalizeItems(s.items);
+            }
+            return s;
+        };
+        // Start by cleaning the provided schema
+        let cleaned = cleanSchema(schema);
+        // Root cannot be `anyOf`: wrap if necessary
+        if (cleaned &&
+            !cleaned.type &&
+            cleaned.anyOf &&
+            Object.keys(cleaned).every((k) => k === 'anyOf' ||
+                k === '$defs' ||
+                k === 'description' ||
+                k === 'title')) {
+            cleaned = {
+                type: 'object',
+                properties: {
+                    value: { anyOf: cleaned.anyOf.map((b) => cleanSchema(b)) },
+                },
+                required: ['value'],
+                additionalProperties: false,
+                ...(cleaned.$defs ? { $defs: cleaned.$defs } : {}),
+                ...(cleaned.title ? { title: cleaned.title } : {}),
+                ...(cleaned.description ? { description: cleaned.description } : {}),
+            };
+        }
+        // Final safety: if an object lacks properties, make properties:{} and still enforce additionalProperties:false
+        if (cleaned.type === 'object' && !cleaned.properties) {
+            cleaned.properties = {};
+            cleaned.required = [];
+            cleaned.additionalProperties = false;
+        }
+        return cleaned;
+    }
     async ping(options) {
         const resp = await this.makeRequest(`/v1/models/${this.openAiConfig.modelName}`, 'GET', undefined, options?.signal);
         if (resp.status === 404) {
@@ -284,189 +467,6 @@ class OpenAiGptClient extends GptClient_1.GptClient {
             }
         }
     }
-    /**
-     * Transform a general JSON Schema into one that fits the OpenAI Structured Outputs subset.
-     * Key behaviors:
-     *  - Enforce additionalProperties:false on objects and require all defined properties.
-     *  - Remove unsupported validation keywords.
-     *  - Convert tuple `items: [A,B]` into `items: { anyOf: [A,B] }`.
-     *  - Preserve $ref and $defs, cleaning nested definitions recursively.
-     *  - If the root is `anyOf`, wrap it into an object schema with a single `value` property.
-     *
-     * Notes for optional fields:
-     *  - Since all fields must be required, emulate optionals with union types that include "null".
-     *    e.g., `type: ["string", "null"]` while keeping the field in `required`.
-     */
-    static createOpenAiCompatibleJsonSchema(schema) {
-        // Defensive deep clone to avoid mutating the caller's object.
-        const clone = (obj) => obj === null || typeof obj !== 'object'
-            ? obj
-            : Array.isArray(obj)
-                ? obj.map(clone)
-                : Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, clone(v)]));
-        // Set of keywords we will strip because they are not supported or risky per docs.
-        // (Docs list these as unsupported in Structured Outputs.)
-        const STRIP_KEYS = new Set([
-            // string
-            'minLength',
-            'maxLength',
-            'pattern',
-            'format',
-            'contentMediaType',
-            'contentEncoding',
-            'contentSchema',
-            // number
-            'minimum',
-            'maximum',
-            'exclusiveMinimum',
-            'exclusiveMaximum',
-            'multipleOf',
-            // object
-            'patternProperties',
-            'unevaluatedProperties',
-            'propertyNames',
-            'minProperties',
-            'maxProperties',
-            'dependentRequired',
-            'dependentSchemas',
-            // arrays
-            'unevaluatedItems',
-            'contains',
-            'minContains',
-            'maxContains',
-            'minItems',
-            'maxItems',
-            'uniqueItems',
-            'additionalItems',
-            'prefixItems',
-            // schema/meta rarely needed for model guidance
-            '$dynamicRef',
-            '$dynamicAnchor',
-            '$vocabulary',
-            'allOf', // conservative: remove; can be rewritten as anyOf in many cases
-            'oneOf', // conservative: remove; prefer anyOf
-            'not', // conservative: remove
-            'if',
-            'then',
-            'else',
-        ]);
-        // Normalize `items`:
-        // - if array (tuple validation), convert to anyOf branch for a simpler, supported pattern.
-        const normalizeItems = (items) => {
-            if (Array.isArray(items)) {
-                return {
-                    anyOf: items.map((s) => cleanSchema(s)),
-                };
-            }
-            return cleanSchema(items);
-        };
-        // Ensure object properties are all required and additionalProperties:false
-        const normalizeObject = (s) => {
-            const out = s;
-            if (!out.properties) {
-                out.properties = {};
-            }
-            // Enforce additionalProperties:false per docs
-            out.additionalProperties = false;
-            // Compute required = all keys in properties (OpenAI requires all params/fields required)
-            const propKeys = Object.keys(out.properties);
-            out.required = Array.from(new Set([...(out.required ?? []), ...propKeys]));
-            // Recurse into each property
-            for (const [key, subschema] of Object.entries(out.properties)) {
-                if (typeof subschema === 'boolean') {
-                    // Convert boolean schemas to permissive object (true) or impossible (false).
-                    // We'll treat `true` as `{}` and `false` as `{ "enum": [] }` which is unmatchable.
-                    out.properties[key] = subschema ? {} : { enum: [] };
-                }
-                else {
-                    out.properties[key] = cleanSchema(subschema);
-                }
-            }
-            return out;
-        };
-        // Core cleaner: strip unsupported keys, normalize arrays/objects/anyOf/$defs.
-        const cleanSchema = (input) => {
-            if (input === undefined) {
-                return {};
-            }
-            if (typeof input === 'boolean') {
-                return input ? {} : { enum: [] }; // keep shape valid; `enum: []` is unsatisfiable.
-            }
-            let s = clone(input);
-            // Remove unsupported keys at this level
-            for (const k of Object.keys(s)) {
-                if (STRIP_KEYS.has(k)) {
-                    delete s[k];
-                }
-            }
-            // Clean $defs recursively
-            if (s.$defs) {
-                for (const [defKey, defSchema] of Object.entries(s.$defs)) {
-                    s.$defs[defKey] = cleanSchema(defSchema);
-                }
-            }
-            // Handle anyOf branches
-            if (s.anyOf) {
-                s.anyOf = s.anyOf.map((branch) => cleanSchema(branch));
-            }
-            // Keep enum/const/description/title/$ref as-is.
-            // Normalize arrays
-            if (s.type === 'array') {
-                if (s.items !== undefined) {
-                    s.items = normalizeItems(s.items);
-                }
-                else {
-                    // Provide a permissive default for items to avoid undefined behavior.
-                    s.items = {};
-                }
-            }
-            // Normalize objects
-            if (s.type === 'object') {
-                s = normalizeObject(s);
-            }
-            // If `type` is a union array, keep it (this is how optionals are expressed: includes "null")
-            // Nothing to do here; we just don't strip it.
-            // If `properties` exists but `type` is missing, make it an object to be explicit
-            if (!s.type && s.properties) {
-                s.type = 'object';
-                s = normalizeObject(s);
-            }
-            // If we still have tuple constructs in "items" (e.g., array of schemas after clean), ensure we normalized
-            if (Array.isArray(s.items)) {
-                s.items = normalizeItems(s.items);
-            }
-            return s;
-        };
-        // Start by cleaning the provided schema
-        let cleaned = cleanSchema(schema);
-        // Root cannot be `anyOf`: wrap if necessary
-        if (cleaned &&
-            !cleaned.type &&
-            cleaned.anyOf &&
-            Object.keys(cleaned).every((k) => k === 'anyOf' ||
-                k === '$defs' ||
-                k === 'description' ||
-                k === 'title')) {
-            cleaned = {
-                type: 'object',
-                properties: {
-                    value: { anyOf: cleaned.anyOf.map((b) => cleanSchema(b)) },
-                },
-                required: ['value'],
-                additionalProperties: false,
-                ...(cleaned.$defs ? { $defs: cleaned.$defs } : {}),
-                ...(cleaned.title ? { title: cleaned.title } : {}),
-                ...(cleaned.description ? { description: cleaned.description } : {}),
-            };
-        }
-        // Final safety: if an object lacks properties, make properties:{} and still enforce additionalProperties:false
-        if (cleaned.type === 'object' && !cleaned.properties) {
-            cleaned.properties = {};
-            cleaned.required = [];
-            cleaned.additionalProperties = false;
-        }
-        return cleaned;
-    }
 }
 exports.OpenAiGptClient = OpenAiGptClient;
 OpenAiGptClient.DEFAULT_API_URL = 'https://api.openai.com';

package/dist/esm/lib/ai/PageAi.js

@@ -9,6 +9,7 @@ const DonobuFlowsManager_1 = require("../../managers/DonobuFlowsManager");
 const ToolManager_1 = require("../../managers/ToolManager");
 const WebTargetInspector_1 = require("../../managers/WebTargetInspector");
 const ControlPanel_1 = require("../../models/ControlPanel");
+const WebTargetProvider_1 = require("../../targets/WebTargetProvider");
 const Logger_1 = require("../../utils/Logger");
 const originalGotoRegistry_1 = require("../page/originalGotoRegistry");
 const cache_1 = require("./cache/cache");
@@ -69,7 +70,7 @@ class PageAiRunner {
         const persistence = await this.donobu.flowsPersistenceRegistry.get();
         const pageWithOriginalGoto = Object.create(config.page);
         pageWithOriginalGoto.goto = (0, originalGotoRegistry_1.getOriginalGoto)(config.page);
-        const donobuFlow = new DonobuFlow_1.DonobuFlow(this.donobu.flowsManager, envData, persistence, this.gptClient, toolManager, config.page._dnb.interactionVisualizer, [], [], [], new WebTargetInspector_1.WebTargetInspector({ type: 'web', current: pageWithOriginalGoto }, config.page.context(), config.page._dnb.interactionVisualizer), augmentedMetadata, config.page._dnb.controlPanelFactory
+        const donobuFlow = new DonobuFlow_1.DonobuFlow(this.donobu.flowsManager, envData, persistence, this.gptClient, toolManager, config.page._dnb.interactionVisualizer, [], [], [], new WebTargetProvider_1.WebTargetProvider(new WebTargetInspector_1.WebTargetInspector({ type: 'web', current: pageWithOriginalGoto }, config.page.context(), config.page._dnb.interactionVisualizer)), augmentedMetadata, config.page._dnb.controlPanelFactory
             ? await config.page._dnb.controlPanelFactory(augmentedMetadata.id)
             : new ControlPanel_1.NoOpControlPanel());
         const flowContext = { flowId: augmentedMetadata.id };

package/dist/esm/lib/page/extendPage.js

@@ -16,6 +16,7 @@ const ToolManager_1 = require("../../managers/ToolManager");
 const WebTargetInspector_1 = require("../../managers/WebTargetInspector");
 const ControlPanel_1 = require("../../models/ControlPanel");
 const MetadataVersion_1 = require("../../models/MetadataVersion");
+const WebTargetProvider_1 = require("../../targets/WebTargetProvider");
 const AnalyzePageTextTool_1 = require("../../tools/AnalyzePageTextTool");
 const AssertTool_1 = require("../../tools/AssertTool");
 const AuditTool_1 = require("../../tools/AuditTool");
@@ -805,7 +806,7 @@ async function runTool(page, toolName, toolParams, gptClient) {
     const toolCallContext = {
         flowsManager: page._dnb.donobuStack.flowsManager,
         envData,
-        targetInspector: new WebTargetInspector_1.WebTargetInspector(webTarget, page.context(), page._dnb.interactionVisualizer),
+        provider: new WebTargetProvider_1.WebTargetProvider(new WebTargetInspector_1.WebTargetInspector(webTarget, page.context(), page._dnb.interactionVisualizer)),
         controlPanel: new ControlPanel_1.NoOpControlPanel(),
         persistence: page._dnb.persistence,
         gptClient: getGptClient(page, gptClient),

package/dist/esm/lib/test/utils/TestFileUpdater.d.ts

@@ -12,6 +12,15 @@ export declare class TestFileUpdater {
      * @returns True if the update was successful, false otherwise
      */
     static updateTestCase(testFilePath: string, testName: string, newTestCode: string): Promise<boolean>;
+    /**
+     * Updates a test file based on a Playwright JSON reporter output.
+     *
+     * @param jsonReportPath Path to the Playwright JSON report
+     * @param testFilePath Path to the test file to update (if not specified, will be extracted from the report)
+     * @param newTestCode The new test code
+     * @returns True if the update was successful, false otherwise
+     */
+    static updateFromPlaywrightReport(jsonReportPath: string, newTestCode: string, testFilePath?: string): Promise<boolean>;
     /**
      * Extracts a specific test case from source code.
      *
@@ -43,14 +52,5 @@ export declare class TestFileUpdater {
      * Checks if a test title matches the target test name.
      */
     private static testTitleMatches;
-    /**
-     * Updates a test file based on a Playwright JSON reporter output.
-     *
-     * @param jsonReportPath Path to the Playwright JSON report
-     * @param testFilePath Path to the test file to update (if not specified, will be extracted from the report)
-     * @param newTestCode The new test code
-     * @returns True if the update was successful, false otherwise
-     */
-    static updateFromPlaywrightReport(jsonReportPath: string, newTestCode: string, testFilePath?: string): Promise<boolean>;
 }
 //# sourceMappingURL=TestFileUpdater.d.ts.map