@ema.co/mcp-toolkit 1.6.0 → 1.7.1

package/dist/mcp/resources.js

@@ -25,6 +25,7 @@ import * as path from "path";
 import { AGENT_CATALOG, WORKFLOW_PATTERNS, WIDGET_CATALOG } from "../sdk/knowledge.js";
 import { INPUT_SOURCE_RULES, ANTI_PATTERNS, OPTIMIZATION_RULES } from "../sdk/validation-rules.js";
 import { EmaClient } from "../sdk/client.js";
+import { APISchemaRegistry } from "../sdk/workflow-validator.js";
 import { loadConfigFromJsonEnv, loadConfigOptional, resolveBearerToken, getEnvByName, getMasterEnv, } from "../sdk/config.js";
 // ─────────────────────────────────────────────────────────────────────────────
 // Security Utilities
@@ -269,6 +270,62 @@ const DYNAMIC_RESOURCES = [
             return md;
         },
     },
+    // Action Schema - Complete action definitions from ema repo
+    {
+        uri: "ema://schema/actions",
+        name: "schema/actions",
+        description: "Complete action schema: all workflow actions with inputs, outputs, types, and documentation from ema_backend/grpc",
+        mimeType: "application/json",
+        generate: async (ctx) => {
+            const schema = await getDynamicActionSchema({ env: ctx.env });
+            return JSON.stringify(schema, null, 2);
+        },
+    },
+    {
+        uri: "ema://schema/actions-summary",
+        name: "schema/actions-summary",
+        description: "Action schema summary: action names, versions, and descriptions for quick reference",
+        mimeType: "text/markdown",
+        generate: async (ctx) => {
+            const schema = await getDynamicActionSchema({ env: ctx.env });
+            if (schema.actions.length === 0) {
+                return "# Action Schema\n\n> No actions loaded. Check API connectivity or bundled schema.\n";
+            }
+            let md = "# Action Schema\n\n";
+            md += `> ${schema.actions.length} actions loaded (source: ${schema.source})\n`;
+            md += `> Version: ${schema.version}\n\n`;
+            const byCategory = new Map();
+            for (const action of schema.actions) {
+                const cat = action.category || "OTHER";
+                if (!byCategory.has(cat))
+                    byCategory.set(cat, []);
+                byCategory.get(cat).push(action);
+            }
+            for (const [category, actions] of byCategory) {
+                md += `## ${category.replace("ACTION_CATEGORY_", "")}\n\n`;
+                md += "| Action | Version | Description | Inputs | Outputs |\n";
+                md += "|--------|---------|-------------|--------|--------|\n";
+                for (const action of actions) {
+                    const inputs = action.inputs?.size || 0;
+                    const outputs = action.outputs?.size || 0;
+                    const desc = action.description?.slice(0, 50) || "-";
+                    md += `| \`${action.name}\` | ${action.version || "v0"} | ${desc}... | ${inputs} | ${outputs} |\n`;
+                }
+                md += "\n";
+            }
+            return md;
+        },
+    },
+    {
+        uri: "ema://schema/action/:name",
+        name: "schema/action",
+        description: "Individual action schema by name (e.g., ema://schema/action/call_llm)",
+        mimeType: "application/json",
+        generate: async (ctx) => {
+            // This is a template - actual resolution happens in getResource
+            return JSON.stringify({ error: "Use specific action name in URI" }, null, 2);
+        },
+    },
 ];
 // ─────────────────────────────────────────────────────────────────────────────
 // Dynamic fetching helpers (Ema API as source of truth when available)
@@ -374,6 +431,56 @@ async function getDynamicPersonaTemplates(opts) {
         return [];
     }
 }
