@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/services/controlplane/sql.js

@@ -4,13 +4,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VOLUME_BY_STREAM = exports.COUNT_PROCESSED_SINCE = exports.COUNT_PENDING = exports.LIST_APPS = void 0;
 /**
  * List all HotMesh applications from the global registry.
- * Keys follow the pattern `hmsh:a:{appId}`. Non-expired only.
+ * Active apps only.
  */
 exports.LIST_APPS = `
-  SELECT DISTINCT key FROM hotmesh_applications
-  WHERE key LIKE 'hmsh:a:%'
-    AND (expiry IS NULL OR expiry > NOW())
-  ORDER BY key`;
+  SELECT app_id, version FROM hmsh_applications
+  WHERE active = TRUE
+  ORDER BY app_id`;
 // ─── Stream statistics ──────────────────────────────────────────────────────
 //
 // HotMesh v0.11.0 split the single `streams` table into `engine_streams`

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

@@ -1,6 +1,7 @@
 /** Type definitions for the control plane service. */
 export interface ControlPlaneApp {
     appId: string;
+    version: string;
 }
 export interface StreamStats {
     pending: number;

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

@@ -1,4 +1,5 @@
 import type { LTWorkflowConfig } from '../../types';
+import type { LTYamlWorkflowRecord } from '../../types/yaml-workflow';
 /**
  * Singleton registry for workflow cron schedules.
  *
@@ -30,6 +31,22 @@ declare class LTCronRegistry {
      * Stops the old cron (if any) and starts a new one if cron_schedule is set.
      */
     restartCron(config: LTWorkflowConfig): Promise<void>;
+    /**
+     * Load all YAML workflows with a cron_schedule and start Virtual.cron for each.
+     */
+    connectYamlCrons(): Promise<void>;
+    /**
+     * Start a single Virtual.cron for a YAML workflow.
+     */
+    startYamlCron(wf: LTYamlWorkflowRecord): Promise<void>;
+    /**
+     * Stop a single YAML workflow cron.
+     */
+    stopYamlCron(yamlWfId: string): Promise<void>;
+    /**
+     * Restart a YAML workflow cron after config change.
+     */
+    restartYamlCron(wf: LTYamlWorkflowRecord): Promise<void>;
     /**
      * Stop all active crons. Call during graceful shutdown.
      */

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/export/index.js

@@ -148,12 +148,16 @@ async function listJobs(params) {
          CASE WHEN j.updated_at != j.created_at THEN j.updated_at
               WHEN ju.value IS NOT NULL THEN to_timestamp(ju.value, 'YYYYMMDDHH24MISS.MS')
               ELSE j.updated_at
-         END as updated_at
+         END as updated_at,
+         ws.id as set_id
        FROM durable.jobs j
        LEFT JOIN durable.jobs_attributes ju
          ON ju.job_id = j.id
          AND ju.symbol IN (SELECT value FROM ju_symbols)
          AND (ju.dimension IS NULL OR ju.dimension = '')
+       LEFT JOIN lt_workflow_sets ws
+         ON ws.source_workflow_id = REPLACE(j.key, 'hmsh:durable:j:', '')
+         AND j.entity = 'mcpWorkflowPlanner'
        WHERE ${where}
        ORDER BY ${buildJobOrderBy(params.sort_by, params.order)}
        LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
@@ -165,6 +169,7 @@ async function listJobs(params) {
         is_live: row.is_live,
         created_at: row.created_at,
         updated_at: row.updated_at,
+        ...(row.set_id ? { set_id: row.set_id } : {}),
     }));
     return { jobs, total: parseInt(countResult.rows[0].count, 10) };
 }

package/build/services/hotmesh-utils.js

@@ -81,13 +81,11 @@ exports.LOAD_SYMBOL_MAP = LOAD_SYMBOL_MAP;
  */
 async function loadSymbolMap(schema, appId) {
     const pool = (0, db_1.getPool)();
-    const symKeyPrefix = `hmsh:${appId}:sym:keys:`;
     try {
-        const result = await pool.query((0, exports.LOAD_SYMBOL_MAP)(schema), [`${symKeyPrefix}%`]);
+        const result = await pool.query((0, exports.LOAD_SYMBOL_MAP)(schema), ['keys:%']);
         const reverseMap = {};
         for (const row of result.rows) {
-            const symbolName = row.key.slice(symKeyPrefix.length);
-            if (row.field && row.value && symbolName !== '') {
+            if (row.field && row.value) {
                 reverseMap[row.value] = row.field;
             }
         }

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

@@ -28,4 +28,22 @@ 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 interface WorkflowPlannerInput {
+    specification: string;
+    setId: string;
+    wait?: boolean;
+    userId?: string;
+}
+export declare function startWorkflowPlanner(input: WorkflowPlannerInput): Promise<McpQueryResult>;
 export declare function describeWorkflow(input: DescribeInput): Promise<DescribeResult>;

package/build/services/insight/index.js

@@ -5,6 +5,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startMcpQuery = startMcpQuery;
+exports.startWorkflowBuilder = startWorkflowBuilder;
+exports.startWorkflowPlanner = startWorkflowPlanner;
 exports.describeWorkflow = describeWorkflow;
 const hotmesh_1 = require("@hotmeshio/hotmesh");
 const db_1 = require("../../lib/db");
@@ -44,6 +46,64 @@ 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,
+    };
+}
+async function startWorkflowPlanner(input) {
+    const { specification, setId, wait = true, userId } = input;
+    const startTime = Date.now();
+    const client = new hotmesh_1.Durable.Client({ connection: (0, db_1.getConnection)() });
+    const workflowId = `wf-planner-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const handle = await client.workflow.start({
+        args: [{
+                data: { specification, setId },
+                metadata: { source: 'dashboard' },
+                lt: { userId },
+            }],
+        taskQueue: 'long-tail-system',
+        workflowName: 'mcpWorkflowPlanner',
+        workflowId,
+        expire: defaults_1.JOB_EXPIRE_SECS,
+        entity: 'mcpWorkflowPlanner',
+    });
+    if (wait === false) {
+        return { workflow_id: workflowId, status: 'started', prompt: specification.slice(0, 200) };
+    }
+    const result = await handle.result({ state: true });
+    const data = result?.data || result;
+    return {
+        ...data,
+        prompt: specification.slice(0, 200),
+        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/client/tools.js

@@ -58,6 +58,7 @@ function deriveAuthFromToolContext() {
  * Resolves the server by ID or name, auto-connecting built-in servers.
  */
 async function callServerTool(serverId, toolName, args, authContext) {
+    logger_1.loggerRegistry.debug(`[lt-mcp:call] entering ${serverId}/${toolName} argKeys=[${Object.keys(args).join(',')}]`);
     const client = await (0, connection_1.resolveClient)(serverId);
     if (!client) {
         throw new Error(`MCP server ${serverId} is not connected`);
@@ -79,13 +80,24 @@ async function callServerTool(serverId, toolName, args, authContext) {
         const textContent = result.content.find((c) => c.type === 'text');
         if (textContent && 'text' in textContent) {
             try {
-                return JSON.parse(textContent.text);
+                const parsed = JSON.parse(textContent.text);
+                const isError = result.isError || ('error' in parsed);
+                logger_1.loggerRegistry.debug(`[lt-mcp:call] leaving ${serverId}/${toolName} ok=${!isError} resultKeys=[${Object.keys(parsed).join(',')}]`);
+                return parsed;
             }
             catch {
+                // Non-JSON text — wrap as error object when isError flag is set
+                // to prevent raw strings from being spread as character indices downstream.
+                if (result.isError) {
+                    logger_1.loggerRegistry.warn(`[lt-mcp:call] leaving ${serverId}/${toolName} error: ${textContent.text.slice(0, 200)}`);
+                    return { error: textContent.text };
+                }
+                logger_1.loggerRegistry.debug(`[lt-mcp:call] leaving ${serverId}/${toolName} raw text (${textContent.text.length} chars)`);
                 return textContent.text;
             }
         }
     }
+    logger_1.loggerRegistry.debug(`[lt-mcp:call] leaving ${serverId}/${toolName} non-text content (${Array.isArray(result.content) ? result.content.length : 0} blocks)`);
     return result.content;
 }
 /**

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/mcp-runs/sql.js

@@ -20,7 +20,7 @@ exports.GET_JOB_ATTRIBUTES = GET_JOB_ATTRIBUTES;
 // ─── Queries (queries.ts) ───────────────────────────────────────────────────
 const LIST_JOBS = (schema, appId, where, limitIdx, offsetIdx) => `WITH ju_symbols AS (
      SELECT value FROM ${schema}.symbols
-     WHERE key LIKE 'hmsh:${appId}:sym:keys:%' AND field = 'metadata/ju'
+     WHERE key LIKE 'keys:%' AND field = 'metadata/ju'
    )
    SELECT j.key, j.entity, j.status, j.is_live, j.created_at,
      CASE WHEN j.updated_at != j.created_at THEN j.updated_at

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

@@ -0,0 +1,16 @@
+import type { LTWorkflowSetRecord, LTWorkflowSetStatus, CreateWorkflowSetInput, PlanItem } from '../../types/workflow-set';
+export declare function createWorkflowSet(input: CreateWorkflowSetInput): Promise<LTWorkflowSetRecord>;
+export declare function getWorkflowSet(id: string): Promise<LTWorkflowSetRecord | null>;
+export declare function updateWorkflowSetPlan(id: string, plan: PlanItem[], namespaces: string[]): Promise<LTWorkflowSetRecord | null>;
+export declare function updateWorkflowSetStatus(id: string, status: LTWorkflowSetStatus): Promise<LTWorkflowSetRecord | null>;
+export declare function updateWorkflowSetSourceWorkflow(id: string, sourceWorkflowId: string): Promise<void>;
+export declare function deleteWorkflowSet(id: string): Promise<boolean>;
+export declare function listWorkflowSets(filters: {
+    status?: LTWorkflowSetStatus;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    sets: LTWorkflowSetRecord[];
+    total: number;
+}>;