@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/auth/model-credential-store.js

@@ -1,4 +1,5 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "./oauth-provider-lock.js";
 import { CredentialResolver, init_credentials } from "./credentials.js";
 //#region src/auth/model-credential-store.ts
 function normalizeProviderId(providerId) {
@@ -30,26 +31,10 @@ function toPersistedToken(credential, current) {
 		createdAt: current?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
 	};
 }
-async function serializeProviderModification(providerId, operation) {
-	const previous = providerModificationTails.get(providerId) ?? Promise.resolve();
-	let release;
-	const gate = new Promise((resolve) => {
-		release = resolve;
-	});
-	const tail = previous.catch(() => void 0).then(() => gate);
-	providerModificationTails.set(providerId, tail);
-	await previous.catch(() => void 0);
-	try {
-		return await operation();
-	} finally {
-		release();
-		if (providerModificationTails.get(providerId) === tail) providerModificationTails.delete(providerId);
-	}
-}
-var providerModificationTails, XopcModelCredentialStore;
+var XopcModelCredentialStore;
 var init_model_credential_store = __esmMin((() => {
 	init_credentials();
-	providerModificationTails = /* @__PURE__ */ new Map();
+	init_oauth_provider_lock();
 	XopcModelCredentialStore = class {
 		runtimeApiKeys = /* @__PURE__ */ new Map();
 		constructor(repository = new CredentialResolver()) {
@@ -81,7 +66,7 @@ var init_model_credential_store = __esmMin((() => {
 		}
 		async modify(providerId, update, options) {
 			const normalizedProvider = normalizeProviderId(providerId);
-			return serializeProviderModification(normalizedProvider, async () => {
+			return withOAuthProviderLock(normalizedProvider, async () => {
 				options?.signal?.throwIfAborted();
 				const persisted = await this.repository.loadOAuthTokenRecord(normalizedProvider);
 				const current = this.runtimeApiKeys.get(normalizedProvider) ?? (persisted ? toRuntimeCredential(persisted) : void 0);
@@ -93,15 +78,15 @@ var init_model_credential_store = __esmMin((() => {
 					this.runtimeApiKeys.delete(normalizedProvider);
 				} else this.runtimeApiKeys.set(normalizedProvider, updated);
 				return updated;
-			});
+			}, { signal: options?.signal });
 		}
 		async delete(providerId, options) {
 			const normalizedProvider = normalizeProviderId(providerId);
-			await serializeProviderModification(normalizedProvider, async () => {
+			await withOAuthProviderLock(normalizedProvider, async () => {
 				options?.signal?.throwIfAborted();
 				await this.repository.deleteOAuthToken(normalizedProvider);
 				this.runtimeApiKeys.delete(normalizedProvider);
-			});
+			}, { signal: options?.signal });
 		}
 	};
 }));

package/dist/src/auth/oauth-provider-lock.d.ts

@@ -0,0 +1,5 @@
+interface OAuthProviderLockOptions {
+    signal?: AbortSignal;
+}
+export declare function withOAuthProviderLock<T>(providerId: string, operation: () => Promise<T>, options?: OAuthProviderLockOptions): Promise<T>;
+export {};

package/dist/src/auth/oauth-provider-lock.js

@@ -0,0 +1,91 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_paths, resolveOAuthPath } from "../config/paths.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+//#region src/auth/oauth-provider-lock.ts
+function lockPath(providerId) {
+	return `${resolveOAuthPath(providerId.toLowerCase())}.lock`;
+}
+function isAlreadyExists(error) {
+	return error?.code === "EEXIST";
+}
+function isMissing(error) {
+	return error?.code === "ENOENT";
+}
+async function removeStaleLock(path) {
+	try {
+		const info = await stat(path);
+		if (Date.now() - info.mtimeMs < STALE_LOCK_MS) return false;
+		await rm(path, { force: true });
+		return true;
+	} catch (error) {
+		if (isMissing(error)) return true;
+		throw error;
+	}
+}
+async function acquireFileLock(providerId, options) {
+	const path = lockPath(providerId);
+	const owner = `${process.pid}:${randomUUID()}`;
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	await mkdir(dirname(path), { recursive: true });
+	while (true) {
+		options.signal?.throwIfAborted();
+		try {
+			const handle = await open(path, "wx", 384);
+			try {
+				await handle.writeFile(owner, "utf8");
+			} finally {
+				await handle.close();
+			}
+			return async () => {
+				try {
+					if (await readFile(path, "utf8") === owner) await rm(path, { force: true });
+				} catch {}
+			};
+		} catch (error) {
+			if (!isAlreadyExists(error)) throw error;
+			if (await removeStaleLock(path)) continue;
+			if (Date.now() >= deadline) throw new Error(`Timed out waiting for OAuth credential lock for ${providerId}`);
+			await setTimeout(LOCK_RETRY_MS, void 0, options.signal ? { signal: options.signal } : void 0);
+		}
+	}
+}
+async function withOAuthProviderLock(providerId, operation, options = {}) {
+	const normalizedProvider = providerId.toLowerCase();
+	const heldLocks = heldProviderLocks.getStore();
+	if (heldLocks?.has(normalizedProvider)) return operation();
+	const previous = providerModificationTails.get(normalizedProvider) ?? Promise.resolve();
+	let releaseQueue;
+	const queueGate = new Promise((resolve) => {
+		releaseQueue = resolve;
+	});
+	const tail = previous.catch(() => void 0).then(() => queueGate);
+	providerModificationTails.set(normalizedProvider, tail);
+	await previous.catch(() => void 0);
+	let releaseFileLock;
+	try {
+		releaseFileLock = await acquireFileLock(normalizedProvider, options);
+		const nextHeldLocks = new Set(heldLocks);
+		nextHeldLocks.add(normalizedProvider);
+		return await heldProviderLocks.run(nextHeldLocks, operation);
+	} finally {
+		await releaseFileLock?.();
+		releaseQueue();
+		if (providerModificationTails.get(normalizedProvider) === tail) providerModificationTails.delete(normalizedProvider);
+	}
+}
+var LOCK_RETRY_MS, LOCK_TIMEOUT_MS, STALE_LOCK_MS, providerModificationTails, heldProviderLocks;
+var init_oauth_provider_lock = __esmMin((() => {
+	init_paths();
+	LOCK_RETRY_MS = 50;
+	LOCK_TIMEOUT_MS = 9e4;
+	STALE_LOCK_MS = 6e4;
+	providerModificationTails = /* @__PURE__ */ new Map();
+	heldProviderLocks = new AsyncLocalStorage();
+}));
+//#endregion
+init_oauth_provider_lock();
+export { init_oauth_provider_lock, withOAuthProviderLock };

package/dist/src/auth/profiles/store.js

@@ -1,5 +1,5 @@
-import { init_paths, resolveCredentialsDir } from "../../config/paths.js";
 import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
+import { init_paths, resolveCredentialsDir } from "../../config/paths.js";
 import path from "node:path";
 import { chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 //#region src/auth/profiles/store.ts

package/dist/src/auth/sync-provider-auth.js

@@ -1,8 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, resolveOAuthPath } from "../config/paths.js";
-import { init_loader, loadConfig } from "../config/loader.js";
 import { init_registry, isOAuthOnlyProvider } from "./oauth/registry.js";
+import { init_loader, loadConfig } from "../config/loader.js";
+import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/auth/sync-provider-auth.ts
 /**

package/dist/src/automations/domain/defaults.d.ts

@@ -1 +1,8 @@
-export declare const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 300;
+import type { AutomationAction } from './types.js';
+export declare const DEFAULT_AUTOMATION_TIMEOUT_SECONDS: number;
+export declare const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS: number;
+export declare function defaultAutomationTimeoutSeconds(action: AutomationAction): number;
+export declare function resolveAutomationTimeoutSeconds(action: AutomationAction, reliability?: {
+    executionTimeoutSeconds?: number;
+    timeoutSeconds?: number;
+}): number;

package/dist/src/automations/domain/defaults.js

@@ -1,4 +1,11 @@
 //#region src/automations/domain/defaults.ts
-const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 300;
+const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 1800;
+const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS = 600;
+function defaultAutomationTimeoutSeconds(action) {
+	return action.kind === "browser_recipe" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
+}
+function resolveAutomationTimeoutSeconds(action, reliability) {
+	return reliability?.executionTimeoutSeconds ?? action.timeoutSeconds ?? reliability?.timeoutSeconds ?? defaultAutomationTimeoutSeconds(action);
+}
 //#endregion
-export { DEFAULT_AUTOMATION_TIMEOUT_SECONDS };
+export { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds };

package/dist/src/automations/domain/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS } from "./defaults.js";
+import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./defaults.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./schedule.js";
 import { AutomationActionSchema, AutomationAfterRunSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./validation.js";
-export { AutomationActionSchema, AutomationAfterRunSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil };
+export { AutomationActionSchema, AutomationAfterRunSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds, timerDelayUntil };

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

@@ -1,5 +1,5 @@
 import type { WorkflowRunInputEnvelope } from '../../workflows/domain/index.js';
-import type { StartWorkflowRunServiceParams, WorkflowRunServiceResult } from '../../workflows/service/workflow-run-service.types.js';
+import type { WorkflowRunServiceLike } from '../../workflows/service/workflow-run-service.types.js';
 export type AutomationSchedule = {
     kind: 'once';
     at: string;
@@ -58,11 +58,20 @@ export type AutomationAfterRun = {
     url: string;
 };
 export interface AutomationReliability {
+    /** Overall run deadline. `timeoutSeconds` remains a read-only legacy fallback. */
+    executionTimeoutSeconds?: number;
     timeoutSeconds?: number;
     retryCount?: number;
     maxConcurrentRuns?: number;
     disableAfterConsecutiveFailures?: number;
 }
+export type AutomationRunPhase = 'queued' | 'action' | 'after_run' | 'cancelling' | 'completed';
+export interface AutomationRunTermination {
+    reason: 'completed' | 'failed' | 'user_cancelled' | 'deadline_exceeded';
+    component?: 'automation' | 'agent_turn' | 'tool' | 'mcp' | 'process';
+    componentName?: string;
+    cancellationConfirmed: boolean;
+}
 export type AutomationSafetyMode = 'suggest_only' | 'ask_before_apply' | 'auto_apply';
 export interface AutomationSafetyPolicy {
     mode: AutomationSafetyMode;
@@ -90,7 +99,7 @@ export interface Automation {
     createdAtMs: number;
     updatedAtMs: number;
 }
-export type AutomationRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'timeout';
+export type AutomationRunStatus = 'queued' | 'running' | 'cancelling' | 'succeeded' | 'failed' | 'cancelled' | 'timeout';
 export interface AutomationRun {
     id: string;
     automationId: string;
@@ -108,8 +117,18 @@ export interface AutomationRun {
     sessionKey?: string;
     workflowRunId?: string;
     model?: string;
+    deadlineAtMs?: number;
+    currentPhase?: AutomationRunPhase;
+    cancelRequestedAtMs?: number;
+    cancelConfirmedAtMs?: number;
+    termination?: AutomationRunTermination;
+    heartbeatAtMs?: number;
+    leaseOwner?: string;
+    leaseExpiresAtMs?: number;
+    attemptNumber?: number;
+    rootRunId?: string;
 }
-export type AutomationRunEventType = 'run.queued' | 'run.started' | 'action.started' | 'action.completed' | 'action.failed' | 'after_run.started' | 'after_run.completed' | 'after_run.failed' | 'run.completed';
+export type AutomationRunEventType = 'run.queued' | 'run.started' | 'run.deadline_resolved' | 'run.cancel_requested' | 'run.cancel_confirmed' | 'run.cancellation_unconfirmed' | 'run.recovered' | 'action.started' | 'action.retry_scheduled' | 'action.completed' | 'action.failed' | 'after_run.started' | 'after_run.completed' | 'after_run.failed' | 'run.completed';
 export interface AutomationRunEvent {
     id: string;
     runId: string;
@@ -147,15 +166,17 @@ export interface AutomationDeps {
             applyAutomationModelOverride?: (sessionKey: string, model: string | undefined) => Promise<boolean>;
         };
         turnDispatcher?: {
-            processDirect: (message: string, sessionKey: string) => Promise<string>;
+            processDirect: (message: string, sessionKey: string, attachments?: unknown[], thinking?: string, options?: {
+                signal?: AbortSignal;
+                runId?: string;
+                deadlineAtMs?: number;
+            }) => Promise<string>;
         };
         getModelForSession?: (sessionKey: string) => string | undefined;
     };
     getDefaultAgentId?: () => string;
     getProjectWorkspaceRoot?: (projectId: string) => string | undefined;
-    workflowRunService?: {
-        startWorkflowRun(params: StartWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
-    };
+    workflowRunService?: WorkflowRunServiceLike;
     browserRecipeService?: {
         runAndWait(recipeId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
             id: string;
@@ -173,4 +194,9 @@ export interface AutomationActionOutcome {
     sessionKey?: string;
     workflowRunId?: string;
     model?: string;
+    deadlineAtMs?: number;
+    termination?: AutomationRunTermination;
+}
+export interface AutomationActionExecutionHooks {
+    onRunPatch?: (patch: Partial<AutomationRun>) => void | Promise<void>;
 }

package/dist/src/automations/domain/validation.d.ts

@@ -73,6 +73,7 @@ export declare const AutomationAfterRunSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     url: z.ZodString;
 }, z.core.$strict>], "kind">;
 export declare const AutomationReliabilitySchema: z.ZodObject<{
+    executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     retryCount: z.ZodOptional<z.ZodNumber>;
     maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
@@ -96,6 +97,7 @@ export declare const AutomationStateSchema: z.ZodObject<{
         cancelled: "cancelled";
         timeout: "timeout";
         succeeded: "succeeded";
+        cancelling: "cancelling";
     }>>;
     lastError: z.ZodOptional<z.ZodString>;
     consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -175,6 +177,7 @@ export declare const AutomationSchema: z.ZodObject<{
         url: z.ZodString;
     }, z.core.$strict>], "kind">>;
     reliability: z.ZodOptional<z.ZodObject<{
+        executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
@@ -191,6 +194,7 @@ export declare const AutomationSchema: z.ZodObject<{
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
+            cancelling: "cancelling";
         }>>;
         lastError: z.ZodOptional<z.ZodString>;
         consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -271,6 +275,7 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         url: z.ZodString;
     }, z.core.$strict>], "kind">>;
     reliability: z.ZodOptional<z.ZodObject<{
+        executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
@@ -289,6 +294,7 @@ export declare const CreateAutomationSchema: z.ZodObject<{
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
+            cancelling: "cancelling";
         }>>>;
         lastError: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         consecutiveFailures: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -337,6 +343,7 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
             cancelled: "cancelled";
             timeout: "timeout";
             succeeded: "succeeded";
+            cancelling: "cancelling";
         }>>;
         lastError: z.ZodOptional<z.ZodString>;
         consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -383,6 +390,7 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         url: z.ZodString;
     }, z.core.$strict>], "kind">>>;
     reliability: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;

package/dist/src/automations/domain/validation.js

@@ -97,6 +97,7 @@ const AutomationAfterRunSchema = z.discriminatedUnion("kind", [
 	}).strict()
 ]);
 const AutomationReliabilitySchema = z.object({
+	executionTimeoutSeconds: z.number().int().min(1).max(86400).optional(),
 	timeoutSeconds: z.number().int().min(1).max(86400).optional(),
 	retryCount: z.number().int().min(0).max(10).optional(),
 	maxConcurrentRuns: z.number().int().min(1).max(20).optional(),
@@ -114,6 +115,7 @@ const AutomationStateSchema = z.object({
 	lastRunStatus: z.enum([
 		"queued",
 		"running",
+		"cancelling",
 		"succeeded",
 		"failed",
 		"cancelled",

package/dist/src/automations/draft/automation-draft-validator.d.ts

@@ -78,6 +78,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             url: string;
         };
         reliability?: {
+            executionTimeoutSeconds?: number;
             timeoutSeconds?: number;
             retryCount?: number;
             maxConcurrentRuns?: number;
@@ -89,7 +90,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             nextRunAtMs?: number;
             runningRunId?: string;
             lastRunAtMs?: number;
-            lastRunStatus?: "queued" | "running" | "failed" | "cancelled" | "timeout" | "succeeded";
+            lastRunStatus?: "queued" | "running" | "failed" | "cancelled" | "timeout" | "succeeded" | "cancelling";
             lastError?: string;
             consecutiveFailures?: number;
         };

package/dist/src/automations/index.js

@@ -1,9 +1,9 @@
 import { onAutomationProductEvent, publishAutomationProductEvent } from "./product-events.js";
-import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS } from "./domain/defaults.js";
+import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./domain/defaults.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./domain/schedule.js";
 import { AutomationActionSchema, AutomationAfterRunSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
 import "./domain/index.js";
 import { AutomationActionExecutor } from "./service/action-executor.js";
 import { AutomationAlreadyRunningError, AutomationService } from "./service/automation-service.js";
 import "./service/index.js";
-export { AutomationActionExecutor, AutomationActionSchema, AutomationAfterRunSchema, AutomationAlreadyRunningError, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, onAutomationProductEvent, publishAutomationProductEvent, timerDelayUntil };
+export { AutomationActionExecutor, AutomationActionSchema, AutomationAfterRunSchema, AutomationAlreadyRunningError, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, onAutomationProductEvent, publishAutomationProductEvent, resolveAutomationTimeoutSeconds, timerDelayUntil };

package/dist/src/automations/service/action-executor.d.ts

@@ -1,8 +1,8 @@
-import type { Automation, AutomationActionOutcome, AutomationDeps, AutomationRun } from '../domain/types.js';
+import type { Automation, AutomationActionExecutionHooks, AutomationActionOutcome, AutomationDeps, AutomationRun } from '../domain/types.js';
 export declare class AutomationActionExecutor {
     private deps;
     setDeps(deps: AutomationDeps): void;
-    execute(automation: Automation, run: AutomationRun, signal: AbortSignal): Promise<AutomationActionOutcome>;
+    execute(automation: Automation, run: AutomationRun, signal: AbortSignal, hooks?: AutomationActionExecutionHooks): Promise<AutomationActionOutcome>;
     private executeWithoutTimeout;
     private executeBrowserRecipe;
     private executeAgent;