@falai/agent 2.6.1 → 3.0.0

package/src/adapters/index.ts

@@ -2,42 +2,42 @@
  * Database adapters for persistence
  */
 
-export { PrismaAdapter } from "./PrismaAdapter";
+export { PrismaAdapter } from "./PrismaAdapter.js";
 export type {
   PrismaClient,
   FieldMappings,
   PrismaAdapterOptions,
-} from "./PrismaAdapter";
+} from "./PrismaAdapter.js";
 
-export { RedisAdapter } from "./RedisAdapter";
-export type { RedisClient, RedisAdapterOptions } from "./RedisAdapter";
+export { RedisAdapter } from "./RedisAdapter.js";
+export type { RedisClient, RedisAdapterOptions } from "./RedisAdapter.js";
 
-export { MongoAdapter } from "./MongoAdapter";
+export { MongoAdapter } from "./MongoAdapter.js";
 export type {
   MongoClient,
   MongoDatabase,
   MongoCollection,
   MongoAdapterOptions,
-} from "./MongoAdapter";
+} from "./MongoAdapter.js";
 
-export { PostgreSQLAdapter } from "./PostgreSQLAdapter";
+export { PostgreSQLAdapter } from "./PostgreSQLAdapter.js";
 export type {
   PgClient,
   PgQueryResult,
   PostgreSQLAdapterOptions,
-} from "./PostgreSQLAdapter";
+} from "./PostgreSQLAdapter.js";
 
-export { SQLiteAdapter } from "./SQLiteAdapter";
+export { SQLiteAdapter } from "./SQLiteAdapter.js";
 export type {
   SqliteDatabase,
   SqliteStatement,
   SQLiteAdapterOptions,
-} from "./SQLiteAdapter";
+} from "./SQLiteAdapter.js";
 
-export { MemoryAdapter } from "./MemoryAdapter";
+export { MemoryAdapter } from "./MemoryAdapter.js";
 
-export { OpenSearchAdapter } from "./OpenSearchAdapter";
+export { OpenSearchAdapter } from "./OpenSearchAdapter.js";
 export type {
   OpenSearchClient,
   OpenSearchAdapterOptions,
-} from "./OpenSearchAdapter";
+} from "./OpenSearchAdapter.js";

package/src/adapters/sessionRow.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared row-mapping for the SQL-shaped session adapters (PostgreSQL, SQLite)
+ * and date coercion for JSON-round-tripped values (Redis).
+ *
+ * One implementation so the adapters can't drift on what a stored session row
+ * means. PostgreSQL's driver returns JSONB pre-parsed and timestamptz as Date
+ * instances; SQLite returns strings — both shapes are accepted here.
+ */
+
+import type {
+  CollectedStateData,
+  SessionData,
+  SessionStatus,
+} from "../types/index.js";
+
+/**
+ * Coerce a raw stored value into a Date. Drivers variously hand back Date
+ * instances (node-postgres timestamptz) or ISO strings (SQLite, JSON blobs).
+ * `null`/`undefined` maps to `undefined`.
+ */
+export function coerceDate(value: unknown): Date | undefined {
+  if (value == null) return undefined;
+  return value instanceof Date ? value : new Date(value as string);
+}
+
+/**
+ * Map a raw snake_case row onto the camelCase SessionData interface.
+ * `collected_data` arrives JSONB-parsed on PostgreSQL and as a raw string on
+ * SQLite — both are handled. Exported for the adapter mapping tests.
+ */
+export function deserializeSessionRow<TData = Record<string, unknown>>(
+  row: Record<string, unknown>
+): SessionData<TData> {
+  const collected = row.collected_data;
+  return {
+    id: row.id as string,
+    userId: (row.user_id as string) || undefined,
+    agentName: (row.agent_name as string) || undefined,
+    status: row.status as SessionStatus,
+    currentFlow: (row.current_flow as string) || undefined,
+    currentStep: (row.current_step as string) || undefined,
+    collectedData:
+      collected == null
+        ? undefined
+        : typeof collected === "string"
+          ? (JSON.parse(collected) as CollectedStateData<TData>)
+          : (collected as CollectedStateData<TData>),
+    messageCount: (row.message_count as number) || 0,
+    lastMessageAt: coerceDate(row.last_message_at),
+    completedAt: coerceDate(row.completed_at),
+    version: (row.version as number | null) ?? undefined,
+    // created_at/updated_at are NOT NULL in every adapter's schema; the
+    // fallback only covers hand-crafted rows.
+    createdAt: coerceDate(row.created_at) ?? new Date(),
+    updatedAt: coerceDate(row.updated_at) ?? new Date(),
+  };
+}

