@synergenius/flow-weaver 0.33.0 → 0.33.1

package/dist/cli/flow-weaver.mjs

@@ -5987,7 +5987,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.33.0";
+    VERSION = "0.33.1";
   }
 });
 
@@ -84248,6 +84248,169 @@ var init_tools_debug = __esm({
   }
 });
 
+// src/mcp/run-registry.ts
+function storePendingRun(run) {
+  pendingRuns.set(run.runId, run);
+}
+function getPendingRun(runId) {
+  return pendingRuns.get(runId);
+}
+function removePendingRun(runId) {
+  pendingRuns.delete(runId);
+}
+var pendingRuns;
+var init_run_registry = __esm({
+  "src/mcp/run-registry.ts"() {
+    "use strict";
+    pendingRuns = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/mcp/tools-workflow-run.ts
+function makeToolResult2(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function makeErrorResult2(code, message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: code, message }) }],
+    isError: true
+  };
+}
+function generateRunId() {
+  return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+async function raceAgentPause(executionPromise, agentChannel) {
+  try {
+    const outcome = await Promise.race([
+      executionPromise.then((r) => ({
+        type: "completed",
+        result: r?.result ?? r
+      })),
+      agentChannel.onPause().then((request) => ({
+        type: "waiting_for_agent",
+        request
+      }))
+    ]);
+    return outcome;
+  } catch (err) {
+    return {
+      type: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function runWorkflowWithAgent(filePath, params, workflowName) {
+  const agentChannel = new AgentChannel();
+  const runId = generateRunId();
+  const executionPromise = executeWorkflowFromFile(
+    filePath,
+    params,
+    {
+      workflowName,
+      agentChannel,
+      includeTrace: true
+    }
+  );
+  const outcome = await raceAgentPause(executionPromise, agentChannel);
+  if (outcome.type === "completed") {
+    return { status: "completed", result: outcome.result };
+  }
+  if (outcome.type === "waiting_for_agent") {
+    storePendingRun({
+      runId,
+      filePath,
+      workflowName,
+      executionPromise,
+      agentChannel,
+      request: outcome.request,
+      createdAt: Date.now(),
+      tmpFiles: []
+    });
+    return { status: "waiting_for_agent", runId, agentRequest: outcome.request, agentChannel };
+  }
+  return { status: "error", message: outcome.message };
+}
+async function resumeWorkflow(runId, agentResult) {
+  const pendingRun = getPendingRun(runId);
+  if (!pendingRun) {
+    return { status: "error", message: `No pending run found with ID "${runId}".` };
+  }
+  pendingRun.agentChannel.resume(agentResult);
+  const outcome = await raceAgentPause(pendingRun.executionPromise, pendingRun.agentChannel);
+  if (outcome.type === "completed") {
+    removePendingRun(runId);
+    return { status: "completed", result: outcome.result };
+  }
+  if (outcome.type === "waiting_for_agent") {
+    pendingRun.request = outcome.request;
+    return { status: "waiting_for_agent", runId, agentRequest: outcome.request, agentChannel: pendingRun.agentChannel };
+  }
+  removePendingRun(runId);
+  return { status: "error", message: outcome.message };
+}
+function registerWorkflowRunTools(mcp) {
+  mcp.tool(
+    "fw_workflow_run",
+    "Run a workflow. If it hits a waitForAgent node, returns the agent request so you can respond. If it completes without pausing, returns the result directly.",
+    {
+      filePath: external_exports.string().describe("Path to the workflow .ts file"),
+      params: external_exports.record(external_exports.unknown()).optional().describe("Input parameters for the workflow"),
+      workflowName: external_exports.string().optional().describe("Specific workflow export name (for multi-workflow files)")
+    },
+    async (args) => {
+      try {
+        const result = await runWorkflowWithAgent(
+          args.filePath,
+          args.params ?? {},
+          args.workflowName
+        );
+        if (result.status === "error") {
+          return makeErrorResult2("EXECUTION_ERROR", result.message);
+        }
+        const { agentChannel: _ac, ...output } = result;
+        return makeToolResult2(output);
+      } catch (err) {
+        return makeErrorResult2(
+          "EXECUTION_ERROR",
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  );
+  mcp.tool(
+    "fw_workflow_resume",
+    "Resume a workflow that paused at waitForAgent. Provide the agent result to continue execution.",
+    {
+      runId: external_exports.string().describe("Run ID from fw_workflow_run"),
+      agentResult: external_exports.record(external_exports.unknown()).describe("The agent result to pass back to the workflow")
+    },
+    async (args) => {
+      try {
+        const result = await resumeWorkflow(args.runId, args.agentResult);
+        if (result.status === "error") {
+          return makeErrorResult2("RESUME_ERROR", result.message);
+        }
+        const { agentChannel: _ac, ...output } = result;
+        return makeToolResult2(output);
+      } catch (err) {
+        return makeErrorResult2(
+          "RESUME_ERROR",
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  );
+}
+var init_tools_workflow_run = __esm({
+  "src/mcp/tools-workflow-run.ts"() {
+    "use strict";
+    init_zod();
+    init_workflow_executor();
+    init_agent_channel();
+    init_run_registry();
+  }
+});
+
 // src/mcp/tools-context.ts
 function registerContextTools(mcp) {
   mcp.tool(
@@ -84492,6 +84655,7 @@ async function startMcpServer(options) {
   registerDocsTools(mcp);
   registerModelTools(mcp);
   registerDebugTools(mcp);
+  registerWorkflowRunTools(mcp);
   registerContextTools(mcp);
   registerResourceTools(mcp);
   registerPrompts(mcp);
@@ -84528,6 +84692,7 @@ var init_server3 = __esm({
     init_tools_docs();
     init_tools_model();
     init_tools_debug();
+    init_tools_workflow_run();
     init_tools_context();
     init_tools_resources();
     init_prompts();
@@ -89091,7 +89256,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.33.0" : "0.0.0-dev";
+var version2 = true ? "0.33.1" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.33.0";
+export declare const VERSION = "0.33.1";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.33.0';
+export const VERSION = '0.33.1';
 //# sourceMappingURL=generated-version.js.map

package/dist/mcp/server.js

@@ -11,6 +11,7 @@ import { registerDiagramTools } from './tools-diagram.js';
 import { registerDocsTools } from './tools-docs.js';
 import { registerModelTools } from './tools-model.js';
 import { registerDebugTools } from './tools-debug.js';
+import { registerWorkflowRunTools } from './tools-workflow-run.js';
 import { registerContextTools } from './tools-context.js';
 import { registerResourceTools } from './tools-resources.js';
 import { registerPrompts } from './prompts.js';
@@ -31,6 +32,7 @@ export async function startMcpServer(options) {
     registerDocsTools(mcp);
     registerModelTools(mcp);
     registerDebugTools(mcp);
+    registerWorkflowRunTools(mcp);
     registerContextTools(mcp);
     registerResourceTools(mcp);
     registerPrompts(mcp);

package/dist/mcp/tools-workflow-run.d.ts

@@ -0,0 +1,40 @@
+/**
+ * MCP tools for running workflows with waitForAgent pause/resume support.
+ *
+ * fw_workflow_run: Starts a workflow. If it hits waitForAgent, returns the
+ * agent request to the MCP caller (e.g. Claude Code) with status "waiting_for_agent".
+ * If the workflow completes without pausing, returns the result directly.
+ *
+ * fw_workflow_resume: Resumes a paused workflow with the agent's result.
+ * Returns the final workflow result (or pauses again if another waitForAgent is hit).
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AgentChannel } from './agent-channel.js';
+/** Exposed for testing — run workflow with pause/resume support */
+export declare function runWorkflowWithAgent(filePath: string, params: Record<string, unknown>, workflowName?: string): Promise<{
+    status: 'completed';
+    result: unknown;
+} | {
+    status: 'waiting_for_agent';
+    runId: string;
+    agentRequest: object;
+    agentChannel: AgentChannel;
+} | {
+    status: 'error';
+    message: string;
+}>;
+/** Exposed for testing — resume a paused workflow with agent result */
+export declare function resumeWorkflow(runId: string, agentResult: Record<string, unknown>): Promise<{
+    status: 'completed';
+    result: unknown;
+} | {
+    status: 'waiting_for_agent';
+    runId: string;
+    agentRequest: object;
+    agentChannel: AgentChannel;
+} | {
+    status: 'error';
+    message: string;
+}>;
+export declare function registerWorkflowRunTools(mcp: McpServer): void;
+//# sourceMappingURL=tools-workflow-run.d.ts.map

package/dist/mcp/tools-workflow-run.js

@@ -0,0 +1,150 @@
+/**
+ * MCP tools for running workflows with waitForAgent pause/resume support.
+ *
+ * fw_workflow_run: Starts a workflow. If it hits waitForAgent, returns the
+ * agent request to the MCP caller (e.g. Claude Code) with status "waiting_for_agent".
+ * If the workflow completes without pausing, returns the result directly.
+ *
+ * fw_workflow_resume: Resumes a paused workflow with the agent's result.
+ * Returns the final workflow result (or pauses again if another waitForAgent is hit).
+ */
+import { z } from 'zod';
+import { executeWorkflowFromFile } from './workflow-executor.js';
+import { AgentChannel } from './agent-channel.js';
+import { storePendingRun, getPendingRun, removePendingRun, } from './run-registry.js';
+function makeToolResult(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+function makeErrorResult(code, message) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error: code, message }) }],
+        isError: true,
+    };
+}
+function generateRunId() {
+    return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Race between workflow completion and agent pause.
+ * Returns whichever happens first.
+ */
+async function raceAgentPause(executionPromise, agentChannel) {
+    try {
+        const outcome = await Promise.race([
+            executionPromise.then((r) => ({
+                type: 'completed',
+                result: r?.result ?? r,
+            })),
+            agentChannel.onPause().then((request) => ({
+                type: 'waiting_for_agent',
+                request,
+            })),
+        ]);
+        return outcome;
+    }
+    catch (err) {
+        return {
+            type: 'error',
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** Exposed for testing — run workflow with pause/resume support */
+export async function runWorkflowWithAgent(filePath, params, workflowName) {
+    const agentChannel = new AgentChannel();
+    const runId = generateRunId();
+    const executionPromise = executeWorkflowFromFile(filePath, params, {
+        workflowName,
+        agentChannel,
+        includeTrace: true,
+    });
+    const outcome = await raceAgentPause(executionPromise, agentChannel);
+    if (outcome.type === 'completed') {
+        return { status: 'completed', result: outcome.result };
+    }
+    if (outcome.type === 'waiting_for_agent') {
+        storePendingRun({
+            runId,
+            filePath,
+            workflowName,
+            executionPromise,
+            agentChannel,
+            request: outcome.request,
+            createdAt: Date.now(),
+            tmpFiles: [],
+        });
+        return { status: 'waiting_for_agent', runId, agentRequest: outcome.request, agentChannel };
+    }
+    return { status: 'error', message: outcome.message };
+}
+/** Exposed for testing — resume a paused workflow with agent result */
+export async function resumeWorkflow(runId, agentResult) {
+    const pendingRun = getPendingRun(runId);
+    if (!pendingRun) {
+        return { status: 'error', message: `No pending run found with ID "${runId}".` };
+    }
+    pendingRun.agentChannel.resume(agentResult);
+    const outcome = await raceAgentPause(pendingRun.executionPromise, pendingRun.agentChannel);
+    if (outcome.type === 'completed') {
+        removePendingRun(runId);
+        return { status: 'completed', result: outcome.result };
+    }
+    if (outcome.type === 'waiting_for_agent') {
+        pendingRun.request = outcome.request;
+        return { status: 'waiting_for_agent', runId, agentRequest: outcome.request, agentChannel: pendingRun.agentChannel };
+    }
+    removePendingRun(runId);
+    return { status: 'error', message: outcome.message };
+}
+export function registerWorkflowRunTools(mcp) {
+    // -------------------------------------------------------------------------
+    // fw_workflow_run - Start a workflow, pause at waitForAgent
+    // -------------------------------------------------------------------------
+    mcp.tool('fw_workflow_run', 'Run a workflow. If it hits a waitForAgent node, returns the agent request so ' +
+        'you can respond. If it completes without pausing, returns the result directly.', {
+        filePath: z.string().describe('Path to the workflow .ts file'),
+        params: z
+            .record(z.unknown())
+            .optional()
+            .describe('Input parameters for the workflow'),
+        workflowName: z
+            .string()
+            .optional()
+            .describe('Specific workflow export name (for multi-workflow files)'),
+    }, async (args) => {
+        try {
+            const result = await runWorkflowWithAgent(args.filePath, args.params ?? {}, args.workflowName);
+            if (result.status === 'error') {
+                return makeErrorResult('EXECUTION_ERROR', result.message);
+            }
+            // Don't leak agentChannel to MCP output
+            const { agentChannel: _ac, ...output } = result;
+            return makeToolResult(output);
+        }
+        catch (err) {
+            return makeErrorResult('EXECUTION_ERROR', err instanceof Error ? err.message : String(err));
+        }
+    });
+    // -------------------------------------------------------------------------
+    // fw_workflow_resume - Resume a paused workflow with agent result
+    // -------------------------------------------------------------------------
+    mcp.tool('fw_workflow_resume', 'Resume a workflow that paused at waitForAgent. Provide the agent result to continue execution.', {
+        runId: z.string().describe('Run ID from fw_workflow_run'),
+        agentResult: z
+            .record(z.unknown())
+            .describe('The agent result to pass back to the workflow'),
+    }, async (args) => {
+        try {
+            const result = await resumeWorkflow(args.runId, args.agentResult);
+            if (result.status === 'error') {
+                return makeErrorResult('RESUME_ERROR', result.message);
+            }
+            const { agentChannel: _ac, ...output } = result;
+            return makeToolResult(output);
+        }
+        catch (err) {
+            return makeErrorResult('RESUME_ERROR', err instanceof Error ? err.message : String(err));
+        }
+    });
+}
+//# sourceMappingURL=tools-workflow-run.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "description": "Flow Weaver: deterministic TypeScript workflow compiler. Define workflows with JSDoc annotations, compile to standalone functions with zero runtime dependencies.",
   "private": false,
   "type": "module",