@hotmeshio/long-tail 0.1.0

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

@@ -0,0 +1,203 @@
+"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 = void 0;
+exports.getEngine = getEngine;
+exports.deployAppId = deployAppId;
+exports.deployYamlWorkflow = deployYamlWorkflow;
+exports.activateYamlWorkflow = activateYamlWorkflow;
+exports.invokeYamlWorkflow = invokeYamlWorkflow;
+exports.invokeYamlWorkflowSync = invokeYamlWorkflowSync;
+exports.stopEngine = stopEngine;
+exports.stopAllEngines = stopAllEngines;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const pg_1 = require("pg");
+const config_1 = require("../../modules/config");
+const defaults_1 = require("../../modules/defaults");
+const logger_1 = require("../logger");
+const namespaceService = __importStar(require("../namespace"));
+const deployer_helpers_1 = require("./deployer-helpers");
+// Re-export helpers so existing `import * from './deployer'` consumers keep working
+var deployer_helpers_2 = require("./deployer-helpers");
+Object.defineProperty(exports, "buildMergedYaml", { enumerable: true, get: function () { return deployer_helpers_2.buildMergedYaml; } });
+/** Cache of HotMesh engine instances keyed by appId */
+const engines = new Map();
+/**
+ * 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).
+ */
+async function getEngine(appId) {
+    const cached = engines.get(appId);
+    if (cached)
+        return cached;
+    const engine = await hotmesh_1.HotMesh.init({
+        appId,
+        engine: {
+            connection: { class: pg_1.Client, options: config_1.postgres_options },
+        },
+    });
+    engines.set(appId, engine);
+    return engine;
+}
+/**
+ * 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.
+ */
+async function deployAppId(appId, version) {
+    await namespaceService.registerNamespace(appId);
+    const mergedYaml = await (0, deployer_helpers_1.buildMergedYaml)(appId, version);
+    logger_1.loggerRegistry.debug(`[yaml-workflow] merged YAML for ${appId} v${version}:\n${mergedYaml}`);
+    const engine = await getEngine(appId);
+    try {
+        const manifest = await engine.deploy(mergedYaml);
+        await engine.activate(version);
+        logger_1.loggerRegistry.info(`[yaml-workflow] deployed+activated ${appId} v${version} (merged)`);
+        return manifest;
+    }
+    catch (err) {
+        logger_1.loggerRegistry.error(`[yaml-workflow] deployment failed for ${appId} v${version}: ${err.message}`);
+        // Attempt recompilation with error context
+        const recompiled = await (0, deployer_helpers_1.recompileWithContext)(appId, mergedYaml, err.message);
+        if (!recompiled)
+            throw err;
+        // Rebuild merged YAML with the recompiled workflow and retry
+        logger_1.loggerRegistry.info(`[yaml-workflow] retrying deployment after recompilation for ${appId}`);
+        try {
+            const retriedYaml = await (0, deployer_helpers_1.buildMergedYaml)(appId, version);
+            const manifest = await engine.deploy(retriedYaml);
+            await engine.activate(version);
+            logger_1.loggerRegistry.info(`[yaml-workflow] recompilation succeeded — deployed+activated ${appId} v${version}`);
+            return manifest;
+        }
+        catch (retryErr) {
+            logger_1.loggerRegistry.error(`[yaml-workflow] recompilation retry also failed for ${appId}: ${retryErr.message}`);
+            throw retryErr;
+        }
+    }
+}
+/**
+ * Deploy a single YAML workflow to HotMesh (inactive until activated).
+ * @deprecated Use deployAppId for merged deployment.
+ */
+async function deployYamlWorkflow(appId, yamlContent) {
+    const engine = await getEngine(appId);
+    const manifest = await engine.deploy(yamlContent);
+    logger_1.loggerRegistry.info(`[yaml-workflow] deployed ${appId}`);
+    return manifest;
+}
+/**
+ * Activate a deployed version of a YAML workflow.
+ */
+async function activateYamlWorkflow(appId, version) {
+    const engine = await getEngine(appId);
+    const result = await engine.activate(version);
+    logger_1.loggerRegistry.info(`[yaml-workflow] activated ${appId} v${version}`);
+    return result;
+}
+/**
+ * Invoke a YAML workflow (fire-and-forget). Returns the job ID.
+ */
+async function invokeYamlWorkflow(appId, topic, data, entity) {
+    const engine = await getEngine(appId);
+    return engine.pub(topic, data, undefined, entity ? { entity } : undefined);
+}
+/**
+ * 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()
+ */
+async function invokeYamlWorkflowSync(appId, topic, data, timeout, entity) {
+    const hotmesh = await getEngine(appId);
+    const engine = hotmesh.engine;
+    const timeoutMs = timeout ?? defaults_1.WORKFLOW_SYNC_TIMEOUT_MS;
+    // Build context with engine GUID for one-time subscription routing
+    // (exactly as engine.pubsub does)
+    const context = {
+        metadata: {
+            ngn: engine.guid,
+        },
+    };
+    // Publish with entity via extended param
+    const extended = entity ? { entity } : undefined;
+    const jobId = await engine.pub(topic, data, context, extended);
+    return new Promise((resolve, reject) => {
+        engine.registerJobCallback(jobId, (_topic, output) => {
+            if (output.metadata.err) {
+                const error = JSON.parse(output.metadata.err);
+                reject({ error, job_id: output.metadata.jid });
+            }
+            else {
+                resolve({
+                    job_id: jobId,
+                    result: output,
+                });
+            }
+        });
+        setTimeout(() => {
+            engine.delistJobCallback(jobId);
+            reject({ code: 598, message: 'timeout', job_id: jobId });
+        }, timeoutMs);
+    });
+}
+/**
+ * Stop a specific YAML workflow engine.
+ */
+async function stopEngine(appId) {
+    const engine = engines.get(appId);
+    if (engine) {
+        await engine.stop();
+        engines.delete(appId);
+    }
+}
+/**
+ * Stop all YAML workflow engines.
+ */
+async function stopAllEngines() {
+    for (const [appId, engine] of engines) {
+        await engine.stop();
+        engines.delete(appId);
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * YAML workflow generator — slim orchestrator for the compilation pipeline.
+ *
+ * Coordinates five stages:
+ *   extract → analyze → compile → build → validate
+ *
+ * Each stage is a dedicated module in ./pipeline/ that receives and returns
+ * a shared PipelineContext.
+ */
+import type { GenerateYamlOptions, GenerateYamlResult } from './types';
+export { capToolArguments } from './pipeline/build';
+export type { GenerateYamlOptions, GenerateYamlResult } from './types';
+export type { EnhancedCompilationPlan as CompilationPlan } from './types';
+/**
+ * Generate a HotMesh YAML workflow from a completed execution's tool call sequence.
+ *
+ * Analyzes the execution events, extracts the ordered tool calls, compiles
+ * them through an LLM-powered intent analysis, and produces a deterministic
+ * YAML DAG that replaces the LLM with direct tool-to-tool piping.
+ */
+export declare function generateYamlFromExecution(options: GenerateYamlOptions): Promise<GenerateYamlResult>;

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

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * YAML workflow generator — slim orchestrator for the compilation pipeline.
+ *
+ * Coordinates five stages:
+ *   extract → analyze → compile → build → validate
+ *
+ * Each stage is a dedicated module in ./pipeline/ that receives and returns
+ * a shared PipelineContext.
+ */
+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.capToolArguments = void 0;
+exports.generateYamlFromExecution = generateYamlFromExecution;
+const index_1 = require("../export/index");
+const extract_1 = require("./pipeline/extract");
+const analyze_1 = require("./pipeline/analyze");
+const compile_1 = require("./pipeline/compile");
+const build_1 = require("./pipeline/build");
+const validate_1 = require("./pipeline/validate");
+const build_2 = require("./pipeline/build");
+// Re-exports for backward compatibility
+var build_3 = require("./pipeline/build");
+Object.defineProperty(exports, "capToolArguments", { enumerable: true, get: function () { return build_3.capToolArguments; } });
+/**
+ * Generate a HotMesh YAML workflow from a completed execution's tool call sequence.
+ *
+ * Analyzes the execution events, extracts the ordered tool calls, compiles
+ * them through an LLM-powered intent analysis, and produces a deterministic
+ * YAML DAG that replaces the LLM with direct tool-to-tool piping.
+ */
+async function generateYamlFromExecution(options) {
+    const appId = options.appId || 'longtail';
+    const graphTopic = options.subscribes || (0, build_2.sanitizeName)(options.name);
+    // 1. Export the execution to get events
+    const execution = await (0, index_1.exportWorkflowExecution)(options.workflowId, options.taskQueue, options.workflowName);
+    // 2. Initialize pipeline context
+    let ctx = {
+        options: { ...options, appId, subscribes: graphTopic },
+        execution,
+        originalPrompt: '',
+        rawSteps: [],
+        collapsedSteps: [],
+        patternAnnotations: [],
+        naiveInputs: [],
+        compilationPlan: null,
+        coreSteps: [],
+        refinedInputs: [],
+        yaml: '',
+        inputSchema: {},
+        outputSchema: {},
+        activityManifest: [],
+        tags: [],
+        category: 'general',
+        validationIssues: [],
+        priorDeployError: options.compilationFeedback || options.priorDeployError,
+        priorFailedYaml: options.priorFailedYaml,
+    };
+    // 3. Run pipeline stages
+    ctx = await (0, extract_1.extract)(ctx);
+    ctx = await (0, analyze_1.analyze)(ctx);
+    ctx = await (0, compile_1.compile)(ctx);
+    ctx = await (0, build_1.build)(ctx);
+    ctx = await (0, validate_1.validate)(ctx);
+    // 4. Log validation warnings (informational — do not recompile)
+    if (ctx.validationIssues.length > 0) {
+        const { loggerRegistry } = await Promise.resolve().then(() => __importStar(require('../logger')));
+        loggerRegistry.warn(`[yaml-workflow] Validation warnings (${ctx.validationIssues.length}): ${ctx.validationIssues.join('; ')}`);
+    }
+    // 5. Return result
+    return {
+        yaml: ctx.yaml,
+        inputSchema: ctx.inputSchema,
+        outputSchema: ctx.outputSchema,
+        activityManifest: ctx.activityManifest,
+        graphTopic,
+        appId,
+        tags: ctx.tags,
+        inputFieldMeta: ctx.refinedInputs,
+        originalPrompt: ctx.originalPrompt,
+        category: ctx.category,
+        compilationPlan: ctx.compilationPlan,
+        validationIssues: ctx.validationIssues,
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from './db';
+export * from './generator';
+export * from './deployer';
+export * from './workers';

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

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./db"), exports);
+__exportStar(require("./generator"), exports);
+__exportStar(require("./deployer"), exports);
+__exportStar(require("./workers"), exports);

package/build/services/yaml-workflow/input-analyzer-helpers.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Helper utilities for semantic input analysis.
+ *
+ * Constants, classification logic, and value-processing functions
+ * used by the main input-analyzer module.
+ */
+import type { InputFieldMeta } from '../../types/yaml-workflow';
+/** Max array length to embed as a default — larger arrays are execution-specific data. */
+export declare const MAX_DEFAULT_ARRAY_LENGTH = 3;
+/** Max JSON string length to embed as an object default. */
+export declare const MAX_DEFAULT_OBJECT_SIZE = 200;
+/** Max string length to embed as a fixed default — longer strings are execution-specific content. */
+export declare const MAX_DEFAULT_STRING_LENGTH = 500;
+/** Keys that represent user-provided, per-invocation values. */
+export declare const DYNAMIC_KEYS: Set<string>;
+/** Keys that represent implementation details with sensible defaults. */
+export declare const FIXED_KEYS: Set<string>;
+/** Keys that represent inter-step wired data (output from a previous step). */
+export declare const WIRED_KEYS: Set<string>;
+export interface ExtractedStepLike {
+    kind: 'tool' | 'llm';
+    toolName: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * Classify a single argument key as dynamic, fixed, or wired.
+ */
+export declare function classifyArgument(key: string, value: unknown, _context?: {
+    stepIndex: number;
+    toolName: string;
+}): 'dynamic' | 'fixed' | 'wired';
+/** Convert a snake_case/camelCase field name to a readable description. */
+export declare function humanize(name: string): string;
+/** Infer a JSON Schema type string from a JS value. */
+export declare function inferType(value: unknown): string;
+/**
+ * Cap a default value to prevent embedding large execution-specific data.
+ * Returns undefined if the value is too large to serve as a sensible default.
+ */
+export declare function capDefault(value: unknown): unknown | undefined;
+/**
+ * Flatten a nested object argument into individual top-level input fields.
+ *
+ * For example, `login: { url: '...', username: '...', password: '...' }`
+ * becomes three separate fields: `login_url` (dynamic), `username` (dynamic),
+ * `password` (dynamic), preserving the relationship via description.
+ */
+export declare function flattenDynamicObject(parentKey: string, obj: Record<string, unknown>, stepIndex: number, toolName: string, originalPrompt: string, seen: Map<string, InputFieldMeta>): void;

package/build/services/yaml-workflow/input-analyzer-helpers.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Helper utilities for semantic input analysis.
+ *
+ * Constants, classification logic, and value-processing functions
+ * used by the main input-analyzer module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WIRED_KEYS = exports.FIXED_KEYS = exports.DYNAMIC_KEYS = exports.MAX_DEFAULT_STRING_LENGTH = exports.MAX_DEFAULT_OBJECT_SIZE = exports.MAX_DEFAULT_ARRAY_LENGTH = void 0;
+exports.classifyArgument = classifyArgument;
+exports.humanize = humanize;
+exports.inferType = inferType;
+exports.capDefault = capDefault;
+exports.flattenDynamicObject = flattenDynamicObject;
+/** Max array length to embed as a default — larger arrays are execution-specific data. */
+exports.MAX_DEFAULT_ARRAY_LENGTH = 3;
+/** Max JSON string length to embed as an object default. */
+exports.MAX_DEFAULT_OBJECT_SIZE = 200;
+/** Max string length to embed as a fixed default — longer strings are execution-specific content. */
+exports.MAX_DEFAULT_STRING_LENGTH = 500;
+/** Keys that represent user-provided, per-invocation values. */
+exports.DYNAMIC_KEYS = new Set([
+    'url', 'base_url', 'site_url', 'target_url',
+    'username', 'password',
+    'directory', 'path',
+    'screenshot_path',
+    'query', 'prompt', 'search',
+]);
+/** Keys that represent implementation details with sensible defaults. */
+exports.FIXED_KEYS = new Set([
+    'selector', 'submit_selector', 'username_selector', 'password_selector',
+    'css_selector', 'wait_until', 'timeout', 'wait_ms',
+    'full_page', 'extract_links', 'extract_metadata',
+    'limit', 'offset', 'wait_after_login', 'not',
+]);
+/** Keys that represent inter-step wired data (output from a previous step). */
+exports.WIRED_KEYS = new Set([
+    'page_id', '_handle', 'content', 'links', 'files', 'result',
+]);
+/**
+ * Classify a single argument key as dynamic, fixed, or wired.
+ */
+function classifyArgument(key, value, _context) {
+    const lower = key.toLowerCase();
+    if (exports.WIRED_KEYS.has(lower))
+        return 'wired';
+    if (exports.DYNAMIC_KEYS.has(lower))
+        return 'dynamic';
+    if (exports.FIXED_KEYS.has(lower))
+        return 'fixed';
+    // Heuristic fallback: keys ending with _id or _handle are likely wired
+    if (lower.endsWith('_id') || lower.endsWith('_handle'))
+        return 'wired';
+    // Keys ending with _selector are fixed
+    if (lower.endsWith('_selector'))
+        return 'fixed';
+    // Keys ending with _url or _path are dynamic
+    if (lower.endsWith('_url') || lower.endsWith('_path'))
+        return 'dynamic';
+    // Objects containing dynamic keys should be treated as dynamic
+    // (e.g., login: { url, username, password } contains dynamic fields)
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (objectContainsDynamicKeys(value)) {
+            return 'dynamic';
+        }
+    }
+    // Arrays: complex instruction arrays (like browser steps) are fixed implementation details.
+    // Only flat data arrays (URLs, IDs) that are large should be dynamic.
+    if (Array.isArray(value)) {
+        if (value.length > 0 && value[0] && typeof value[0] === 'object' && !Array.isArray(value[0])) {
+            // Array of objects — check if it's an instruction array (has 'action', 'step', 'type' keys)
+            const firstItem = value[0];
+            if ('action' in firstItem || 'step' in firstItem || 'type' in firstItem) {
+                return 'fixed'; // Implementation recipe — not user input
+            }
+        }
+        if (value.length > exports.MAX_DEFAULT_ARRAY_LENGTH) {
+            return 'dynamic';
+        }
+    }
+    // Long strings are execution-specific content (prompts, templates), not reusable defaults
+    if (typeof value === 'string' && value.length > exports.MAX_DEFAULT_STRING_LENGTH) {
+        return 'dynamic';
+    }
+    // Default: treat as fixed (has a default from the execution)
+    return 'fixed';
+}
+/**
+ * Check if an object's keys overlap with known dynamic keys.
+ * E.g., { url: '...', username: '...', password: '...' } -> true
+ */
+function objectContainsDynamicKeys(obj) {
+    for (const key of Object.keys(obj)) {
+        const lower = key.toLowerCase();
+        if (exports.DYNAMIC_KEYS.has(lower))
+            return true;
+        if (lower.endsWith('_url') || lower.endsWith('_path'))
+            return true;
+    }
+    return false;
+}
+/** Convert a snake_case/camelCase field name to a readable description. */
+function humanize(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[_-]/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase())
+        .trim();
+}
+/** Infer a JSON Schema type string from a JS value. */
+function inferType(value) {
+    if (value === null || value === undefined)
+        return 'string';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'number')
+        return 'number';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'object')
+        return 'object';
+    return 'string';
+}
+/**
+ * Cap a default value to prevent embedding large execution-specific data.
+ * Returns undefined if the value is too large to serve as a sensible default.
+ */
+function capDefault(value) {
+    if (Array.isArray(value)) {
+        if (value.length > exports.MAX_DEFAULT_ARRAY_LENGTH)
+            return undefined;
+        return value;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const serialized = JSON.stringify(value);
+        if (serialized.length > exports.MAX_DEFAULT_OBJECT_SIZE)
+            return undefined;
+        return value;
+    }
+    return value;
+}
+/**
+ * Flatten a nested object argument into individual top-level input fields.
+ *
+ * For example, `login: { url: '...', username: '...', password: '...' }`
+ * becomes three separate fields: `login_url` (dynamic), `username` (dynamic),
+ * `password` (dynamic), preserving the relationship via description.
+ */
+function flattenDynamicObject(parentKey, obj, stepIndex, toolName, originalPrompt, seen) {
+    for (const [childKey, childValue] of Object.entries(obj)) {
+        const childClassification = classifyArgument(childKey, childValue, {
+            stepIndex,
+            toolName,
+        });
+        if (childClassification === 'wired')
+            continue;
+        // Avoid key collisions: if the child key already exists at top level,
+        // prefix with parent name (e.g., login_url instead of url)
+        let flatKey = childKey;
+        if (seen.has(childKey)) {
+            flatKey = `${parentKey}_${childKey}`;
+        }
+        if (seen.has(flatKey))
+            continue;
+        let description = `${humanize(childKey)} (from ${humanize(parentKey)})`;
+        if (originalPrompt && childValue !== null && childValue !== undefined) {
+            const valueStr = String(childValue);
+            if (valueStr.length > 2 && valueStr.length < 200 && originalPrompt.includes(valueStr)) {
+                description += ` (from prompt: "${valueStr}")`;
+            }
+        }
+        const cappedDefault = childClassification === 'fixed' ? capDefault(childValue) : undefined;
+        seen.set(flatKey, {
+            key: flatKey,
+            type: inferType(childValue),
+            ...(cappedDefault !== undefined ? { default: cappedDefault } : {}),
+            description,
+            classification: childClassification,
+            source_step_index: stepIndex,
+            source_tool: toolName,
+        });
+    }
+}

package/build/services/yaml-workflow/input-analyzer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Semantic input extraction for YAML workflow generator.
+ *
+ * Analyzes all steps from an execution and classifies each argument as:
+ * - **dynamic**: user-provided at invocation time (e.g., url, query, password)
+ * - **fixed**: implementation detail with a sensible default (e.g., selector, timeout)
+ * - **wired**: inter-step data from previous step output (e.g., page_id, content)
+ */
+import type { InputFieldMeta } from '../../types/yaml-workflow';
+import type { ExtractedStepLike } from './input-analyzer-helpers';
+export { classifyArgument } from './input-analyzer-helpers';
+export type { ExtractedStepLike } from './input-analyzer-helpers';
+/**
+ * Scan ALL steps from an execution and return classified `InputFieldMeta[]`.
+ *
+ * - Iterates every step's arguments and classifies each key
+ * - Deduplicates by key (first occurrence wins)
+ * - Skips wired arguments (they come from step chaining)
+ * - Flattens nested objects that contain dynamic keys
+ * - Caps large defaults (arrays, objects) to prevent hardcoded execution data
+ * - Enhances descriptions using the original prompt where possible
+ */
+export declare function extractSemanticInputs(steps: ExtractedStepLike[], originalPrompt: string): InputFieldMeta[];
+/**
+ * Build a JSON Schema from classified input field metadata.
+ *
+ * - `dynamic` fields become required properties (no default — user must provide)
+ * - `fixed` fields become optional properties with defaults from the execution
+ */
+export declare function buildEnrichedInputSchema(fieldMeta: InputFieldMeta[]): Record<string, unknown>;