@xopcai/xopc 0.0.161 → 0.0.163

package/dist/src/agent/tools/browser-recipe-tool.js

@@ -0,0 +1,113 @@
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/browser-recipe-tool.ts
+const BrowserRecipeToolSchema = Type.Object({
+	action: Type.Union([
+		Type.Literal("list"),
+		Type.Literal("get"),
+		Type.Literal("save"),
+		Type.Literal("enable"),
+		Type.Literal("disable"),
+		Type.Literal("delete"),
+		Type.Literal("run")
+	]),
+	recipeId: Type.Optional(Type.String({ description: "Workflow id for get, enable, disable, delete, or run." })),
+	yaml: Type.Optional(Type.String({ description: "Canonical Browser Recipe v1 YAML generated internally when saving." })),
+	args: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Typed workflow inputs for a run." }))
+});
+function result(text, details) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details
+	};
+}
+function presentWorkflow(recipe) {
+	if (!recipe) return void 0;
+	return {
+		id: recipe.id,
+		name: recipe.name,
+		description: recipe.description,
+		enabled: recipe.status === "published",
+		risk: recipe.risk,
+		domains: recipe.domains
+	};
+}
+function createBrowserRecipeTool(deps) {
+	return {
+		name: "browser_recipe",
+		label: "Browser Automation",
+		description: "Create and manage reusable browser automations for the user. Use save after a successful browser_use sequence when the user asks to save or repeat it. The yaml field is an internal Browser Recipe document: apiVersion must be xopc.ai/browser-recipe/v1; include kebab-case id, user-facing name and description, risk, exact domains, typed args, and pipeline. Every pipeline step has exactly one action with an object value. Use ${{ args.name }} for variable inputs. New saves are enabled immediately. Only delete on an explicit user request. Users should never need to write or see this YAML.",
+		parameters: BrowserRecipeToolSchema,
+		async execute(_toolCallId, params, signal) {
+			const service = deps.getBrowserRecipeService();
+			if (!service) return result("Browser automation is not available.", { ok: false });
+			if (params.action === "list") {
+				const recipes = service.list();
+				return result(recipes.length === 0 ? "No browser automations." : recipes.map((recipe) => `- ${recipe.id}: ${recipe.name} (${recipe.status === "published" ? "enabled" : "paused"}, ${recipe.risk})`).join("\n"), { workflows: recipes.map(presentWorkflow) });
+			}
+			const recipeId = params.recipeId?.trim();
+			if (params.action === "save") {
+				if (!params.yaml?.trim()) return result("The internal definition is required to save a browser automation.", { ok: false });
+				try {
+					const recipe = service.save({ yaml: params.yaml });
+					return result(`Saved and enabled browser automation: ${recipe.name}`, {
+						ok: true,
+						workflow: presentWorkflow(recipe)
+					});
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return result(`Could not save browser automation: ${message}`, {
+						ok: false,
+						error: message
+					});
+				}
+			}
+			if (!recipeId) return result("recipeId is required.", { ok: false });
+			if (params.action === "get") {
+				const recipe = service.get(recipeId);
+				if (!recipe) return result(`Browser automation not found: ${recipeId}`, { ok: false });
+				return result(`${recipe.name}\nEnabled: ${recipe.status === "published" ? "yes" : "no"}\nRisk: ${recipe.risk}\nDomains: ${recipe.domains.join(", ")}`, { workflow: presentWorkflow(recipe) });
+			}
+			if (params.action === "enable" || params.action === "disable") {
+				const recipe = service.get(recipeId);
+				if (!recipe) return result(`Browser automation not found: ${recipeId}`, { ok: false });
+				const saved = service.save({
+					yaml: recipe.yaml,
+					status: params.action === "enable" ? "published" : "disabled",
+					expectedId: recipe.id
+				});
+				return result(`${saved.name} is now ${params.action === "enable" ? "enabled" : "disabled"}.`, {
+					ok: true,
+					workflow: presentWorkflow(saved)
+				});
+			}
+			if (params.action === "delete") try {
+				const removed = service.remove(recipeId);
+				return result(removed ? `Deleted browser automation: ${recipeId}` : `Browser automation not found: ${recipeId}`, { ok: removed });
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return result(`Could not delete browser automation: ${message}`, {
+					ok: false,
+					error: message
+				});
+			}
+			try {
+				const run = await service.runAndWait(recipeId, params.args ?? {}, signal);
+				return result(run.status === "succeeded" ? `Browser automation ${recipeId} completed.` : `Browser automation ${recipeId} ${run.status}: ${run.error ?? "No error details"}`, {
+					ok: run.status === "succeeded",
+					run
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return result(`Browser automation failed: ${message}`, {
+					ok: false,
+					error: message
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { createBrowserRecipeTool };

package/dist/src/agent/tools/factory.d.ts

@@ -15,6 +15,7 @@ import type { MemoryManager } from '../memory/manager.js';
 import type { SessionStore } from '../../session/store.js';
 import type { GatewayClarifyRequestFn } from './clarify-tool.js';
 import type { AutomationService } from '../../automations/index.js';
+import type { BrowserRecipeService } from '../../browser/recipes/index.js';
 import type { NotesService } from '../../notes/index.js';
 import type { ProjectService } from '../../projects/index.js';
 import type { WorkItemService } from '../../work-items/index.js';
@@ -48,6 +49,7 @@ export interface ToolFactoryDeps {
     };
     /** Gateway: enables the `automation` tool. */
     getAutomationService?: () => AutomationService | undefined;
+    getBrowserRecipeService?: () => BrowserRecipeService | undefined;
     /** Gateway: enables the `xopc_use` product-object tool. */
     getNotesService?: () => NotesService | undefined;
     getProjectService?: () => ProjectService | undefined;

package/dist/src/agent/tools/factory.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
 import { createReadFileTool } from "./read.js";
 import { createWriteFileTool } from "./write.js";
 import { createListDirTool } from "./list-dir.js";
@@ -32,6 +33,7 @@ import "./delegate-tool.js";
 import { createWorkflowTool } from "./workflow-tool.js";
 import "./execute-code-tool.js";
 import { createAutomationTool } from "./automation-tool.js";
+import { createBrowserRecipeTool } from "./browser-recipe-tool.js";
 import { createGoalTool } from "./goal-tool.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
 import { createSkillViewTool, createSkillsListTool } from "./skills-tools.js";
@@ -55,6 +57,7 @@ import { getAgentCapabilityToolNames } from "../capabilities/registry.js";
 import "../capabilities/index.js";
 import { isCodeIntelligenceEnabledForAgent } from "../code-intelligence/tool-gating.js";
 //#region src/agent/tools/factory.ts
+init_agent_scope();
 init_logger();
 const log = createLogger("AgentToolsFactory");
 /** Channels where `clarify` can block for a user answer (web UI, Telegram, CLI readline). */
@@ -172,7 +175,8 @@ var AgentToolsFactory = class {
 		});
 		const imageGenerateTool = createImageGenerateTool({
 			config: cfg,
-			workspace
+			workspace,
+			agentId: options?.agentId ?? (cfg ? resolveDefaultAgentId(cfg) : "main")
 		});
 		const codeIntelligenceConfig = cfg?.codeIntelligence;
 		const agentId = options?.agentId;
@@ -284,6 +288,7 @@ var AgentToolsFactory = class {
 				getCurrentSessionKey: () => this.deps.getCurrentContext()?.sessionKey
 			})] : [],
 			...this.deps.getAutomationService ? [createAutomationTool({ getAutomationService: this.deps.getAutomationService })] : [],
+			...browserEnabled && this.deps.getBrowserRecipeService ? [createBrowserRecipeTool({ getBrowserRecipeService: this.deps.getBrowserRecipeService })] : [],
 			...this.deps.getProjectService || this.deps.getNotesService || this.deps.getWorkItemService || this.deps.getLocalAppService ? [createXopcUseTool({
 				getConfig: () => this.deps.getConfig?.(),
 				getCurrentAgentId: () => options.agentId,

package/dist/src/agent/tools/image-generate-tool.d.ts

@@ -5,8 +5,10 @@ import type { ToolModelConfig } from '../image/tool-model-config.js';
 export { parseImageDataUrl };
 export declare function resolveImageGenerationModelConfigForTool(params: {
     cfg?: Config;
+    agentId: string;
 }): ToolModelConfig | null;
 export declare function createImageGenerateTool(options: {
     config?: Config;
     workspace: string;
+    agentId: string;
 }): AgentTool<any, Record<string, unknown>> | null;

package/dist/src/agent/tools/image-generate-tool.js

@@ -37,7 +37,7 @@ const ALLOWED_RESOLUTIONS = [
 const ImageGenerateToolSchema = Type.Object({
 	action: Type.Optional(Type.String({ description: "Optional: \"generate\" (default) or \"list\" available image-generation providers." })),
 	prompt: Type.Optional(Type.String({ description: "Image generation prompt." })),
-	model: Type.Optional(Type.String({ description: "Optional provider/model override, e.g. openai/gpt-image-1 / dashscope/wan2.7-image-pro / minimax/image-01." })),
+	model: Type.Optional(Type.String({ description: "Optional provider/model override, e.g. openai/gpt-image-2 / dashscope/wan2.7-image-pro / minimax/image-01." })),
 	filename: Type.Optional(Type.String({ description: "Optional basename hint for saved files." })),
 	size: Type.Optional(Type.String({ description: "Optional pixel size, e.g. 1024x1024." })),
 	aspectRatio: Type.Optional(Type.String({ description: "Optional aspect ratio, e.g. 16:9 / 9:16 / 1:1." })),
@@ -126,20 +126,23 @@ async function loadInputImages(params) {
 	return out;
 }
 function resolveImageGenerationModelConfigForTool(params) {
-	const explicit = params.cfg ? getAgentDefaultImageGenerationModelConfig(params.cfg) : void 0;
+	const explicit = params.cfg ? getAgentDefaultImageGenerationModelConfig(params.cfg, params.agentId) : void 0;
 	if (explicit?.primary?.trim()) return {
 		primary: explicit.primary.trim(),
 		...explicit.fallbacks?.length ? { fallbacks: explicit.fallbacks } : {},
 		...explicit.timeoutMs ? { timeoutMs: explicit.timeoutMs } : {},
 		...explicit.autoProviderFallback ? { autoProviderFallback: true } : {}
 	};
-	const providers = listImageGenerationProvidersSummary(params.cfg);
+	const providers = listImageGenerationProvidersSummary();
 	const candidates = [];
 	for (const providerSummary of providers) {
-		const provider = getImageGenerationProvider(providerSummary.id, params.cfg);
+		const provider = getImageGenerationProvider(providerSummary.id);
 		let configured = false;
 		try {
-			configured = provider?.isConfigured?.({ cfg: params.cfg }) ?? false;
+			configured = provider?.isConfigured?.({
+				cfg: params.cfg,
+				agentId: params.agentId
+			}) ?? false;
 		} catch {
 			configured = false;
 		}
@@ -169,7 +172,10 @@ async function saveGeneratedImages(params) {
 	return out;
 }
 function createImageGenerateTool(options) {
-	const imageGenerationModelConfig = resolveImageGenerationModelConfigForTool({ cfg: options.config });
+	const imageGenerationModelConfig = resolveImageGenerationModelConfigForTool({
+		cfg: options.config,
+		agentId: options.agentId
+	});
 	if (!imageGenerationModelConfig) return null;
 	const effectiveCfg = applyImageGenerationModelConfigDefaults(options.config, imageGenerationModelConfig) ?? options.config;
 	return {
@@ -181,7 +187,7 @@ function createImageGenerateTool(options) {
 			const params = args;
 			const action = (readStringParam(params, "action") || "generate").toLowerCase();
 			if (action === "list") {
-				const providers = listImageGenerationProvidersSummary(effectiveCfg);
+				const providers = listImageGenerationProvidersSummary();
 				return {
 					content: [{
 						type: "text",
@@ -234,6 +240,7 @@ function createImageGenerateTool(options) {
 			try {
 				const result = await generateImage({
 					cfg: effectiveCfg,
+					agentId: options.agentId,
 					modelConfig: imageGenerationModelConfig,
 					prompt,
 					...modelOverride ? { modelOverride } : {},

package/dist/src/agent/tools/index.d.ts

@@ -27,6 +27,7 @@ export { createDelegateTool, DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, } f
 export { createWorkflowTool, type WorkflowToolDeps, type WorkflowToolInput } from './workflow-tool.js';
 export { createExecuteCodeTool, buildSandboxToolMap, SANDBOX_ALLOWED_TOOLS, } from './execute-code-tool.js';
 export { createAutomationTool, type AutomationToolDeps } from './automation-tool.js';
+export { createBrowserRecipeTool } from './browser-recipe-tool.js';
 export { createGoalTool, type GoalToolOptions } from './goal-tool.js';
 export { createXopcUseTool, type XopcUseToolDeps, type XopcUseToolInput } from './xopc-use-tool.js';
 export { createSkillsListTool, createSkillViewTool, type SkillsToolsDeps } from './skills-tools.js';

package/dist/src/agent/tools/index.js

@@ -31,6 +31,7 @@ import { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, createDelegateTool } fr
 import { createWorkflowTool } from "./workflow-tool.js";
 import { SANDBOX_ALLOWED_TOOLS, buildSandboxToolMap, createExecuteCodeTool } from "./execute-code-tool.js";
 import { createAutomationTool } from "./automation-tool.js";
+import { createBrowserRecipeTool } from "./browser-recipe-tool.js";
 import { createGoalTool } from "./goal-tool.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
 import { createSkillViewTool, createSkillsListTool } from "./skills-tools.js";
@@ -42,4 +43,4 @@ import { createCodeIntelligenceTools } from "../code-intelligence/tools.js";
 import { resolveImageModelConfigForTool } from "../image/tool-model-config.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from "./image-generate-tool.js";
-export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createCuratedMemoryTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGoalTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };
+export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createCuratedMemoryTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGoalTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };

package/dist/src/auth/sync-provider-auth.d.ts

@@ -2,12 +2,15 @@
  * Synchronous checks that mirror CredentialResolver.resolveApiKey sources
  * used by isProviderConfiguredSync (fallback candidate filtering).
  */
+import type { Config } from '../config/schema.js';
 /**
  * Synchronous API key / OAuth access for {@link Agent} `getApiKey` (pi-agent requires sync).
  * Order: default agent auth-profiles → global auth-profiles → OAuth token file.
  * Does not read standard env vars or models.json registry — callers chain `getApiKeySync` after this.
  */
 export declare function resolveProviderApiKeySync(provider: string): string | undefined;
+/** Resolve one agent's private credential, then the shared credential and OAuth token. */
+export declare function resolveProviderApiKeyForAgentSync(provider: string, agentId?: string, config?: Config): string | undefined;
 /**
  * True if credentials exist in auth profiles (global or agent) or OAuth store,
  * matching async CredentialResolver resolution (excluding env — callers check env separately).

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

@@ -88,6 +88,17 @@ function resolveProviderApiKeySync(provider) {
 	if (fromGlobal) return fromGlobal;
 	return readOAuthAccessTokenSync(normalized);
 }
+/** Resolve one agent's private credential, then the shared credential and OAuth token. */
+function resolveProviderApiKeyForAgentSync(provider, agentId, config) {
+	const normalized = provider.toLowerCase();
+	if (agentId?.trim()) {
+		const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(config ?? loadConfig(), agentId.trim()), normalized);
+		if (fromAgent) return fromAgent;
+	}
+	const fromGlobal = readApiKeyFromProfilesFile(resolveAuthProfilesPath(), normalized);
+	if (fromGlobal) return fromGlobal;
+	return readOAuthAccessTokenSync(normalized);
+}
 /**
 * True if credentials exist in auth profiles (global or agent) or OAuth store,
 * matching async CredentialResolver resolution (excluding env — callers check env separately).
@@ -106,4 +117,4 @@ var init_sync_provider_auth = __esmMin((() => {
 }));
 //#endregion
 init_sync_provider_auth();
-export { hasProviderAuthOnDiskSync, init_sync_provider_auth, resolveProviderApiKeySync };
+export { hasProviderAuthOnDiskSync, init_sync_provider_auth, resolveProviderApiKeyForAgentSync, resolveProviderApiKeySync };

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

@@ -43,6 +43,11 @@ export type AutomationAction = {
     concurrency?: number;
     maxSubagents?: number;
     timeoutSeconds?: number;
+} | {
+    kind: 'browser_recipe';
+    recipeId: string;
+    args?: Record<string, unknown>;
+    timeoutSeconds?: number;
 };
 export type AutomationAfterRun = {
     kind: 'none';
@@ -151,6 +156,14 @@ export interface AutomationDeps {
     workflowRunService?: {
         startWorkflowRun(params: StartWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
     };
+    browserRecipeService?: {
+        runAndWait(recipeId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
+            id: string;
+            status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+            result?: unknown;
+            error?: string;
+        }>;
+    };
     onRunCompleted?: (run: AutomationRun) => void;
 }
 export interface AutomationActionOutcome {

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

@@ -58,6 +58,11 @@ export declare const AutomationActionSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     concurrency: z.ZodOptional<z.ZodNumber>;
     maxSubagents: z.ZodOptional<z.ZodNumber>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"browser_recipe">;
+    recipeId: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>], "kind">;
 export declare const AutomationAfterRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"none">;
@@ -85,12 +90,12 @@ export declare const AutomationStateSchema: z.ZodObject<{
     runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
     lastRunAtMs: z.ZodOptional<z.ZodNumber>;
     lastRunStatus: z.ZodOptional<z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        succeeded: "succeeded";
         failed: "failed";
         cancelled: "cancelled";
         timeout: "timeout";
+        succeeded: "succeeded";
+        running: "running";
+        queued: "queued";
     }>>;
     lastError: z.ZodOptional<z.ZodString>;
     consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -148,6 +153,11 @@ export declare const AutomationSchema: z.ZodObject<{
         concurrency: z.ZodOptional<z.ZodNumber>;
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser_recipe">;
+        recipeId: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>], "kind">;
     safety: z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
@@ -175,12 +185,12 @@ export declare const AutomationSchema: z.ZodObject<{
         runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
         lastRunAtMs: z.ZodOptional<z.ZodNumber>;
         lastRunStatus: z.ZodOptional<z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            succeeded: "succeeded";
             failed: "failed";
             cancelled: "cancelled";
             timeout: "timeout";
+            succeeded: "succeeded";
+            running: "running";
+            queued: "queued";
         }>>;
         lastError: z.ZodOptional<z.ZodString>;
         consecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -213,6 +223,11 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         concurrency: z.ZodOptional<z.ZodNumber>;
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser_recipe">;
+        recipeId: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>], "kind">;
     description: z.ZodOptional<z.ZodString>;
     trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -268,12 +283,12 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         runningRunId: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodString>>>;
         lastRunAtMs: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         lastRunStatus: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            succeeded: "succeeded";
             failed: "failed";
             cancelled: "cancelled";
             timeout: "timeout";
+            succeeded: "succeeded";
+            running: "running";
+            queued: "queued";
         }>>>;
         lastError: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         consecutiveFailures: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -305,7 +320,27 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         concurrency: z.ZodOptional<z.ZodNumber>;
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser_recipe">;
+        recipeId: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>], "kind">>;
+    state: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        nextRunAtMs: z.ZodOptional<z.ZodNumber>;
+        runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        lastRunAtMs: z.ZodOptional<z.ZodNumber>;
+        lastRunStatus: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            cancelled: "cancelled";
+            timeout: "timeout";
+            succeeded: "succeeded";
+            running: "running";
+            queued: "queued";
+        }>>;
+        lastError: z.ZodOptional<z.ZodString>;
+        consecutiveFailures: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
     description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"manual">;
@@ -332,21 +367,6 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         source: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
         payloadMatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
     }, z.core.$strict>], "kind">>;
-    state: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-        nextRunAtMs: z.ZodOptional<z.ZodNumber>;
-        runningRunId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
-        lastRunAtMs: z.ZodOptional<z.ZodNumber>;
-        lastRunStatus: z.ZodOptional<z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            succeeded: "succeeded";
-            failed: "failed";
-            cancelled: "cancelled";
-            timeout: "timeout";
-        }>>;
-        lastError: z.ZodOptional<z.ZodString>;
-        consecutiveFailures: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>>;
     safety: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
             suggest_only: "suggest_only";

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

@@ -61,24 +61,33 @@ const WorkflowRunInputEnvelopeSchema = z.object({
 	variables: z.record(z.string(), z.unknown()).optional(),
 	context: z.record(z.string(), z.unknown()).optional()
 }).strict();
-const AutomationActionSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("agent"),
-	agentId: optionalTrimmedString(64),
-	instruction: nonEmptyString.max(5e4),
-	workingDirectory: optionalTrimmedString(4096),
-	model: optionalTrimmedString(100),
-	timeoutSeconds: z.number().int().min(1).max(86400).optional()
-}).strict(), z.object({
-	kind: z.literal("workflow"),
-	workflowId: nonEmptyString.max(200),
-	agentId: optionalTrimmedString(64),
-	input: z.unknown().optional(),
-	inputEnvelope: WorkflowRunInputEnvelopeSchema.optional(),
-	goal: optionalTrimmedString(5e3),
-	concurrency: z.number().int().min(1).max(50).optional(),
-	maxSubagents: z.number().int().min(1).max(100).optional(),
-	timeoutSeconds: z.number().int().min(1).max(86400).optional()
-}).strict()]);
+const AutomationActionSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("agent"),
+		agentId: optionalTrimmedString(64),
+		instruction: nonEmptyString.max(5e4),
+		workingDirectory: optionalTrimmedString(4096),
+		model: optionalTrimmedString(100),
+		timeoutSeconds: z.number().int().min(1).max(86400).optional()
+	}).strict(),
+	z.object({
+		kind: z.literal("workflow"),
+		workflowId: nonEmptyString.max(200),
+		agentId: optionalTrimmedString(64),
+		input: z.unknown().optional(),
+		inputEnvelope: WorkflowRunInputEnvelopeSchema.optional(),
+		goal: optionalTrimmedString(5e3),
+		concurrency: z.number().int().min(1).max(50).optional(),
+		maxSubagents: z.number().int().min(1).max(100).optional(),
+		timeoutSeconds: z.number().int().min(1).max(86400).optional()
+	}).strict(),
+	z.object({
+		kind: z.literal("browser_recipe"),
+		recipeId: nonEmptyString.max(100),
+		args: z.record(z.string(), z.unknown()).optional(),
+		timeoutSeconds: z.number().int().min(1).max(86400).optional()
+	}).strict()
+]);
 const AutomationAfterRunSchema = z.discriminatedUnion("kind", [
 	z.object({ kind: z.literal("none") }).strict(),
 	z.object({ kind: z.literal("saveToSession") }).strict(),

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

@@ -34,6 +34,11 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             concurrency?: number;
             maxSubagents?: number;
             timeoutSeconds?: number;
+        } | {
+            kind: "browser_recipe";
+            recipeId: string;
+            args?: Record<string, unknown>;
+            timeoutSeconds?: number;
         };
         description?: string;
         trigger?: {
@@ -84,7 +89,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             nextRunAtMs?: number;
             runningRunId?: string;
             lastRunAtMs?: number;
-            lastRunStatus?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | "timeout";
+            lastRunStatus?: "failed" | "cancelled" | "timeout" | "succeeded" | "running" | "queued";
             lastError?: string;
             consecutiveFailures?: number;
         };

package/dist/src/automations/draft/automation-draft-validator.js

@@ -90,6 +90,7 @@ function summarizeTrigger(trigger) {
 }
 function summarizeAction(action) {
 	if (action.kind === "workflow") return `Starts workflow ${action.workflowId}.`;
+	if (action.kind === "browser_recipe") return `Runs browser automation ${action.recipeId}.`;
 	return action.agentId ? `Runs agent ${action.agentId}.` : "Runs the default agent.";
 }
 function repairPatchNeedsApproval(patch) {

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

@@ -4,6 +4,7 @@ export declare class AutomationActionExecutor {
     setDeps(deps: AutomationDeps): void;
     execute(automation: Automation, run: AutomationRun, signal: AbortSignal): Promise<AutomationActionOutcome>;
     private executeWithoutTimeout;
+    private executeBrowserRecipe;
     private executeAgent;
     private executeWorkflow;
 }

package/dist/src/automations/service/action-executor.js

@@ -56,8 +56,30 @@ var AutomationActionExecutor = class {
 			error: "Automation run was cancelled"
 		};
 		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run);
+		if (automation.action.kind === "browser_recipe") return this.executeBrowserRecipe(automation, automation.action, signal);
 		return this.executeAgent(automation, automation.action);
 	}
+	async executeBrowserRecipe(automation, action, signal) {
+		const safetyMode = automation.safety?.mode ?? "auto_apply";
+		if (safetyMode !== "auto_apply") return {
+			status: "succeeded",
+			summary: `${safetyMode === "suggest_only" ? "Suggest only" : "Ask before applying"}: Browser automation ${action.recipeId} was not run.`
+		};
+		const service = this.deps.browserRecipeService;
+		if (!service) return {
+			status: "failed",
+			error: "Browser automation is not available"
+		};
+		const run = await service.runAndWait(action.recipeId, action.args ?? {}, signal);
+		if (run.status === "succeeded") return {
+			status: "succeeded",
+			summary: `Browser automation ${action.recipeId} completed: ${JSON.stringify(run.result ?? null).slice(0, 3500)}`
+		};
+		return {
+			status: run.status === "cancelled" ? "cancelled" : "failed",
+			error: run.error ?? `Browser automation ${action.recipeId} ${run.status}`
+		};
+	}
 	async executeAgent(automation, action) {
 		const agentService = this.deps.agentService;
 		if (!agentService?.turnDispatcher?.processDirect) return {

package/dist/src/browser/index.d.ts

@@ -13,5 +13,4 @@ export { createBrowserActionRegistry } from './actions/registry.js';
 export type { BrowserActionName, BrowserActionContext, BrowserActionHandler, BrowserActionRegistry as BrowserActionRegistryType, BrowserActionResult, BrowserArtifact, BrowserDiagnostics, } from './actions/types.js';
 export { parseBrowserPipeline, type PipelineDocument, type PipelineStep } from './pipeline/schema.js';
 export { runBrowserPipeline, validateBrowserPipeline } from './pipeline/runner.js';
-export { loadBrowserPipelineSource } from './pipeline/source.js';
 export { resolveTemplate, resolveTemplateDeep } from './pipeline/template.js';

package/dist/src/browser/index.js

@@ -12,6 +12,5 @@ import { WEBDRIVER_OVERRIDE_SCRIPT, buildLocalStealthArgs, buildStealthArgs, gen
 import { resolveTemplate, resolveTemplateDeep } from "./pipeline/template.js";
 import { createBrowserActionRegistry } from "./actions/registry.js";
 import { parseBrowserPipeline } from "./pipeline/schema.js";
-import { loadBrowserPipelineSource } from "./pipeline/source.js";
 import { runBrowserPipeline, validateBrowserPipeline } from "./pipeline/runner.js";
-export { BrowserBackSchema, BrowserCdpSchema, BrowserClickSchema, BrowserCloseSchema, BrowserConsoleSchema, BrowserDialogSchema, BrowserGetImagesSchema, BrowserManager, BrowserNavigateSchema, BrowserNotReadyError, BrowserPressSchema, BrowserScreenshotSchema, BrowserScrollSchema, BrowserSnapshotSchema, BrowserTypeSchema, BrowserVisionSchema, CdpSupervisor, WEBDRIVER_OVERRIDE_SCRIPT, assertBrowserUrlAllowed, buildBrowserSetupDeepLink, buildLocalStealthArgs, buildStealthArgs, checkBotDetection, checkBrowserReadiness, checkPostRedirectUrl, cleanupOrphanProcesses, containsApiKeyPattern, createBrowserActionRegistry, generateFingerprintSeed, generateMousePath, generateScrollPlan, generateTypingPlan, humanizedClick, humanizedFill, humanizedPress, humanizedScroll, isAlwaysBlockedUrl, loadBrowserPipelineSource, makeExecutable, parseBrowserPipeline, removeQuarantineAttr, resolveBrowserBackendFromConfig, resolveBrowserCommandTimeoutMs, resolveHumanConfig, resolveTemplate, resolveTemplateDeep, runBrowserPipeline, snapshotSummaryHeader, startTracing, stopTracing, truncateSnapshotAtBoundary, validateBrowserPipeline };
+export { BrowserBackSchema, BrowserCdpSchema, BrowserClickSchema, BrowserCloseSchema, BrowserConsoleSchema, BrowserDialogSchema, BrowserGetImagesSchema, BrowserManager, BrowserNavigateSchema, BrowserNotReadyError, BrowserPressSchema, BrowserScreenshotSchema, BrowserScrollSchema, BrowserSnapshotSchema, BrowserTypeSchema, BrowserVisionSchema, CdpSupervisor, WEBDRIVER_OVERRIDE_SCRIPT, assertBrowserUrlAllowed, buildBrowserSetupDeepLink, buildLocalStealthArgs, buildStealthArgs, checkBotDetection, checkBrowserReadiness, checkPostRedirectUrl, cleanupOrphanProcesses, containsApiKeyPattern, createBrowserActionRegistry, generateFingerprintSeed, generateMousePath, generateScrollPlan, generateTypingPlan, humanizedClick, humanizedFill, humanizedPress, humanizedScroll, isAlwaysBlockedUrl, makeExecutable, parseBrowserPipeline, removeQuarantineAttr, resolveBrowserBackendFromConfig, resolveBrowserCommandTimeoutMs, resolveHumanConfig, resolveTemplate, resolveTemplateDeep, runBrowserPipeline, snapshotSummaryHeader, startTracing, stopTracing, truncateSnapshotAtBoundary, validateBrowserPipeline };

package/dist/src/browser/pipeline/runner.d.ts

@@ -13,8 +13,15 @@ export interface ValidateResult {
 }
 export interface RunBrowserPipelineOptions {
     dryRun?: boolean;
-    sourceLocation?: string;
+    onStep?: (event: BrowserRecipeStepEvent) => void;
+}
+export interface BrowserRecipeStepEvent {
+    index: number;
+    scope: string;
+    action: string;
+    status: 'started' | 'completed' | 'failed';
+    elapsedMs?: number;
+    error?: string;
 }
 export declare function validateBrowserPipeline(yamlSource: string, registry?: BrowserActionRegistry): ValidateResult;
-export declare function validateBrowserPipelineSource(yamlSource: string, registry?: BrowserActionRegistry, sourceLocation?: string): Promise<ValidateResult>;
 export declare function runBrowserPipeline(yamlSource: string, argOverrides: Record<string, unknown>, ctx: BrowserActionContext, registry: BrowserActionRegistry, options?: RunBrowserPipelineOptions): Promise<BrowserActionResult>;