@synergenius/flow-weaver 0.24.0 → 0.24.2

package/dist/agent/index.d.ts

@@ -4,7 +4,8 @@
  * Provider-agnostic agent loop with MCP bridge for tool execution.
  * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
-export type { StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
+export type { SplitPrompt, StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
+export { joinSplitPrompt } from './types.js';
 export { runAgentLoop } from './agent-loop.js';
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export type { AnthropicProviderOptions } from './providers/anthropic.js';

package/dist/agent/index.js

@@ -4,6 +4,8 @@
  * Provider-agnostic agent loop with MCP bridge for tool execution.
  * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
+// Prompt utilities
+export { joinSplitPrompt } from './types.js';
 // Agent loop
 export { runAgentLoop } from './agent-loop.js';
 // Providers

package/dist/agent/providers/anthropic.js

@@ -4,6 +4,19 @@
  *
  * Adapted from pack-weaver's streamAnthropicWithTools.
  */
+/**
+ * Convert a SplitPrompt to Anthropic's system content block array.
+ * The prefix gets cache_control for prompt caching; the suffix does not.
+ */
+function buildSystemBlocks(prompt) {
+    const blocks = [
+        { type: 'text', text: prompt.prefix, cache_control: { type: 'ephemeral' } },
+    ];
+    if (prompt.suffix) {
+        blocks.push({ type: 'text', text: prompt.suffix });
+    }
+    return blocks;
+}
 export class AnthropicProvider {
     apiKey;
     model;
@@ -49,7 +62,7 @@ export class AnthropicProvider {
             model,
             max_tokens: maxTokens,
             stream: true,
-            ...(options?.systemPrompt ? { system: options.systemPrompt } : {}),
+            ...(options?.systemPrompt ? { system: buildSystemBlocks(options.systemPrompt) } : {}),
             messages: apiMessages,
             ...(apiTools.length > 0 ? { tools: apiTools } : {}),
         });

package/dist/agent/providers/claude-cli.d.ts

@@ -5,7 +5,7 @@
  * Adapted from platform's streamClaudeCliChat. Platform-specific dependencies
  * (spawnSandboxed, getBinPath, config) are replaced with injectable options.
  */
-import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions, ClaudeCliProviderOptions } from '../types.js';
+import { type AgentProvider, type AgentMessage, type ToolDefinition, type StreamEvent, type StreamOptions, type ClaudeCliProviderOptions } from '../types.js';
 export declare class ClaudeCliProvider implements AgentProvider {
     private binPath;
     private cwd;

package/dist/agent/providers/claude-cli.js

@@ -6,6 +6,7 @@
  * (spawnSandboxed, getBinPath, config) are replaced with injectable options.
  */
 import { spawn as nodeSpawn } from 'node:child_process';
+import { joinSplitPrompt, } from '../types.js';
 import { StreamJsonParser } from '../streaming.js';
 import { createMcpBridge } from '../mcp-bridge.js';
 export class ClaudeCliProvider {
@@ -31,7 +32,9 @@ export class ClaudeCliProvider {
         const model = options?.model ?? this.model;
         // Format messages into a single prompt for -p mode
         const prompt = formatPrompt(messages);
-        const systemPrompt = options?.systemPrompt;
+        const systemPrompt = options?.systemPrompt
+            ? joinSplitPrompt(options.systemPrompt)
+            : undefined;
         // Set up MCP bridge for tool access if tools are provided and no config given
         let bridge = null;
         let mcpConfigPath = this.mcpConfigPath;

package/dist/agent/providers/openai-compat.d.ts

@@ -5,7 +5,7 @@
  * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
  * Converts OpenAI's delta format to the canonical StreamEvent union.
  */
-import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+import { type AgentProvider, type AgentMessage, type ToolDefinition, type StreamEvent, type StreamOptions } from '../types.js';
 export interface OpenAICompatProviderOptions {
     apiKey: string;
     model?: string;

package/dist/agent/providers/openai-compat.js

@@ -5,6 +5,7 @@
  * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
  * Converts OpenAI's delta format to the canonical StreamEvent union.
  */
+import { joinSplitPrompt } from '../types.js';
 export class OpenAICompatProvider {
     apiKey;
     model;
@@ -38,7 +39,7 @@ export class OpenAICompatProvider {
         const body = {
             model,
             messages: [
-                ...(options?.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+                ...(options?.systemPrompt ? [{ role: 'system', content: joinSplitPrompt(options.systemPrompt) }] : []),
                 ...apiMessages,
             ],
             max_tokens: maxTokens,

package/dist/agent/providers/platform.d.ts

@@ -3,7 +3,7 @@
  * Uses the platform's AI credits, no local API key needed.
  * Connects to POST /ai-chat/stream and parses SSE events.
  */
-import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+import { type AgentProvider, type AgentMessage, type ToolDefinition, type StreamEvent, type StreamOptions } from '../types.js';
 export interface PlatformProviderOptions {
     /** JWT token or API key for platform auth */
     token: string;

package/dist/agent/providers/platform.js

@@ -3,6 +3,7 @@
  * Uses the platform's AI credits, no local API key needed.
  * Connects to POST /ai-chat/stream and parses SSE events.
  */
+import { joinSplitPrompt } from '../types.js';
 export class PlatformProvider {
     token;
     baseUrl;
@@ -37,7 +38,8 @@ export class PlatformProvider {
         const body = { message };
         if (options?.systemPrompt) {
             // Platform doesn't accept system prompt directly via API — embed in message
-            body.message = `[System context: ${options.systemPrompt.slice(0, 2000)}]\n\n${message}`;
+            const systemStr = joinSplitPrompt(options.systemPrompt);
+            body.message = `[System context: ${systemStr.slice(0, 2000)}]\n\n${message}`;
         }
         const response = await fetch(`${this.baseUrl}/ai-chat/stream`, {
             method: 'POST',

package/dist/agent/types.d.ts

@@ -65,8 +65,25 @@ export interface ToolEvent {
     result?: string;
     isError?: boolean;
 }
+/**
+ * Split system prompt for Anthropic API cache optimization.
+ *
+ * The prefix (stable FW knowledge) is cached across calls via cache_control.
+ * The suffix (per-task context) varies per call but rides on the cached prefix.
+ *
+ * Providers that support structured system blocks (Anthropic) use both parts.
+ * Providers that only accept strings (CLI, OpenAI, platform) concatenate them.
+ */
+export interface SplitPrompt {
+    /** Stable prefix — identical across calls. Cacheable. */
+    prefix: string;
+    /** Dynamic suffix — varies per task/call. Not cached. */
+    suffix: string;
+}
+/** Convert a SplitPrompt to a single string (for providers that don't support blocks). */
+export declare function joinSplitPrompt(prompt: SplitPrompt): string;
 export interface StreamOptions {
-    systemPrompt?: string;
+    systemPrompt?: SplitPrompt;
     model?: string;
     maxTokens?: number;
     signal?: AbortSignal;
@@ -89,7 +106,7 @@ export interface McpBridge {
     cleanup: () => void;
 }
 export interface AgentLoopOptions {
-    systemPrompt?: string;
+    systemPrompt?: SplitPrompt;
     maxIterations?: number;
     maxTokens?: number;
     model?: string;
@@ -145,6 +162,8 @@ export interface CliSessionOptions {
     model: string;
     /** Pre-configured MCP config path. */
     mcpConfigPath?: string;
+    /** Disable specific built-in tools (e.g. ['Read', 'Edit', 'Write', 'Bash'] to force MCP tools). */
+    disallowedTools?: string[];
     /** Custom spawn function. Defaults to child_process.spawn. */
     spawnFn?: SpawnFn;
     /** Idle timeout in milliseconds. Defaults to 600000 (10 minutes). */

package/dist/agent/types.js

@@ -3,5 +3,10 @@
  *
  * All types are pure — no runtime imports, no side effects.
  */
-export {};
+/** Convert a SplitPrompt to a single string (for providers that don't support blocks). */
+export function joinSplitPrompt(prompt) {
+    if (!prompt.suffix)
+        return prompt.prefix;
+    return prompt.prefix + '\n\n' + prompt.suffix;
+}
 //# sourceMappingURL=types.js.map

package/dist/cli/flow-weaver.mjs

@@ -9886,7 +9886,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.24.0";
+    VERSION = "0.24.2";
   }
 });
 
@@ -36053,8 +36053,10 @@ var init_parser2 = __esm({
           }
           try {
             let nodeTypes;
-            if (this.importCache.has(importedFilePath)) {
-              nodeTypes = this.importCache.get(importedFilePath);
+            const importStats = fs5.statSync(importedFilePath);
+            const cached2 = this.importCache.get(importedFilePath);
+            if (cached2 && cached2.mtime === importStats.mtimeMs) {
+              nodeTypes = cached2.nodeTypes;
             } else {
               this.importStack.add(importedFilePath);
               try {
@@ -36078,7 +36080,7 @@ var init_parser2 = __esm({
                 const inferredFromImport = this.inferAllUnannotatedFunctions(importedFile, nodeTypes);
                 nodeTypes.push(...inferredFromImport);
                 this.project.removeSourceFile(importedFile);
-                this.importCache.set(importedFilePath, nodeTypes);
+                this.importCache.set(importedFilePath, { mtime: importStats.mtimeMs, nodeTypes });
               } finally {
                 this.importStack.delete(importedFilePath);
               }
@@ -36119,8 +36121,21 @@ var init_parser2 = __esm({
         const importedNames = /* @__PURE__ */ new Set();
         namedImports.forEach((ni) => importedNames.add(ni.getName()));
         const cacheKey = `npm:${moduleSpecifier}`;
-        if (this.importCache.has(cacheKey)) {
-          return this.importCache.get(cacheKey).filter((nt) => importedNames.has(nt.functionName));
+        const npmCached = this.importCache.get(cacheKey);
+        if (npmCached) {
+          const currentDir2 = path6.dirname(currentFilePath);
+          const resolvedDts = resolvePackageTypesPath(moduleSpecifier, currentDir2);
+          if (resolvedDts) {
+            try {
+              const dtsStats = fs5.statSync(resolvedDts);
+              if (npmCached.mtime === dtsStats.mtimeMs) {
+                return npmCached.nodeTypes.filter((nt) => importedNames.has(nt.functionName));
+              }
+            } catch {
+            }
+          } else {
+            return npmCached.nodeTypes.filter((nt) => importedNames.has(nt.functionName));
+          }
         }
         const currentDir = path6.dirname(currentFilePath);
         const dtsPath = resolvePackageTypesPath(moduleSpecifier, currentDir);
@@ -36146,7 +36161,8 @@ var init_parser2 = __esm({
             allNodeTypes.push(nodeType);
           }
           this.project.removeSourceFile(dtsFile);
-          this.importCache.set(cacheKey, allNodeTypes);
+          const dtsMtime = fs5.statSync(dtsPath).mtimeMs;
+          this.importCache.set(cacheKey, { mtime: dtsMtime, nodeTypes: allNodeTypes });
           return allNodeTypes.filter((nt) => importedNames.has(nt.functionName));
         } catch {
           return [];
@@ -36215,7 +36231,7 @@ var init_parser2 = __esm({
         const cacheKey = `npm:${imp.importSource}`;
         if (this.importCache.has(cacheKey)) {
           const cached2 = this.importCache.get(cacheKey);
-          const found = cached2.find((nt) => nt.functionName === imp.functionName);
+          const found = cached2.nodeTypes.find((nt) => nt.functionName === imp.functionName);
           if (found) {
             return { ...found, name: imp.name, importSource: imp.importSource };
           }
@@ -36245,7 +36261,8 @@ var init_parser2 = __esm({
             allNodeTypes.push(nodeType);
           }
           this.project.removeSourceFile(dtsFile);
-          this.importCache.set(cacheKey, allNodeTypes);
+          const dtsMtime2 = fs5.statSync(dtsPath).mtimeMs;
+          this.importCache.set(cacheKey, { mtime: dtsMtime2, nodeTypes: allNodeTypes });
           const found = allNodeTypes.find((nt) => nt.functionName === imp.functionName);
           if (found) {
             return { ...found, name: imp.name, importSource: imp.importSource };
@@ -91095,8 +91112,8 @@ var init_debug_session = __esm({
 import * as path36 from "path";
 import * as fs31 from "fs";
 async function getExecutionOrder(filePath, workflowName) {
-  const source = fs31.readFileSync(path36.resolve(filePath), "utf8");
-  const parsed = await parseWorkflow(source, { workflowName });
+  const resolvedPath = path36.resolve(filePath);
+  const parsed = await parseWorkflow(resolvedPath, { workflowName });
   if (parsed.errors.length > 0) {
     throw new Error(`Failed to parse workflow: ${parsed.errors.join(", ")}`);
   }
@@ -95943,7 +95960,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.24.0" : "0.0.0-dev";
+var version2 = true ? "0.24.2" : "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.24.0";
+export declare const VERSION = "0.24.2";
 //# 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.24.0';
+export const VERSION = '0.24.2';
 //# sourceMappingURL=generated-version.js.map

package/dist/mcp/tools-debug.js

@@ -13,8 +13,8 @@ import { makeToolResult, makeErrorResult } from './response-utils.js';
  * Helper: get execution order for a workflow file by parsing its annotations.
  */
 async function getExecutionOrder(filePath, workflowName) {
-    const source = fs.readFileSync(path.resolve(filePath), 'utf8');
-    const parsed = await parseWorkflow(source, { workflowName });
+    const resolvedPath = path.resolve(filePath);
+    const parsed = await parseWorkflow(resolvedPath, { workflowName });
     if (parsed.errors.length > 0) {
         throw new Error(`Failed to parse workflow: ${parsed.errors.join(', ')}`);
     }

package/dist/parser.js

@@ -399,10 +399,12 @@ export class AnnotationParser {
                 throw new Error(`Circular dependency detected:\n  ${cycle.join('\n  -> ')}`);
             }
             try {
-                // Check cache first
+                // Check cache first — validate mtime to detect file changes
                 let nodeTypes;
-                if (this.importCache.has(importedFilePath)) {
-                    nodeTypes = this.importCache.get(importedFilePath);
+                const importStats = fs.statSync(importedFilePath);
+                const cached = this.importCache.get(importedFilePath);
+                if (cached && cached.mtime === importStats.mtimeMs) {
+                    nodeTypes = cached.nodeTypes;
                 }
                 else {
                     // Add to import stack for circular dependency detection
@@ -428,8 +430,8 @@ export class AnnotationParser {
                         nodeTypes.push(...inferredFromImport);
                         // Clean up imported source file to prevent Project bloat
                         this.project.removeSourceFile(importedFile);
-                        // Cache the parsed node types
-                        this.importCache.set(importedFilePath, nodeTypes);
+                        // Cache the parsed node types with mtime for invalidation
+                        this.importCache.set(importedFilePath, { mtime: importStats.mtimeMs, nodeTypes });
                     }
                     finally {
                         // Remove from stack after processing
@@ -477,10 +479,25 @@ export class AnnotationParser {
             return [];
         const importedNames = new Set();
         namedImports.forEach((ni) => importedNames.add(ni.getName()));
-        // Check cache
+        // Check cache (npm imports use package path mtime for invalidation)
         const cacheKey = `npm:${moduleSpecifier}`;
-        if (this.importCache.has(cacheKey)) {
-            return this.importCache.get(cacheKey).filter((nt) => importedNames.has(nt.functionName));
+        const npmCached = this.importCache.get(cacheKey);
+        if (npmCached) {
+            // For npm packages, check mtime of the resolved .d.ts file
+            const currentDir = path.dirname(currentFilePath);
+            const resolvedDts = resolvePackageTypesPath(moduleSpecifier, currentDir);
+            if (resolvedDts) {
+                try {
+                    const dtsStats = fs.statSync(resolvedDts);
+                    if (npmCached.mtime === dtsStats.mtimeMs) {
+                        return npmCached.nodeTypes.filter((nt) => importedNames.has(nt.functionName));
+                    }
+                }
+                catch { /* file gone — re-parse */ }
+            }
+            else {
+                return npmCached.nodeTypes.filter((nt) => importedNames.has(nt.functionName));
+            }
         }
         // Resolve .d.ts path
         const currentDir = path.dirname(currentFilePath);
@@ -509,8 +526,9 @@ export class AnnotationParser {
             }
             // Clean up the temporary source file
             this.project.removeSourceFile(dtsFile);
-            // Cache all node types from this package
-            this.importCache.set(cacheKey, allNodeTypes);
+            // Cache all node types from this package (with mtime of the .d.ts file)
+            const dtsMtime = fs.statSync(dtsPath).mtimeMs;
+            this.importCache.set(cacheKey, { mtime: dtsMtime, nodeTypes: allNodeTypes });
             // Return only the ones in the import statement
             return allNodeTypes.filter((nt) => importedNames.has(nt.functionName));
         }
@@ -596,7 +614,7 @@ export class AnnotationParser {
         const cacheKey = `npm:${imp.importSource}`;
         if (this.importCache.has(cacheKey)) {
             const cached = this.importCache.get(cacheKey);
-            const found = cached.find((nt) => nt.functionName === imp.functionName);
+            const found = cached.nodeTypes.find((nt) => nt.functionName === imp.functionName);
             if (found) {
                 // Return a copy with the correct name from @fwImport
                 return { ...found, name: imp.name, importSource: imp.importSource };
@@ -627,8 +645,9 @@ export class AnnotationParser {
                 allNodeTypes.push(nodeType);
             }
             this.project.removeSourceFile(dtsFile);
-            // Cache all node types from this package
-            this.importCache.set(cacheKey, allNodeTypes);
+            // Cache all node types from this package (with mtime of the .d.ts file)
+            const dtsMtime2 = fs.statSync(dtsPath).mtimeMs;
+            this.importCache.set(cacheKey, { mtime: dtsMtime2, nodeTypes: allNodeTypes });
             // Find the specific function we need
             const found = allNodeTypes.find((nt) => nt.functionName === imp.functionName);
             if (found) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",