+const actionSchemaCache = new Map();
+/**
+ * Get action schema with layered loading:
+ * 1. Try bundled schema (resources/action-schema.json)
+ * 2. Augment with live API data if available
+ */
+async function getDynamicActionSchema(opts) {
+    const cacheKey = opts.env ?? "";
+    const now = Date.now();
+    const cached = actionSchemaCache.get(cacheKey);
+    if (cached && now - cached.ts < 60_000)
+        return cached.data;
+    const registry = new APISchemaRegistry();
+    // Try to load from bundled schema first (code source of truth)
+    const bundlePath = path.resolve(__dirname, "../../resources/action-schema.json");
+    try {
+        registry.loadFromBundle(bundlePath);
+    }
+    catch {
+        // Bundle not available - try API
+        const client = getClientForEnvName(opts.env);
+        if (client) {
+            try {
+                await registry.load(client);
+            }
+            catch {
+                // Neither bundle nor API available
+            }
+        }
+    }
+    const response = {
+        version: registry.metadata.version ?? "unknown",
+        source: registry.metadata.source ?? "bundle",
+        actions: registry.getAllActions(),
+    };
+    actionSchemaCache.set(cacheKey, { ts: now, data: response });
+    return response;
+}
+/**
+ * Get a specific action by name from the schema.
+ */
+async function getActionByName(name, env) {
+    const schema = await getDynamicActionSchema({ env });
+    // Find latest version of action
+    const matching = schema.actions.filter(a => a.name === name);
+    if (matching.length === 0)
+        return null;
+    // Return latest version (sort by version desc)
+    return matching.sort((a, b) => (b.version || "v0").localeCompare(a.version || "v0"))[0];
+}
 /**
  * Convert PersonaTemplateDTO to a simplified format for MCP resources.
  */
@@ -483,6 +590,23 @@ export class ResourceRegistry {
                 text: await dynamicResource.generate({ env: envFromQuery }),
             };
         }
+        // Handle pattern URIs (e.g., ema://schema/action/:name)
+        const actionMatch = baseUri.match(/^ema:\/\/schema\/action\/(.+)$/);
+        if (actionMatch) {
+            const actionName = actionMatch[1];
+            const action = await getActionByName(actionName, envFromQuery);
+            if (!action) {
+                return {
+                    code: "NOT_FOUND",
+                    message: `Action not found: ${actionName}. Use ema://schema/actions-summary to list available actions.`,
+                };
+            }
+            return {
+                uri: baseUri,
+                mimeType: "application/json",
+                text: JSON.stringify(action, null, 2),
+            };
+        }
         // Look up in file-backed allowlist
         const resourceConfig = RESOURCE_MAP[baseUri];
         if (!resourceConfig) {

package/dist/mcp/server.js

@@ -14,9 +14,19 @@
  * - Default environment is set via EMA_ENV_NAME or first in config
  * - Available environments come from sync config (EMA_AGENT_SYNC_CONFIG)
  */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Read package.json for version info
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, "..", "..", "package.json");
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+export const TOOLKIT_NAME = packageJson.name;
+export const TOOLKIT_VERSION = packageJson.version;
 // Prompts and Resources
 import { PromptRegistry, isPromptError } from "./prompts.js";
 import { ResourceRegistry, isResourceError } from "./resources.js";
