@synergenius/flow-weaver-pack-weaver 0.9.193 → 0.9.196

package/src/workflows/weaver-agent.ts

@@ -16,21 +16,413 @@ import { weaverBotReport } from '../node-types/bot-report.js';
 // DO NOT EDIT - This section is auto-generated by Flow Weaver
 // ============================================================================
 
-import { GeneratedExecutionContext, CancellationError } from '@synergenius/flow-weaver/runtime';
-import type { TDebugger, TDebugController } from '@synergenius/flow-weaver/runtime';
+// ============================================================================
+// Runtime Types
+// ============================================================================
+
+type TStatusType =
+  | "RUNNING"
+  | "SCHEDULED"
+  | "SUCCEEDED"
+  | "FAILED"
+  | "CANCELLED"
+  | "PENDING";
+
+type TVariableIdentification = {
+  nodeTypeName: string;
+  id: string;
+  scope?: string | undefined;
+  side?: "start" | "exit" | undefined;
+  portName: string;
+  executionIndex: number;
+  key?: string | undefined;
+};
+
+type TStatusChangedEvent = {
+  type: "STATUS_CHANGED";
+  nodeTypeName: string;
+  id: string;
+  scope?: string;
+  side?: "start" | "exit";
+  executionIndex: number;
+  status: TStatusType;
+  innerFlowInvocation?: boolean;
+};
+
+type TVariableSetEvent = {
+  type: "VARIABLE_SET";
+  identifier: TVariableIdentification;
+  value?: unknown;
+  innerFlowInvocation?: boolean;
+};
+
+type TErrorLogEvent = {
+  type: "LOG_ERROR";
+  nodeTypeName: string;
+  id: string;
+  scope?: string;
+  side?: "start" | "exit";
+  executionIndex: number;
+  error: string;
+  innerFlowInvocation?: boolean;
+};
+
+type TWorkflowCompletedEvent = {
+  type: "WORKFLOW_COMPLETED";
+  executionIndex: number;
+  status: "SUCCEEDED" | "FAILED" | "CANCELLED";
+  result?: unknown;
+  innerFlowInvocation?: boolean;
+};
+
+type TEvent =
+  | TStatusChangedEvent
+  | TVariableSetEvent
+  | TErrorLogEvent
+  | TWorkflowCompletedEvent;
+
+type TDebugger = {
+  sendEvent: (event: TEvent) => void | Promise<void>;
+  innerFlowInvocation: boolean;
+  sessionId?: string;
+};
+
 declare const __flowWeaverDebugger__: TDebugger | undefined;
