donobu 5.57.0 → 5.60.0

package/dist/esm/codegen/CodeGenerator.js

@@ -76,6 +76,7 @@ const SummarizeLearningsTool_1 = require("../tools/SummarizeLearningsTool");
 const WaitTool_1 = require("../tools/WaitTool");
 const JsonUtils_1 = require("../utils/JsonUtils");
 const MiscUtils_1 = require("../utils/MiscUtils");
+const TargetCodeGenerator_1 = require("./TargetCodeGenerator");
 function getLocalPlaywrightVersion() {
     const pkgPath = require.resolve('playwright/package.json');
     const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
@@ -112,6 +113,28 @@ function computeRuntimeCacheKeyFields(toolCalls, defaultToolNames, minimalToolNa
         maxToolCalls: resolvedMaxToolCalls,
     };
 }
+/**
+ * Built-in code generator for the web (Playwright) target. Owns the full web
+ * spec/cache output; non-web targets (API, mobile, …) register their own
+ * generators, which may emit an entirely different shape.
+ */
+const webCodeGenerator = {
+    targetType: 'web',
+    generateClassicScript: (ctx) => getFlowAsPlaywrightScript(ctx.flowMetadata, ctx.toolCalls, ctx.options, ctx.toolRegistry),
+    generateAiScript: (ctx) => getFlowAsAiPlaywrightScript(ctx.flowMetadata, ctx.toolCalls, ctx.options, ctx.toolRegistry),
+    buildCacheEntry: (ctx) => cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(ctx.pageUrl, ctx.metadata, ctx.toolCalls),
+    cachePageUrl: (metadata) => {
+        const website = metadata.web?.targetWebsite ?? '';
+        try {
+            return new URL(website).hostname;
+        }
+        catch {
+            return website;
+        }
+    },
+    requiresBrowserInstall: () => true,
+};
+(0, TargetCodeGenerator_1.registerCodeGenerator)(webCodeGenerator);
 /** Creates a Node.js Microsoft Playwright script to replay the given flow. */
 async function getFlowAsPlaywrightScript(flowMetadata, toolCalls, options = {}, toolRegistry) {
     // These tools are not supported in the generated script because they have
@@ -166,12 +189,10 @@ async function getFlowAsPlaywrightScript(flowMetadata, toolCalls, options = {},
             .replace(/\n/g, '\\n')
             // Escape carriage returns.
             .replace(/\r/g, '\\r')
-        : `Test for ${flowMetadata.web?.targetWebsite ?? 'flow'}`;
+        : `Test for ${getFlowTargetLabel(flowMetadata)}`;
     const scriptedToolCalls = toolCalls
         .filter((toolCall) => !unsupportedToolsByName.has(toolCall.name))
-        .map((toolCall) => {
-        return convertProposedToolCallToPlaywrightCode(toolCall);
-    })
+        .map((toolCall) => convertProposedToolCallToPlaywrightCode(toolCall))
         .join('\n\n');
     const annotationsLiteral = combinedAnnotations.length > 0
         ? JSON.stringify({ annotation: combinedAnnotations }, null, 2)
@@ -185,7 +206,7 @@ const extractedObject = await page.ai.extract(
 testInfo.attach('extracted-object', { body: JSON.stringify(extractedObject), contentType: 'application/json' });`
         : '';
     const needsExpectImport = toolCalls.some((toolCall) => toolCall.name === AssertPageTool_1.AssertPageTool.NAME);
-    const needsJsonSchemaToZodImport = flowMetadata.resultJsonSchema;
+    const needsJsonSchemaToZodImport = !!flowMetadata.resultJsonSchema;
     const preamble = gptSetupNote.trim().length > 0
         ? `/**
 ${gptSetupNote}*/`
@@ -207,9 +228,10 @@ async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options, too
     const [firstToolCall, ...remaingToolCalls] = toolCalls;
     // If the first tool call is "GoToWebpage", then we peel it off and treat it
     // specially.
-    const specialCaseGoto = firstToolCall.name === GoToWebpageTool_1.GoToWebpageTool.NAME && remaingToolCalls.length > 0;
+    const specialCaseGoto = firstToolCall?.name === GoToWebpageTool_1.GoToWebpageTool.NAME && remaingToolCalls.length > 0;
     const cachePath = (0, cacheLocator_1.relativePageAiCachePathForSource)(node_path_1.default.join('tests', getTestFileName(flowMetadata)));
-    const gptSetupNote = ` * This test replays a recorded Donobu flow via \`page.ai(...)\` using the cached
+    const aiHelper = 'page.ai';
+    const gptSetupNote = ` * This test replays a recorded Donobu flow via \`${aiHelper}(...)\` using the cached
  * tool calls stored for this spec in \`${cachePath}\`.
  * If the cache entry is missing or the parameters change, the run falls back
  * to autonomous mode and will require a GPT API key (e.g. DONOBU_API_KEY,
@@ -225,10 +247,10 @@ async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options, too
             .replace(/\n/g, '\\n')
             // Escape carriage returns.
             .replace(/\r/g, '\\r')
-        : `Test for ${flowMetadata.web?.targetWebsite ?? 'flow'}`;
+        : `Test for ${getFlowTargetLabel(flowMetadata)}`;
     const instructionSource = flowMetadata.overallObjective?.trim()
         ? flowMetadata.overallObjective
-        : `Replay the recorded flow for ${flowMetadata.web?.targetWebsite ?? 'flow'}`;
+        : `Replay the recorded flow for ${getFlowTargetLabel(flowMetadata)}`;
     const sanitizedInstruction = sanitizeForTemplateLiteral(instructionSource);
     const annotations = [
         ...(options?.flowAnnotations?.[flowMetadata.id] ?? []),
@@ -265,8 +287,8 @@ async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options, too
     }
     const aiOptionsLiteral = optionsLines.length > 0 ? `{${optionsLines.join(',')}}` : '';
     const aiCallExpression = optionsLines.length > 0
-        ? `page.ai(\`${sanitizedInstruction}\`, ${aiOptionsLiteral})`
-        : `page.ai(\`${sanitizedInstruction}\`)`;
+        ? `${aiHelper}(\`${sanitizedInstruction}\`, ${aiOptionsLiteral})`
+        : `${aiHelper}(\`${sanitizedInstruction}\`)`;
     const needsTestInfo = flowMetadata.resultJsonSchema !== null;
     const aiInvocation = needsTestInfo
         ? `const extractedObj = await ${aiCallExpression};
@@ -479,29 +501,29 @@ async function buildCacheContents(flowsWithToolCalls, toolRegistry) {
     const defaultToolNames = new Set(toolRegistry.defaultTools().map((tool) => tool.name));
     const minimalToolNames = new Set(toolRegistry.minimalTools().map((t) => t.name));
     const entries = flowsWithToolCalls
-        // We can only create page.ai caches for flows that have an objective.
-        .filter(({ metadata }) => metadata.overallObjective?.trim() &&
+        // We can only create ai caches for targets that codegen knows how to
+        // replay (web + any plugin with a registered generator), with an objective.
+        .filter(({ metadata }) => (0, TargetCodeGenerator_1.hasCodeGenerator)(metadata.target) &&
+        metadata.overallObjective?.trim() &&
         (metadata.runMode === 'AUTONOMOUS' ||
             metadata.runMode === 'SUPERVISED'))
         .map(({ metadata, toolCalls }) => {
+        // Filtered above on hasCodeGenerator, so this is defined.
+        const generator = (0, TargetCodeGenerator_1.getCodeGenerator)(metadata.target);
         const [firstToolCall, ...remaingToolCalls] = toolCalls;
-        // If the first tool call is "GoToWebpage", then we peel it off and treat it
-        // specially (i.e. it will be an explicit tool call in the generated test file).
+        // A leading GoToWebpage is peeled off (it becomes an explicit nav in the
+        // generated spec). Naturally a no-op for non-web targets, which never
+        // emit GoToWebpage.
         const specialCaseGoto = firstToolCall?.name === GoToWebpageTool_1.GoToWebpageTool.NAME &&
             remaingToolCalls.length > 0;
         const toolCallsForCache = specialCaseGoto ? remaingToolCalls : toolCalls;
-        // Extract hostname from URL for cache key to allow caching across different
-        // paths and query parameters on the same domain
-        let pageUrlForCache;
-        try {
-            const url = new URL(metadata.web?.targetWebsite ?? '');
-            pageUrlForCache = url.hostname;
-        }
-        catch {
-            // Fallback to full URL if parsing fails
-            pageUrlForCache = metadata.web?.targetWebsite ?? '';
-        }
-        const cacheEntry = cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(pageUrlForCache, metadata, toolCallsForCache);
+        // Cache key pageUrl (e.g. hostname) is target-specific.
+        const pageUrlForCache = generator.cachePageUrl(metadata);
+        const cacheEntry = generator.buildCacheEntry({
+            pageUrl: pageUrlForCache,
+            metadata,
+            toolCalls: toolCallsForCache,
+        });
         // Compute allowedTools and maxToolCalls as the runtime will see them,
         // so the cache lock file keys match the keys built by PageAi.buildDescriptor
         // when the generated test code is executed.
@@ -738,13 +760,18 @@ async function generatePlaywrightConfig(flows, storageStatePaths, options) {
         projects.push(generateProjectConfig(projectName, flow, storageStatePath));
     }
     const { areElementIdsVolatile, disableSelectorFailover, runInHeadedMode, slowMotionDelay, } = options;
-    const useConfig = {
-        screenshot: 'on',
-        video: 'on',
-        ...(runInHeadedMode && { headless: !runInHeadedMode }),
-        ...(slowMotionDelay &&
-            slowMotionDelay > 0 && { launchOptions: { slowMo: slowMotionDelay } }),
-    };
+    const hasBrowserFlows = flows.some((flow) => (0, TargetCodeGenerator_1.getCodeGenerator)(flow.target)?.requiresBrowserInstall(flow) ?? false);
+    const useConfig = hasBrowserFlows
+        ? {
+            screenshot: 'on',
+            video: 'on',
+            ...(runInHeadedMode && { headless: !runInHeadedMode }),
+            ...(slowMotionDelay &&
+                slowMotionDelay > 0 && {
+                launchOptions: { slowMo: slowMotionDelay },
+            }),
+        }
+        : {};
     const selfHealingOptions = {
         areElementIdsVolatile,
         disableSelectorFailover,
@@ -783,6 +810,14 @@ function generateProjectConfig(projectName, flow, storageStatePath) {
     // Round up to the nearest 10000ms
     const timeoutMilliseconds = Math.max(minimumTimeoutMilliseconds, Math.ceil(calculatedTimeout / 10000) * 10000);
     const testMatch = `tests/${getTestFileName(flow)}`;
+    if (!((0, TargetCodeGenerator_1.getCodeGenerator)(flow.target)?.requiresBrowserInstall(flow) ?? true)) {
+        return `{
+  name: '${projectName}',
+  testMatch: '${testMatch}',
+  use: {},
+  timeout: ${timeoutMilliseconds}
+}`;
+    }
     // Get device name from flow config, default to 'Desktop Chromium'
     const deviceName = flow.web?.browser?.using?.type === 'device'
         ? flow.web.browser.using.deviceName || 'Desktop Chromium'
@@ -804,12 +839,19 @@ async function generateTestFiles(flowsWithToolCalls, options, toolRegistry) {
     const files = [];
     const scriptVariant = options.playwrightScriptVariant === 'classic' ? 'classic' : 'ai';
     for (const { metadata, toolCalls } of flowsWithToolCalls) {
+        const generator = (0, TargetCodeGenerator_1.getCodeGenerator)(metadata.target) ?? webCodeGenerator;
         const fileName = getTestFileName(metadata);
+        const ctx = {
+            flowMetadata: metadata,
+            toolCalls,
+            options,
+            toolRegistry,
+        };
         const content = scriptVariant === 'classic' ||
             !metadata.overallObjective?.trim() ||
             (metadata.runMode !== 'AUTONOMOUS' && metadata.runMode !== 'SUPERVISED')
-            ? await getFlowAsPlaywrightScript(metadata, toolCalls, options, toolRegistry)
-            : await getFlowAsAiPlaywrightScript(metadata, toolCalls, options, toolRegistry);
+            ? await generator.generateClassicScript(ctx)
+            : await generator.generateAiScript(ctx);
         files.push({
             path: `tests/${fileName}`,
             content,
@@ -827,7 +869,7 @@ function generatePackageJson(options) {
     return JSON.stringify({
         name: 'playwright-tests',
         version: '1.0.0',
-        description: 'Playwright-based website tests made with Donobu',
+        description: 'Playwright-based tests made with Donobu',
         scripts: {
             test: `donobu test${selfHealingArg}`,
         },
@@ -856,7 +898,7 @@ Some tests depend on pre-existing browser state (cookies, localStorage, etc.) fr
         : '';
     return `# Playwright Tests
 
-This project contains [Playwright](https://playwright.dev/)-based tests made with [Donobu](https://www.donobu.com/).
+This project contains [Playwright](https://playwright.dev/)-based web and API tests made with [Donobu](https://www.donobu.com/).
 
 ## Installation
 
@@ -879,6 +921,9 @@ npm test
 \`\`\`
 ${browserStatesSection}`;
 }
+function getFlowTargetLabel(flow) {
+    return flow.web?.targetWebsite ?? 'flow';
+}
 /**
  * Gets a project name for a flow
  */

package/dist/esm/codegen/TargetCodeGenerator.d.ts

@@ -0,0 +1,54 @@
+import type { PageAiCacheEntry } from '../lib/ai/cache/cache';
+import type { ToolRegistry } from '../managers/ToolRegistry';
+import type { CodeGenerationOptions } from '../models/CodeGenerationOptions';
+import type { FlowMetadata } from '../models/FlowMetadata';
+import type { ProposedToolCall } from '../models/ProposedToolCall';
+/**
+ * Inputs for generating one flow's replay spec.
+ */
+export interface CodeGenContext {
+    flowMetadata: FlowMetadata;
+    toolCalls: ProposedToolCall[];
+    options: CodeGenerationOptions;
+    toolRegistry: ToolRegistry;
+}
+export interface CacheEntryContext {
+    pageUrl: string;
+    metadata: FlowMetadata;
+    toolCalls: ProposedToolCall[];
+}
+/**
+ * A target's code generator. This is an opaque, whole-artifact contract: core
+ * asks a generator to produce a flow's replay spec / cache entry and makes NO
+ * assumptions about the artifact's internals. Web (Playwright specs) is the
+ * built-in; other targets (API, mobile, …) register their own and are free to
+ * emit a completely different shape — or none. Deliberately NOT parameterized
+ * with web-spec knobs (fixtures, AI helpers, etc.): those would presume every
+ * target produces a Playwright test, which they do not.
+ */
+export interface TargetCodeGenerator {
+    readonly targetType: string;
+    /** Produce the deterministic ("classic") replay spec for one flow. */
+    generateClassicScript(ctx: CodeGenContext): Promise<string>;
+    /** Produce the AI/cache-backed replay spec for one flow. */
+    generateAiScript(ctx: CodeGenContext): Promise<string>;
+    /** Build the AI-cache entry (runSource) for one flow. */
+    buildCacheEntry(ctx: CacheEntryContext): PageAiCacheEntry;
+    /** Cache-key pageUrl for a flow of this target. */
+    cachePageUrl(metadata: FlowMetadata): string;
+    /**
+     * Whether flows of this target require a browser install in the generated
+     * project (drives CI setup and the Playwright project `use` block). A coarse
+     * capability question, not a directive about spec contents.
+     */
+    requiresBrowserInstall(metadata: FlowMetadata): boolean;
+}
+/** Register a target's code generator. Core registers `web`; plugins register
+ * their own at startup. */
+export declare function registerCodeGenerator(generator: TargetCodeGenerator): void;
+/** Resolve the generator for a target type, or `undefined` if none is
+ * registered (the caller decides how to handle unsupported targets). */
+export declare function getCodeGenerator(targetType: string): TargetCodeGenerator | undefined;
+/** Whether a code generator is registered for the given target type. */
+export declare function hasCodeGenerator(targetType: string): boolean;
+//# sourceMappingURL=TargetCodeGenerator.d.ts.map

package/dist/esm/codegen/TargetCodeGenerator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCodeGenerator = registerCodeGenerator;
+exports.getCodeGenerator = getCodeGenerator;
+exports.hasCodeGenerator = hasCodeGenerator;
+const registry = new Map();
+/** Register a target's code generator. Core registers `web`; plugins register
+ * their own at startup. */
+function registerCodeGenerator(generator) {
+    registry.set(generator.targetType, generator);
+}
+/** Resolve the generator for a target type, or `undefined` if none is
+ * registered (the caller decides how to handle unsupported targets). */
+function getCodeGenerator(targetType) {
+    return registry.get(targetType);
+}
+/** Whether a code generator is registered for the given target type. */
+function hasCodeGenerator(targetType) {
+    return registry.has(targetType);
+}
+//# sourceMappingURL=TargetCodeGenerator.js.map

package/dist/esm/lib/ai/cache/assertCache.d.ts

@@ -53,15 +53,28 @@ export declare function buildAssertExecutor(steps: PlaywrightAssertionStep[]): A
  * on the same domain always resolves to the same cached entry.
  */
 export type AssertCacheKey = {
+    /**
+     * Target device discriminator; defaults to `'web'`. Plugin targets supply
+     * their own opaque value — core treats any non-`'web'` value as an opaque
+     * string.
+     */
+    deviceType?: string;
     pageUrl: string;
     assertion: string;
 };
+/**
+ * A structured assertion step. Web entries store
+ * {@link PlaywrightAssertionStep}s, which core compiles into Playwright
+ * `expect` calls. Non-web (plugin-target) entries store their own step
+ * shapes — opaque to core; the owning plugin interprets them on replay.
+ */
+export type AssertStep = PlaywrightAssertionStep | Record<string, unknown>;
 /**
  * Serialised cache entry stored on disk. Contains structured assertion
  * steps rather than raw code strings.
  */
 export type AssertCacheEntry = AssertCacheKey & {
-    steps: PlaywrightAssertionStep[];
+    steps: AssertStep[];
 };
 /**
  * Entry hydrated with an executable runner.

package/dist/esm/lib/ai/cache/cache.d.ts

@@ -9,8 +9,12 @@ import type { AssertCacheEntry, AssertCacheEntryWithRunner, AssertCacheKey, Loca
  * For mobile entries, `pageUrl` is the sentinel `"mobile://app"`.
  */
 export type PageAiCacheKey = {
-    /** Discriminator for web vs mobile cache entries. Defaults to `'web'` for backwards compat. */
-    deviceType?: 'web' | 'android' | 'ios';
+    /**
+     * Target device discriminator; defaults to `'web'`. Plugin targets supply
+     * their own opaque value (e.g. mobile `'android'`/`'ios'`, API `'api'`) — core
+     * treats any non-`'web'` value as an opaque string.
+     */
+    deviceType?: string;
     pageUrl: string;
     instruction: string | null;
     schema: Record<string, unknown> | null;
@@ -39,9 +43,13 @@ export type PageAiCacheContents = {
     locators?: LocateCacheEntry[];
 };
 export type PageAiCacheExecutionContext = {
+    /** Legacy cutout for the built-in web target. */
     page?: DonobuExtendedPage;
-    /** Plugin-provided device (e.g. mobile). Typed as `unknown` — callers cast as needed. */
-    device?: unknown;
+    /**
+     * Plugin targets supply their own handle under a target-specific key,
+     * opaque to core; the plugin's cache replay casts to its concrete shape.
+     */
+    [targetHandle: string]: unknown;
 };
 export type PageAiCacheExecutor = (context: PageAiCacheExecutionContext) => Promise<unknown>;
 /**

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

@@ -108,15 +108,30 @@ const cloneEntryWithRunner = (entry) => ({
 // ---------------------------------------------------------------------------
 // Assert cache helpers
 // ---------------------------------------------------------------------------
-const assertCacheKeysMatch = (left, right) => left.pageUrl === right.pageUrl && left.assertion === right.assertion;
+const assertCacheKeysMatch = (left, right) => (left.deviceType ?? 'web') === (right.deviceType ?? 'web') &&
+    left.pageUrl === right.pageUrl &&
+    left.assertion === right.assertion;
 const materializeAssertEntry = (entry) => ({
     ...entry,
-    run: (0, assertCache_1.buildAssertExecutor)(entry.steps),
+    // Only web steps compile into Playwright `expect` calls. Non-web entries
+    // are interpreted by their owning plugin, which reads `steps` directly.
+    run: (entry.deviceType ?? 'web') === 'web'
+        ? (0, assertCache_1.buildAssertExecutor)(entry.steps)
+        : async () => {
+            throw new Error(`No assert executor for deviceType '${entry.deviceType}'; the owning plugin interprets cached steps directly.`);
+        },
 });
-const cloneAssertEntry = (entry) => ({
+// Drops the live runner to produce a JSON-safe shape for storage/serialization.
+const stripAssertRunner = (entry) => ({
+    ...(entry.deviceType && entry.deviceType !== 'web'
+        ? { deviceType: entry.deviceType }
+        : {}),
     pageUrl: entry.pageUrl,
     assertion: entry.assertion,
     steps: entry.steps,
+});
+const cloneAssertEntry = (entry) => ({
+    ...stripAssertRunner(entry),
     run: entry.run,
 });
 // ---------------------------------------------------------------------------
@@ -152,7 +167,17 @@ const serializeEntry = (entry) => {
 const renderCacheModule = (entries, assertions, locators) => {
     const serializedEntries = entries.map(serializeEntry).join(', ');
     const assertionsPart = assertions && assertions.length > 0
-        ? `, assertions: [${assertions.map((a) => JSON.stringify({ pageUrl: a.pageUrl, assertion: a.assertion, steps: a.steps })).join(', ')}]`
+        ? `, assertions: [${assertions
+            .map((a) => JSON.stringify({
+            // Only emit deviceType for non-web entries (backwards compat).
+            ...(a.deviceType && a.deviceType !== 'web'
+                ? { deviceType: a.deviceType }
+                : {}),
+            pageUrl: a.pageUrl,
+            assertion: a.assertion,
+            steps: a.steps,
+        }))
+            .join(', ')}]`
         : '';
     const locatorsPart = locators && locators.length > 0
         ? `, locators: [${locators.map((l) => JSON.stringify({ pageUrl: l.pageUrl, description: l.description, result: l.result })).join(', ')}]`
@@ -227,11 +252,7 @@ class FilePageAiCache {
             state,
             result: {
                 caches: state.caches.map((entry) => stripRunner(entry)),
-                assertions: state.assertions.map((a) => ({
-                    pageUrl: a.pageUrl,
-                    assertion: a.assertion,
-                    steps: a.steps,
-                })),
+                assertions: state.assertions.map((a) => stripAssertRunner(a)),
                 locators: state.locators.map((l) => ({
                     pageUrl: l.pageUrl,
                     description: l.description,
@@ -370,11 +391,11 @@ class FilePageAiCache {
                     throw new Error(`Invalid cache entry: run must be a function for ${entry.pageUrl ?? 'unknown page'}.`);
                 }
                 const normalized = {
-                    ...(entry.deviceType === 'android'
-                        ? { deviceType: 'android' }
-                        : entry.deviceType === 'ios'
-                            ? { deviceType: 'ios' }
-                            : {}),
+                    // Preserve any non-web device type verbatim — values are opaque to
+                    // core (web is the built-in; plugin targets supply their own).
+                    ...(entry.deviceType && entry.deviceType !== 'web'
+                        ? { deviceType: String(entry.deviceType) }
+                        : {}),
                     pageUrl: String(entry.pageUrl ?? ''),
                     instruction: entry.instruction === null || entry.instruction === undefined
                         ? null
@@ -406,6 +427,9 @@ class FilePageAiCache {
                     ? entry.steps
                     : [];
                 return materializeAssertEntry({
+                    ...(entry.deviceType && entry.deviceType !== 'web'
+                        ? { deviceType: String(entry.deviceType) }
+                        : {}),
                     pageUrl: String(entry.pageUrl ?? ''),
                     assertion: String(entry.assertion ?? ''),
                     steps,
@@ -431,11 +455,7 @@ class FilePageAiCache {
     }
     async writeCacheFile(state) {
         const serializedCaches = state.caches.map((entry) => stripRunner(entry));
-        const serializedAssertions = state.assertions.map((e) => ({
-            pageUrl: e.pageUrl,
-            assertion: e.assertion,
-            steps: e.steps,
-        }));
+        const serializedAssertions = state.assertions.map((e) => stripAssertRunner(e));
         const serializedLocators = state.locators.map((e) => ({
             pageUrl: e.pageUrl,
             description: e.description,
@@ -517,11 +537,7 @@ class InMemoryPageAiCache {
     async snapshot() {
         return {
             caches: this.cache.map((entry) => stripRunner(entry)),
-            assertions: this.assertions.map((a) => ({
-                pageUrl: a.pageUrl,
-                assertion: a.assertion,
-                steps: a.steps,
-            })),
+            assertions: this.assertions.map((a) => stripAssertRunner(a)),
             locators: this.locators.map((l) => ({
                 pageUrl: l.pageUrl,
                 description: l.description,

package/dist/esm/lib/ai/cache/cacheEntryBuilder.d.ts

@@ -2,9 +2,9 @@ import type { FlowMetadata } from '../../../models/FlowMetadata';
 import type { ProposedToolCall } from '../../../models/ProposedToolCall';
 import type { PageAiCacheEntry } from './cache';
 /**
- * Utility for translating flow metadata into cache entries. By centralising the
- * logic here, both the runtime (`PageAi`) and the code generator can build
- * matching cache files without duplicating knowledge about the schema.
+ * Builds web (Playwright) cache entries. Shared by the web runtime (`PageAi`)
+ * and the web code generator so both emit matching `page.run(...)` replay
+ * source. Non-web targets build their own cache entries in their own plugins.
  */
 export declare class PageAiCacheEntryBuilder {
     /**

package/dist/esm/lib/ai/cache/cacheEntryBuilder.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageAiCacheEntryBuilder = void 0;
 const CodeGenerator_1 = require("../../../codegen/CodeGenerator");
 /**
- * Utility for translating flow metadata into cache entries. By centralising the
- * logic here, both the runtime (`PageAi`) and the code generator can build
- * matching cache files without duplicating knowledge about the schema.
+ * Builds web (Playwright) cache entries. Shared by the web runtime (`PageAi`)
+ * and the web code generator so both emit matching `page.run(...)` replay
+ * source. Non-web targets build their own cache entries in their own plugins.
  */
 class PageAiCacheEntryBuilder {
     /**
@@ -20,9 +20,7 @@ class PageAiCacheEntryBuilder {
             maxToolCalls: metadata.maxToolCalls,
             envVars: metadata.envVars,
             runSource: `async ({ page }) => {${toolCallCache
-                .map((toolCall) => {
-                return (0, CodeGenerator_1.convertProposedToolCallToPlaywrightCode)(toolCall);
-            })
+                .map((toolCall) => (0, CodeGenerator_1.convertProposedToolCallToPlaywrightCode)(toolCall))
                 .join('\n\n')}}`,
         };
     }

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

@@ -266,6 +266,8 @@ Valid options:
                     const cached = await cache.getAssert({ pageUrl, assertion });
                     if (cached) {
                         aiInvocationCacheHit = true;
+                        // The key above carries no deviceType, so it only matches web
+                        // entries — whose steps are Playwright-shaped by construction.
                         aiInvocationAssertSteps = cached.steps;
                         Logger_1.appLogger.debug(`Assert cache HIT for: "${assertion}" - running cached Playwright assertion`);
                         const envData = await resolveEnvData();

package/dist/esm/lib/test/testExtension.js

@@ -1109,6 +1109,12 @@ function getSanitizedTestName(testInfo) {
 }
 /** Builds a TestMetadata from the fields available on a FlowMetadata. */
 function flowMetadataToTestMetadata(testId, flowMeta) {
+    const targetConfig = {};
+    if (flowMeta.target &&
+        flowMeta.target !== 'web' &&
+        flowMeta.target in flowMeta) {
+        targetConfig[flowMeta.target] = flowMeta[flowMeta.target];
+    }
     return {
         id: testId,
         name: flowMeta.name,
@@ -1125,6 +1131,7 @@ function flowMetadataToTestMetadata(testId, flowMeta) {
         suiteId: null,
         nextRunMode: 'DETERMINISTIC',
         provenance: (0, buildProvenance_1.buildProvenance)('CODE'),
+        ...targetConfig,
     };
 }
 //# sourceMappingURL=testExtension.js.map

package/dist/esm/lib/test/utils/selfHealing.js

@@ -267,6 +267,20 @@ to someone who is tasked with completing it as a goal.
     }
 }
 async function buildToolList(donobuFlowMetadata, toolRegistry) {
+    if (donobuFlowMetadata.target !== 'web') {
+        const targetDefaultTools = toolRegistry
+            .defaultTools()
+            .filter((tool) => tool.supportedTargets.length === 0 ||
+            tool.supportedTargets.includes(donobuFlowMetadata.target))
+            .map((tool) => tool.name);
+        const defaultTools = new Set([
+            ...(donobuFlowMetadata.allowedTools
+                ? donobuFlowMetadata.allowedTools
+                : []),
+            ...targetDefaultTools,
+        ]);
+        return [...defaultTools];
+    }
     const baseTools = [
         AnalyzePageTextTool_1.AnalyzePageTextTool.NAME,
         AssertTool_1.AssertTool.NAME,

package/dist/esm/main.d.ts

@@ -6,6 +6,7 @@ export { GptClient } from './clients/GptClient';
 export { type GptClientPlugin, GptClientPluginRegistry, } from './clients/GptClientPlugin';
 export { OpenAiGptClient } from './clients/OpenAiGptClient';
 export { VercelAiGptClient } from './clients/VercelAiGptClient';
+export * from './codegen/TargetCodeGenerator';
 export { env } from './envVars';
 export * from './exceptions/DonobuException';
 export * from './exceptions/FlowIdCollisionException';
@@ -14,6 +15,7 @@ export * from './exceptions/GptApiKeysNotSetupException';
 export * from './exceptions/GptPlatformAuthenticationFailedException';
 export * from './exceptions/InvalidParamValueException';
 export * from './exceptions/ToolCallFailedException';
+export * from './lib/ai/cache/assertCache';
 export * from './lib/ai/cache/cache';
 export * from './lib/ai/cache/cacheLocator';
 export type * from './lib/page/DonobuExtendedPage';
@@ -29,7 +31,7 @@ export { type DonobuStack, setupDonobuStack } from './managers/DonobuStack';
 export { InteractionVisualizer } from './managers/InteractionVisualizer';
 export { type LoadedPlugins, type PluginDependencies, PluginLoader, } from './managers/PluginLoader';
 export type * from './managers/TargetInspector';
-export { ToolManager } from './managers/ToolManager';
+export { buildToolInterpolationDataSource, ToolManager, } from './managers/ToolManager';
 export { createDefaultToolRegistry, type ToolRegistry, } from './managers/ToolRegistry';
 export * from './managers/WebTargetInspector';
 export type * from './models/AiQuery';
@@ -55,6 +57,7 @@ export type * from './models/ToolCall';
 export type * from './models/ToolCallContext';
 export * from './models/ToolCallResult';
 export * from './models/ToolSchema';
+export type * from './models/ToolTemplateDataSource';
 export type { VideoSegment } from './models/VideoSegment';
 export type { EnvPersistence } from './persistence/env/EnvPersistence';
 export { type FileUploadAggregateStatus, type FileUploadPlatformStatus, getFileUploadAggregateStatus, shutdownFileUploadWorkers, } from './persistence/files/fileUploadWorkerRegistry';
@@ -65,17 +68,20 @@ export type { TestsPersistence } from './persistence/tests/TestsPersistence';
 export type * from './targets/TargetProvider';
 export type { TargetRuntime } from './targets/TargetRuntime';
 export { type TargetRuntimeParams, type TargetRuntimePlugin, TargetRuntimePluginRegistry, } from './targets/TargetRuntimePlugin';
+export * from './tools/InputFakerTool';
 export * from './tools/ReplayableInteraction';
 export * from './tools/Tool';
 export * from './utils/buildProvenance';
 export * from './utils/createTool';
 export * from './utils/FlowLogBuffer';
+export * from './utils/JsonPath';
 export * from './utils/JsonSchemaUtils';
 export * from './utils/JsonUtils';
 export * from './utils/Logger';
 export * from './utils/MiscUtils';
 export * from './utils/PlaywrightUtils';
 export * from './utils/TargetUtils';
+export * from './utils/TemplateInterpolator';
 /**
  * Starts a Donobu API server at the given port. The server assumes that the
  * Playwright browsers have been installed.