package/src/core/Agent.ts

@@ -18,12 +18,12 @@ import type {
   AiProvider,
   CompactionOptions,
   Directive,
-} from "../types";
-import type { Signal } from "../types/signals";
-import { NotImplementedError } from "../types/errors";
-import { SignalProcessor } from "./SignalProcessor";
-import { SignalEvaluator } from "./SignalEvaluator";
-import type { StreamOptions, GenerateOptions, RespondParams, ResponseModalDeps } from "./ResponseModal";
+} from "../types/index.js";
+import type { Signal } from "../types/signals.js";
+import { NotImplementedError } from "../types/errors.js";
+import { SignalProcessor } from "./SignalProcessor.js";
+import { SignalEvaluator } from "./SignalEvaluator.js";
+import type { StreamOptions, GenerateOptions, RespondParams, ResponseModalDeps } from "./ResponseModal.js";
 import {
   mergeCollected,
   enterFlow,
@@ -32,18 +32,18 @@ import {
   logger,
   LoggerLevel,
   generateSignalId,
-} from "../utils";
+} from "../utils/index.js";
 
-import { Flow } from "./Flow";
-import { Step, FlowConfigurationError as StepFlowConfigurationError } from "./Step";
-import { PersistenceManager } from "./PersistenceManager";
-import { SessionManager } from "./SessionManager";
-import { FlowRouter } from "./FlowRouter";
-import { PromptSectionCache } from "./PromptSectionCache";
+import { Flow } from "./Flow.js";
+import { Step, FlowConfigurationError as StepFlowConfigurationError } from "./Step.js";
+import { PersistenceManager } from "./PersistenceManager.js";
+import { SessionManager } from "./SessionManager.js";
+import { FlowRouter } from "./FlowRouter.js";
+import { PromptSectionCache } from "./PromptSectionCache.js";
 