+
+type TDebugController = {
+  beforeNode(nodeId: string, ctx: GeneratedExecutionContext): Promise<boolean> | boolean;
+  afterNode(nodeId: string, ctx: GeneratedExecutionContext): Promise<void> | void;
+};
+
+declare const __abortSignal__: AbortSignal | undefined;
+
+interface VariableAddress {
+  id: string;
+  portName: string;
+  executionIndex: number;
+  nodeTypeName?: string | undefined;
+  scope?: string | undefined;
+  side?: 'start' | 'exit' | undefined;
+}
+
+interface ExecutionInfo {
+  id: string;
+  index: number;
+  parentIndex?: number | undefined;
+  scopeName?: string | undefined;
+}
+
+type VariableValue = unknown | (() => unknown) | (() => Promise<unknown>);
+
+// ============================================================================
+// Cancellation Error
+// ============================================================================
+
+class CancellationError extends Error {
+  public readonly executionIndex: number;
+  public readonly nodeId?: string;
+  public readonly timestamp: number;
+
+  constructor(
+    message: string = 'Workflow execution cancelled',
+    executionIndex: number = 0,
+    nodeId?: string,
+    timestamp: number = Date.now()
+  ) {
+    super(message);
+    this.name = 'CancellationError';
+    this.executionIndex = executionIndex;
+    this.nodeId = nodeId;
+    this.timestamp = timestamp;
+  }
+
+  static isCancellationError(error: unknown): error is CancellationError {
+    return (
+      error instanceof CancellationError ||
+      (error instanceof Error && error.name === 'CancellationError')
+    );
+  }
+}
+
+// ============================================================================
+// Execution Context
+// ============================================================================
+
+class GeneratedExecutionContext {
+  private variables: Map<string, VariableValue> = new Map();
+  private executions: Map<string, ExecutionInfo> = new Map();
+  private executionCounter: number = 0;
+  private nodeExecutionCounts: Map<string, number> = new Map();
+  private isAsync: boolean;
+  private flowWeaverDebugger?: TDebugger | undefined;
+  private pullExecutors: Map<string, () => void | Promise<void>> = new Map();
+  private nodeExecutionIndices: Map<string, number> = new Map();
+  private abortSignal?: AbortSignal | undefined;
+
+  constructor(isAsync: boolean = true, flowWeaverDebugger?: TDebugger, abortSignal?: AbortSignal) {
+    this.isAsync = isAsync;
+    this.flowWeaverDebugger = flowWeaverDebugger;
+    this.abortSignal = abortSignal;
+  }
+
+  registerPullExecutor(id: string, executor: () => void | Promise<void>): void {
+    this.pullExecutors.set(id, executor);
+  }
+
+  addExecution(id: string, parentIndex?: number, scopeName?: string): number {
+    // Use per-node execution counter (each node starts at 0)
+    const currentCount = this.nodeExecutionCounts.get(id) || 0;
+    const index = currentCount;
+    this.nodeExecutionCounts.set(id, currentCount + 1);
+    this.executionCounter++;
+    this.executions.set(this.getExecutionKey(id, index), {
+      id,
+      index,
+      parentIndex,
+      scopeName,
+    });
+    this.nodeExecutionIndices.set(id, index);
+    return index;
+  }
+
+  setVariable(address: VariableAddress, value: VariableValue): void | Promise<void> {
+    const key = this.getVariableKey(address);
+    this.variables.set(key, value);
+    if (this.flowWeaverDebugger) {
+      const actualValue = typeof value === "function" ? value() : value;
+      this.sendVariableSetEvent({
+        identifier: {
+          nodeTypeName: address.nodeTypeName || "unknown",
+          id: address.id,
+          portName: address.portName,
+          executionIndex: address.executionIndex,
+          key: "default",
+          ...(address.scope && { scope: address.scope }),
+          ...(address.side && { side: address.side }),
+        },
+        value: actualValue,
+      });
+    }
+    return this.isAsync ? Promise.resolve() : undefined;
+  }
+
+  getVariable(address: VariableAddress): unknown | Promise<unknown> {
+    const executor = this.pullExecutors.get(address.id);
+    if (executor) {
+      if (!this.hasVariable(address)) {
+        const result = executor();
+        // Handle async executor (returns Promise)
+        if (result instanceof Promise) {
+          return result.then(() => {
+            const trackedIndex = this.nodeExecutionIndices.get(address.id);
+            const finalAddress = trackedIndex !== undefined
+              ? { ...address, executionIndex: trackedIndex }
+              : address;
+            return this.retrieveVariable(finalAddress);
+          });
+        }
+        // Handle sync executor (returns void)
+        const trackedIndex = this.nodeExecutionIndices.get(address.id);
+        const finalAddress = trackedIndex !== undefined
+          ? { ...address, executionIndex: trackedIndex }
+          : address;
+        return this.retrieveVariable(finalAddress);
+      }
+    }
+    return this.retrieveVariable(address);
+  }
+
+  private retrieveVariable(address: VariableAddress): unknown | Promise<unknown> {
+    const key = this.getVariableKey(address);
+    if (!this.variables.has(key)) {
+      throw new Error(`Variable not found: ${address.id}.${address.portName}[${address.executionIndex}]`);
+    }
+    const value = this.variables.get(key);
+    if (typeof value === "function") {
+      const result = value();
+      if (result instanceof Promise) {
+        return result;
+      }
+      return this.isAsync ? Promise.resolve(result) : result;
+    }
+    return this.isAsync ? Promise.resolve(value) : value;
+  }
+
+  hasVariable(address: VariableAddress): boolean {
+    const key = this.getVariableKey(address);
+    return this.variables.has(key);
+  }
+
+  getExecution(id: string, index: number): ExecutionInfo | undefined {
+    return this.executions.get(this.getExecutionKey(id, index));
+  }
+
+  createScope(_parentNodeName: string, _parentIndex: number, _scopeName: string, cleanScope: boolean = false, isAsyncOverride?: boolean): GeneratedExecutionContext {
+    const effectiveIsAsync = isAsyncOverride !== undefined ? isAsyncOverride : this.isAsync;
+    const scopedContext = new GeneratedExecutionContext(effectiveIsAsync, this.flowWeaverDebugger, this.abortSignal);
+    // For per-port function scopes (cleanScope=true), start with empty variables
+    // For node-level scopes (cleanScope=false), inherit parent variables
+    scopedContext.variables = cleanScope ? new Map() : new Map(this.variables);
+    scopedContext.executions = new Map(this.executions);
+    scopedContext.executionCounter = this.executionCounter;
+    scopedContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);
+    return scopedContext;
+  }
+
+  mergeScope(scopedContext: GeneratedExecutionContext): void {
+    scopedContext.executions.forEach((info, key) => {
+      this.executions.set(key, info);
+    });
+    scopedContext.variables.forEach((value, key) => {
+      this.variables.set(key, value);
+    });
+    this.executionCounter = Math.max(this.executionCounter, scopedContext.executionCounter);
+    scopedContext.nodeExecutionCounts.forEach((count, id) => {
+      const currentCount = this.nodeExecutionCounts.get(id) || 0;
+      this.nodeExecutionCounts.set(id, Math.max(currentCount, count));
+    });
+  }
+
+  private getVariableKey(address: VariableAddress): string {
+    return `${address.id}:${address.portName}:${address.executionIndex}`;
+  }
+
+  private getExecutionKey(id: string, index: number): string {
+    return `${id}:${index}`;
+  }
+
+  getExecutionCount(): number {
+    return this.executionCounter;
+  }
+
+  reset(): void {
+    this.variables.clear();
+    this.executions.clear();
+    this.executionCounter = 0;
+    this.nodeExecutionCounts.clear();
+  }
+
+  isAborted(): boolean {
+    return this.abortSignal?.aborted ?? false;
+  }
+
+  checkAborted(nodeId?: string): void {
+    if (this.abortSignal?.aborted) {
+      throw new CancellationError(
+        `Workflow execution cancelled${nodeId ? ` at ${nodeId}` : ''}`,
+        this.executionCounter,
+        nodeId
+      );
+    }
+  }
+
+  async sendStatusChangedEvent(args: {
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    status: TStatusType;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "STATUS_CHANGED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  private async sendVariableSetEvent(args: {
+    identifier: TVariableIdentification;
+    value: unknown;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "VARIABLE_SET",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  async sendLogErrorEvent(args: {
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    error: string;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "LOG_ERROR",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  async sendWorkflowCompletedEvent(args: {
+    executionIndex: number;
+    status: "SUCCEEDED" | "FAILED" | "CANCELLED";
+    result?: unknown;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "WORKFLOW_COMPLETED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  serialize(): {
+    variables: Record<string, unknown>;
+    executions: Record<string, ExecutionInfo>;
+    executionCounter: number;
+    nodeExecutionCounts: Record<string, number>;
+  } {
+    const vars: Record<string, unknown> = {};
+    for (const [key, value] of this.variables) {
+      if (typeof value === "function") {
+        try { vars[key] = (value as () => unknown)(); } catch { vars[key] = value; }
+      } else {
+        vars[key] = value;
+      }
+    }
+    const execs: Record<string, ExecutionInfo> = {};
+    for (const [key, info] of this.executions) { execs[key] = { ...info }; }
+    const nodeCounts: Record<string, number> = {};
+    for (const [key, count] of this.nodeExecutionIndices) { nodeCounts[key] = count; }
+    return { variables: vars, executions: execs, executionCounter: this.executionCounter, nodeExecutionCounts: nodeCounts };
+  }
+
+  restore(data: {
+    variables: Record<string, unknown>;
+    executions: Record<string, ExecutionInfo>;
+    executionCounter: number;
+    nodeExecutionCounts: Record<string, number>;
+  }): void {
+    this.variables = new Map(Object.entries(data.variables));
+    this.executions = new Map(Object.entries(data.executions));
+    this.executionCounter = data.executionCounter;
+    this.nodeExecutionIndices = new Map(Object.entries(data.nodeExecutionCounts));
+  }
+}
+
 // @flow-weaver-runtime-end
 
 /**
  * @flowWeaver workflow
  * @node cfg weaverLoadConfig [color: "teal"] [icon: "settings"] [position: 200 200]
- * @node detect weaverDetectProvider [color: "cyan"] [icon: "search"] [position: 400 200] [suppress: "OBJECT_TYPE_MISMATCH", "ANNOTATION_SIGNATURE_TYPE_MISMATCH"]
+ * @node detect weaverDetectProvider [color: "cyan"] [icon: "search"] [suppress: "OBJECT_TYPE_MISMATCH", "ANNOTATION_SIGNATURE_TYPE_MISMATCH"] [position: 400 200]
  * @node receive weaverReceiveTask [color: "blue"] [icon: "send"] [position: 600 200]
  * @node context weaverBuildContext [color: "teal"] [icon: "code"] [position: 800 200]
  * @node agent weaverAgentExecute [color: "purple"] [icon: "psychology"] [position: 1000 200]
  * @node gitOps weaverGitOps [color: "green"] [icon: "code"] [position: 1200 100]
- * @node notify weaverSendNotify [color: "yellow"] [icon: "send"] [position: 1200 300] [suppress: "UNUSED_OUTPUT_PORT"]
- * @node report weaverBotReport [color: "green"] [icon: "description"] [position: 1400 200] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"]
+ * @node notify weaverSendNotify [color: "yellow"] [icon: "send"] [suppress: "UNUSED_OUTPUT_PORT"] [position: 1200 300]
+ * @node report weaverBotReport [color: "green"] [icon: "description"] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"] [position: 1400 200]
  * @path Start -> cfg -> detect -> receive -> context -> agent -> gitOps -> report -> Exit
  * @path agent -> notify
  * @path receive:fail -> report
@@ -94,11 +486,14 @@ export async function weaverAgent(
     let gitOpsIdx: number | undefined;
     let notifyIdx: number | undefined;
     let reportIdx: number | undefined;
-
+    let notify_success = false;
     let cfg_success = false;
     let detect_success = false;
     let receive_success = false;
     let context_success = false;
+    let agent_success = false;
+    let gitOps_success = false;
+
 
     if (await __ctrl__.beforeNode('cfg', ctx)) {
 
@@ -298,7 +693,9 @@ export async function weaverAgent(
           await ctx.setVariable({ id: 'receive', portName: 'env', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receive_env);
           const receive_taskJson = await ctx.getVariable({ id: 'Start', portName: 'taskJson', executionIndex: startIdx }) as string;
           await ctx.setVariable({ id: 'receive', portName: 'taskJson', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receive_taskJson);
-          const receiveResult = await weaverReceiveTask(receive_execute, receive_env, receive_taskJson);
+          const receive_frozenPromptPrefix = undefined;
+          await ctx.setVariable({ id: 'receive', portName: 'frozenPromptPrefix', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receive_frozenPromptPrefix);
+          const receiveResult = await weaverReceiveTask(receive_execute, receive_env, receive_taskJson, receive_frozenPromptPrefix);
           await ctx.setVariable({ id: 'receive', portName: 'ctx', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receiveResult.ctx);
           await ctx.setVariable({ id: 'receive', portName: 'onSuccess', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receiveResult.onSuccess);
           await ctx.setVariable({ id: 'receive', portName: 'onFailure', executionIndex: receiveIdx, nodeTypeName: 'weaverReceiveTask' }, receiveResult.onFailure);
@@ -400,14 +797,14 @@ export async function weaverAgent(
         context_success = false;
 
         try {
-          await ctx.setVariable({ id: 'context', portName: 'execute', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, true);
+          const context_execute = receiveIdx !== undefined ? await ctx.getVariable({ id: 'receive', portName: 'onSuccess', executionIndex: receiveIdx }) as boolean : false;
+          await ctx.setVariable({ id: 'context', portName: 'execute', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, context_execute);
           const context_ctx = await ctx.getVariable({ id: 'receive', portName: 'ctx', executionIndex: receiveIdx! }) as string;
           await ctx.setVariable({ id: 'context', portName: 'ctx', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, context_ctx);
-          const contextResult = weaverBuildContext(context_ctx);
-          const contextResult_raw: unknown = contextResult;
-          await ctx.setVariable({ id: 'context', portName: 'ctx', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, typeof contextResult_raw === 'object' && contextResult_raw !== null && 'ctx' in contextResult_raw ? contextResult_raw.ctx : contextResult_raw);
-          await ctx.setVariable({ id: 'context', portName: 'onSuccess', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, true);
-          await ctx.setVariable({ id: 'context', portName: 'onFailure', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, false);
+          const contextResult = await weaverBuildContext(context_execute, context_ctx);
+          await ctx.setVariable({ id: 'context', portName: 'ctx', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, contextResult.ctx);
+          await ctx.setVariable({ id: 'context', portName: 'onFailure', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, contextResult.onFailure);
+          await ctx.setVariable({ id: 'context', portName: 'onSuccess', executionIndex: contextIdx, nodeTypeName: 'weaverBuildContext' }, contextResult.onSuccess);
           await ctx.sendStatusChangedEvent({
             nodeTypeName: 'weaverBuildContext',
             id: 'context',
@@ -415,7 +812,7 @@ export async function weaverAgent(
             status: 'SUCCEEDED',
           });
           await __ctrl__.afterNode('context', ctx);
-          context_success = true;
+          context_success = contextResult.onSuccess;
         } catch (error: unknown) {
           const isCancellation = CancellationError.isCancellationError(error);
           await ctx.sendStatusChangedEvent({
@@ -481,7 +878,6 @@ export async function weaverAgent(
       });
     }
     if (cfg_success && detect_success && receive_success && context_success) {
-      let agent_success = false;
       if (await __ctrl__.beforeNode('agent', ctx)) {
 
         // ── agent (weaverAgentExecute) ──
@@ -502,7 +898,9 @@ export async function weaverAgent(
           await ctx.setVariable({ id: 'agent', portName: 'execute', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agent_execute);
           const agent_ctx = await ctx.getVariable({ id: 'context', portName: 'ctx', executionIndex: contextIdx! }) as string;
           await ctx.setVariable({ id: 'agent', portName: 'ctx', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agent_ctx);
-          const agentResult = await weaverAgentExecute(agent_execute, agent_ctx);
+          const agent_modelOverride = undefined;
+          await ctx.setVariable({ id: 'agent', portName: 'modelOverride', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agent_modelOverride);
+          const agentResult = await weaverAgentExecute(agent_execute, agent_ctx, agent_modelOverride);
           await ctx.setVariable({ id: 'agent', portName: 'ctx', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agentResult.ctx);
           await ctx.setVariable({ id: 'agent', portName: 'onSuccess', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agentResult.onSuccess);
           await ctx.setVariable({ id: 'agent', portName: 'onFailure', executionIndex: agentIdx, nodeTypeName: 'weaverAgentExecute' }, agentResult.onFailure);
@@ -572,6 +970,8 @@ export async function weaverAgent(
             status: 'RUNNING',
           });
 
+          gitOps_success = false;
+
           try {
             await ctx.setVariable({ id: 'gitOps', portName: 'execute', executionIndex: gitOpsIdx, nodeTypeName: 'weaverGitOps' }, true);
             const gitOps_ctx = await ctx.getVariable({ id: 'agent', portName: 'ctx', executionIndex: agentIdx! }) as string;
@@ -588,6 +988,7 @@ export async function weaverAgent(
               status: 'SUCCEEDED',
             });
             await __ctrl__.afterNode('gitOps', ctx);
+            gitOps_success = true;
           } catch (error: unknown) {
             const isCancellation = CancellationError.isCancellationError(error);
             await ctx.sendStatusChangedEvent({
@@ -605,11 +1006,13 @@ export async function weaverAgent(
               });
               await ctx.setVariable({ id: 'gitOps', portName: 'onSuccess', executionIndex: gitOpsIdx, nodeTypeName: 'weaverGitOps' }, false);
               await ctx.setVariable({ id: 'gitOps', portName: 'onFailure', executionIndex: gitOpsIdx, nodeTypeName: 'weaverGitOps' }, true);
+              gitOps_success = false;
             }
             throw error;
           }
         } else {
           gitOpsIdx = ctx.addExecution('gitOps');
+          gitOps_success = true;
         }
 
         if (await __ctrl__.beforeNode('notify', ctx)) {
@@ -625,6 +1028,8 @@ export async function weaverAgent(
             status: 'RUNNING',
           });
 
+          notify_success = false;
+
           try {
             await ctx.setVariable({ id: 'notify', portName: 'execute', executionIndex: notifyIdx, nodeTypeName: 'weaverSendNotify' }, true);
             const notify_ctx = await ctx.getVariable({ id: 'agent', portName: 'ctx', executionIndex: agentIdx! }) as string;
@@ -641,6 +1046,7 @@ export async function weaverAgent(
               status: 'SUCCEEDED',
             });
             await __ctrl__.afterNode('notify', ctx);
+            notify_success = true;
           } catch (error: unknown) {
             const isCancellation = CancellationError.isCancellationError(error);
             await ctx.sendStatusChangedEvent({
@@ -658,11 +1064,13 @@ export async function weaverAgent(
               });
               await ctx.setVariable({ id: 'notify', portName: 'onSuccess', executionIndex: notifyIdx, nodeTypeName: 'weaverSendNotify' }, false);
               await ctx.setVariable({ id: 'notify', portName: 'onFailure', executionIndex: notifyIdx, nodeTypeName: 'weaverSendNotify' }, true);
+              notify_success = false;
             }
             throw error;
           }
         } else {
           notifyIdx = ctx.addExecution('notify');
+          notify_success = true;
         }
 
       } else {
@@ -728,7 +1136,7 @@ export async function weaverAgent(
       });
 
       try {
-        const report_execute = (notifyIdx !== undefined ? await ctx.getVariable({ id: 'notify', portName: 'onSuccess', executionIndex: notifyIdx }) as boolean : false) || (gitOpsIdx !== undefined ? await ctx.getVariable({ id: 'gitOps', portName: 'onSuccess', executionIndex: gitOpsIdx }) as boolean : false);
+        const report_execute = (notifyIdx !== undefined ? await ctx.getVariable({ id: 'notify', portName: 'onSuccess', executionIndex: notifyIdx }) as boolean : false) || (gitOpsIdx !== undefined ? await ctx.getVariable({ id: 'gitOps', portName: 'onSuccess', executionIndex: gitOpsIdx }) as boolean : false) || (receiveIdx !== undefined ? await ctx.getVariable({ id: 'receive', portName: 'onFailure', executionIndex: receiveIdx }) as boolean : false) || (agentIdx !== undefined ? await ctx.getVariable({ id: 'agent', portName: 'onFailure', executionIndex: agentIdx }) as boolean : false);
         await ctx.setVariable({ id: 'report', portName: 'execute', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_execute);
         const report_mainCtx = gitOpsIdx !== undefined ? await ctx.getVariable({ id: 'gitOps', portName: 'ctx', executionIndex: gitOpsIdx }) as string : undefined;
         await ctx.setVariable({ id: 'report', portName: 'mainCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_mainCtx);
@@ -736,8 +1144,11 @@ export async function weaverAgent(
         await ctx.setVariable({ id: 'report', portName: 'readCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_readCtx);
         const report_abortCtx = undefined;
         await ctx.setVariable({ id: 'report', portName: 'abortCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_abortCtx);
-        const reportResult = await weaverBotReport(report_execute, report_mainCtx, report_readCtx, report_abortCtx);
+        const report_failCtx = undefined;
+        await ctx.setVariable({ id: 'report', portName: 'failCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_failCtx);
+        const reportResult = await weaverBotReport(report_execute, report_mainCtx, report_readCtx, report_abortCtx, report_failCtx);
         await ctx.setVariable({ id: 'report', portName: 'summary', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.summary);
+        await ctx.setVariable({ id: 'report', portName: 'report', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.report);
         await ctx.setVariable({ id: 'report', portName: 'reportJson', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.reportJson);
         await ctx.setVariable({ id: 'report', portName: 'onFailure', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.onFailure);
         await ctx.setVariable({ id: 'report', portName: 'onSuccess', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.onSuccess);