lemura 1.4.2 → 1.4.4

package/dist/index.mjs

@@ -1923,8 +1923,13 @@ ${block}` : block;
 var ContinuationPlanner = class {
   plan;
   outputs = /* @__PURE__ */ new Map();
-  constructor(plan) {
+  retryCount = /* @__PURE__ */ new Map();
+  onStepSkipped;
+  onStepFailed;
+  constructor(plan, callbacks) {
     this.plan = { ...plan, steps: plan.steps.map((s) => ({ ...s })) };
+    this.onStepSkipped = callbacks?.onStepSkipped;
+    this.onStepFailed = callbacks?.onStepFailed;
   }
   // -------------------------------------------------------------------------
   // State queries
@@ -2005,17 +2010,31 @@ var ContinuationPlanner = class {
   /**
    * Marks a step as failed and propagates `skipped` to all transitively dependent steps.
    */
-  markStepFailed(stepId) {
+  markStepFailed(stepId, reason = "step failed") {
     this._updateStep(stepId, { status: "failed" });
+    this.onStepFailed?.(stepId, reason);
     this._skipDependants(stepId);
   }
   /**
    * Marks a step as skipped (e.g., condition not met) and propagates to its dependants.
    */
-  markStepSkipped(stepId) {
+  markStepSkipped(stepId, reason = "condition not met") {
     this._updateStep(stepId, { status: "skipped" });
+    this.onStepSkipped?.(stepId, reason);
     this._skipDependants(stepId);
   }
+  /**
+   * Resets a step back to `pending` for a retry attempt.
+   * Increments the internal retry counter for the step.
+   */
+  markStepPending(stepId) {
+    this._updateStep(stepId, { status: "pending" });
+    this.retryCount.set(stepId, (this.retryCount.get(stepId) ?? 0) + 1);
+  }
+  /** Returns how many times a step has been retried. */
+  getRetryCount(stepId) {
+    return this.retryCount.get(stepId) ?? 0;
+  }
   // -------------------------------------------------------------------------
   // Output / input mapping helpers
   // -------------------------------------------------------------------------
@@ -2057,6 +2076,7 @@ var ContinuationPlanner = class {
       for (const step of this.plan.steps) {
         if (step.status === "pending" && step.dependsOn.some((d) => toSkip.has(d))) {
           this._updateStep(step.stepId, { status: "skipped" });
+          this.onStepSkipped?.(step.stepId, `dependency '${failedStepId}' failed or was skipped`);
           toSkip.add(step.stepId);
           changed = true;
         }
@@ -2585,6 +2605,21 @@ var SessionManager = class {
     }
     this.media = new MediaBridge(this.adapter);
     this.stepCounter = new StepCounter(config.maxSteps ?? 20);
+    if (config.maxSteps !== void 0 && config.maxIterations === void 0) {
+      const defaultMaxIts = 10;
+      if (config.maxSteps > defaultMaxIts) {
+        this.logger.warn(
+          `[Config] maxSteps=${config.maxSteps} is set but maxIterations is not. The default maxIterations=${defaultMaxIts} may stop the agent before maxSteps is reached. Consider setting maxIterations to at least Math.ceil(maxSteps / avgToolCallsPerTurn).`
+        );
+      }
+    }
+    if (config.maxSteps !== void 0 && config.maxIterations !== void 0) {
+      if (config.maxSteps > config.maxIterations * 10) {
+        this.logger.warn(
+          `[Config] maxSteps (${config.maxSteps}) is much larger than maxIterations (${config.maxIterations}). The agent will be stopped by maxIterations before maxSteps is ever reached.`
+        );
+      }
+    }
     this.toolResponseProcessor = config.toolResponseProcessor instanceof ToolResponseProcessor ? config.toolResponseProcessor : config.toolResponseProcessor ? config.toolResponseProcessor : new ToolResponseProcessor();
     for (const strategy of config.compressionStrategies || []) {
       this.contextManager.registerStrategy(strategy);
@@ -2784,16 +2819,39 @@ var SessionManager = class {
    * ```
    */
   setPlan(steps, strategy = "sequential") {
-    this.continuationPlanner = new ContinuationPlanner({
-      steps,
-      currentStepIndex: 0,
-      strategy
-    });
+    this.continuationPlanner = new ContinuationPlanner(
+      { steps, currentStepIndex: 0, strategy },
+      {
+        onStepFailed: (stepId, reason) => this.emitTrace("planning", "step_failed", { stepId, reason }),
+        onStepSkipped: (stepId, reason) => this.emitTrace("planning", "step_skipped", { stepId, reason })
+      }
+    );
     this.context.metadata["continuationPlan"] = this.continuationPlanner.getPlan();
     this.logger.debug(`[ContinuationPlanner] Plan set with ${steps.length} steps (strategy: ${strategy})`);
     this.emitTrace("planning", "plan_set", { stepCount: steps.length, strategy });
   }
   // -----------------------------------------------------------------------
