@ai-setting/roy-agent-core 1.5.36 → 1.5.40

package/dist/shared/@ai-setting/{roy-agent-core-c2wjwx16.js → roy-agent-core-c8f2hync.js}

@@ -5,26 +5,29 @@ import {
 import {
   ContextError
 } from "./roy-agent-core-ctdhjv68.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   globalHookManager
-} from "./roy-agent-core-86gphny5.js";
-import {
-  SessionMessageConverter
-} from "./roy-agent-core-jfh9q2qh.js";
+} from "./roy-agent-core-jqy2mdyq.js";
 import {
-  TracedAs,
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
+  runWithEnvContextAsync
+} from "./roy-agent-core-z33en0cz.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  SessionMessageConverter
+} from "./roy-agent-core-7b35emr7.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
@@ -463,195 +466,85 @@ class AgentComponent extends BaseComponent {
         logger.warn(`Failed to load session history: ${err}`);
       }
     }
-    this.pushEnvEvent({
-      type: "agent.start",
-      payload: {
-        sessionId: effectiveContext.sessionId,
-        model: effectiveContext.model
-      }
-    });
-    this.pushMessage(hookCtx, {
-      role: "user",
-      content: query
-    });
-    await this.executePluginHooks(agent, "agent:before.start", hookCtx);
-    if (hookCtx._stopped) {
-      return this.finalizeResult(result, hookCtx);
-    }
-    let iteration = 0;
-    let finalText;
-    while (iteration < agent.config.maxIterations) {
+    const envContext = {
+      traceId: effectiveContext.metadata?.traceId,
+      sessionId: effectiveContext.sessionId,
+      userId: effectiveContext.metadata?.userId,
+      messageId: effectiveContext.metadata?.messageId,
+      pluginEnabled: effectiveContext.pluginEnabled,
+      plugins: effectiveContext.plugins,
+      envEvent: effectiveContext.envEvent,
+      replyChannel: effectiveContext.envEvent?.metadata?.replyChannel,
+      sourceId: effectiveContext.envEvent?.metadata?.sourceId,
+      sourceType: effectiveContext.envEvent?.metadata?.sourceType,
+      metadata: { ...effectiveContext.metadata }
+    };
+    return await runWithEnvContextAsync(envContext, async () => {
+      this.pushEnvEvent({
+        type: "agent.start",
+        payload: {
+          sessionId: effectiveContext.sessionId,
+          model: effectiveContext.model
+        }
+      });
+      this.pushMessage(hookCtx, {
+        role: "user",
+        content: query
+      });
+      await this.executePluginHooks(agent, "agent:before.start", hookCtx);
       if (hookCtx._stopped) {
-        break;
-      }
-      if (this.aborted.get(runId)) {
-        hookCtx._stopped = true;
-        hookCtx._stopReason = "aborted";
-        break;
-      }
-      if (effectiveContext.abort?.aborted) {
-        hookCtx._stopped = true;
-        hookCtx._stopReason = "abort_signal";
-        break;
+        return this.finalizeResult(result, hookCtx);
       }
-      iteration++;
-      hookCtx.iteration = iteration;
-      result.iterations = iteration;
-      logger.debug(`Iteration ${iteration} started`);
-      this.doomLoopCaches.set(runId, new Map);
-      hookCtx.maxIterations = agent.config.maxIterations;
-      try {
-        logger.debug(`[ReAct] Iteration ${iteration} buildMessages result: ${hookCtx.messages.length} messages`);
-        await this.executePluginHooks(agent, "agent:before.llm", hookCtx);
-        if (hookCtx._stopped)
+      let iteration = 0;
+      let finalText;
+      while (iteration < agent.config.maxIterations) {
+        if (hookCtx._stopped) {
           break;
-        const llmOutput = await this.invokeLLM(hookCtx);
-        hookCtx.llmOutput = llmOutput;
-        if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+        }
+        if (this.aborted.get(runId)) {
           hookCtx._stopped = true;
           hookCtx._stopReason = "aborted";
           break;
         }
-        await this.executePluginHooks(agent, "agent:after.llm", hookCtx);
-        if (hookCtx._stopped)
+        if (effectiveContext.abort?.aborted) {
+          hookCtx._stopped = true;
+          hookCtx._stopReason = "abort_signal";
           break;
-        if (llmOutput.content && !llmOutput.toolCalls?.length) {
+        }
+        iteration++;
+        hookCtx.iteration = iteration;
+        result.iterations = iteration;
+        logger.debug(`Iteration ${iteration} started`);
+        this.doomLoopCaches.set(runId, new Map);
+        hookCtx.maxIterations = agent.config.maxIterations;
+        try {
+          logger.debug(`[ReAct] Iteration ${iteration} buildMessages result: ${hookCtx.messages.length} messages`);
+          await this.executePluginHooks(agent, "agent:before.llm", hookCtx);
+          if (hookCtx._stopped)
+            break;
+          const llmOutput = await this.invokeLLM(hookCtx);
+          hookCtx.llmOutput = llmOutput;
           if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
             hookCtx._stopped = true;
             hookCtx._stopReason = "aborted";
             break;
           }
-          finalText = llmOutput.content;
-          this.pushMessage(hookCtx, {
-            role: "assistant",
-            content: llmOutput.content
-          });
-          break;
-        }
-        if (llmOutput.toolCalls?.length) {
-          const assistantParts = [];
-          if (llmOutput.content) {
-            assistantParts.push({
-              type: "text",
-              text: llmOutput.content
-            });
-          }
-          if (llmOutput.reasoning) {
-            assistantParts.push({
-              type: "reasoning",
-              text: llmOutput.reasoning,
-              reasoningType: "core"
-            });
-          }
-          for (const tc of llmOutput.toolCalls) {
-            let argsStr = "";
-            let argsObj = {};
-            if (tc.function?.arguments) {
-              if (typeof tc.function.arguments === "string") {
-                argsStr = tc.function.arguments;
-                try {
-                  argsObj = JSON.parse(argsStr);
-                } catch {
-                  argsObj = { _raw: argsStr };
-                }
-              } else {
-                argsObj = tc.function.arguments;
-                argsStr = JSON.stringify(argsObj);
-              }
-            } else if (tc.arguments) {
-              if (typeof tc.arguments === "string") {
-                argsStr = tc.arguments;
-                try {
-                  argsObj = JSON.parse(argsStr);
-                } catch {
-                  argsObj = { _raw: argsStr };
-                }
-              } else {
-                argsObj = tc.arguments;
-                argsStr = JSON.stringify(argsObj);
-              }
-            }
-            assistantParts.push({
-              type: "tool-call",
-              toolCallId: tc.id,
-              toolName: tc.function?.name || tc.name || "unknown",
-              input: argsObj,
-              toolCall: {
-                name: tc.function?.name || tc.name || "unknown",
-                arguments: argsStr
-              }
-            });
-          }
-          const assistantContent = llmOutput.content?.substring(0, 80) || "(no text)";
-          const toolCallNames = llmOutput.toolCalls?.map((tc) => tc.function?.name || tc.name).join(", ") || "none";
-          logger.debug(`[ReAct] Iteration ${iteration} Adding assistant message: text="${assistantContent}" toolCalls=[${toolCallNames}]`);
-          this.pushMessage(hookCtx, {
-            role: "assistant",
-            content: assistantParts
-          });
-          const allToolCalls = llmOutput.toolCalls;
-          let processedCount = 0;
-          for (const toolCall of allToolCalls) {
+          await this.executePluginHooks(agent, "agent:after.llm", hookCtx);
+          if (hookCtx._stopped)
+            break;
+          if (llmOutput.content && !llmOutput.toolCalls?.length) {
             if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
               hookCtx._stopped = true;
               hookCtx._stopReason = "aborted";
-              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted");
-              break;
-            }
-            const func = toolCall.function;
-            const tcName = func?.name || toolCall.name || "unknown";
-            const tcArgs = func?.arguments ? typeof func.arguments === "string" ? JSON.parse(func.arguments) : func.arguments : toolCall.arguments;
-            hookCtx.currentToolCall = {
-              id: toolCall.id,
-              name: tcName,
-              arguments: tcArgs
-            };
-            const doomKey = `${tcName}:${JSON.stringify(tcArgs)}`;
-            const agentCache = this.doomLoopCaches.get(runId) || new Map;
-            const doomCount = agentCache.get(doomKey) || 0;
-            if (doomCount >= agent.config.doomLoopThreshold) {
-              hookCtx.error = new Error(`Doom loop detected: ${tcName}`);
-              await this.executePluginHooks(agent, "on.error", hookCtx);
-              result.error = hookCtx.error.message;
-              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted: Doom loop detected");
               break;
             }
-            agentCache.set(doomKey, doomCount + 1);
-            this.doomLoopCaches.set(runId, agentCache);
-            await this.executePluginHooks(agent, "agent:before.tool", hookCtx);
-            if (hookCtx._stopped) {
-              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted by plugin hook");
-              break;
-            }
-            const toolResult = await this.executeTool(hookCtx);
-            hookCtx.toolResult = toolResult;
-            await this.executePluginHooks(agent, "agent:after.tool", hookCtx);
-            if (hookCtx._stopped) {
-              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount + 1, "Execution aborted by plugin hook");
-              break;
-            }
-            const toolOutput = toolResult.success ? toolResult.result.output || "" : toolResult.result.error || "Unknown error";
-            const toolOutputPreview = typeof toolOutput === "string" ? toolOutput.substring(0, 50) : JSON.stringify(toolOutput).substring(0, 50);
-            logger.debug(`[ReAct] Iteration ${iteration} Adding tool message: tool=${toolResult.name} output="${toolOutputPreview}..."`);
+            finalText = llmOutput.content;
             this.pushMessage(hookCtx, {
-              role: "tool",
-              content: [{
-                type: "tool-result",
-                toolCallId: hookCtx.currentToolCall.id,
-                toolName: toolResult.name,
-                output: toolOutput
-              }]
+              role: "assistant",
+              content: llmOutput.content
             });
-            result.toolCalls.push(hookCtx.currentToolCall);
-            processedCount++;
+            break;
           }
-          await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
-        }
-      } catch (error) {
-        logger.error(`Iteration ${iteration} error`, { error });
-        hookCtx.error = error instanceof Error ? error : new Error(String(error));
-        if (error instanceof Error && error instanceof ContextError && error.llmOutput) {
-          const llmOutput = error.llmOutput;
           if (llmOutput.toolCalls?.length) {
             const assistantParts = [];
             if (llmOutput.content) {
@@ -668,152 +561,277 @@ class AgentComponent extends BaseComponent {
               });
             }
             for (const tc of llmOutput.toolCalls) {
+              let argsStr = "";
+              let argsObj = {};
+              if (tc.function?.arguments) {
+                if (typeof tc.function.arguments === "string") {
+                  argsStr = tc.function.arguments;
+                  try {
+                    argsObj = JSON.parse(argsStr);
+                  } catch {
+                    argsObj = { _raw: argsStr };
+                  }
+                } else {
+                  argsObj = tc.function.arguments;
+                  argsStr = JSON.stringify(argsObj);
+                }
+              } else if (tc.arguments) {
+                if (typeof tc.arguments === "string") {
+                  argsStr = tc.arguments;
+                  try {
+                    argsObj = JSON.parse(argsStr);
+                  } catch {
+                    argsObj = { _raw: argsStr };
+                  }
+                } else {
+                  argsObj = tc.arguments;
+                  argsStr = JSON.stringify(argsObj);
+                }
+              }
               assistantParts.push({
                 type: "tool-call",
                 toolCallId: tc.id,
                 toolName: tc.function?.name || tc.name || "unknown",
-                input: typeof tc.function?.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.arguments || {}
+                input: argsObj,
+                toolCall: {
+                  name: tc.function?.name || tc.name || "unknown",
+                  arguments: argsStr
+                }
               });
             }
+            const assistantContent = llmOutput.content?.substring(0, 80) || "(no text)";
+            const toolCallNames = llmOutput.toolCalls?.map((tc) => tc.function?.name || tc.name).join(", ") || "none";
+            logger.debug(`[ReAct] Iteration ${iteration} Adding assistant message: text="${assistantContent}" toolCalls=[${toolCallNames}]`);
             this.pushMessage(hookCtx, {
               role: "assistant",
               content: assistantParts
             });
-          } else if (llmOutput.content) {
-            const assistantParts = [];
-            if (llmOutput.content) {
-              assistantParts.push({
-                type: "text",
-                text: llmOutput.content
-              });
-            }
-            if (llmOutput.reasoning) {
-              assistantParts.push({
-                type: "reasoning",
-                text: llmOutput.reasoning,
-                reasoningType: "core"
-              });
-            }
-            this.pushMessage(hookCtx, {
-              role: "assistant",
-              content: assistantParts.length > 0 ? assistantParts : llmOutput.content
-            });
-          }
-        }
-        await this.executePluginHooks(agent, "agent:on.error", hookCtx);
-        if (!hookCtx._stopped) {
-          hookCtx._stopped = true;
-          if (error instanceof AskUserError) {
-            hookCtx._stopReason = "ask-user";
-            if (hookCtx.currentToolCall) {
+            const allToolCalls = llmOutput.toolCalls;
+            let processedCount = 0;
+            for (const toolCall of allToolCalls) {
+              if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+                hookCtx._stopped = true;
+                hookCtx._stopReason = "aborted";
+                this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted");
+                break;
+              }
+              const func = toolCall.function;
+              const tcName = func?.name || toolCall.name || "unknown";
+              const tcArgs = func?.arguments ? typeof func.arguments === "string" ? JSON.parse(func.arguments) : func.arguments : toolCall.arguments;
+              hookCtx.currentToolCall = {
+                id: toolCall.id,
+                name: tcName,
+                arguments: tcArgs
+              };
+              const doomKey = `${tcName}:${JSON.stringify(tcArgs)}`;
+              const agentCache = this.doomLoopCaches.get(runId) || new Map;
+              const doomCount = agentCache.get(doomKey) || 0;
+              if (doomCount >= agent.config.doomLoopThreshold) {
+                hookCtx.error = new Error(`Doom loop detected: ${tcName}`);
+                await this.executePluginHooks(agent, "on.error", hookCtx);
+                result.error = hookCtx.error.message;
+                this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted: Doom loop detected");
+                break;
+              }
+              agentCache.set(doomKey, doomCount + 1);
+              this.doomLoopCaches.set(runId, agentCache);
+              await this.executePluginHooks(agent, "agent:before.tool", hookCtx);
+              if (hookCtx._stopped) {
+                this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted by plugin hook");
+                break;
+              }
+              const toolResult = await this.executeTool(hookCtx);
+              hookCtx.toolResult = toolResult;
+              await this.executePluginHooks(agent, "agent:after.tool", hookCtx);
+              if (hookCtx._stopped) {
+                this.addRemainingToolResults(hookCtx, allToolCalls, processedCount + 1, "Execution aborted by plugin hook");
+                break;
+              }
+              const toolOutput = toolResult.success ? toolResult.result.output || "" : toolResult.result.error || "Unknown error";
+              const toolOutputPreview = typeof toolOutput === "string" ? toolOutput.substring(0, 50) : JSON.stringify(toolOutput).substring(0, 50);
+              logger.debug(`[ReAct] Iteration ${iteration} Adding tool message: tool=${toolResult.name} output="${toolOutputPreview}..."`);
               this.pushMessage(hookCtx, {
                 role: "tool",
                 content: [{
                   type: "tool-result",
                   toolCallId: hookCtx.currentToolCall.id,
-                  toolName: "ask_user",
-                  output: JSON.stringify({
-                    error: "AskUserError",
-                    query: error.query,
-                    message: error.message
-                  })
+                  toolName: toolResult.name,
+                  output: toolOutput
                 }]
               });
+              result.toolCalls.push(hookCtx.currentToolCall);
+              processedCount++;
             }
-            const errorInfo = {
-              query: error.query,
-              sessionId: error.sessionId,
-              nodeId: error.nodeId,
-              nodeType: error.nodeType
-            };
-            result.error = `__ASK_USER_ERROR__:${JSON.stringify(errorInfo)}`;
-          } else {
-            result.error = hookCtx.error.message;
-            if (error?.name === "AbortError") {
-              hookCtx._stopReason = hookCtx._stopReason || "aborted";
+            await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
+          }
+        } catch (error) {
+          logger.error(`Iteration ${iteration} error`, { error });
+          hookCtx.error = error instanceof Error ? error : new Error(String(error));
+          if (error instanceof Error && error instanceof ContextError && error.llmOutput) {
+            const llmOutput = error.llmOutput;
+            if (llmOutput.toolCalls?.length) {
+              const assistantParts = [];
+              if (llmOutput.content) {
+                assistantParts.push({
+                  type: "text",
+                  text: llmOutput.content
+                });
+              }
+              if (llmOutput.reasoning) {
+                assistantParts.push({
+                  type: "reasoning",
+                  text: llmOutput.reasoning,
+                  reasoningType: "core"
+                });
+              }
+              for (const tc of llmOutput.toolCalls) {
+                assistantParts.push({
+                  type: "tool-call",
+                  toolCallId: tc.id,
+                  toolName: tc.function?.name || tc.name || "unknown",
+                  input: typeof tc.function?.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.arguments || {}
+                });
+              }
+              this.pushMessage(hookCtx, {
+                role: "assistant",
+                content: assistantParts
+              });
+            } else if (llmOutput.content) {
+              const assistantParts = [];
+              if (llmOutput.content) {
+                assistantParts.push({
+                  type: "text",
+                  text: llmOutput.content
+                });
+              }
+              if (llmOutput.reasoning) {
+                assistantParts.push({
+                  type: "reasoning",
+                  text: llmOutput.reasoning,
+                  reasoningType: "core"
+                });
+              }
+              this.pushMessage(hookCtx, {
+                role: "assistant",
+                content: assistantParts.length > 0 ? assistantParts : llmOutput.content
+              });
+            }
+          }
+          await this.executePluginHooks(agent, "agent:on.error", hookCtx);
+          if (!hookCtx._stopped) {
+            hookCtx._stopped = true;
+            if (error instanceof AskUserError) {
+              hookCtx._stopReason = "ask-user";
+              if (hookCtx.currentToolCall) {
+                this.pushMessage(hookCtx, {
+                  role: "tool",
+                  content: [{
+                    type: "tool-result",
+                    toolCallId: hookCtx.currentToolCall.id,
+                    toolName: "ask_user",
+                    output: JSON.stringify({
+                      error: "AskUserError",
+                      query: error.query,
+                      message: error.message
+                    })
+                  }]
+                });
+              }
+              const errorInfo = {
+                query: error.query,
+                sessionId: error.sessionId,
+                nodeId: error.nodeId,
+                nodeType: error.nodeType
+              };
+              result.error = `__ASK_USER_ERROR__:${JSON.stringify(errorInfo)}`;
             } else {
-              hookCtx._stopReason = "error";
+              result.error = hookCtx.error.message;
+              if (error?.name === "AbortError") {
+                hookCtx._stopReason = hookCtx._stopReason || "aborted";
+              } else {
+                hookCtx._stopReason = "error";
+              }
+              if (hookCtx.currentToolCall) {
+                this.pushMessage(hookCtx, {
+                  role: "tool",
+                  content: [{
+                    type: "tool-result",
+                    toolCallId: hookCtx.currentToolCall.id,
+                    toolName: hookCtx.currentToolCall.name,
+                    output: JSON.stringify({ error: hookCtx.error.message })
+                  }]
+                });
+              }
             }
+          } else {
+            result.error = hookCtx.error.message;
             if (hookCtx.currentToolCall) {
+              const errorMsg = hookCtx.error?.message || "Execution interrupted";
               this.pushMessage(hookCtx, {
                 role: "tool",
                 content: [{
                   type: "tool-result",
                   toolCallId: hookCtx.currentToolCall.id,
                   toolName: hookCtx.currentToolCall.name,
-                  output: JSON.stringify({ error: hookCtx.error.message })
+                  output: JSON.stringify({ error: errorMsg })
                 }]
               });
             }
           }
-        } else {
-          result.error = hookCtx.error.message;
-          if (hookCtx.currentToolCall) {
-            const errorMsg = hookCtx.error?.message || "Execution interrupted";
-            this.pushMessage(hookCtx, {
-              role: "tool",
-              content: [{
-                type: "tool-result",
-                toolCallId: hookCtx.currentToolCall.id,
-                toolName: hookCtx.currentToolCall.name,
-                output: JSON.stringify({ error: errorMsg })
-              }]
-            });
-          }
+          break;
         }
-        break;
       }
-    }
-    result.finalText = finalText;
-    if (iteration >= agent.config.maxIterations && !result.finalText) {
-      result.finalText = "Maximum iterations reached.";
-    }
-    const reactContext = {
-      messages: hookCtx.messages,
-      sessionId: effectiveContext.sessionId,
-      summary: result.finalText
-    };
-    await this.executePluginHooks(agent, "agent:after.react", {
-      ...hookCtx,
-      ...reactContext
-    });
-    await this.executePluginHooks(agent, "agent:after.complete", hookCtx);
-    if (this.aborted.get(runId) === true || hookCtx._stopped) {
-      agent.status = "stopped";
-    } else {
-      agent.status = "idle";
-    }
-    this.aborted.delete(runId);
-    this.abortControllers.delete(runId);
-    if (result.error) {
-      this.pushEnvEvent({
-        type: "agent.error",
-        payload: {
-          error: result.error,
-          iterations: result.iterations,
-          stopReason: result.stopReason
-        }
+      result.finalText = finalText;
+      if (iteration >= agent.config.maxIterations && !result.finalText) {
+        result.finalText = "Maximum iterations reached.";
+      }
+      const reactContext = {
+        messages: hookCtx.messages,
+        sessionId: effectiveContext.sessionId,
+        summary: result.finalText
+      };
+      await this.executePluginHooks(agent, "agent:after.react", {
+        ...hookCtx,
+        ...reactContext
       });
-    } else {
-      this.pushEnvEvent({
-        type: "agent.completed",
-        payload: {
-          finalText: result.finalText,
-          iterations: result.iterations,
-          stopReason: result.stopReason
-        }
+      await this.executePluginHooks(agent, "agent:after.complete", hookCtx);
+      if (this.aborted.get(runId) === true || hookCtx._stopped) {
+        agent.status = "stopped";
+      } else {
+        agent.status = "idle";
+      }
+      this.aborted.delete(runId);
+      this.abortControllers.delete(runId);
+      if (result.error) {
+        this.pushEnvEvent({
+          type: "agent.error",
+          payload: {
+            error: result.error,
+            iterations: result.iterations,
+            stopReason: result.stopReason
+          }
+        });
+      } else {
+        this.pushEnvEvent({
+          type: "agent.completed",
+          payload: {
+            finalText: result.finalText,
+            iterations: result.iterations,
+            stopReason: result.stopReason
+          }
+        });
+      }
+      let newMessages = hookCtx.messages.slice(historyMessageCount);
+      logger.info(`Agent run completed: ${agentName}`, {
+        iterations: result.iterations,
+        hasError: !!result.error,
+        hookCtxMessages: hookCtx.messages.length,
+        historyMessageCount,
+        sessionId: effectiveContext.sessionId
       });
-    }
-    let newMessages = hookCtx.messages.slice(historyMessageCount);
-    logger.info(`Agent run completed: ${agentName}`, {
-      iterations: result.iterations,
-      hasError: !!result.error,
-      hookCtxMessages: hookCtx.messages.length,
-      historyMessageCount,
-      sessionId: effectiveContext.sessionId
+      await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
+      return this.finalizeResult(result, hookCtx);
     });
-    await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
-    return this.finalizeResult(result, hookCtx);
   }
   abort(agentName) {
     for (const key of this.aborted.keys()) {