-import { ResponseModal } from "./ResponseModal";
-import { ToolManager } from "./ToolManager";
-import { CompactionEngine } from "./CompactionEngine";
+import { ResponseModal } from "./ResponseModal.js";
+import { ToolManager } from "./ToolManager.js";
+import { CompactionEngine } from "./CompactionEngine.js";
 
 /**
  * Error thrown when data validation fails
@@ -205,8 +205,14 @@ export class Agent<TContext = unknown, TData = unknown> implements ResponseModal
       this.signalProcessor = undefined;
     }
 
-    // Set log level based on debug option
+    // Set log level based on debug option. NOTE: loglevel's default logger is
+    // process-global — one agent enabling debug turns on DEBUG for every agent
+    // in the process. Warned so multi-tenant embedders aren't surprised.
     if (options.debug) {
+      logger.warn(
+        `[Agent] "${options.name}" enabled debug logging via the PROCESS-GLOBAL loglevel level. ` +
+        `Every agent in this process now logs at DEBUG. Scope logging in your host if needed.`
+      );
       logger.setLevel(LoggerLevel.DEBUG);
     }
 
@@ -868,6 +874,26 @@ export class Agent<TContext = unknown, TData = unknown> implements ResponseModal
       }
     }
 
+    // Overlap detection: warn (don't throw) when the incoming flow's
+    // requiredFields intersect another registered flow's — the schema is
+    // agent-level, so both flows complete together and one is silently
+    // excluded from routing.
+    if (options.requiredFields && options.requiredFields.length > 0) {
+      const incoming = new Set(options.requiredFields.map(String));
+      for (const existing of this._flows) {
+        const shared = (existing.requiredFields ?? [])
+          .map(String)
+          .filter((f) => incoming.has(f));
+        if (shared.length > 0) {
+          logger.warn(
+            `[FlowConfigurationError] Overlapping requiredFields: flows "${existing.title}" and "${options.title}" share [${shared.join(', ')}]. ` +
+            `The schema is agent-level, so data collected for one flow marks the other complete and excludes it from routing. ` +
+            `Give each flow distinct requiredFields, or set \`reentrant: true\` on flows that legitimately share fields.`
+          );
+        }
+      }
+    }
+
     const flow = new Flow<TContext, TData>(options, this);
 
     // Validate that step collect fields reference valid schema keys
@@ -1151,12 +1177,20 @@ export class Agent<TContext = unknown, TData = unknown> implements ResponseModal
    *
    * String form desugars to `{ goTo: target }`.
    *
+   * Durability: with a persistence adapter and autoSave configured (the
+   * defaults), the queued directive is persisted immediately — safe for
+   * out-of-process callers like webhooks or cron. Without an adapter it is
+   * memory-only, as is `persistence.autoSave: false` (then persisting before
+   * the next turn is the caller's job).
+   *
    * @param target - Flow ID/title string (desugars to `{ goTo: target }`) or a full Directive
    * @param session - Session to update (uses current session if not provided)
    * @returns Updated session with `pendingDirective` set
    *
    * @throws FlowConfigurationError if the string target doesn't match any flow
    * @throws FlowConfigurationError if the directive fails validation
+   * @throws SessionConflictError when persistence is enabled and another writer
+   * moved the stored session since this copy was loaded
    *
    * @example
    * // String shorthand — desugars to { goTo: 'Feedback' }
@@ -1166,7 +1200,6 @@ export class Agent<TContext = unknown, TData = unknown> implements ResponseModal
    * // Full directive
    * const updated = await agent.dispatch({ goTo: 'Billing', reply: 'Transferring you now.' }, session);
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
   async dispatch(
     target: string | Directive<TContext, TData>,
     session?: SessionState<TData>
@@ -1225,6 +1258,19 @@ export class Agent<TContext = unknown, TData = unknown> implements ResponseModal
       },
     };
 
+    // Durability: with an adapter + autoSave configured, dispatch persists
+    // immediately — webhooks/cron run out-of-process from the responder, and a
+    // memory-only queue would evaporate with this process. The save stamps the
+    // new version back onto updatedSession, so the next turn's auto-save CAS
+    // stays clean. Persisting BEFORE the in-memory sync keeps the existing
+    // invariant: a throwing dispatch leaves the session untouched.
+    if (this._persistenceManager && this.options.persistence?.autoSave !== false) {
+      await this._persistenceManager.saveSessionState(updatedSession.id, updatedSession);
+      logger.debug(
+        `[Agent] Dispatched directive persisted to adapter for session ${updatedSession.id}`
+      );
+    }
+
     // Update current session in place if no explicit session was passed
     if (!session && this.session.current) {
       this.session.syncSession(updatedSession);

package/src/core/AutoChainExecutor.ts

@@ -15,36 +15,30 @@
  * Implements Algorithm 1 from `.kiro/specs/auto-steps/design.md`.
  */
 
-import type { SessionState } from "../types";
-import type { Event } from "../types/history";
-import { FlowConfigurationError, Step } from "./Step";
-import { Flow } from "./Flow";
-import { enterStep, mergeCollected, logger } from "../utils";
-import { createTemplateContext } from "../utils/template";
+import type { Directive, SessionState } from "../types/index.js";
+import type { Event } from "../types/history.js";
+import { FlowConfigurationError, Step } from "./Step.js";
+import { Flow } from "./Flow.js";
+import { flow } from "./flow-namespace.js";
+import { enterStep, mergeCollected, logger } from "../utils/index.js";
+import { createTemplateContext } from "../utils/template.js";
 import type {
     StoppedReason,
     BranchMap,
     BranchEntry,
     BranchPredicateContext,
-} from "../types/flow";
-import { evaluateIfPredicates } from "../utils/condition";
+} from "../types/flow.js";
+import { evaluateIfPredicates } from "../utils/condition.js";
 
 /**
  * The directive-like object that `prepare` may return on auto-steps.
- * This is a structural subset of Directive (pre-LLM fields).
+ * A structural subset of Directive (pre-LLM + position fields), so results
+ * merge through the canonical Algorithm 4 (`flow.merge`).
  */