+  // Plan inspection API
+  // -----------------------------------------------------------------------
+  /**
+   * Returns a snapshot of the current continuation plan, or `null` if no plan
+   * has been set via `setPlan()`.
+   *
+   * Use this after `run()` to inspect which steps completed, failed, or were skipped.
+   *
+   * @since 1.4.4
+   *
+   * @example
+   * ```typescript
+   * await session.run('Run the pipeline');
+   * const plan = session.getPlan();
+   * const failed = plan?.steps.filter(s => s.status === 'failed');
+   * ```
+   */
+  getPlan() {
+    return this.continuationPlanner ? this.continuationPlanner.getPlan() : null;
+  }
+  // -----------------------------------------------------------------------
   // Goal planning API
   // -----------------------------------------------------------------------
   /**
@@ -2885,7 +2943,7 @@ Respond ONLY with valid JSON (no markdown, no explanations):
       const response = await this.adapter.complete({
         model: this.config.model,
         messages: [{ role: "user", content: planningPrompt }],
-        maxTokens: this.config.maxCompletionTokens ?? 2e3
+        maxTokens: this.config.maxCompletionTokens ?? 4e3
       });
       const raw = response.content.replace(/```json|```/g, "").trim();
       const parsed = JSON.parse(raw);
@@ -3202,6 +3260,36 @@ ${planStatus}`;
         (s) => s.toolName === tc.name && s.status === "running"
       );
       if (runningStep) {
+        if (runningStep.verify) {
+          const maxRetries = runningStep.verify.maxRetries ?? 0;
+          const retryCount = this.continuationPlanner.getRetryCount(runningStep.stepId);
+          let verdict;
+          try {
+            verdict = await runningStep.verify.check(content, args);
+          } catch (verifyErr) {
+            verdict = { status: "fail", reason: `Verifier threw: ${verifyErr.message}` };
+          }
+          if (verdict.status === "fail" || verdict.status === "retry" && retryCount >= maxRetries) {
+            this.continuationPlanner.markStepFailed(runningStep.stepId);
+            this.context.metadata["continuationPlan"] = this.continuationPlanner.getPlan();
+            this.emitTrace("planning", "step_failed", {
+              stepId: runningStep.stepId,
+              reason: verdict.reason ?? "verifier returned fail",
+              retryCount
+            });
+            return content;
+          }
+          if (verdict.status === "retry") {
+            this.continuationPlanner.markStepPending(runningStep.stepId);
+            this.context.metadata["continuationPlan"] = this.continuationPlanner.getPlan();
+            this.emitTrace("planning", "step_retry", {
+              stepId: runningStep.stepId,
+              reason: verdict.reason,
+              retryCount: this.continuationPlanner.getRetryCount(runningStep.stepId)
+            });
+            return content;
+          }
+        }
         this.continuationPlanner.markStepDone(runningStep.stepId, content);
         if (runningStep.outputKey) {
           const outputs = this.context.metadata["toolOutputs"] ?? {};
@@ -3272,7 +3360,7 @@ ${planStatus}`;
     const maxIts = this.config.maxIterations || 10;
     this.iterations = 0;
     this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
-    const maxCompletionTokens = this.config.maxCompletionTokens ?? 2e3;
+    const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
     while (this.iterations < maxIts) {
       this.iterations++;
       this.logger.debug(`ReAct Iteration ${this.iterations}/${maxIts}`);
@@ -3469,7 +3557,7 @@ ${planStatus}`;
     const maxIts = this.config.maxIterations || 10;
     this.iterations = 0;
     this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
-    const maxCompletionTokens = this.config.maxCompletionTokens ?? 2e3;
+    const maxCompletionTokens = this.config.maxCompletionTokens ?? 4e3;
     while (this.iterations < maxIts) {
       this.iterations++;
       this.logger.debug(`[stream] ReAct Iteration ${this.iterations}/${maxIts}`);