@hotmeshio/long-tail 0.1.0

package/build/services/yaml-workflow/db-utils.d.ts

@@ -0,0 +1,25 @@
+import type { LTYamlWorkflowRecord, LTYamlWorkflowStatus } from '../../types/yaml-workflow';
+/**
+ * Extract the `app.version` value from YAML content using a simple regex.
+ * Returns null if not found.
+ */
+export declare function parseVersionFromYaml(yaml: string): string | null;
+export declare function updateYamlWorkflowStatus(id: string, status: LTYamlWorkflowStatus): Promise<LTYamlWorkflowRecord | null>;
+export declare function listYamlWorkflows(filters: {
+    status?: LTYamlWorkflowStatus;
+    graph_topic?: string;
+    app_id?: string;
+    tags?: string[];
+    search?: string;
+    source_workflow_id?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    workflows: LTYamlWorkflowRecord[];
+    total: number;
+}>;
+/**
+ * Find active YAML workflows matching any of the given tags.
+ * Uses GIN index on tags column for efficient lookup.
+ */
+export declare function findYamlWorkflowsByTags(tags: string[], match?: 'any' | 'all'): Promise<LTYamlWorkflowRecord[]>;

package/build/services/yaml-workflow/db-utils.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersionFromYaml = parseVersionFromYaml;
+exports.updateYamlWorkflowStatus = updateYamlWorkflowStatus;
+exports.listYamlWorkflows = listYamlWorkflows;
+exports.findYamlWorkflowsByTags = findYamlWorkflowsByTags;
+const db_1 = require("../db");
+const defaults_1 = require("../../modules/defaults");
+const sql_1 = require("./sql");
+/**
+ * Extract the `app.version` value from YAML content using a simple regex.
+ * Returns null if not found.
+ */
+function parseVersionFromYaml(yaml) {
+    const match = yaml.match(/^app:\s*\n(?:.*\n)*?\s+version:\s*['"]?(\S+?)['"]?\s*$/m);
+    if (match)
+        return match[1];
+    const lines = yaml.split('\n');
+    let inApp = false;
+    for (const line of lines) {
+        if (/^app:\s*$/.test(line)) {
+            inApp = true;
+            continue;
+        }
+        if (inApp && /^\S/.test(line))
+            break;
+        if (inApp) {
+            const vm = line.match(/^\s+version:\s*['"]?(.+?)['"]?\s*$/);
+            if (vm)
+                return vm[1];
+        }
+    }
+    return null;
+}
+async function updateYamlWorkflowStatus(id, status) {
+    const pool = (0, db_1.getPool)();
+    const timestampField = status === 'deployed' ? ', deployed_at = NOW()' :
+        status === 'active' ? ', activated_at = NOW()' : '';
+    const { rows } = await pool.query(`${sql_1.UPDATE_STATUS_BASE}${timestampField}${sql_1.UPDATE_STATUS_SUFFIX}`, [id, status]);
+    return rows[0] || null;
+}
+async function listYamlWorkflows(filters) {
+    const pool = (0, db_1.getPool)();
+    const conditions = [];
+    const values = [];
+    let idx = 1;
+    if (filters.status) {
+        conditions.push(`status = $${idx++}`);
+        values.push(filters.status);
+    }
+    if (filters.graph_topic) {
+        conditions.push(`graph_topic = $${idx++}`);
+        values.push(filters.graph_topic);
+    }
+    if (filters.app_id) {
+        conditions.push(`app_id = $${idx++}`);
+        values.push(filters.app_id);
+    }
+    if (filters.tags?.length) {
+        conditions.push(`tags && $${idx++}::text[]`);
+        values.push(filters.tags);
+    }
+    if (filters.search) {
+        conditions.push(`(name ILIKE $${idx} OR graph_topic ILIKE $${idx} OR description ILIKE $${idx} OR app_id ILIKE $${idx})`);
+        values.push(`%${filters.search}%`);
+        idx++;
+    }
+    if (filters.source_workflow_id) {
+        conditions.push(`source_workflow_id = $${idx++}`);
+        values.push(filters.source_workflow_id);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filters.limit || defaults_1.YAML_LIST_LIMIT;
+    const offset = filters.offset || 0;
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(`SELECT COUNT(*) FROM lt_yaml_workflows ${where}`, values),
+        pool.query(`SELECT * FROM lt_yaml_workflows ${where} ORDER BY created_at DESC LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
+    ]);
+    return {
+        workflows: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+/**
+ * Find active YAML workflows matching any of the given tags.
+ * Uses GIN index on tags column for efficient lookup.
+ */
+async function findYamlWorkflowsByTags(tags, match = 'any') {
+    const pool = (0, db_1.getPool)();
+    const sql = match === 'all' ? sql_1.FIND_BY_TAGS_ALL : sql_1.FIND_BY_TAGS_ANY;
+    const { rows } = await pool.query(sql, [tags]);
+    return rows;
+}

package/build/services/yaml-workflow/db.d.ts

@@ -0,0 +1,27 @@
+import type { LTYamlWorkflowRecord, LTYamlWorkflowVersionRecord, ActivityManifestEntry } from '../../types/yaml-workflow';
+import type { CreateYamlWorkflowInput } from './types';
+export { parseVersionFromYaml, updateYamlWorkflowStatus, listYamlWorkflows, findYamlWorkflowsByTags, } from './db-utils';
+export declare function createYamlWorkflow(input: CreateYamlWorkflowInput): Promise<LTYamlWorkflowRecord>;
+export declare function getYamlWorkflow(id: string): Promise<LTYamlWorkflowRecord | null>;
+export declare function getYamlWorkflowByName(name: string): Promise<LTYamlWorkflowRecord | null>;
+export declare function updateYamlWorkflowVersion(id: string, version: string): Promise<void>;
+export declare function updateYamlWorkflow(id: string, updates: Partial<Pick<CreateYamlWorkflowInput, 'name' | 'description' | 'app_id' | 'yaml_content' | 'graph_topic' | 'input_schema' | 'output_schema' | 'activity_manifest' | 'tags' | 'metadata'>>): Promise<LTYamlWorkflowRecord | null>;
+export declare function deleteYamlWorkflow(id: string): Promise<boolean>;
+/**
+ * Ranked discovery: find active workflows matching the user's prompt
+ * via full-text search (tsvector) + tag overlap + optional category filter.
+ */
+export declare function discoverWorkflows(prompt: string, tags: string[], category?: string | null, limit?: number): Promise<(LTYamlWorkflowRecord & {
+    fts_rank: number;
+})[]>;
+export declare function getActiveYamlWorkflows(): Promise<LTYamlWorkflowRecord[]>;
+export declare function listYamlWorkflowsByAppId(appId: string): Promise<LTYamlWorkflowRecord[]>;
+export declare function getDistinctAppIds(): Promise<string[]>;
+export declare function createVersionSnapshot(workflowId: string, version: number, yamlContent: string, activityManifest: ActivityManifestEntry[] | unknown, inputSchema: Record<string, unknown> | unknown, outputSchema: Record<string, unknown> | unknown, inputFieldMeta?: unknown, changeSummary?: string): Promise<LTYamlWorkflowVersionRecord>;
+export declare function getVersionHistory(workflowId: string, limit?: number, offset?: number): Promise<{
+    versions: LTYamlWorkflowVersionRecord[];
+    total: number;
+}>;
+export declare function getVersionSnapshot(workflowId: string, version: number): Promise<LTYamlWorkflowVersionRecord | null>;
+export declare function markContentDeployed(workflowId: string): Promise<void>;
+export declare function markAppIdContentDeployed(appId: string): Promise<void>;

package/build/services/yaml-workflow/db.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findYamlWorkflowsByTags = exports.listYamlWorkflows = exports.updateYamlWorkflowStatus = exports.parseVersionFromYaml = void 0;
+exports.createYamlWorkflow = createYamlWorkflow;
+exports.getYamlWorkflow = getYamlWorkflow;
+exports.getYamlWorkflowByName = getYamlWorkflowByName;
+exports.updateYamlWorkflowVersion = updateYamlWorkflowVersion;
+exports.updateYamlWorkflow = updateYamlWorkflow;
+exports.deleteYamlWorkflow = deleteYamlWorkflow;
+exports.discoverWorkflows = discoverWorkflows;
+exports.getActiveYamlWorkflows = getActiveYamlWorkflows;
+exports.listYamlWorkflowsByAppId = listYamlWorkflowsByAppId;
+exports.getDistinctAppIds = getDistinctAppIds;
+exports.createVersionSnapshot = createVersionSnapshot;
+exports.getVersionHistory = getVersionHistory;
+exports.getVersionSnapshot = getVersionSnapshot;
+exports.markContentDeployed = markContentDeployed;
+exports.markAppIdContentDeployed = markAppIdContentDeployed;
+const db_1 = require("../db");
+const defaults_1 = require("../../modules/defaults");
+const sql_1 = require("./sql");
+const db_utils_1 = require("./db-utils");
+// Re-export functions from db-utils
+var db_utils_2 = require("./db-utils");
+Object.defineProperty(exports, "parseVersionFromYaml", { enumerable: true, get: function () { return db_utils_2.parseVersionFromYaml; } });
+Object.defineProperty(exports, "updateYamlWorkflowStatus", { enumerable: true, get: function () { return db_utils_2.updateYamlWorkflowStatus; } });
+Object.defineProperty(exports, "listYamlWorkflows", { enumerable: true, get: function () { return db_utils_2.listYamlWorkflows; } });
+Object.defineProperty(exports, "findYamlWorkflowsByTags", { enumerable: true, get: function () { return db_utils_2.findYamlWorkflowsByTags; } });
+async function createYamlWorkflow(input) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CREATE_YAML_WORKFLOW, [
+        input.name,
+        input.description || null,
+        input.app_id,
+        input.app_version || (0, db_utils_1.parseVersionFromYaml)(input.yaml_content) || '0',
+        input.source_workflow_id || null,
+        input.source_workflow_type || null,
+        input.yaml_content,
+        input.graph_topic,
+        JSON.stringify(input.input_schema || {}),
+        JSON.stringify(input.output_schema || {}),
+        JSON.stringify(input.activity_manifest || []),
+        JSON.stringify(input.input_field_meta || []),
+        input.original_prompt || null,
+        input.category || null,
+        input.tags || [],
+        input.metadata ? JSON.stringify(input.metadata) : null,
+    ]);
+    const record = rows[0];
+    await createVersionSnapshot(record.id, 1, record.yaml_content, input.activity_manifest || [], input.input_schema || {}, input.output_schema || {}, input.input_field_meta || [], 'Initial version');
+    return record;
+}
+async function getYamlWorkflow(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_YAML_WORKFLOW, [id]);
+    return rows[0] || null;
+}
+async function getYamlWorkflowByName(name) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_YAML_WORKFLOW_BY_NAME, [name]);
+    return rows[0] || null;
+}
+async function updateYamlWorkflowVersion(id, version) {
+    const pool = (0, db_1.getPool)();
+    await pool.query(sql_1.UPDATE_YAML_WORKFLOW_VERSION, [id, version]);
+}
+async function updateYamlWorkflow(id, updates) {
+    const pool = (0, db_1.getPool)();
+    const sets = [];
+    const values = [];
+    let idx = 1;
+    const yamlChanging = updates.yaml_content !== undefined;
+    if (updates.name !== undefined) {
+        sets.push(`name = $${idx++}`);
+        values.push(updates.name);
+    }
+    if (updates.description !== undefined) {
+        sets.push(`description = $${idx++}`);
+        values.push(updates.description);
+    }
+    if (updates.app_id !== undefined) {
+        sets.push(`app_id = $${idx++}`);
+        values.push(updates.app_id);
+    }
+    if (updates.yaml_content !== undefined) {
+        sets.push(`yaml_content = $${idx++}`);
+        values.push(updates.yaml_content);
+    }
+    if (updates.graph_topic !== undefined) {
+        sets.push(`graph_topic = $${idx++}`);
+        values.push(updates.graph_topic);
+    }
+    if (updates.input_schema !== undefined) {
+        sets.push(`input_schema = $${idx++}`);
+        values.push(JSON.stringify(updates.input_schema));
+    }
+    if (updates.output_schema !== undefined) {
+        sets.push(`output_schema = $${idx++}`);
+        values.push(JSON.stringify(updates.output_schema));
+    }
+    if (updates.activity_manifest !== undefined) {
+        sets.push(`activity_manifest = $${idx++}`);
+        values.push(JSON.stringify(updates.activity_manifest));
+    }
+    if (updates.tags !== undefined) {
+        sets.push(`tags = $${idx++}`);
+        values.push(updates.tags);
+    }
+    if (updates.metadata !== undefined) {
+        sets.push(`metadata = $${idx++}`);
+        values.push(JSON.stringify(updates.metadata));
+    }
+    if (yamlChanging) {
+        sets.push(`content_version = content_version + 1`);
+        const parsedVersion = (0, db_utils_1.parseVersionFromYaml)(updates.yaml_content);
+        if (parsedVersion) {
+            sets.push(`app_version = $${idx++}`);
+            values.push(parsedVersion);
+        }
+    }
+    if (sets.length === 0)
+        return getYamlWorkflow(id);
+    values.push(id);
+    const { rows } = await pool.query(`UPDATE lt_yaml_workflows SET ${sets.join(', ')} WHERE id = $${idx} RETURNING *`, values);
+    const record = rows[0] || null;
+    if (record && yamlChanging) {
+        await createVersionSnapshot(record.id, record.content_version, record.yaml_content, record.activity_manifest, record.input_schema, record.output_schema, record.input_field_meta);
+    }
+    return record;
+}
+async function deleteYamlWorkflow(id) {
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(sql_1.DELETE_YAML_WORKFLOW, [id]);
+    return (rowCount || 0) > 0;
+}
+/**
+ * Ranked discovery: find active workflows matching the user's prompt
+ * via full-text search (tsvector) + tag overlap + optional category filter.
+ */
+async function discoverWorkflows(prompt, tags, category, limit = 5) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.DISCOVER_WORKFLOWS, [prompt, tags, category || null, limit]);
+    return rows;
+}
+async function getActiveYamlWorkflows() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ACTIVE_YAML_WORKFLOWS);
+    return rows;
+}
+async function listYamlWorkflowsByAppId(appId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.LIST_BY_APP_ID, [appId]);
+    return rows;
+}
+async function getDistinctAppIds() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_DISTINCT_APP_IDS);
+    return rows.map((r) => r.app_id);
+}
+// -- Version history ---------------------------------------------------------
+async function createVersionSnapshot(workflowId, version, yamlContent, activityManifest, inputSchema, outputSchema, inputFieldMeta, changeSummary) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CREATE_VERSION_SNAPSHOT, [
+        workflowId, version, yamlContent,
+        JSON.stringify(activityManifest),
+        JSON.stringify(inputSchema),
+        JSON.stringify(outputSchema),
+        JSON.stringify(inputFieldMeta || []),
+        changeSummary || null,
+    ]);
+    return rows[0];
+}
+async function getVersionHistory(workflowId, limit = defaults_1.YAML_VERSION_LIMIT, offset = 0) {
+    const pool = (0, db_1.getPool)();
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(sql_1.COUNT_VERSIONS, [workflowId]),
+        pool.query(sql_1.LIST_VERSIONS, [workflowId, limit, offset]),
+    ]);
+    return {
+        versions: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+async function getVersionSnapshot(workflowId, version) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_VERSION_SNAPSHOT, [workflowId, version]);
+    return rows[0] || null;
+}
+async function markContentDeployed(workflowId) {
+    const pool = (0, db_1.getPool)();
+    await pool.query(sql_1.MARK_CONTENT_DEPLOYED, [workflowId]);
+}
+async function markAppIdContentDeployed(appId) {
+    const pool = (0, db_1.getPool)();
+    await pool.query(sql_1.MARK_APP_ID_CONTENT_DEPLOYED, [appId]);
+}

package/build/services/yaml-workflow/deployer-helpers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Merge all YAML graphs for an app_id into a single YAML document.
+ * HotMesh supports multiple graphs in one app definition under `app.graphs[]`.
+ */
+export declare function buildMergedYaml(appId: string, version: string): Promise<string>;
+/**
+ * Re-run the compilation pipeline for the most recently compiled workflow
+ * in the app, feeding the deployment error as context so the LLM can
+ * produce a plan that avoids the same issue.
+ *
+ * Returns true if recompilation succeeded and the DB was updated, false otherwise.
+ */
+export declare function recompileWithContext(appId: string, failedYaml: string, errorMessage: string): Promise<boolean>;

package/build/services/yaml-workflow/deployer-helpers.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMergedYaml = buildMergedYaml;
+exports.recompileWithContext = recompileWithContext;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const yaml = require('js-yaml');
+const defaults_1 = require("../../modules/defaults");
+const logger_1 = require("../logger");
+const yamlDb = __importStar(require("./db"));
+/**
+ * Merge all YAML graphs for an app_id into a single YAML document.
+ * HotMesh supports multiple graphs in one app definition under `app.graphs[]`.
+ */
+async function buildMergedYaml(appId, version) {
+    const workflows = await yamlDb.listYamlWorkflowsByAppId(appId);
+    if (workflows.length === 0) {
+        throw new Error(`No YAML workflows found for app_id: ${appId}`);
+    }
+    const allGraphs = [];
+    for (const wf of workflows) {
+        const parsed = yaml.load(wf.yaml_content);
+        if (parsed?.app?.graphs) {
+            allGraphs.push(...parsed.app.graphs);
+        }
+    }
+    // Pre-validate: check for duplicate activity IDs across all graphs
+    const activityIds = new Map(); // id -> graph subscribes topic
+    const duplicates = [];
+    for (const graph of allGraphs) {
+        const g = graph;
+        const topic = g.subscribes || 'unknown';
+        if (g.activities) {
+            for (const id of Object.keys(g.activities)) {
+                if (activityIds.has(id)) {
+                    duplicates.push(`"${id}" in both "${activityIds.get(id)}" and "${topic}"`);
+                }
+                else {
+                    activityIds.set(id, topic);
+                }
+            }
+        }
+    }
+    if (duplicates.length > 0) {
+        const msg = `Duplicate activity IDs across graphs in app "${appId}": ${duplicates.join('; ')}`;
+        logger_1.loggerRegistry.error(`[yaml-workflow] ${msg}`);
+        throw new Error(msg);
+    }
+    const merged = {
+        app: {
+            id: appId,
+            version,
+            graphs: allGraphs,
+        },
+    };
+    return yaml.dump(merged, { lineWidth: defaults_1.YAML_LINE_WIDTH, noRefs: true, sortKeys: false });
+}
+/**
+ * Re-run the compilation pipeline for the most recently compiled workflow
+ * in the app, feeding the deployment error as context so the LLM can
+ * produce a plan that avoids the same issue.
+ *
+ * Returns true if recompilation succeeded and the DB was updated, false otherwise.
+ */
+async function recompileWithContext(appId, failedYaml, errorMessage) {
+    try {
+        // Find the most recently updated non-archived workflow for this app_id
+        const workflows = await yamlDb.listYamlWorkflowsByAppId(appId);
+        // Sort by updated_at desc to find the one that likely triggered the failure
+        const sorted = workflows.sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime());
+        const target = sorted[0];
+        if (!target?.source_workflow_id) {
+            logger_1.loggerRegistry.warn('[yaml-workflow] recompilation skipped: no source workflow to recompile from');
+            return false;
+        }
+        logger_1.loggerRegistry.info(`[yaml-workflow] recompiling "${target.name}" (source: ${target.source_workflow_id}) with error context`);
+        const { generateYamlFromExecution } = await Promise.resolve().then(() => __importStar(require('./generator')));
+        const result = await generateYamlFromExecution({
+            workflowId: target.source_workflow_id,
+            taskQueue: 'long-tail-system',
+            workflowName: 'mcpQuery',
+            name: target.name,
+            description: target.description || undefined,
+            appId: target.app_id,
+            subscribes: target.graph_topic,
+            priorDeployError: errorMessage,
+            priorFailedYaml: failedYaml,
+        });
+        // Update the workflow record with the recompiled YAML
+        await yamlDb.updateYamlWorkflow(target.id, {
+            yaml_content: result.yaml,
+            activity_manifest: result.activityManifest,
+        });
+        logger_1.loggerRegistry.info(`[yaml-workflow] recompilation complete for "${target.name}" (${result.yaml.length} chars)`);
+        return true;
+    }
+    catch (err) {
+        logger_1.loggerRegistry.warn(`[yaml-workflow] recompilation failed: ${err.message}`);
+        return false;
+    }
+}

package/build/services/yaml-workflow/deployer.d.ts

@@ -0,0 +1,54 @@
+import { HotMesh } from '@hotmeshio/hotmesh';
+import type { HotMeshManifest } from '@hotmeshio/hotmesh/build/types/hotmesh';
+export { buildMergedYaml } from './deployer-helpers';
+/**
+ * Get or create a HotMesh engine instance for a given app ID.
+ * Flows sharing the same appId share the same engine (and DB connection pool).
+ */
+export declare function getEngine(appId: string): Promise<HotMesh>;
+/**
+ * Deploy all YAML workflows for an app_id as a single merged version.
+ *
+ * On failure, attempts one recompilation cycle:
+ *   1. Identifies the workflow that was most recently compiled (the trigger)
+ *   2. Re-runs the full compilation pipeline with the error as context
+ *   3. The compile stage's LLM receives the error + failed YAML to avoid the same issue
+ *   4. Stores the recompiled YAML and retries deployment
+ *
+ * If recompilation is unavailable or fails, the original error is thrown.
+ */
+export declare function deployAppId(appId: string, version: string): Promise<HotMeshManifest>;
+/**
+ * Deploy a single YAML workflow to HotMesh (inactive until activated).
+ * @deprecated Use deployAppId for merged deployment.
+ */
+export declare function deployYamlWorkflow(appId: string, yamlContent: string): Promise<HotMeshManifest>;
+/**
+ * Activate a deployed version of a YAML workflow.
+ */
+export declare function activateYamlWorkflow(appId: string, version: string): Promise<boolean>;
+/**
+ * Invoke a YAML workflow (fire-and-forget). Returns the job ID.
+ */
+export declare function invokeYamlWorkflow(appId: string, topic: string, data: Record<string, unknown>, entity?: string): Promise<string>;
+/**
+ * Invoke a YAML workflow and wait for the result.
+ *
+ * Replicates HotMesh's engine.pubsub() logic exactly, but adds the
+ * `extended` parameter (where entity lives) to the internal pub() call.
+ * HotMesh's pubsub omits extended, so entity was never set.
+ *
+ * Source: @hotmeshio/hotmesh engine/index.js pubsub()
+ */
+export declare function invokeYamlWorkflowSync(appId: string, topic: string, data: Record<string, unknown>, timeout?: number, entity?: string): Promise<{
+    job_id: string;
+    result: Record<string, unknown>;
+}>;
+/**
+ * Stop a specific YAML workflow engine.
+ */
+export declare function stopEngine(appId: string): Promise<void>;
+/**
+ * Stop all YAML workflow engines.
+ */
+export declare function stopAllEngines(): Promise<void>;