@@ -4692,7 +4702,7 @@ const toolHandlers = {
         return handleEnv({}, () => getAvailableEnvironments().map(e => ({
             name: e.name,
             isDefault: e.name === getDefaultEnvName(),
-        })));
+        })), { name: TOOLKIT_NAME, version: TOOLKIT_VERSION });
     },
     persona: async (args) => {
         const targetEnv = args.env ?? getDefaultEnvName();
@@ -5278,7 +5288,7 @@ function generateEntityDocument(entityType, entity, related, tags) {
 const promptRegistry = new PromptRegistry();
 const resourceRegistry = new ResourceRegistry();
 export async function startMcpServer() {
-    const server = new Server({ name: "ema", version: "1.0.0" }, {
+    const server = new Server({ name: TOOLKIT_NAME, version: TOOLKIT_VERSION }, {
         capabilities: {
             tools: {},
             prompts: {},

package/dist/mcp/tools-consolidated.js

@@ -42,7 +42,7 @@ export function generateConsolidatedTools(envNames, defaultEnv) {
         // ═══════════════════════════════════════════════════════════════════════
         {
             name: "env",
-            description: "List available Ema environments. Shows which is default.",
+            description: "List available Ema environments and toolkit info. Returns environments (with default marker) and toolkit name/version.",
             inputSchema: { type: "object", properties: {}, required: [] },
         },
         // ═══════════════════════════════════════════════════════════════════════
@@ -185,7 +185,9 @@ For complex workflows, send the prompt to an LLM and deploy:
                 },
                 template_id: { type: "string", description: "Specific template ID (usually auto-selected)" },
                 clone_from: { type: "string", description: "Clone from existing persona ID" },
-                clone_data: { type: "boolean", description: "Also clone knowledge base files" },
+                clone_data: { type: "boolean", description: "Also clone knowledge base files and dashboard rows (auto-enables persona for dashboard cloning)" },
+                sanitize: { type: "boolean", description: "Sanitize/obfuscate PII and sensitive data (for demo environments)" },
+                sanitize_examples: { type: "array", items: { type: "string" }, description: "Additional items to treat as sensitive (e.g., company names)" },
                 enabled: { type: "boolean", description: "Enable/disable persona" },
                 // === TEMPLATES ===
                 templates: { type: "boolean", description: "List available templates" },
@@ -427,12 +429,20 @@ Ask the user these questions, then put answers into ONE workflow() call.
 
 **Attach data source to workflow node**:
   knowledge(persona_id="abc", mode="attach", node_name="knowledge_search_1")
-  knowledge(persona_id="abc", mode="attach", node_name="knowledge_search_1", widget_name="fileUpload")`,
+  knowledge(persona_id="abc", mode="attach", node_name="knowledge_search_1", widget_name="fileUpload")
+
+**Dashboard rows** (for Dashboard personas):
+  knowledge(persona_id="abc", mode="dashboard_rows")
+  knowledge(persona_id="abc", mode="dashboard_rows", limit=10)
+
+**Clone dashboard data** (copy rows from source to target):
+  knowledge(persona_id="target", mode="dashboard_clone", source_persona_id="source")
+  knowledge(persona_id="target", mode="dashboard_clone", source_persona_id="source", sanitize=true)`,
             inputSchema: withEnv({
                 persona_id: { type: "string", description: "AI Employee ID (required)" },
                 mode: {
                     type: "string",
-                    enum: ["list", "aggregates", "upload", "delete", "status", "toggle", "attach"],
+                    enum: ["list", "aggregates", "upload", "delete", "status", "toggle", "attach", "dashboard_rows", "dashboard_clone"],
                     description: "Operation. Default: 'list'"
                 },
                 // List flags
@@ -448,6 +458,10 @@ Ask the user these questions, then put answers into ONE workflow() call.
                 enabled: { type: "boolean", description: "Enable/disable embedding" },
                 // Attach flags
                 node_name: { type: "string", description: "Workflow node name to attach data source to (e.g., 'knowledge_search_1')" },
+                // Dashboard clone flags
+                source_persona_id: { type: "string", description: "Source persona ID for dashboard clone" },
+                sanitize: { type: "boolean", description: "Sanitize/obfuscate data during clone" },
+                sanitize_examples: { type: "array", items: { type: "string" }, description: "Additional sensitive items to sanitize" },
             }, ["persona_id"]),
         },
         // ═══════════════════════════════════════════════════════════════════════

package/dist/sdk/action-schema-parser.js

@@ -0,0 +1,379 @@
+/**
+ * Parser for Ema action definitions from .txtpb files
+ *
+ * This parses the Protocol Buffer text format used in ema_backend/grpc/workflow_actions/
+ * to extract action schemas for validation.
+ */
+import * as fs from "fs";
+import * as path from "path";
+// ============================================================================
+// Parser
+// ============================================================================
+/**
+ * Parse a .txtpb file content into a ParsedAction
+ */
+export function parseTextproto(content, filePath) {
+    try {
+        // Extract type_name block using brace matching
+        const typeNameBlock = extractBlock(content, "type_name");
+        // Get the innermost name (action name, not the outer "name" block)
+        const nameMatches = [...typeNameBlock.matchAll(/name:\s*"([^"]+)"/g)];
+        const name = nameMatches.length > 0 ? nameMatches[nameMatches.length - 1][1] : undefined;
+        const version = extractField(typeNameBlock, /version:\s*"([^"]+)"/) || "v0";
+        const displayName = extractField(content, /display_name:\s*"([^"]+)"/);
+        const description = extractField(content, /description:\s*"([^"]+)"/) ||
+            extractMultilineField(content, /description:\s*\n\s*"([^"]+)"/);
+        // Extract directly from source - no hardcoded validation
+        const category = extractField(content, /category:\s*(\w+)/);
+        const lifecycle = extractField(content, /lifecycle:\s*(\w+)/);
+        if (!name) {
+            console.warn(`Could not parse action name from ${filePath}`);
+            return null;
+        }
+        // Parse inputs
+        const inputs = parseInputs(content);
+        // Parse outputs
+        const outputs = parseOutputs(content);
+        // Parse type parameters
+        const typeParameters = parseTypeParameters(content);
+        // Parse required model features
+        const requiredModelFeatures = parseRequiredModelFeatures(content);
+        return {
+            name,
+            version,
+            displayName: displayName || name,
+            description: description || "",
+            category,
+            lifecycle,
+            inputs,
+            outputs,
+            typeParameters,
+            requiredModelFeatures,
+        };
+    }
+    catch (error) {
+        console.error(`Error parsing ${filePath}:`, error);
+        return null;
+    }
+}
+function extractField(content, regex) {
+    const match = content.match(regex);
+    return match?.[1];
+}
+/**
+ * Extract a block by keyword using brace matching
+ */
+function extractBlock(content, keyword) {
+    // Handle both "keyword {" and "keyword: {"
+    const regex = new RegExp(`${keyword}:?\\s*\\{`);
+    const match = content.match(regex);
+    if (!match || match.index === undefined)
+        return "";
+    const start = match.index;
+    let depth = 0;
+    let inBlock = false;
+    let blockEnd = start;
+    for (let i = start; i < content.length; i++) {
+        if (content[i] === "{") {
+            depth++;
+            inBlock = true;
+        }
+        if (content[i] === "}") {
+            depth--;
+        }
+        if (inBlock && depth === 0) {
+            blockEnd = i + 1;
+            break;
+        }
+    }
+    return content.slice(start, blockEnd);
+}
+function extractMultilineField(content, regex) {
+    const match = content.match(regex);
+    return match?.[1];
+}
+/**
+ * Parse required_model_features from content
+ */
+function parseRequiredModelFeatures(content) {
+    const features = [];
+    const regex = /required_model_features:\s*(\w+)/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        features.push(match[1]);
+    }
+    return features;
+}
+function parseInputs(content) {
+    const inputs = [];
+    // Find the inputs block
+    const inputsStart = content.indexOf("\ninputs {");
+    if (inputsStart === -1)
+        return inputs;
+    // Find the end of inputs block (next top-level section)
+    const outputsStart = content.indexOf("\noutputs {", inputsStart);
+    const inputsEnd = outputsStart !== -1 ? outputsStart : content.length;
+    const inputsBlock = content.slice(inputsStart, inputsEnd);
+    // Find each input definition by key
+    const keyMatches = [...inputsBlock.matchAll(/key:\s*"([^"]+)"/g)];
+    for (const keyMatch of keyMatches) {
+        const key = keyMatch[1];
+        const keyIndex = keyMatch.index;
+        // Find the value block after this key
+        const valueStart = inputsBlock.indexOf("value {", keyIndex);
+        if (valueStart === -1)
+            continue;
+        // Find matching closing brace for the value block
+        let valueDepth = 0;
+        let valueEnd = valueStart;
+        for (let i = valueStart; i < inputsBlock.length; i++) {
+            if (inputsBlock[i] === "{")
+                valueDepth++;
+            else if (inputsBlock[i] === "}") {
+                valueDepth--;
+                if (valueDepth === 0) {
+                    valueEnd = i + 1;
+                    break;
+                }
+            }
+        }
+        const valueBlock = inputsBlock.slice(valueStart, valueEnd);
+        const input = {
+            name: key,
+            displayName: extractField(valueBlock, /display_name:\s*"([^"]+)"/) || key,
+            argType: parseArgType(valueBlock),
+            isOptional: /is_optional:\s*true/.test(valueBlock),
+            isAdvanced: /is_advanced:\s*true/.test(valueBlock),
+            isConfigDriven: /is_likely_config_driven:\s*true/.test(valueBlock),
+            isActionOutput: /is_likely_action_output:\s*true/.test(valueBlock),
+            description: extractField(valueBlock, /description:\s*"([^"]+)"/),
+            placeholderDisplayValue: extractField(valueBlock, /placeholder_display_value:\s*"([^"]+)"/),
+        };
+        inputs.push(input);
+    }
+    return inputs;
+}
+function parseOutputs(content) {
+    const outputs = [];
+    // Find the outputs block - more permissive matching
+    const outputsStart = content.indexOf("\noutputs {");
+    if (outputsStart === -1)
+        return outputs;
+    // Find the end of outputs block
+    let depth = 0;
+    let outputsEnd = outputsStart;
+    let started = false;
+    for (let i = outputsStart; i < content.length; i++) {
+        if (content[i] === "{") {
+            depth++;
+            started = true;
+        }
+        else if (content[i] === "}") {
+            depth--;
+            if (started && depth === 0) {
+                outputsEnd = i + 1;
+                break;
+            }
+        }
+    }
+    const outputsBlock = content.slice(outputsStart, outputsEnd);
+    // Find each output definition - handle nested braces
+    const keyMatches = [...outputsBlock.matchAll(/key:\s*"([^"]+)"/g)];
+    for (const keyMatch of keyMatches) {
+        const key = keyMatch[1];
+        const keyIndex = keyMatch.index;
+        // Find the value block after this key
+        const valueStart = outputsBlock.indexOf("value {", keyIndex);
+        if (valueStart === -1)
+            continue;
+        // Find matching closing brace
+        let valueDepth = 0;
+        let valueEnd = valueStart;
+        for (let i = valueStart; i < outputsBlock.length; i++) {
+            if (outputsBlock[i] === "{")
+                valueDepth++;
+            else if (outputsBlock[i] === "}") {
+                valueDepth--;
+                if (valueDepth === 0) {
+                    valueEnd = i + 1;
+                    break;
+                }
+            }
+        }
+        const valueBlock = outputsBlock.slice(valueStart, valueEnd);
+        const output = {
+            name: key,
+            displayName: extractField(valueBlock, /display_name:\s*"([^"]+)"/) || key,
+            argType: parseArgType(valueBlock, true),
+        };
+        outputs.push(output);
+    }
+    return outputs;
+}
+function parseArgType(block, isOutput = false) {
+    const argType = {};
+    // Check for type_parameter (enum types)
+    const typeParam = extractField(block, /type_parameter:\s*"([^"]+)"/);
+    if (typeParam) {
+        argType.typeParameter = typeParam;
+        return argType;
+    }
+    // Check for well_known_type directly
+    const wellKnownDirect = extractField(block, /well_known_type:\s*(\w+)/);
+    // Check for array_type { well_known_type: ... }
+    const arrayMatch = block.match(/array_type\s*\{[\s\S]*?well_known_type:\s*(\w+)/);
+    // Check for array_type { named_type { well_known_type: ... } }
+    const namedArrayMatch = block.match(/array_type\s*\{[\s\S]*?named_type\s*\{[\s\S]*?well_known_type:\s*(\w+)/);
+    if (namedArrayMatch) {
+        argType.wellKnownType = namedArrayMatch[1];
+        argType.isArray = true;
+        argType.isNamed = true;
+    }
+    else if (arrayMatch) {
+        argType.wellKnownType = arrayMatch[1];
+        argType.isArray = true;
+    }
+    else if (wellKnownDirect) {
+        argType.wellKnownType = wellKnownDirect;
+    }
+    return argType;
+}
+function parseTypeParameters(content) {
+    const params = [];
+    const typeParamsMatch = content.match(/type_parameters\s*\{([\s\S]*?)\n\}/);
+    if (!typeParamsMatch)
+        return params;
+    const keyRegex = /key:\s*"([^"]+)"/g;
+    let match;
+    while ((match = keyRegex.exec(typeParamsMatch[1])) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}
+// ============================================================================
+// File System Helpers
+// ============================================================================
+/**
+ * Parse all .txtpb files from a directory
+ */
+export function parseActionDirectory(dirPath) {
+    const actions = [];
+    if (!fs.existsSync(dirPath)) {
+        console.warn(`Directory not found: ${dirPath}`);
+        return actions;
+    }
+    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".txtpb"));
+    for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const parsed = parseTextproto(content, filePath);
+        if (parsed) {
+            actions.push(parsed);
+        }
+    }
+    return actions;
+}
+/**
+ * Load documentation for an action from .md files
+ */
+export function loadDocumentation(docDir, actionName) {
+    if (!fs.existsSync(docDir))
+        return undefined;
+    // Try common naming patterns
+    const patterns = [
+        `${actionName}.md`,
+        `${actionName.replace(/_/g, " ")}.md`,
+        `${toTitleCase(actionName.replace(/_/g, " "))}.md`,
+        `${toTitleCase(actionName.replace(/_/g, " "))}_Agent.md`,
+    ];
+    for (const pattern of patterns) {
+        const filePath = path.join(docDir, pattern);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, "utf-8");
+        }
+    }
+    // Fallback: search for files containing the action name
+    const files = fs.readdirSync(docDir);
+    const searchName = actionName.replace(/_/g, "").toLowerCase();
+    for (const file of files) {
+        if (file.toLowerCase().replace(/_/g, "").includes(searchName)) {
+            return fs.readFileSync(path.join(docDir, file), "utf-8");
+        }
+    }
+    return undefined;
+}
+function toTitleCase(str) {
+    return str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase());
+}
+/**
+ * Generate a complete action schema bundle from the ema repo
+ */
+export function generateSchemaBundle(config) {
+    const prodDir = path.join(config.basePath, config.prodDir || "system_agents/prod");
+    const devDir = path.join(config.basePath, config.devDir || "system_agents/dev");
+    const docsDir = path.join(config.basePath, config.docsDir || "documentation");
+    // Parse all actions
+    const prodActions = parseActionDirectory(prodDir);
+    const devActions = parseActionDirectory(devDir);
+    // Group by action name
+    const actionMap = {};
+    for (const action of [...prodActions, ...devActions]) {
+        if (!actionMap[action.name]) {
+            actionMap[action.name] = [];
+        }
+        // Add raw documentation - LLM will interpret at generation time
+        action.documentation = loadDocumentation(docsDir, action.name);
+        // Note: capabilities field is intentionally left undefined
+        // The LLM should analyze documentation in context, not pre-computed extraction
+        // Avoid duplicates (same name + version)
+        const exists = actionMap[action.name].some((a) => a.version === action.version);
+        if (!exists) {
+            actionMap[action.name].push(action);
+        }
+    }
+    return {
+        version: new Date().toISOString().split("T")[0], // YYYY-MM-DD
+        generatedAt: new Date().toISOString(),
+        source: "code",
+        sourcePath: config.basePath,
+        actions: actionMap,
+    };
+}
+// ============================================================================
+// Type Compatibility Matrix
+// ============================================================================
+/**
+ * Type compatibility rules for workflow validation
+ */
+export const TYPE_COMPATIBILITY = {
+    // What inputs can accept each type
+    WELL_KNOWN_TYPE_CHAT_CONVERSATION: ["conversation", "chat_conversation"],
+    WELL_KNOWN_TYPE_TEXT_WITH_SOURCES: ["query", "text", "user_query", "input"],
+    WELL_KNOWN_TYPE_SEARCH_RESULT: ["search_results", "results"],
+    WELL_KNOWN_TYPE_ANY: ["*"], // Accepts anything
+    WELL_KNOWN_TYPE_STRING: ["text", "query", "instructions", "input"],
+    WELL_KNOWN_TYPE_STRUCT: ["custom_data", "extracted_variables", "json"],
+};
+/**
+ * Check if an output type is compatible with an input type
+ */
+export function isTypeCompatible(sourceType, targetType, targetInputName) {
+    // ANY accepts everything
+    if (targetType === "WELL_KNOWN_TYPE_ANY")
+        return true;
+    // Same type is always compatible
+    if (sourceType === targetType)
+        return true;
+    // named_inputs accepts anything
+    if (targetInputName?.startsWith("named_inputs"))
+        return true;
+    // Check explicit compatibility
+    if (sourceType && TYPE_COMPATIBILITY[sourceType]) {
+        const compatible = TYPE_COMPATIBILITY[sourceType];
+        if (compatible.includes("*"))
+            return true;
+        if (targetInputName && compatible.some((c) => targetInputName.includes(c)))
+            return true;
+    }
+    return false;
+}