@dotsetlabs/bellwether 0.10.0

package/dist/workflow/discovery.js

@@ -0,0 +1,195 @@
+/**
+ * Workflow discovery - uses LLM to identify likely tool workflows.
+ */
+import { getLogger } from '../logging/logger.js';
+const logger = getLogger('workflow-discovery');
+/**
+ * Default discovery options.
+ */
+const DEFAULT_OPTIONS = {
+    maxWorkflows: 3,
+    minSteps: 2,
+    maxSteps: 5,
+};
+/**
+ * Discovers likely workflows from a set of tools.
+ */
+export class WorkflowDiscoverer {
+    llm;
+    options;
+    constructor(llm, options = {}) {
+        this.llm = llm;
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Discover workflows from available tools.
+     */
+    async discover(tools) {
+        if (tools.length < 2) {
+            return [];
+        }
+        // Build tool summary for LLM
+        const toolSummary = tools.map(t => {
+            const params = this.extractParams(t);
+            return `- ${t.name}: ${t.description ?? 'No description'}\n  Parameters: ${params}`;
+        }).join('\n');
+        const prompt = `You are analyzing a set of API tools to identify realistic usage workflows.
+
+Available Tools:
+${toolSummary}
+
+Identify ${this.options.maxWorkflows} realistic workflows that chain these tools together.
+Each workflow should represent a common usage pattern where the output of one tool feeds into another.
+
+For each workflow:
+1. Give it a short, descriptive name
+2. Describe what it accomplishes
+3. List ${this.options.minSteps}-${this.options.maxSteps} steps with the tool to call and how to map outputs to inputs
+
+Respond with a JSON array:
+[
+  {
+    "name": "Workflow name",
+    "description": "What this workflow accomplishes",
+    "expectedOutcome": "What should happen if successful",
+    "steps": [
+      {
+        "tool": "tool_name",
+        "description": "What this step does",
+        "args": { "param": "example_value" },
+        "argMapping": { "param": "$steps[0].result.field" }
+      }
+    ]
+  }
+]
+
+Notes:
+- Use $steps[N].result.path.to.field to reference output from step N
+- Only use tool names that exist in the available tools list
+- Create realistic example argument values
+- Consider error handling and optional steps
+
+Return ONLY the JSON array.`;
+        try {
+            const response = await this.llm.complete(prompt, {
+                temperature: 0.4,
+                responseFormat: 'json',
+            });
+            const workflows = this.llm.parseJSON(response);
+            return this.normalizeWorkflows(workflows, tools);
+        }
+        catch (error) {
+            // Fallback: try to create a simple workflow from tools with related names
+            logger.debug({ error }, 'LLM workflow discovery failed, using fallback');
+            return this.fallbackDiscovery(tools);
+        }
+    }
+    /**
+     * Extract parameter information from a tool schema.
+     */
+    extractParams(tool) {
+        const schema = tool.inputSchema;
+        if (!schema?.properties) {
+            return 'none';
+        }
+        const params = Object.entries(schema.properties).map(([name, prop]) => {
+            const propSchema = prop;
+            const required = schema.required?.includes(name) ? '*' : '';
+            return `${name}${required}: ${propSchema.type ?? 'any'}`;
+        });
+        return params.join(', ') || 'none';
+    }
+    /**
+     * Normalize and validate discovered workflows.
+     */
+    normalizeWorkflows(raw, tools) {
+        const toolNames = new Set(tools.map(t => t.name));
+        const workflows = [];
+        for (const workflow of raw) {
+            // Validate all steps reference valid tools
+            const validSteps = workflow.steps.filter(s => toolNames.has(s.tool));
+            if (validSteps.length < 2)
+                continue;
+            workflows.push({
+                id: this.generateId(workflow.name),
+                name: workflow.name,
+                description: workflow.description ?? '',
+                expectedOutcome: workflow.expectedOutcome ?? 'Workflow completes successfully',
+                steps: validSteps.map(s => this.normalizeStep(s)),
+                discovered: true,
+            });
+        }
+        return workflows.slice(0, this.options.maxWorkflows);
+    }
+    /**
+     * Normalize a workflow step.
+     */
+    normalizeStep(raw) {
+        return {
+            tool: raw.tool,
+            description: raw.description ?? `Call ${raw.tool}`,
+            args: raw.args,
+            argMapping: raw.argMapping,
+            optional: raw.optional ?? false,
+        };
+    }
+    /**
+     * Generate a URL-safe ID from a name.
+     */
+    generateId(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+    /**
+     * Fallback discovery when LLM fails.
+     * Tries to identify tools that might work together based on naming patterns.
+     */
+    fallbackDiscovery(tools) {
+        const workflows = [];
+        // Look for common CRUD patterns
+        const toolsByPrefix = new Map();
+        for (const tool of tools) {
+            const match = tool.name.match(/^(get|list|create|update|delete|search|find)_?(.+)/i);
+            if (match) {
+                const resource = match[2].toLowerCase();
+                if (!toolsByPrefix.has(resource)) {
+                    toolsByPrefix.set(resource, []);
+                }
+                toolsByPrefix.get(resource).push(tool);
+            }
+        }
+        // Create workflows for resources with multiple operations
+        for (const [resource, resourceTools] of toolsByPrefix.entries()) {
+            if (resourceTools.length < 2)
+                continue;
+            // Sort by typical operation order
+            const opOrder = ['list', 'search', 'find', 'get', 'create', 'update', 'delete'];
+            resourceTools.sort((a, b) => {
+                const aOp = a.name.split('_')[0].toLowerCase();
+                const bOp = b.name.split('_')[0].toLowerCase();
+                return opOrder.indexOf(aOp) - opOrder.indexOf(bOp);
+            });
+            // Create a simple read workflow
+            const readTools = resourceTools.filter(t => /^(list|search|find|get)/i.test(t.name)).slice(0, 2);
+            if (readTools.length >= 2) {
+                workflows.push({
+                    id: `discover_${resource}`,
+                    name: `Discover ${resource}`,
+                    description: `Search for and retrieve ${resource} details`,
+                    expectedOutcome: `Successfully retrieve ${resource} information`,
+                    steps: readTools.map(t => ({
+                        tool: t.name,
+                        description: t.description ?? `Call ${t.name}`,
+                    })),
+                    discovered: true,
+                });
+            }
+            if (workflows.length >= (this.options.maxWorkflows ?? 3))
+                break;
+        }
+        return workflows;
+    }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/workflow/executor.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Workflow executor - runs workflows and tracks data flow.
+ */
+import type { MCPClient } from '../transport/mcp-client.js';
+import type { MCPTool } from '../transport/types.js';
+import type { LLMClient } from '../llm/client.js';
+import type { Workflow, WorkflowResult, WorkflowExecutorOptions } from './types.js';
+/**
+ * Executes workflows against an MCP server.
+ */
+export declare class WorkflowExecutor {
+    private client;
+    private llm;
+    private tools;
+    private options;
+    private stepResults;
+    private onProgress?;
+    private logger;
+    private stateTracker?;
+    private timeouts;
+    constructor(client: MCPClient, llm: LLMClient | null, tools: MCPTool[], options?: WorkflowExecutorOptions);
+    /**
+     * Emit progress event if callback is registered.
+     */
+    private emitProgress;
+    /**
+     * Execute a workflow.
+     *
+     * @param workflow - The workflow to execute
+     * @throws AbortError if the operation is aborted via signal
+     */
+    execute(workflow: Workflow): Promise<WorkflowResult>;
+    /**
+     * Execute a single workflow step.
+     */
+    private executeStep;
+    /**
+     * Resolve arguments for a step, applying mappings from previous step outputs.
+     */
+    private resolveArguments;
+    /**
+     * Resolve a JSONPath-like expression against previous step results.
+     * Supports: $steps[n].result.path.to.value
+     */
+    private resolvePath;
+    /**
+     * Navigate a dot-separated path in an object.
+     */
+    private navigatePath;
+    /**
+     * Run assertions against a step response.
+     */
+    private runAssertions;
+    /**
+     * Run a single assertion.
+     */
+    private runAssertion;
+    /**
+     * Extract error message from a tool response.
+     */
+    private extractErrorMessage;
+    /**
+     * Get indices of dependency steps that have failed.
+     * Dependencies are steps referenced in argMapping.
+     */
+    private getFailedDependencies;
+    /**
+     * Build a data flow graph showing how data moves between steps.
+     */
+    private buildDataFlowGraph;
+    /**
+     * Generate LLM analysis for a step.
+     * Returns a fallback message if LLM is not available (check mode).
+     */
+    private analyzeStep;
+    /**
+     * Generate a summary of the workflow execution.
+     * Returns a fallback message if LLM is not available (check mode).
+     */
+    private generateWorkflowSummary;
+}
+//# sourceMappingURL=executor.d.ts.map