-export interface AutoStepPrepareResult {
-    dataUpdate?: Record<string, unknown>;
-    contextUpdate?: Record<string, unknown>;
-    halt?: boolean;
-    reply?: string;
-    /** Position-changing: jump to a step within the current flow. */
-    goToStep?: string;
-    /** Position-changing: jump to another flow. */
-    goTo?: string;
-    /** Position-changing: mark the flow as complete. */
-    complete?: boolean;
-}
+export type AutoStepPrepareResult<TContext = unknown, TData = unknown> = Pick<
+    Directive<TContext, TData>,
+    "dataUpdate" | "contextUpdate" | "halt" | "reply" | "goToStep" | "goTo" | "complete"
+>;
 
 /**
  * Result of running the auto-chain.
@@ -53,7 +47,7 @@ export interface AutoChainResult<TContext = unknown, TData = unknown> {
     /** The interactive step to hand off to the LLM path (undefined if chain ended without one). */
     resolvedStep?: Step<TContext, TData>;
     /** The merged directive from the halting auto-step's prepare (only set when stoppedReason = 'halt'). */
-    mergedDirective?: AutoStepPrepareResult;
+    mergedDirective?: AutoStepPrepareResult<TContext, TData>;
     /** Why the chain stopped, if it didn't reach an interactive step normally. */
     stoppedReason?: StoppedReason;
     /** Updated session after all auto-step state writes. */
