@hotmeshio/long-tail 0.1.14 → 0.1.16

package/build/api/{yaml-workflows.js → yaml-workflows/crud.js}

@@ -41,33 +41,31 @@ exports.getYamlWorkflow = getYamlWorkflow;
 exports.updateYamlWorkflow = updateYamlWorkflow;
 exports.regenerateYamlWorkflow = regenerateYamlWorkflow;
 exports.deleteYamlWorkflow = deleteYamlWorkflow;
-exports.deployYamlWorkflow = deployYamlWorkflow;
-exports.activateYamlWorkflow = activateYamlWorkflow;
-exports.invokeYamlWorkflow = invokeYamlWorkflow;
-exports.archiveYamlWorkflow = archiveYamlWorkflow;
-exports.restoreYamlWorkflow = restoreYamlWorkflow;
-exports.getVersionHistory = getVersionHistory;
-exports.getVersionSnapshot = getVersionSnapshot;
-exports.getYamlContent = getYamlContent;
-exports.setCronSchedule = setCronSchedule;
-exports.clearCronSchedule = clearCronSchedule;
-exports.getCronStatus = getCronStatus;
-const yamlDb = __importStar(require("../services/yaml-workflow/db"));
-const yamlGenerator = __importStar(require("../services/yaml-workflow/generator"));
-const yamlDeployer = __importStar(require("../services/yaml-workflow/deployer"));
-const yamlWorkers = __importStar(require("../services/yaml-workflow/workers"));
-const invoke_1 = require("../services/yaml-workflow/invoke");
-const task_1 = require("../services/task");
-const cron_1 = require("../services/cron");
-const utils_1 = require("../modules/utils");
-/** Return true if a Postgres error indicates an invalid/missing ID */
-function isNotFoundError(err) {
-    const msg = err?.message ?? '';
-    return msg.includes('invalid input syntax for type uuid') || msg.includes('not found');
+exports.createYamlWorkflowFromDurable = createYamlWorkflowFromDurable;
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
+const durable_compiler_1 = require("../../services/yaml-workflow/durable-compiler");
+const builder_regenerate_1 = require("../../services/yaml-workflow/builder-regenerate");
+const task_1 = require("../../services/task");
+const utils_1 = require("../../modules/utils");
+const helpers_1 = require("./helpers");
+/**
+ * Strip the qualified `{slug}__` prefix from mcp_tool_name entries.
+ * The builder LLM sometimes echoes the qualified name (e.g.
+ * "long_tail_playwright_cli__capture_page") instead of the short
+ * tool name ("capture_page"). MCP servers register tools by short
+ * name, so the qualified form fails at runtime.
+ */
+function normalizeManifestToolNames(manifest) {
+    if (!manifest)
+        return manifest;
+    for (const entry of manifest) {
+        if (entry.mcp_tool_name?.includes('__')) {
+            entry.mcp_tool_name = entry.mcp_tool_name.slice(entry.mcp_tool_name.indexOf('__') + 2);
+        }
+    }
+    return manifest;
 }
-// ---------------------------------------------------------------------------
-// CRUD
-// ---------------------------------------------------------------------------
 /**
  * List YAML workflows with optional filtering and pagination.
  *
@@ -98,7 +96,7 @@ async function listYamlWorkflows(input) {
         return { status: 200, data: result };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -176,7 +174,7 @@ async function createYamlWorkflow(input) {
             graph_topic: result.graphTopic,
             input_schema: result.inputSchema,
             output_schema: result.outputSchema,
-            activity_manifest: result.activityManifest,
+            activity_manifest: normalizeManifestToolNames(result.activityManifest),
             tags: mergedTags,
             source_workflow_id: workflow_id,
             source_workflow_type: workflow_name,
@@ -261,7 +259,7 @@ async function createYamlWorkflowDirect(input) {
             graph_topic: graphTopic,
             input_schema: input_schema || {},
             output_schema: {},
-            activity_manifest: activity_manifest || [],
+            activity_manifest: normalizeManifestToolNames(activity_manifest) || [],
             tags: tags || [],
             original_prompt: description,
             category: 'builder',
@@ -301,7 +299,7 @@ async function getYamlWorkflow(input) {
         return { status: 200, data: wf };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -319,6 +317,9 @@ async function getYamlWorkflow(input) {
 async function updateYamlWorkflow(input) {
     try {
         const { id, ...fields } = input;
+        if (fields.activity_manifest) {
+            normalizeManifestToolNames(fields.activity_manifest);
+        }
         const wf = await yamlDb.updateYamlWorkflow(id, fields);
         if (!wf) {
             return { status: 404, error: 'YAML workflow not found' };
@@ -326,7 +327,7 @@ async function updateYamlWorkflow(input) {
         return { status: 200, data: wf };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -354,10 +355,32 @@ async function regenerateYamlWorkflow(input) {
         if (wf.status === 'archived') {
             return { status: 400, error: 'Archived workflows cannot be regenerated' };
         }
+        // Plan Build workflows: recompile from original prompt via builder LLM
+        if (!wf.source_workflow_id && wf.source_workflow_type === 'mcpWorkflowPlanner') {
+            if (!wf.original_prompt) {
+                return { status: 400, error: 'Cannot recompile: original prompt not stored. Re-run the plan to rebuild this workflow.' };
+            }
+            const feedback = input.compilation_feedback;
+            const result = await (0, builder_regenerate_1.rebuildFromPrompt)({
+                prompt: wf.original_prompt,
+                feedback: feedback || undefined,
+                priorYaml: feedback ? wf.yaml_content : undefined,
+                name: wf.name,
+                appId: wf.app_id,
+            });
+            const updated = await yamlDb.updateYamlWorkflow(wf.id, {
+                yaml_content: result.yaml,
+                input_schema: result.inputSchema,
+                output_schema: result.outputSchema,
+                activity_manifest: normalizeManifestToolNames(result.activityManifest),
+                tags: result.tags,
+            });
+            return { status: 200, data: updated };
+        }
         if (!wf.source_workflow_id || !wf.source_workflow_type) {
             return { status: 400, error: 'Missing source workflow reference — cannot regenerate' };
         }
-        // Look up task queue from the source task record, or use input override
+        // Execution-trace workflows: recompile from source execution
         let taskQueue = input.task_queue;
         if (!taskQueue) {
             const sourceTask = await (0, task_1.getTaskByWorkflowId)(wf.source_workflow_id);
@@ -380,14 +403,14 @@ async function regenerateYamlWorkflow(input) {
             yaml_content: result.yaml,
             input_schema: result.inputSchema,
             output_schema: result.outputSchema,
-            activity_manifest: result.activityManifest,
+            activity_manifest: normalizeManifestToolNames(result.activityManifest),
             tags: result.tags,
             metadata: { input_field_meta: result.inputFieldMeta },
         });
         return { status: 200, data: updated };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -415,364 +438,60 @@ async function deleteYamlWorkflow(input) {
         return { status: 200, data: { deleted: true } };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-// ---------------------------------------------------------------------------
-// Deployment
-// ---------------------------------------------------------------------------
-/**
- * Deploy a YAML workflow and all sibling workflows sharing its app_id namespace.
- *
- * Merges and deploys the full app_id YAML, registers HotMesh workers for every
- * non-archived sibling, transitions draft/deployed siblings to active, and marks
- * the app_id content as deployed. Uses the app_version declared in the workflow record.
- *
- * @param input.id — UUID of the workflow to deploy
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after deployment
- */
-async function deployYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        // Compute the next app-level version for the namespace.
-        // Each deploy increments regardless of individual tool versions —
-        // adding a second tool (v1 of itself) to an app already at v1 produces app v2.
-        const deployVersion = await yamlDb.getNextAppVersion(wf.app_id);
-        // Deploy + activate merged YAML for the full app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
-        // Register workers and mark all non-archived siblings as active
-        for (const sibling of siblings) {
-            await yamlDb.updateYamlWorkflowVersion(sibling.id, deployVersion);
-            await yamlWorkers.registerWorkersForWorkflow(sibling);
-            if (sibling.status === 'draft' || sibling.status === 'deployed') {
-                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
-            }
-        }
-        // Mark content as deployed for the entire app_id
-        await yamlDb.markAppIdContentDeployed(wf.app_id);
-        const updated = await yamlDb.getYamlWorkflow(input.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return {
-            status: 500,
-            error: err.message,
-        };
-    }
-}
-/**
- * Activate a previously deployed YAML workflow and its app_id siblings.
- *
- * Calls the deployer to activate the app_id at its current version, then registers
- * HotMesh workers for all sibling workflows. Siblings in "deployed" status are
- * transitioned to "active". The workflow must already be in deployed or active status.
- *
- * @param input.id — UUID of the workflow to activate
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after activation
- */
-async function activateYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status !== 'deployed' && wf.status !== 'active') {
-            return { status: 400, error: 'Workflow must be deployed before activation' };
-        }
-        await yamlDeployer.activateYamlWorkflow(wf.app_id, wf.app_version);
-        // Register workers for ALL workflows sharing this app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        for (const sibling of siblings) {
-            await yamlWorkers.registerWorkersForWorkflow(sibling);
-            if (sibling.status === 'deployed') {
-                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
-            }
-        }
-        const updated = await yamlDb.getYamlWorkflow(input.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
     }
 }
 /**
- * Invoke an active YAML workflow, executing its DAG pipeline.
+ * Compile a durable TypeScript workflow into a YAML DAG.
  *
- * The workflow must be in "active" status. Delegates to the invoke service which
- * starts the HotMesh execution. Supports both synchronous (wait for result) and
- * asynchronous (fire-and-forget) invocation modes.
+ * Accepts inline source code or a file path. The LLM translates the procedural
+ * orchestration into an equivalent HotMesh YAML DAG that runs without replay.
  *
- * @param input.id — UUID of the workflow to invoke
- * @param input.data — input payload passed to the workflow's entry point
- * @param input.sync — when true, block until the workflow completes and return its output
- * @param input.timeout — max milliseconds to wait when sync is true
- * @param input.execute_as — override identity for the execution context
- * @param auth — authenticated user context; userId is forwarded to the invoke service
- * @returns `{ status: 200, data: ... }` workflow execution result (sync) or job metadata (async)
+ * @param input.source — TypeScript source code or file path
+ * @param input.is_file_path — whether source is a file path (default: false)
+ * @param input.workflow_name — name of the exported workflow function
+ * @param input.name — name for the generated YAML workflow
+ * @param input.description — optional description
+ * @param input.app_id — target namespace (defaults to "longtail")
+ * @param input.subscribes — graph topic override
+ * @param input.tags — additional tags
+ * @returns `{ status: 201, data: YamlWorkflow }` the newly created draft record
  */
