@synergenius/flow-weaver 0.24.1 → 0.24.3

package/dist/agent/agent-loop.js

@@ -79,6 +79,17 @@ export async function runAgentLoop(provider, tools, executor, messages, options)
         }
         // If no tool calls, we're done
         if (finishReason !== 'tool_calls' || collectedToolCalls.length === 0) {
+            // Final turn hook
+            if (options?.onTurnEnd) {
+                await options.onTurnEnd({
+                    iteration,
+                    maxIterations,
+                    messages: conversation,
+                    toolCallCount,
+                    usage: { promptTokens: totalPromptTokens, completionTokens: totalCompletionTokens },
+                    isFinalTurn: true,
+                });
+            }
             return buildResult(finishReason !== 'error', text || 'Task completed', conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
         }
         // Execute tool calls and add results to conversation
@@ -106,6 +117,23 @@ export async function runAgentLoop(provider, tools, executor, messages, options)
                 toolCallId: tc.id,
             });
         }
+        // Between-turns hook — runs after tool execution, before next LLM call
+        if (options?.onTurnEnd) {
+            const turnResult = await options.onTurnEnd({
+                iteration,
+                maxIterations,
+                messages: conversation,
+                toolCallCount,
+                usage: { promptTokens: totalPromptTokens, completionTokens: totalCompletionTokens },
+                isFinalTurn: false,
+            });
+            if (turnResult?.continue === false) {
+                return buildResult(true, turnResult.injectMessage ?? 'Stopped by hook', conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
+            }
+            if (turnResult?.injectMessage) {
+                conversation.push({ role: 'user', content: turnResult.injectMessage });
+            }
+        }
     }
     return buildResult(false, `Reached max iterations (${maxIterations})`, conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
 }

package/dist/agent/index.d.ts

@@ -4,7 +4,7 @@
  * 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 { SplitPrompt, StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
+export type { SplitPrompt, TurnEndContext, TurnEndResult, 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';

package/dist/agent/types.d.ts

@@ -105,6 +105,31 @@ export interface McpBridge {
     /** Tear down the socket server and remove temp files */
     cleanup: () => void;
 }
+/** Context passed to the onTurnEnd callback after each agent loop iteration. */
+export interface TurnEndContext {
+    /** Current iteration number (0-based). */
+    iteration: number;
+    /** Maximum iterations configured. */
+    maxIterations: number;
+    /** Full conversation history up to this point. */
+    messages: ReadonlyArray<AgentMessage>;
+    /** Total tool calls executed so far. */
+    toolCallCount: number;
+    /** Cumulative token usage. */
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+    /** true if the model stopped calling tools (final turn). */
+    isFinalTurn: boolean;
+}
+/** Result from the onTurnEnd callback. */
+export interface TurnEndResult {
+    /** If false, abort the agent loop early. */
+    continue?: boolean;
+    /** Optional message to inject into the conversation (steering nudge). */
+    injectMessage?: string;
+}
 export interface AgentLoopOptions {
     systemPrompt?: SplitPrompt;
     maxIterations?: number;
@@ -113,6 +138,8 @@ export interface AgentLoopOptions {
     signal?: AbortSignal;
     onToolEvent?: (event: ToolEvent) => void;
     onStreamEvent?: (event: StreamEvent) => void;
+    /** Called after each agent loop iteration (between turns and on final turn). */
+    onTurnEnd?: (context: TurnEndContext) => Promise<TurnEndResult | void>;
     logger?: Logger;
 }
 export interface AgentLoopResult {

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.1";
+    VERSION = "0.24.3";
   }
 });
 
@@ -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 };
@@ -95943,7 +95960,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.24.1" : "0.0.0-dev";
+var version2 = true ? "0.24.3" : "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.1";
+export declare const VERSION = "0.24.3";
 //# 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.1';
+export const VERSION = '0.24.3';
 //# sourceMappingURL=generated-version.js.map

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.1",
+  "version": "0.24.3",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",