@hotmeshio/long-tail 0.1.5 → 0.1.6

package/build/services/cron/index.js

@@ -42,6 +42,8 @@ const configService = __importStar(require("../config"));
 const principal_1 = require("../iam/principal");
 const CRON_TOPIC_PREFIX = 'lt.cron';
 const CRON_ID_PREFIX = 'lt-cron';
+const YAML_CRON_TOPIC_PREFIX = 'lt.cron.yaml';
+const YAML_CRON_ID_PREFIX = 'lt-cron-yaml';
 /**
  * Singleton registry for workflow cron schedules.
  *
@@ -71,6 +73,8 @@ class LTCronRegistry {
         for (const config of cronConfigs) {
             await this.startCron(config);
         }
+        // Connect YAML workflow crons
+        await this.connectYamlCrons();
         this.connected = true;
         if (cronConfigs.length > 0) {
             logger_1.loggerRegistry.info(`[lt-cron] started ${cronConfigs.length} cron(s): ${cronConfigs.map((c) => c.workflow_type).join(', ')}`);
@@ -171,12 +175,101 @@ class LTCronRegistry {
             logger_1.loggerRegistry.info(`[lt-cron] restarted ${config.workflow_type} (${config.cron_schedule})`);
         }
     }
+    // ── YAML workflow crons ────────────────────────────────────────────────────
+    /**
+     * Load all YAML workflows with a cron_schedule and start Virtual.cron for each.
+     */
+    async connectYamlCrons() {
+        const { getCronScheduledWorkflows } = await Promise.resolve().then(() => __importStar(require('../yaml-workflow/db')));
+        const yamlWfs = await getCronScheduledWorkflows();
+        for (const wf of yamlWfs) {
+            await this.startYamlCron(wf);
+        }
+        if (yamlWfs.length > 0) {
+            logger_1.loggerRegistry.info(`[lt-cron] started ${yamlWfs.length} YAML cron(s): ${yamlWfs.map((w) => w.graph_topic).join(', ')}`);
+        }
+    }
+    /**
+     * Start a single Virtual.cron for a YAML workflow.
+     */
+    async startYamlCron(wf) {
+        if (!wf.cron_schedule)
+            return;
+        const connection = (0, db_1.getConnection)();
+        const topic = `${YAML_CRON_TOPIC_PREFIX}.${wf.id}`;
+        const cronId = `${YAML_CRON_ID_PREFIX}-${wf.id}`;
+        const cronEnvelope = wf.cron_envelope || {};
+        const wfId = wf.id;
+        const graphTopic = wf.graph_topic;
+        const appId = wf.app_id;
+        let cronCallCount = 0;
+        await hotmesh_1.Virtual.cron({
+            topic,
+            connection,
+            callback: async () => {
+                try {
+                    cronCallCount++;
+                    logger_1.loggerRegistry.info(`[lt-cron] tick #${cronCallCount} at ${new Date().toISOString()} — pub(${appId}/${graphTopic})`);
+                    const { getEngine } = await Promise.resolve().then(() => __importStar(require('../yaml-workflow/deployer')));
+                    const engine = await getEngine(appId);
+                    await engine.pub(graphTopic, cronEnvelope, undefined, { entity: graphTopic });
+                    logger_1.loggerRegistry.info(`[lt-cron] tick #${cronCallCount} published successfully`);
+                }
+                catch (err) {
+                    logger_1.loggerRegistry.error(`[lt-cron] tick #${cronCallCount} failed: ${err?.message}`);
+                }
+            },
+            args: [],
+            options: {
+                id: cronId,
+                interval: wf.cron_schedule,
+            },
+        });
+        this.activeCrons.set(`yaml:${wf.id}`, cronId);
+    }
+    /**
+     * Stop a single YAML workflow cron.
+     */
+    async stopYamlCron(yamlWfId) {
+        const key = `yaml:${yamlWfId}`;
+        const cronId = this.activeCrons.get(key);
+        if (!cronId)
+            return;
+        const connection = (0, db_1.getConnection)();
+        const topic = `${YAML_CRON_TOPIC_PREFIX}.${yamlWfId}`;
+        try {
+            await hotmesh_1.Virtual.interrupt({
+                topic,
+                connection,
+                options: { id: cronId },
+            });
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[lt-cron] interrupt failed for YAML workflow ${yamlWfId}: ${err?.message}`);
+        }
+        this.activeCrons.delete(key);
+    }
+    /**
+     * Restart a YAML workflow cron after config change.
+     */
+    async restartYamlCron(wf) {
+        await this.stopYamlCron(wf.id);
+        if (wf.cron_schedule && wf.status === 'active') {
+            await this.startYamlCron(wf);
+            logger_1.loggerRegistry.info(`[lt-cron] restarted YAML cron ${wf.graph_topic} (${wf.cron_schedule})`);
+        }
+    }
     /**
      * Stop all active crons. Call during graceful shutdown.
      */
     async disconnect() {
         for (const workflowType of [...this.activeCrons.keys()]) {
-            await this.stopCron(workflowType);
+            if (workflowType.startsWith('yaml:')) {
+                await this.stopYamlCron(workflowType.replace('yaml:', ''));
+            }
+            else {
+                await this.stopCron(workflowType);
+            }
         }
         this.connected = false;
     }

package/build/services/insight/index.d.ts

@@ -28,4 +28,15 @@ export interface DescribeResult {
     tags: string[];
 }
 export declare function startMcpQuery(input: McpQueryInput): Promise<McpQueryResult>;
+export interface WorkflowBuilderInput {
+    prompt: string;
+    tags?: string[];
+    wait?: boolean;
+    feedback?: string;
+    prior_yaml?: string;
+    answers?: string;
+    prior_questions?: string[];
+    userId?: string;
+}
+export declare function startWorkflowBuilder(input: WorkflowBuilderInput): Promise<McpQueryResult>;
 export declare function describeWorkflow(input: DescribeInput): Promise<DescribeResult>;

package/build/services/insight/index.js

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startMcpQuery = startMcpQuery;
+exports.startWorkflowBuilder = startWorkflowBuilder;
 exports.describeWorkflow = describeWorkflow;
 const hotmesh_1 = require("@hotmeshio/hotmesh");
 const db_1 = require("../../lib/db");
@@ -44,6 +45,35 @@ async function startMcpQuery(input) {
         duration_ms: Date.now() - startTime,
     };
 }
+async function startWorkflowBuilder(input) {
+    const { prompt, tags, wait = true, feedback, prior_yaml, answers, prior_questions, userId } = input;
+    const startTime = Date.now();
+    const client = new hotmesh_1.Durable.Client({ connection: (0, db_1.getConnection)() });
+    const workflowId = `wf-builder-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const handle = await client.workflow.start({
+        args: [{
+                data: { prompt, tags, feedback, prior_yaml, answers, prior_questions },
+                metadata: { source: 'dashboard' },
+                lt: { userId },
+            }],
+        taskQueue: 'long-tail-system',
+        workflowName: 'mcpWorkflowBuilder',
+        workflowId,
+        expire: defaults_1.JOB_EXPIRE_SECS,
+        entity: 'mcpWorkflowBuilder',
+    });
+    if (wait === false) {
+        return { workflow_id: workflowId, status: 'started', prompt };
+    }
+    const result = await handle.result({ state: true });
+    const data = result?.data || result;
+    return {
+        ...data,
+        prompt,
+        workflow_id: workflowId,
+        duration_ms: Date.now() - startTime,
+    };
+}
 // ── Workflow description generation ──────────────────────────────────────────
 async function describeWorkflow(input) {
     const { prompt, result_title, result_summary } = input;

package/build/services/mcp/client/connection.d.ts

@@ -40,6 +40,15 @@ export declare function listServerTools(serverId: string): Promise<LTMcpToolMani
  * Check if a server is connected.
  */
 export declare function isConnected(serverId: string): boolean;
+/**
+ * Test connectivity to an MCP server without persisting.
+ * Creates a temporary client, connects, lists tools, then disconnects.
+ */
+export declare function testConnection(transportType: 'stdio' | 'sse' | 'streamable-http', transportConfig: Record<string, any>): Promise<{
+    success: boolean;
+    tools: LTMcpToolManifest[];
+    error?: string;
+}>;
 /**
  * Clear all state. Used in tests.
  */

package/build/services/mcp/client/connection.js

@@ -41,10 +41,12 @@ exports.connectAutoServers = connectAutoServers;
 exports.disconnectAll = disconnectAll;
 exports.listServerTools = listServerTools;
 exports.isConnected = isConnected;
+exports.testConnection = testConnection;
 exports.clear = clear;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
 const logger_1 = require("../../../lib/logger");
 const mcpDbService = __importStar(require("../db"));
@@ -106,13 +108,17 @@ async function connectToServer(server) {
     }
     const client = new index_js_1.Client({ name: 'long-tail', version: '1.0.0' });
     let transport;
-    if (server.transport_type === 'stdio') {
+    const ttype = server.transport_type;
+    if (ttype === 'stdio') {
         transport = new stdio_js_1.StdioClientTransport({
             command: server.transport_config.command,
             args: server.transport_config.args || [],
             env: server.transport_config.env,
         });
     }
+    else if (ttype === 'streamable-http') {
+        transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(server.transport_config.url));
+    }
     else {
         transport = new sse_js_1.SSEClientTransport(new URL(server.transport_config.url));
     }
@@ -272,6 +278,48 @@ async function listServerTools(serverId) {
 function isConnected(serverId) {
     return clients.has(serverId);
 }
+/**
+ * Test connectivity to an MCP server without persisting.
+ * Creates a temporary client, connects, lists tools, then disconnects.
+ */
+async function testConnection(transportType, transportConfig) {
+    const client = new index_js_1.Client({ name: 'long-tail-test', version: '1.0.0' });
+    const timeout = setTimeout(() => { throw new Error('Connection timed out (10s)'); }, 10_000);
+    try {
+        let transport;
+        if (transportType === 'stdio') {
+            transport = new stdio_js_1.StdioClientTransport({
+                command: transportConfig.command,
+                args: transportConfig.args || [],
+                env: transportConfig.env,
+            });
+        }
+        else if (transportType === 'streamable-http') {
+            transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(transportConfig.url));
+        }
+        else {
+            transport = new sse_js_1.SSEClientTransport(new URL(transportConfig.url));
+        }
+        await client.connect(transport);
+        const { tools } = await client.listTools();
+        const manifest = tools.map((t) => ({
+            name: t.name,
+            description: t.description || '',
+            inputSchema: t.inputSchema || {},
+        }));
+        return { success: true, tools: manifest };
+    }
+    catch (err) {
+        return { success: false, tools: [], error: err.message };
+    }
+    finally {
+        clearTimeout(timeout);
+        try {
+            await client.close();
+        }
+        catch { /* ignore close errors */ }
+    }
+}
 /**
  * Clear all state. Used in tests.
  */

package/build/services/mcp/db-server/schemas.d.ts

@@ -14,8 +14,8 @@ export declare const findTasksSchema: z.ZodObject<{
 }, {
     status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
-    limit?: number | undefined;
     workflow_id?: string | undefined;
+    limit?: number | undefined;
     origin_id?: string | undefined;
 }>;
 export declare const findEscalationsSchema: z.ZodObject<{
@@ -34,8 +34,8 @@ export declare const findEscalationsSchema: z.ZodObject<{
     role?: string | undefined;
     status?: "pending" | "resolved" | undefined;
     type?: string | undefined;
-    priority?: number | undefined;
     limit?: number | undefined;
+    priority?: number | undefined;
 }>;
 export declare const getProcessSummarySchema: z.ZodObject<{
     workflow_type: z.ZodOptional<z.ZodString>;

package/build/services/mcp/db.d.ts

@@ -3,7 +3,7 @@ import type { CreateMcpServerInput } from './types';
 export declare function createMcpServer(input: CreateMcpServerInput): Promise<LTMcpServerRecord>;
 export declare function getMcpServer(id: string): Promise<LTMcpServerRecord | null>;
 export declare function getMcpServerByName(name: string): Promise<LTMcpServerRecord | null>;
-export declare function updateMcpServer(id: string, updates: Partial<Pick<CreateMcpServerInput, 'name' | 'description' | 'transport_type' | 'transport_config' | 'auto_connect' | 'metadata' | 'tags'>>): Promise<LTMcpServerRecord | null>;
+export declare function updateMcpServer(id: string, updates: Partial<Pick<CreateMcpServerInput, 'name' | 'description' | 'transport_type' | 'transport_config' | 'auto_connect' | 'metadata' | 'tags' | 'compile_hints' | 'credential_providers'>>): Promise<LTMcpServerRecord | null>;
 export declare function deleteMcpServer(id: string): Promise<boolean>;
 export declare function updateMcpServerStatus(id: string, status: LTMcpServerStatus, toolManifest?: LTMcpToolManifest[]): Promise<void>;
 export declare function listMcpServers(filters: {

package/build/services/mcp/db.js

@@ -21,6 +21,8 @@ async function createMcpServer(input) {
         input.auto_connect ?? false,
         input.metadata ? JSON.stringify(input.metadata) : null,
         input.tags || [],
+        input.compile_hints || null,
+        input.credential_providers || [],
     ]);
     return rows[0];
 }
@@ -67,6 +69,14 @@ async function updateMcpServer(id, updates) {
         sets.push(`tags = $${idx++}`);
         values.push(updates.tags);
     }
+    if (updates.compile_hints !== undefined) {
+        sets.push(`compile_hints = $${idx++}`);
+        values.push(updates.compile_hints || null);
+    }
+    if (updates.credential_providers !== undefined) {
+        sets.push(`credential_providers = $${idx++}`);
+        values.push(updates.credential_providers);
+    }
     if (sets.length === 0)
         return getMcpServer(id);
     values.push(id);

package/build/services/mcp/playwright-server/schemas.d.ts

@@ -17,13 +17,13 @@ export declare const screenshotSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     path: string;
     page_id?: string | undefined;
-    full_page?: boolean | undefined;
     selector?: string | undefined;
+    full_page?: boolean | undefined;
 }, {
     path: string;
     page_id?: string | undefined;
-    full_page?: boolean | undefined;
     selector?: string | undefined;
+    full_page?: boolean | undefined;
 }>;
 export declare const clickSchema: z.ZodObject<{
     page_id: z.ZodOptional<z.ZodString>;
@@ -54,12 +54,12 @@ export declare const waitForSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     selector: string;
-    timeout?: number | undefined;
     page_id?: string | undefined;
+    timeout?: number | undefined;
 }, {
     selector: string;
-    timeout?: number | undefined;
     page_id?: string | undefined;
+    timeout?: number | undefined;
 }>;
 export declare const evaluateSchema: z.ZodObject<{
     page_id: z.ZodOptional<z.ZodString>;

package/build/services/mcp/sql.d.ts

@@ -1,4 +1,4 @@
-export declare const CREATE_MCP_SERVER = "\n  INSERT INTO lt_mcp_servers\n    (name, description, transport_type, transport_config, auto_connect, metadata, tags)\n  VALUES ($1, $2, $3, $4, $5, $6, $7)\n  RETURNING *";
+export declare const CREATE_MCP_SERVER = "\n  INSERT INTO lt_mcp_servers\n    (name, description, transport_type, transport_config, auto_connect, metadata, tags, compile_hints, credential_providers)\n  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)\n  RETURNING *";
 export declare const GET_MCP_SERVER = "\n  SELECT * FROM lt_mcp_servers WHERE id = $1";
 export declare const GET_MCP_SERVER_BY_NAME = "\n  SELECT * FROM lt_mcp_servers WHERE name = $1";
 export declare const DELETE_MCP_SERVER = "\n  DELETE FROM lt_mcp_servers WHERE id = $1";

package/build/services/mcp/sql.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SEED_MCP_SERVER = exports.DELETE_STALE_BUILTIN_SERVERS = exports.HEALTH_DURABLE_WORKFLOWS = exports.HEALTH_WORKFLOW_CONFIGS = exports.HEALTH_COMPILED_WORKFLOWS = exports.HEALTH_MCP_SERVER_LIST = exports.HEALTH_MCP_SERVERS = exports.HEALTH_RECENT_ACTIVITY = exports.HEALTH_ACTIVE_WORKFLOW_TYPES = exports.HEALTH_ESCALATION_COUNTS = exports.HEALTH_TASK_COUNTS = exports.GET_AUTO_CONNECT_SERVERS = exports.UPDATE_STATUS = exports.UPDATE_STATUS_CONNECTED = exports.DELETE_MCP_SERVER = exports.GET_MCP_SERVER_BY_NAME = exports.GET_MCP_SERVER = exports.CREATE_MCP_SERVER = void 0;
 exports.CREATE_MCP_SERVER = `
   INSERT INTO lt_mcp_servers
-    (name, description, transport_type, transport_config, auto_connect, metadata, tags)
-  VALUES ($1, $2, $3, $4, $5, $6, $7)
+    (name, description, transport_type, transport_config, auto_connect, metadata, tags, compile_hints, credential_providers)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
   RETURNING *`;
 exports.GET_MCP_SERVER = `
   SELECT * FROM lt_mcp_servers WHERE id = $1`;

package/build/services/mcp/types.d.ts

@@ -2,11 +2,13 @@
 export interface CreateMcpServerInput {
     name: string;
     description?: string;
-    transport_type: 'stdio' | 'sse';
+    transport_type: 'stdio' | 'sse' | 'streamable-http';
     transport_config: Record<string, any>;
     auto_connect?: boolean;
     metadata?: Record<string, any>;
     tags?: string[];
+    compile_hints?: string;
+    credential_providers?: string[];
 }
 export interface BuiltInMcpAdapterOptions {
     server?: {

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

@@ -25,3 +25,6 @@ export declare function getVersionHistory(workflowId: string, limit?: number, of
 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>;
+export declare function updateCronSchedule(id: string, cronSchedule: string, cronEnvelope: Record<string, unknown> | null, executeAs: string | null): Promise<LTYamlWorkflowRecord | null>;
+export declare function clearCronSchedule(id: string): Promise<LTYamlWorkflowRecord | null>;
+export declare function getCronScheduledWorkflows(): Promise<LTYamlWorkflowRecord[]>;

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

@@ -16,6 +16,9 @@ exports.getVersionHistory = getVersionHistory;
 exports.getVersionSnapshot = getVersionSnapshot;
 exports.markContentDeployed = markContentDeployed;
 exports.markAppIdContentDeployed = markAppIdContentDeployed;
+exports.updateCronSchedule = updateCronSchedule;
+exports.clearCronSchedule = clearCronSchedule;
+exports.getCronScheduledWorkflows = getCronScheduledWorkflows;
 const db_1 = require("../../lib/db");
 const defaults_1 = require("../../modules/defaults");
 const sql_1 = require("./sql");
@@ -194,3 +197,24 @@ async function markAppIdContentDeployed(appId) {
     const pool = (0, db_1.getPool)();
     await pool.query(sql_1.MARK_APP_ID_CONTENT_DEPLOYED, [appId]);
 }
+// -- Cron scheduling ---------------------------------------------------------
+async function updateCronSchedule(id, cronSchedule, cronEnvelope, executeAs) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.UPDATE_CRON_SCHEDULE, [
+        id,
+        cronSchedule,
+        cronEnvelope ? JSON.stringify(cronEnvelope) : null,
+        executeAs,
+    ]);
+    return rows[0] || null;
+}
+async function clearCronSchedule(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CLEAR_CRON_SCHEDULE, [id]);
+    return rows[0] || null;
+}
+async function getCronScheduledWorkflows() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_CRON_SCHEDULED_WORKFLOWS);
+    return rows;
+}

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

@@ -0,0 +1,19 @@
+import type { LTYamlWorkflowRecord } from '../../types/yaml-workflow';
+interface InvokeOptions {
+    data?: Record<string, unknown>;
+    sync?: boolean;
+    timeout?: number;
+    execute_as?: string;
+    userId?: string;
+    /** Source identifier for metadata injection (e.g., 'cron') */
+    source?: string;
+}
+/**
+ * Invoke a YAML workflow with scope injection.
+ * Shared by HTTP route and cron callback.
+ */
+export declare function invokeYamlWorkflow(wf: LTYamlWorkflowRecord, options?: InvokeOptions): Promise<{
+    job_id: string;
+    result?: unknown;
+}>;
+export {};

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

@@ -0,0 +1,80 @@
+"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.invokeYamlWorkflow = invokeYamlWorkflow;
+const yamlDeployer = __importStar(require("./deployer"));
+const principal_1 = require("../iam/principal");
+/**
+ * Invoke a YAML workflow with scope injection.
+ * Shared by HTTP route and cron callback.
+ */
+async function invokeYamlWorkflow(wf, options = {}) {
+    const data = { ...(options.data || {}) };
+    // Inject _scope so compiled workflow activities have identity context
+    if (!data._scope) {
+        const executeAs = options.execute_as;
+        const userId = options.userId;
+        if (executeAs) {
+            const [botPrincipal, invokerPrincipal] = await Promise.all([
+                (0, principal_1.resolvePrincipal)(executeAs),
+                userId ? (0, principal_1.resolvePrincipal)(userId) : Promise.resolve(null),
+            ]);
+            if (botPrincipal) {
+                data._scope = {
+                    principal: botPrincipal,
+                    scopes: ['mcp:tool:call'],
+                    ...(invokerPrincipal ? { initiatedBy: userId, initiatingPrincipal: invokerPrincipal } : {}),
+                };
+            }
+        }
+        else if (userId) {
+            const principal = await (0, principal_1.resolvePrincipal)(userId);
+            if (principal) {
+                data._scope = { principal, scopes: ['mcp:tool:call'] };
+            }
+        }
+    }
+    if (options.source) {
+        if (!data._metadata)
+            data._metadata = {};
+        data._metadata.source = options.source;
+    }
+    if (options.sync) {
+        const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, data, options.timeout, wf.graph_topic);
+        return { job_id, result };
+    }
+    const jobId = await yamlDeployer.invokeYamlWorkflow(wf.app_id, wf.graph_topic, data, wf.graph_topic);
+    return { job_id: jobId };
+}

package/build/services/yaml-workflow/pipeline/build/dag.js

@@ -78,7 +78,7 @@ function appendNormalStep(dag, idx, step, prefix, graphTopic, plan, steps, trigg
     if (plan) {
         dag.prevActivityId = (0, transform_1.insertTransformActivities)(idx, plan, steps, prefix, graphTopic, dag.triggerId, triggerInputKeys, dag.stepIndexToActivityId, collapsedToCoreIndex, dag.activities, dag.transitions, dag.manifest, dag.prevActivityId);
     }
-    // Wire input mappings from upstream steps
+    // Wire input mappings from upstream steps (may include @pipe objects for derivations)
     const inputMappings = (0, wiring_1.wireStepInputs)(idx, step, plan, dag.stepIndexToActivityId, dag.triggerId, triggerInputKeys, steps, prefix, dag.prevActivityId, dag.prevResult, collapsedToCoreIndex);
     // Build the activity definition
     const resultSchema = step.result ? (0, utils_1.inferSchema)(step.result) : { type: 'object' };

package/build/services/yaml-workflow/pipeline/build/wiring.d.ts

@@ -6,4 +6,4 @@ import type { ExtractedStep, EnhancedCompilationPlan } from '../../types';
  * Build input mappings for a step using the compilation plan's data flow edges.
  * Falls back to mechanical backward-scan when no plan is available.
  */
-export declare function wireStepInputs(stepIdx: number, step: ExtractedStep, plan: EnhancedCompilationPlan | null, stepIndexToActivityId: Map<number, string>, triggerId: string, triggerInputKeys: Set<string>, steps: ExtractedStep[], prefix: string, prevActivityId: string, prevResult: unknown, collapsedToCoreIndex?: Map<number, number>): Record<string, string>;
+export declare function wireStepInputs(stepIdx: number, step: ExtractedStep, plan: EnhancedCompilationPlan | null, stepIndexToActivityId: Map<number, string>, triggerId: string, triggerInputKeys: Set<string>, steps: ExtractedStep[], prefix: string, prevActivityId: string, prevResult: unknown, collapsedToCoreIndex?: Map<number, number>): Record<string, unknown>;