-async function invokeYamlWorkflow(input, auth) {
+async function createYamlWorkflowFromDurable(input) {
     try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status !== 'active') {
-            return { status: 400, error: 'Workflow must be active to invoke' };
+        const { source, workflow_name, name, description, app_id, subscribes, tags: userTags } = input;
+        if (!source || !workflow_name || !name) {
+            return { status: 400, error: 'source, workflow_name, and name are required' };
         }
-        const result = await (0, invoke_1.invokeYamlWorkflow)(wf, {
-            data: input.data,
-            sync: input.sync,
-            timeout: input.timeout,
-            execute_as: input.execute_as,
-            userId: auth?.userId,
+        const result = await (0, durable_compiler_1.compileDurableToYaml)({
+            source,
+            isFilePath: !!input.is_file_path,
+            workflowName: workflow_name,
+            name,
+            description,
+            appId: app_id,
+            subscribes,
         });
-        return { status: 200, data: result };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Archive a YAML workflow, removing it from active service.
- *
- * If the workflow is currently active, its HotMesh engine is stopped before
- * transitioning the status to "archived". Archived workflows cannot be invoked
- * or regenerated but can still be viewed or deleted.
- *
- * @param input.id — UUID of the workflow to archive
- * @returns `{ status: 200, data: YamlWorkflow }` the updated record with status "archived"
- */
-async function archiveYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status === 'active') {
-            await yamlDeployer.stopEngine(wf.app_id);
-        }
-        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'archived');
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Restore an archived YAML workflow back to draft status.
- *
- * Transitions the workflow from "archived" to "draft" so it can be
- * redeployed. The workflow must be in "archived" status.
- */
-async function restoreYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status !== 'archived') {
-            return { status: 400, error: 'Only archived workflows can be restored' };
-        }
-        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'draft');
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-// ---------------------------------------------------------------------------
-// Versions
-// ---------------------------------------------------------------------------
-/**
- * Retrieve the version history for a YAML workflow.
- *
- * Returns a paginated list of version snapshots ordered by version number.
- *
- * @param input.id — UUID of the workflow
- * @param input.limit — max versions to return (defaults to 20)
- * @param input.offset — pagination offset (defaults to 0)
- * @returns `{ status: 200, data: VersionSnapshot[] }` paginated version history
- */
-async function getVersionHistory(input) {
-    try {
-        const limit = input.limit ?? 20;
-        const offset = input.offset ?? 0;
-        const result = await yamlDb.getVersionHistory(input.id, limit, offset);
-        return { status: 200, data: result };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Retrieve a specific version snapshot of a YAML workflow.
- *
- * Validates that the version number is a positive integer before querying.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — 1-based version number to retrieve
- * @returns `{ status: 200, data: VersionSnapshot }` the snapshot at the requested version, or 404
- */
-async function getVersionSnapshot(input) {
-    try {
-        const version = input.version;
-        if (isNaN(version) || version < 1) {
-            return { status: 400, error: 'Invalid version number' };
-        }
-        const snapshot = await yamlDb.getVersionSnapshot(input.id, version);
-        if (!snapshot) {
-            return { status: 404, error: `Version ${version} not found` };
-        }
-        return { status: 200, data: snapshot };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Retrieve the raw YAML content for a workflow, optionally at a specific version.
- *
- * When a version is provided, fetches from the version snapshot table. Otherwise
- * returns the current yaml_content from the live workflow record.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — optional version number; when omitted, returns the current content
- * @returns `{ status: 200, data: string }` the raw YAML string
- */
-async function getYamlContent(input) {
-    try {
-        if (input.version) {
-            const snapshot = await yamlDb.getVersionSnapshot(input.id, input.version);
-            if (!snapshot) {
-                return { status: 404, error: `Version ${input.version} not found` };
-            }
-            return { status: 200, data: snapshot.yaml_content };
-        }
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 200, data: wf.yaml_content };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-// ---------------------------------------------------------------------------
-// Cron
-// ---------------------------------------------------------------------------
-/**
- * Set or update the cron schedule for a YAML workflow.
- *
- * Persists the schedule in the DB and restarts the in-process cron timer via the
- * cron registry so the change takes effect immediately.
- *
- * @param input.id — UUID of the workflow to schedule
- * @param input.cron_schedule — cron expression (e.g. "0 * * * *")
- * @param input.cron_envelope — optional payload passed to each scheduled invocation
- * @param input.execute_as — optional identity override for scheduled executions
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields set
- */
-async function setCronSchedule(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (!input.cron_schedule || typeof input.cron_schedule !== 'string') {
-            return { status: 400, error: 'cron_schedule is required' };
-        }
-        const updated = await yamlDb.updateCronSchedule(wf.id, input.cron_schedule.trim(), input.cron_envelope ?? null, input.execute_as ?? null);
-        if (updated) {
-            await cron_1.cronRegistry.restartYamlCron(updated);
-        }
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Remove the cron schedule from a YAML workflow.
- *
- * Stops the in-process cron timer first, then clears the schedule fields in the DB.
- *
- * @param input.id — UUID of the workflow to unschedule
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields cleared
- */
-async function clearCronSchedule(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        await cron_1.cronRegistry.stopYamlCron(wf.id);
-        const updated = await yamlDb.clearCronSchedule(wf.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * List all YAML workflows that have a cron schedule, with their live timer status.
- *
- * Fetches all cron-scheduled workflows from the DB and cross-references with the
- * in-process cron registry to determine which timers are actually running.
- *
- * @returns `{ status: 200, data: { schedules: Array<{ id, name, graph_topic, app_id, cron_schedule, execute_as, active }> } }`
- */
-async function getCronStatus() {
-    try {
-        const workflows = await yamlDb.getCronScheduledWorkflows();
-        const activeTypes = cron_1.cronRegistry.activeWorkflowTypes;
-        const schedules = workflows.map((wf) => ({
-            id: wf.id,
-            name: wf.name,
-            graph_topic: wf.graph_topic,
-            app_id: wf.app_id,
-            cron_schedule: wf.cron_schedule,
-            execute_as: wf.execute_as,
-            active: activeTypes.includes(`yaml:${wf.id}`),
-        }));
-        return { status: 200, data: { schedules } };
+        const mergedTags = [...new Set([...(result.tags || []), ...(Array.isArray(userTags) ? userTags : [])])];
+        const record = await yamlDb.createYamlWorkflow({
+            name,
+            description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: normalizeManifestToolNames(result.activityManifest),
+            tags: mergedTags,
+            source_workflow_type: 'durable',
+            original_prompt: description,
+            category: result.category,
+            metadata: { durable_source: source.slice(0, 5000) },
+        });
+        return { status: 201, data: record };
     }
     catch (err) {
         return { status: 500, error: err.message };

package/build/api/yaml-workflows/deploy.d.ts

@@ -0,0 +1,71 @@
+import type { LTApiResult, LTApiAuth } from '../../types/sdk';
+/**
+ * Deploy a YAML workflow and all sibling workflows sharing its app_id namespace.
+ *
+ * Merges and deploys the full app_id YAML, registers HotMesh workers for every
+ * non-archived sibling, transitions draft/deployed siblings to active, and marks
+ * the app_id content as deployed. Uses the app_version declared in the workflow record.
+ *
+ * @param input.id — UUID of the workflow to deploy
+ * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after deployment
+ */
+export declare function deployYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Activate a previously deployed YAML workflow and its app_id siblings.
+ *
+ * Calls the deployer to activate the app_id at its current version, then registers
+ * HotMesh workers for all sibling workflows. Siblings in "deployed" status are
+ * transitioned to "active". The workflow must already be in deployed or active status.
+ *
+ * @param input.id — UUID of the workflow to activate
+ * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after activation
+ */
+export declare function activateYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Invoke an active YAML workflow, executing its DAG pipeline.
+ *
+ * The workflow must be in "active" status. Delegates to the invoke service which
+ * starts the HotMesh execution. Supports both synchronous (wait for result) and
+ * asynchronous (fire-and-forget) invocation modes.
+ *
+ * @param input.id — UUID of the workflow to invoke
+ * @param input.data — input payload passed to the workflow's entry point
+ * @param input.sync — when true, block until the workflow completes and return its output
+ * @param input.timeout — max milliseconds to wait when sync is true
+ * @param input.execute_as — override identity for the execution context
+ * @param auth — authenticated user context; userId is forwarded to the invoke service
+ * @returns `{ status: 200, data: ... }` workflow execution result (sync) or job metadata (async)
+ */
+export declare function invokeYamlWorkflow(input: {
+    id: string;
+    data?: any;
+    sync?: boolean;
+    timeout?: number;
+    execute_as?: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Archive a YAML workflow, removing it from active service.
+ *
+ * If the workflow is currently active, its HotMesh engine is stopped before
+ * transitioning the status to "archived". Archived workflows cannot be invoked
+ * or regenerated but can still be viewed or deleted.
+ *
+ * @param input.id — UUID of the workflow to archive
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated record with status "archived"
+ */
+export declare function archiveYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Restore an archived YAML workflow back to draft status.
+ *
+ * Transitions the workflow from "archived" to "draft" so it can be
+ * redeployed. The workflow must be in "archived" status.
+ */
+export declare function restoreYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;