@xopcai/xopc 0.0.368 → 0.0.370

package/dist/src/browser/automations/schema.d.ts

@@ -8,8 +8,8 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
         read: "read";
         draft: "draft";
         destructive: "destructive";
-        external_effect: "external_effect";
         sensitive: "sensitive";
+        external_effect: "external_effect";
     }>;
     inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         type: z.ZodEnum<{
@@ -41,6 +41,11 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>;
         expect: z.ZodOptional<z.ZodObject<{
             urlIncludes: z.ZodOptional<z.ZodString>;
@@ -58,6 +63,11 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>;
         value: z.ZodString;
         submit: z.ZodOptional<z.ZodBoolean>;
@@ -77,6 +87,11 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>;
         value: z.ZodString;
         expect: z.ZodOptional<z.ZodObject<{
@@ -89,12 +104,30 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
                 visible: "visible";
             }>>;
         }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"check">;
+        target: z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        checked: z.ZodBoolean;
     }, z.core.$strict>, z.ZodObject<{
         action: z.ZodLiteral<"press">;
         target: z.ZodOptional<z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         key: z.ZodString;
         expect: z.ZodOptional<z.ZodObject<{
@@ -113,6 +146,11 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         deltaY: z.ZodNumber;
         expect: z.ZodOptional<z.ZodObject<{
@@ -138,7 +176,52 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
             role: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
             nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>], "action">>;
+    successCriteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        target: z.ZodOptional<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        field: z.ZodEnum<{
+            value: "value";
+            text: "text";
+            title: "title";
+            url: "url";
+            checked: "checked";
+        }>;
+        equals: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
+        includes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        target: z.ZodOptional<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+            testId: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodObject<{
+                role: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        field: z.ZodEnum<{
+            value: "value";
+            text: "text";
+            title: "title";
+            url: "url";
+            href: "href";
+        }>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;

package/dist/src/browser/automations/schema.js

@@ -10,7 +10,12 @@ const ExpectationSchema = z.object({
 const TargetSchema = z.object({
 	role: z.string().min(1),
 	name: z.string().min(1).optional(),
-	nameIncludes: z.string().min(1).optional()
+	nameIncludes: z.string().min(1).optional(),
+	testId: z.string().min(1).optional(),
+	scope: z.object({
+		role: z.string().min(1),
+		name: z.string().min(1)
+	}).strict().optional()
 }).strict().superRefine((target, ctx) => {
 	if (target.name && target.nameIncludes) ctx.addIssue({
 		code: "custom",
@@ -41,6 +46,11 @@ const StepSchema = z.discriminatedUnion("action", [
 		value: z.string(),
 		expect: ExpectationSchema.optional()
 	}).strict(),
+	z.object({
+		action: z.literal("check"),
+		target: TargetSchema,
+		checked: z.boolean()
+	}).strict(),
 	z.object({
 		action: z.literal("press"),
 		target: TargetSchema.optional(),
@@ -115,13 +125,61 @@ const BrowserAutomationDefinitionSchema = z.object({
 		"sensitive"
 	]),
 	inputs: z.record(z.string(), InputSchema).default({}),
-	steps: z.array(StepSchema).min(1).max(100)
+	steps: z.array(StepSchema).min(1).max(100),
+	successCriteria: z.array(z.object({
+		target: TargetSchema.optional(),
+		field: z.enum([
+			"text",
+			"value",
+			"url",
+			"title",
+			"checked"
+		]),
+		equals: z.union([z.string(), z.boolean()]).optional(),
+		includes: z.string().optional()
+	}).strict().superRefine((assertion, ctx) => {
+		if (assertion.equals === void 0 === (assertion.includes === void 0)) ctx.addIssue({
+			code: "custom",
+			message: "Specify exactly one comparison."
+		});
+		if (assertion.field === "checked" && typeof assertion.equals !== "boolean") ctx.addIssue({
+			code: "custom",
+			message: "Checked assertions require a boolean comparison."
+		});
+		if (assertion.field !== "checked" && typeof assertion.equals === "boolean") ctx.addIssue({
+			code: "custom",
+			message: "Text assertions require a string comparison."
+		});
+		if (!["url", "title"].includes(assertion.field) && !assertion.target) ctx.addIssue({
+			code: "custom",
+			message: "Element assertions require a target."
+		});
+	})).max(20).optional(),
+	outputs: z.record(z.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/), z.object({
+		target: TargetSchema.optional(),
+		field: z.enum([
+			"text",
+			"value",
+			"url",
+			"title",
+			"href"
+		])
+	}).strict().superRefine((output, ctx) => {
+		if (!["url", "title"].includes(output.field) && !output.target) ctx.addIssue({
+			code: "custom",
+			message: "Element outputs require a target."
+		});
+	})).optional()
 }).strict().superRefine((definition, ctx) => {
 	if (new Set(definition.allowedDomains).size !== definition.allowedDomains.length) ctx.addIssue({
 		code: "custom",
 		path: ["allowedDomains"],
 		message: "Domains must be unique."
 	});
+	for (const spec of Object.values(definition.inputs)) if (spec.default !== void 0 && spec.choices && !spec.choices.includes(spec.default)) ctx.addIssue({
+		code: "custom",
+		message: "Default must be an allowed choice."
+	});
 	for (const [index, step] of definition.steps.entries()) {
 		const values = step.action === "navigate" ? [step.url] : step.action === "fill" || step.action === "select" ? [step.value] : step.action === "press" ? [step.key] : step.action === "wait" && step.value ? [step.value] : [];
 		for (const value of values) for (const match of value.matchAll(/\$\{input\.([a-zA-Z][a-zA-Z0-9_]*)\}/g)) if (!definition.inputs[match[1]]) ctx.addIssue({
@@ -130,6 +188,14 @@ const BrowserAutomationDefinitionSchema = z.object({
 			message: `Unknown input template: ${match[1]}.`
 		});
 	}
+	for (const [index, assertion] of (definition.successCriteria ?? []).entries()) for (const value of [assertion.equals, assertion.includes]) {
+		if (typeof value !== "string") continue;
+		for (const match of value.matchAll(/\$\{input\.([a-zA-Z][a-zA-Z0-9_]*)\}/g)) if (!definition.inputs[match[1]]) ctx.addIssue({
+			code: "custom",
+			path: ["successCriteria", index],
+			message: `Unknown input template: ${match[1]}.`
+		});
+	}
 });
 //#endregion
 export { BrowserAutomationDefinitionSchema };

package/dist/src/browser/automations/service.d.ts

@@ -4,10 +4,12 @@ export type BrowserAutomationExecutor = (input: {
     inputs: Record<string, unknown>;
     signal: AbortSignal;
     onStep: (event: unknown) => void;
+    runId: string;
 }) => Promise<{
     ok: boolean;
     result?: unknown;
     error?: string;
+    businessOutcome?: BrowserAutomationRun['businessOutcome'];
 }>;
 export declare class BrowserAutomationService {
     private readonly executor;
@@ -18,6 +20,7 @@ export declare class BrowserAutomationService {
     constructor(executor: BrowserAutomationExecutor, emit?: (type: string, payload: unknown) => void);
     list(): BrowserAutomation[];
     get(id: string): BrowserAutomation;
+    versions(id: string): BrowserAutomation[];
     listRuns(automationId?: string): BrowserAutomationRun[];
     getRun(id: string): BrowserAutomationRun;
     listRunEvents(id: string): import("./types.js").BrowserAutomationRunEvent[];
@@ -25,7 +28,7 @@ export declare class BrowserAutomationService {
         id: string;
         name: string;
         allowedDomains: string[];
-        risk: "read" | "draft" | "destructive" | "external_effect" | "sensitive";
+        risk: "read" | "draft" | "destructive" | "sensitive" | "external_effect";
         inputs: Record<string, {
             type: "string" | "number" | "boolean";
             required?: boolean;
@@ -49,6 +52,11 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             expect?: {
                 urlIncludes?: string;
@@ -63,6 +71,11 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             value: string;
             submit?: boolean;
@@ -79,6 +92,11 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             value: string;
             expect?: {
@@ -88,6 +106,19 @@ export declare class BrowserAutomationService {
                 ref?: string;
                 state?: "hidden" | "visible";
             };
+        } | {
+            action: "check";
+            target: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
+            };
+            checked: boolean;
         } | {
             action: "press";
             key: string;
@@ -95,6 +126,11 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             expect?: {
                 urlIncludes?: string;
@@ -110,6 +146,11 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             expect?: {
                 urlIncludes?: string;
@@ -126,15 +167,49 @@ export declare class BrowserAutomationService {
                 role: string;
                 name?: string;
                 nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
             };
             timeoutMs?: number;
         })[];
         description?: string;
+        successCriteria?: {
+            field: "value" | "text" | "title" | "url" | "checked";
+            target?: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
+            };
+            equals?: string | boolean;
+            includes?: string;
+        }[];
+        outputs?: Record<string, {
+            field: "value" | "text" | "title" | "url" | "href";
+            target?: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+                testId?: string;
+                scope?: {
+                    role: string;
+                    name: string;
+                };
+            };
+        }>;
     }>;
     save(input: {
         definition: unknown;
         status?: BrowserAutomationStatus;
         expectedId?: string;
+        expectedRevision?: number;
     }): BrowserAutomation;
     remove(id: string): boolean;
     startRun(automationId: string, inputs: Record<string, unknown>, context?: BrowserAutomationExecutionContext): BrowserAutomationRun;
@@ -145,6 +220,8 @@ export declare class BrowserAutomationService {
     private execute;
 }
 export interface BrowserAutomationExecutionContext {
+    revision?: number;
+    clientRequestId?: string;
     triggerEvent?: {
         type: string;
         source?: string;

package/dist/src/browser/automations/service.js

@@ -1,6 +1,6 @@
 import { BrowserAutomationDefinitionSchema } from "./schema.js";
 import { resolveBrowserAutomationInputs } from "./runner.js";
-import { appendBrowserAutomationRunEvent, deleteBrowserAutomation, getBrowserAutomation, getBrowserAutomationRun, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun } from "./repository.js";
+import { appendBrowserAutomationRunEvent, deleteBrowserAutomation, findBrowserAutomationRunByRequest, getBrowserAutomation, getBrowserAutomationRun, getBrowserAutomationVersion, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomationVersions, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun, verifyBrowserAutomationRun } from "./repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/browser/automations/service.ts
 var BrowserAutomationService = class {
@@ -15,7 +15,8 @@ var BrowserAutomationService = class {
 			saveBrowserAutomationRun({
 				...run,
 				status: "failed",
-				error: "Gateway stopped before the run completed.",
+				businessOutcome: "unknown",
+				error: "Gateway stopped before the run completed. Check the business result before running again.",
 				endedAtMs,
 				durationMs: run.startedAtMs ? endedAtMs - run.startedAtMs : void 0
 			});
@@ -27,6 +28,9 @@ var BrowserAutomationService = class {
 	get(id) {
 		return getBrowserAutomation(id);
 	}
+	versions(id) {
+		return listBrowserAutomationVersions(id);
+	}
 	listRuns(automationId) {
 		return listBrowserAutomationRuns(automationId);
 	}
@@ -43,10 +47,13 @@ var BrowserAutomationService = class {
 		const parsed = BrowserAutomationDefinitionSchema.parse(input.definition);
 		if (input.expectedId && parsed.id !== input.expectedId) throw new Error("Browser automation id cannot change.");
 		const existing = getBrowserAutomation(parsed.id);
+		if (input.expectedRevision !== void 0 && existing?.revision !== input.expectedRevision) throw new Error("Browser automation revision changed. Reload before saving.");
+		const changed = !existing || canonical(existing.definition) !== canonical(parsed);
 		const now = Date.now();
 		const automation = {
 			id: parsed.id,
-			revision: (existing?.revision ?? 0) + 1,
+			verified: !changed && !!existing?.verified,
+			revision: (existing?.revision ?? 0) + (changed ? 1 : 0),
 			status: input.status ?? existing?.status ?? "enabled",
 			definition: parsed,
 			createdAtMs: existing?.createdAtMs ?? now,
@@ -60,12 +67,22 @@ var BrowserAutomationService = class {
 		return deleteBrowserAutomation(id);
 	}
 	startRun(automationId, inputs, context) {
-		const automation = getBrowserAutomation(automationId);
+		const requestId = context?.clientRequestId;
+		if (requestId) {
+			const previous = findBrowserAutomationRunByRequest(requestId);
+			if (previous) {
+				const contextualInputs = mergeBrowserAutomationTriggerInputs(previous.definition, inputs, context);
+				if (previous.automationId !== automationId || context?.revision !== void 0 && context.revision !== previous.automationRevision || canonical(previous.inputs) !== canonical(resolveBrowserAutomationInputs(previous.definition, contextualInputs))) throw new Error("Run request id was reused with a different automation, revision or inputs.");
+				return previous;
+			}
+		}
+		const automation = context?.revision !== void 0 ? getBrowserAutomationVersion(automationId, context.revision) : getBrowserAutomation(automationId);
 		if (!automation) throw new Error("Browser automation not found.");
 		if (automation.status !== "enabled") throw new Error("Browser automation is disabled.");
 		const contextualInputs = mergeBrowserAutomationTriggerInputs(automation.definition, inputs, context);
 		const resolvedInputs = resolveBrowserAutomationInputs(automation.definition, contextualInputs);
 		const run = {
+			clientRequestId: requestId,
 			id: randomUUID(),
 			automationId,
 			automationRevision: automation.revision,
@@ -93,6 +110,8 @@ var BrowserAutomationService = class {
 	}
 	async runAndWait(automationId, inputs, signal, context) {
 		const run = this.startRun(automationId, inputs, context);
+		const terminal = this.getRun(run.id);
+		if (terminal && !["queued", "running"].includes(terminal.status)) return terminal;
 		return new Promise((resolve) => {
 			const complete = (value) => {
 				signal?.removeEventListener("abort", onAbort);
@@ -131,6 +150,7 @@ var BrowserAutomationService = class {
 		this.addEvent(run.id, "run.started");
 		try {
 			const outcome = await this.executor({
+				runId: run.id,
 				definition: run.definition,
 				inputs: run.inputs,
 				signal: controller.signal,
@@ -142,6 +162,13 @@ var BrowserAutomationService = class {
 				status: controller.signal.aborted ? "cancelled" : outcome.ok ? "succeeded" : "failed",
 				result: outcome.result,
 				error: outcome.error,
+				businessOutcome: outcome.businessOutcome ?? (!outcome.ok && run.definition.steps.some((step) => [
+					"click",
+					"press",
+					"fill",
+					"select",
+					"check"
+				].includes(step.action)) ? "unknown" : "completed"),
 				endedAtMs,
 				durationMs: endedAtMs - startedAtMs
 			};
@@ -150,12 +177,14 @@ var BrowserAutomationService = class {
 			current = {
 				...current,
 				status: controller.signal.aborted ? "cancelled" : "failed",
+				businessOutcome: "unknown",
 				error: error instanceof Error ? error.message : String(error),
 				endedAtMs,
 				durationMs: endedAtMs - startedAtMs
 			};
 		}
 		saveBrowserAutomationRun(current);
+		verifyBrowserAutomationRun(current);
 		this.addEvent(run.id, "run.completed", {
 			status: current.status,
 			error: current.error
@@ -178,5 +207,8 @@ function mergeBrowserAutomationTriggerInputs(definition, inputs, context) {
 	for (const name of Object.keys(definition.inputs)) if (merged[name] === void 0 && candidates[name] !== void 0) merged[name] = candidates[name];
 	return merged;
 }
+function canonical(value) {
+	return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+}
 //#endregion
 export { BrowserAutomationService, mergeBrowserAutomationTriggerInputs };

package/dist/src/browser/automations/types.d.ts

@@ -1,4 +1,6 @@
 import type { BrowserExpectation, BrowserRiskLevel } from '@xopcai/browser-control-contract';
+import type { BrowserSemanticTarget } from '@xopcai/browser-control-contract';
+export type { BrowserSemanticTarget } from '@xopcai/browser-control-contract';
 export type BrowserAutomationStatus = 'enabled' | 'disabled';
 export type BrowserAutomationRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
 export interface BrowserAutomationInputDefinition {
@@ -8,10 +10,11 @@ export interface BrowserAutomationInputDefinition {
     description?: string;
     choices?: Array<string | number | boolean>;
 }
-export interface BrowserSemanticTarget {
-    role: string;
-    name?: string;
-    nameIncludes?: string;
+export interface BrowserAutomationAssertion {
+    target?: BrowserSemanticTarget;
+    field: 'text' | 'value' | 'url' | 'title' | 'checked';
+    equals?: string | boolean;
+    includes?: string;
 }
 export type BrowserAutomationStep = {
     action: 'navigate';
@@ -32,6 +35,10 @@ export type BrowserAutomationStep = {
     target: BrowserSemanticTarget;
     value: string;
     expect?: BrowserExpectation;
+} | {
+    action: 'check';
+    target: BrowserSemanticTarget;
+    checked: boolean;
 } | {
     action: 'press';
     target?: BrowserSemanticTarget;
@@ -57,10 +64,16 @@ export interface BrowserAutomationDefinition {
     risk: BrowserRiskLevel;
     inputs: Record<string, BrowserAutomationInputDefinition>;
     steps: BrowserAutomationStep[];
+    successCriteria?: BrowserAutomationAssertion[];
+    outputs?: Record<string, {
+        target?: BrowserSemanticTarget;
+        field: 'text' | 'value' | 'url' | 'title' | 'href';
+    }>;
 }
 export interface BrowserAutomation {
     id: string;
     revision: number;
+    verified: boolean;
     status: BrowserAutomationStatus;
     definition: BrowserAutomationDefinition;
     createdAtMs: number;
@@ -70,6 +83,8 @@ export interface BrowserAutomationRun {
     id: string;
     automationId: string;
     automationRevision: number;
+    clientRequestId?: string;
+    businessOutcome?: 'completed' | 'verified' | 'unknown';
     definition: BrowserAutomationDefinition;
     status: BrowserAutomationRunStatus;
     inputs: Record<string, unknown>;

package/dist/src/browser/drivers/extension-driver.d.ts

@@ -3,7 +3,7 @@ import type { BrowserDriver, BrowserPrimitiveInput } from './browser-driver.js';
 type ExtensionProvider = {
     start(): Promise<void>;
     waitForConnection(timeoutMs?: number): Promise<void>;
-    send(input: import('@xopcai/browser-control-contract').BrowserActionInput, timeoutMs?: number, visualFallback?: boolean): Promise<import('@xopcai/browser-control-contract').BrowserWireResult>;
+    send(input: import('@xopcai/browser-control-contract').BrowserActionInput, timeoutMs?: number, visualFallback?: boolean, signal?: AbortSignal): Promise<import('@xopcai/browser-control-contract').BrowserWireResult>;
 };
 export declare class ExtensionDriver implements BrowserDriver {
     private readonly provider;
@@ -16,10 +16,10 @@ export declare class ExtensionDriver implements BrowserDriver {
     disconnect(): Promise<void>;
     createSession(_sessionId: string): Promise<void>;
     closeSession(sessionId: string): Promise<void>;
-    navigate(sessionId: string, input: BrowserNavigateInput): Promise<BrowserControlResult>;
-    observe(sessionId: string, input: BrowserObserveInput): Promise<BrowserObservation>;
-    perform(sessionId: string, input: BrowserPrimitiveInput): Promise<BrowserControlResult>;
-    tabs(sessionId: string, input: BrowserTabsInput): Promise<BrowserControlResult>;
+    navigate(sessionId: string, input: BrowserNavigateInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    observe(sessionId: string, input: BrowserObserveInput, signal?: AbortSignal): Promise<BrowserObservation>;
+    perform(sessionId: string, input: BrowserPrimitiveInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    tabs(sessionId: string, input: BrowserTabsInput, signal?: AbortSignal): Promise<BrowserControlResult>;
     private send;
 }
 export {};

package/dist/src/browser/drivers/extension-driver.js

@@ -23,36 +23,36 @@ var ExtensionDriver = class {
 			sessionId
 		});
 	}
-	navigate(sessionId, input) {
+	navigate(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	async observe(sessionId, input) {
+	async observe(sessionId, input, signal) {
 		const result = await this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 		if ("error" in result) throw new Error(result.error.message);
 		const observation = result.receipt.observation;
 		if (!observation) throw new Error("Extension returned no browser observation");
 		return observation;
 	}
-	perform(sessionId, input) {
+	perform(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	tabs(sessionId, input) {
+	tabs(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	async send(input) {
-		return (await this.provider.send(input, this.timeoutMs, this.visualFallback)).result;
+	async send(input, signal) {
+		return (await this.provider.send(input, this.timeoutMs, this.visualFallback, signal)).result;
 	}
 };
 //#endregion