@synergenius/flow-weaver 0.24.2 → 0.24.4

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.2";
+    VERSION = "0.24.4";
   }
 });
 
@@ -36231,9 +36231,22 @@ var init_parser2 = __esm({
         const cacheKey = `npm:${imp.importSource}`;
         if (this.importCache.has(cacheKey)) {
           const cached2 = this.importCache.get(cacheKey);
-          const found = cached2.nodeTypes.find((nt) => nt.functionName === imp.functionName);
-          if (found) {
-            return { ...found, name: imp.name, importSource: imp.importSource };
+          const resolvedDts = resolvePackageTypesPath(imp.importSource, currentDir);
+          let cacheValid = false;
+          if (resolvedDts) {
+            try {
+              const dtsStats = fs5.statSync(resolvedDts);
+              cacheValid = cached2.mtime === dtsStats.mtimeMs;
+            } catch {
+            }
+          } else {
+            cacheValid = true;
+          }
+          if (cacheValid) {
+            const found = cached2.nodeTypes.find((nt) => nt.functionName === imp.functionName);
+            if (found) {
+              return { ...found, name: imp.name, importSource: imp.importSource };
+            }
           }
         }
         const dtsPath = resolvePackageTypesPath(imp.importSource, currentDir);
@@ -95960,7 +95973,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.24.2" : "0.0.0-dev";
+var version2 = true ? "0.24.4" : "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.2";
+export declare const VERSION = "0.24.4";
 //# 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.2';
+export const VERSION = '0.24.4';
 //# sourceMappingURL=generated-version.js.map

package/dist/parser.js

@@ -610,14 +610,28 @@ export class AnnotationParser {
      * Resolve an npm package @fwImport to a node type by reading .d.ts declarations.
      */
     resolveNpmImportAnnotation(imp, currentDir) {
-        // Check cache
+        // Check cache (with mtime validation — same pattern as resolveNpmImports)
         const cacheKey = `npm:${imp.importSource}`;
         if (this.importCache.has(cacheKey)) {
             const cached = this.importCache.get(cacheKey);
-            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 };
+            const resolvedDts = resolvePackageTypesPath(imp.importSource, currentDir);
+            let cacheValid = false;
+            if (resolvedDts) {
+                try {
+                    const dtsStats = fs.statSync(resolvedDts);
+                    cacheValid = cached.mtime === dtsStats.mtimeMs;
+                }
+                catch { /* file gone — re-parse */ }
+            }
+            else {
+                // No .d.ts found — trust cache (package may have been removed)
+                cacheValid = true;
+            }
+            if (cacheValid) {
+                const found = cached.nodeTypes.find((nt) => nt.functionName === imp.functionName);
+                if (found) {
+                    return { ...found, name: imp.name, importSource: imp.importSource };
+                }
             }
         }
         // Resolve .d.ts path

package/package.json

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