@@ -192,10 +186,24 @@ export class AutoChainExecutor<TContext = unknown, TData = unknown> {
 
                 // STEP 5: position-changing directive (goToStep, goTo, complete)
                 if (merged.goToStep) {
-                    const targetStep = flow.getStep(merged.goToStep);
+                    // String form targets the current flow; object form carrying
+                    // a different `flow` defers to the pipeline for cross-flow
+                    // resolution (same as goTo).
+                    const goTarget = typeof merged.goToStep === "string"
+                        ? { step: merged.goToStep, flowId: undefined }
+                        : { step: merged.goToStep.step, flowId: merged.goToStep.flow };
+                    if (goTarget.flowId && goTarget.flowId !== flow.id) {
+                        return {
+                            resolvedStep: step,
+                            mergedDirective: merged,
+                            stoppedReason: 'goto',
+                            session,
+                        };
+                    }
+                    const targetStep = flow.getStep(goTarget.step);
                     if (!targetStep) {
                         throw new FlowConfigurationError(
-                            `[FlowConfigurationError] Auto-step "${step.id}" goToStep targets unknown step: "${merged.goToStep}" does not exist in the current flow. ` +
+                            `[FlowConfigurationError] Auto-step "${step.id}" goToStep targets unknown step: "${goTarget.step}" does not exist in the current flow. ` +
                             `Check the step id or use goTo to target a different flow.`
                         );
                     }
@@ -263,26 +271,15 @@ export class AutoChainExecutor<TContext = unknown, TData = unknown> {
     }
 
     /**
-     * Run onEnter and prepare hooks for an auto-step, collecting any
+     * Run the prepare hook for an auto-step, collecting any
      * Directive return values (pre-LLM fields honored).
      */
     private async runStepHooks(
         step: Step<TContext, TData>,
         session: SessionState<TData>,
         context: TContext
-    ): Promise<AutoStepPrepareResult | undefined> {
-        let merged: AutoStepPrepareResult | undefined;
-
-        // onEnter (future hook — not yet in StepOptions, but handle if present)
-        const stepWithHooks = step as Step<TContext, TData> & {
-            onEnter?: (context: TContext, data: Partial<TData> | undefined) => Promise<unknown>;
-        };
-        if (typeof stepWithHooks.onEnter === 'function') {
-            const onEnterResult = await stepWithHooks.onEnter(context, session.data);
-            if (onEnterResult && typeof onEnterResult === 'object') {
-                merged = this.mergeDirectives(merged, onEnterResult as AutoStepPrepareResult);
-            }
-        }
+    ): Promise<AutoStepPrepareResult<TContext, TData> | undefined> {
+        let merged: AutoStepPrepareResult<TContext, TData> | undefined;
 
         // prepare hook — for auto-steps, prepare may return a Directive with pre-LLM fields
         if (step.prepare) {
@@ -296,7 +293,7 @@ export class AutoChainExecutor<TContext = unknown, TData = unknown> {
                 );
                 // prepare may return void or a directive-like object
                 if (prepareResult && typeof prepareResult === 'object') {
-                    merged = this.mergeDirectives(merged, prepareResult as AutoStepPrepareResult);
+                    merged = this.mergeDirectives(merged, prepareResult as AutoStepPrepareResult<TContext, TData>);
                 }
             } else {
                 // Tool reference (string or Tool object) — for auto-steps, tool-based
@@ -312,27 +309,17 @@ export class AutoChainExecutor<TContext = unknown, TData = unknown> {
     }
 
     /**
-     * Merge two directive-like objects. Later values override earlier ones
-     * for scalar fields; object fields (dataUpdate, contextUpdate) are deep-merged.
+     * Merge two directive-like objects via the canonical Algorithm 4 merge —
+     * one algorithm shared with tools, hooks and signals.
      */
     private mergeDirectives(
-        base: AutoStepPrepareResult | undefined,
-        incoming: AutoStepPrepareResult
-    ): AutoStepPrepareResult {
+        base: AutoStepPrepareResult<TContext, TData> | undefined,
+        incoming: AutoStepPrepareResult<TContext, TData>
+    ): AutoStepPrepareResult<TContext, TData> {
         if (!base) return { ...incoming };
-        return {
-            dataUpdate: incoming.dataUpdate
-                ? { ...(base.dataUpdate || {}), ...incoming.dataUpdate }
-                : base.dataUpdate,
-            contextUpdate: incoming.contextUpdate
-                ? { ...(base.contextUpdate || {}), ...incoming.contextUpdate }
-                : base.contextUpdate,
-            halt: incoming.halt ?? base.halt,
-            reply: incoming.reply ?? base.reply,
-            goTo: incoming.goTo ?? base.goTo,
-            goToStep: incoming.goToStep ?? base.goToStep,
-            complete: incoming.complete ?? base.complete,
-        };
+        // AutoStepPrepareResult is a structural subset of Directive, so both
+        // sides flow through the canonical merge directly — no casts needed.
+        return flow.merge<TContext, TData>(base, incoming);
     }
 
     /**

package/src/core/BranchEvaluator.ts

@@ -12,11 +12,11 @@ import type {
     BranchMap,
     BranchPredicateContext,
     Directive,
-} from "../types/flow";
-import type { AiProvider } from "../types/ai";
-import type { Event } from "../types/history";
-import { eventsToHistory, logger } from "../utils";
-import { splitWhenConditions, evaluateIfPredicates, type WhenConditionGroups } from "../utils/condition";
+} from "../types/flow.js";
+import type { AiProvider } from "../types/ai.js";
+import type { Event } from "../types/history.js";
+import { eventsToHistory, logger } from "../utils/index.js";
+import { splitWhenConditions, evaluateIfPredicates, type WhenConditionGroups } from "../utils/condition.js";
 
 /**
  * The AI condition evaluator function signature.

package/src/core/CompactionEngine.ts

@@ -9,8 +9,8 @@
  */
 
 import log from "loglevel";
-import type { HistoryItem } from "../types/history";
-import type { CompactionOptions, CompactionResult } from "../types/compaction";
+import type { HistoryItem } from "../types/history.js";
+import type { CompactionOptions, CompactionResult } from "../types/compaction.js";
 
 export class CompactionEngine {
     /**
@@ -180,6 +180,27 @@ export class CompactionEngine {
         }
     }
 
+    /**
+     * Adjust the left edge of a preserved window so it never begins with an
+     * orphaned tool result — a role:'tool' message whose assistant tool_calls
+     * parent lies outside the window. Providers reject such histories at the
+     * next request.
+     *
+     * The preserve count is a target, not a hard guarantee: when the naive
+     * message-count boundary would split an assistant/tool pair, the window
+     * grows left just enough to keep the pair together.
+     */
+    private static alignPreserveStart(
+        history: HistoryItem[],
+        start: number
+    ): number {
+        let aligned = Math.max(0, Math.min(start, history.length));
+        while (aligned > 0 && history[aligned].role === "tool") {
+            aligned--;
+        }
+        return aligned;
+    }
+
     /**
      * Aggressive truncation fallback: remove oldest messages (no LLM needed).
      * Keeps only the most recent messages that fit within the token budget.
@@ -191,11 +212,16 @@ export class CompactionEngine {
         const threshold = options.maxTokens * options.compactionThreshold;
         const preserveCount = options.preserveRecentCount;
 
-        // Always preserve the last preserveRecentCount messages
-        const preserved = history.slice(-preserveCount);
+        // Always preserve the last ~preserveRecentCount messages (aligned so
+        // the window never opens on an orphaned tool result)
+        const preserveStart = CompactionEngine.alignPreserveStart(
+            history,
+            Math.max(0, history.length - preserveCount)
+        );
+        const preserved = history.slice(preserveStart);
 
         // Try to keep as many older messages as fit within budget
-        const older = history.slice(0, -preserveCount);
+        const older = history.slice(0, preserveStart);
         const result: HistoryItem[] = [];
 
         // Add older messages from most recent backwards until we'd exceed budget
@@ -219,7 +245,9 @@ export class CompactionEngine {
      * Layer 3 (micro_compact): Compress verbose tool outputs inline
      * Layer 4 (auto_compact): Summarize old messages via LLM provider
      *
-     * The last `preserveRecentCount` messages are NEVER modified or removed.
+     * The last `preserveRecentCount` messages are NEVER modified or removed
+     * (the preserved window may extend slightly further left so it never
+     * splits an assistant/tool pair at its boundary).
      */
     static async checkAndCompact(
         history: HistoryItem[],
@@ -277,8 +305,14 @@ export class CompactionEngine {
         }
 
         // Layer 4: Auto-compact (summarize old messages via LLM)
-        const oldMessages = microCompacted.slice(0, -preserveCount);
-        const recentMessages = microCompacted.slice(-preserveCount);
+        // preserveRecentCount is a target, not a hard guarantee: the window's
+        // left edge is aligned so it never opens on an orphaned tool result.
+        const preserveStart = CompactionEngine.alignPreserveStart(
+            microCompacted,
+            Math.max(0, microCompacted.length - preserveCount)
+        );
+        const oldMessages = microCompacted.slice(0, preserveStart);
+        const recentMessages = microCompacted.slice(preserveStart);
 
         const summary = await CompactionEngine.summarizeMessages(
             oldMessages,

package/src/core/DirectiveChainTracker.ts

@@ -12,9 +12,9 @@
  * Validates: Requirements 22.1, 22.2, 22.3
  */
 
-import { FlowConfigurationError } from "./Step";
-import { logger } from "../utils";
-import type { Directive } from "../types/flow";
+import { FlowConfigurationError } from "./Step.js";
+import { logger } from "../utils/index.js";
+import type { Directive } from "../types/flow.js";
 
 /**
  * Entry in the directive chain log — records what was emitted and by whom.

package/src/core/Events.ts

@@ -11,8 +11,8 @@ import type {
   MessageData,
   HistoryItem,
   History,
-} from "../types";
-import { EventKind, MessageRole } from "../types";
+} from "../types/index.js";
+import { EventKind, MessageRole } from "../types/index.js";
 
 /**
  * Convert a simple JSON history message to an internal Event

package/src/core/Flow.ts

@@ -13,16 +13,16 @@ import type {
   TemplateContext,
   ConditionEvaluationResult,
   Directive,
-} from "../types";
-import type { SessionState } from "../types/session";
-import type { StepResult } from "../types/flow";
-import type { ConditionWhen, ConditionIf } from "../types/flow";
+} from "../types/index.js";
+import type { SessionState } from "../types/session.js";
+import type { StepResult } from "../types/flow.js";
+import type { ConditionWhen, ConditionIf } from "../types/flow.js";
 
-import { generateFlowId, logger } from "../utils";
-import { splitWhenConditions } from "../utils/condition";
+import { generateFlowId, logger } from "../utils/index.js";
+import { splitWhenConditions } from "../utils/condition.js";
 
-import { Step, FlowConfigurationError } from "./Step";
-import { Agent } from './Agent'
+import { Step, FlowConfigurationError } from "./Step.js";
+import { Agent } from './Agent.js'
 
 /**
  * Represents a conversational flow/journey
@@ -647,7 +647,7 @@ export class Flow<TContext = unknown, TData = unknown> {
         context: context as TContext,
         data: session.data ?? {} as Partial<TData>,
         session: {} as SessionState<TData>,
-        history: [] as import("../types/history").Event[],
+        history: [] as import("../types/history.js").Event[],
         dispatch: () => { },
       };
       const result = await this.hooks.onComplete(hookCtx);