@kb-labs/agent-entry 2.93.0 → 2.96.0

package/dist/rest/handlers/execute-session-plan-handler.js

@@ -1,4 +1,4 @@
-import { defineHandler, useAnalytics, useCache, useConfig, usePlatform } from '@kb-labs/sdk';
+import { defineHandler, useAnalytics, useCache, useConfig, rethrowForRest, usePlatform } from '@kb-labs/sdk';
 import { bootstrapAgentSDK, SessionManager, createSessionMemoryBridge, createCoreToolPack, PlanDocumentService } from '@kb-labs/agent-core';
 import fs, { promises } from 'fs';
 import { createDefaultResponseRequirementsSelector } from '@kb-labs/agent-runtime';
@@ -353,161 +353,165 @@ async function inferFollowUpWorkingDir(sessionManager, sessionId, baseWorkingDir
 }
 var run_handler_default = defineHandler({
   async execute(ctx, input) {
-    const body = input.body;
-    if (!body?.task) {
-      throw new Error("Task is required");
-    }
-    const analytics = useAnalytics();
-    const runId = RunManager.generateRunId();
-    const startTime = Date.now();
-    let sessionId = body.sessionId;
-    let workingDir = body.workingDir || ctx.cwd;
-    let sessionManager = new SessionManager(workingDir);
-    if (!sessionId) {
-      const session = await sessionManager.createSession({
-        mode: "execute",
-        task: body.task,
-        agentId: body.agentId ?? "orchestrator"
-      });
-      sessionId = session.id;
-      ctx.platform.logger.info(`[run-handler] Created new session ${sessionId}`);
-    } else {
-      const existingSession = await sessionManager.loadSession(sessionId);
-      let resolvedSession = existingSession;
-      if (!resolvedSession && pathExists(ctx.cwd)) {
-        const fallbackManager = new SessionManager(ctx.cwd);
-        const fallbackSession = await fallbackManager.loadSession(sessionId);
-        if (fallbackSession) {
-          sessionManager = fallbackManager;
-          resolvedSession = fallbackSession;
-        }
-      }
-      if (!resolvedSession) {
-        throw new Error(`Session not found: ${sessionId} (cwd=${ctx.cwd})`);
+    try {
+      const body = input.body;
+      if (!body?.task) {
+        throw new Error("Task is required");
       }
-      workingDir = body.workingDir || resolvedSession.workingDir || workingDir;
-      if (!body.workingDir && isLikelyFollowUpScopeTask(body.task)) {
-        const inferred = await inferFollowUpWorkingDir(sessionManager, sessionId, resolvedSession.workingDir || ctx.cwd);
-        if (inferred && inferred !== workingDir) {
-          ctx.platform.logger.info(`[run-handler] Follow-up scope inferred: ${workingDir} -> ${inferred}`);
-          workingDir = inferred;
+      const analytics = useAnalytics();
+      const runId = RunManager.generateRunId();
+      const startTime = Date.now();
+      let sessionId = body.sessionId;
+      let workingDir = body.workingDir || ctx.cwd;
+      let sessionManager = new SessionManager(workingDir);
+      if (!sessionId) {
+        const session = await sessionManager.createSession({
+          mode: "execute",
+          task: body.task,
+          agentId: body.agentId ?? "orchestrator"
+        });
+        sessionId = session.id;
+        ctx.platform.logger.info(`[run-handler] Created new session ${sessionId}`);
+      } else {
+        const existingSession = await sessionManager.loadSession(sessionId);
+        let resolvedSession = existingSession;
+        if (!resolvedSession && pathExists(ctx.cwd)) {
+          const fallbackManager = new SessionManager(ctx.cwd);
+          const fallbackSession = await fallbackManager.loadSession(sessionId);
+          if (fallbackSession) {
+            sessionManager = fallbackManager;
+            resolvedSession = fallbackSession;
+          }
         }
+        if (!resolvedSession) {
+          throw new Error(`Session not found: ${sessionId} (cwd=${ctx.cwd})`);
+        }
+        workingDir = body.workingDir || resolvedSession.workingDir || workingDir;
+        if (!body.workingDir && isLikelyFollowUpScopeTask(body.task)) {
+          const inferred = await inferFollowUpWorkingDir(sessionManager, sessionId, resolvedSession.workingDir || ctx.cwd);
+          if (inferred && inferred !== workingDir) {
+            ctx.platform.logger.info(`[run-handler] Follow-up scope inferred: ${workingDir} -> ${inferred}`);
+            workingDir = inferred;
+          }
+        }
+        sessionManager = new SessionManager(workingDir);
+        ctx.platform.logger.info(`[run-handler] Continuing session ${sessionId} (workingDir=${workingDir})`);
       }
-      sessionManager = new SessionManager(workingDir);
-      ctx.platform.logger.info(`[run-handler] Continuing session ${sessionId} (workingDir=${workingDir})`);
-    }
-    ctx.platform.logger.info(`[run-handler] Starting run ${runId} for task: ${body.task}`);
-    await sessionManager.createUserTurn(sessionId, body.task, runId);
-    await analytics?.track(AGENT_ANALYTICS_EVENTS.RUN_STARTED, {
-      runId,
-      sessionId,
-      taskLength: body.task.length,
-      tier: body.tier ?? "medium",
-      enableEscalation: body.enableEscalation ?? true,
-      responseMode: body.responseMode ?? "auto",
-      verbose: body.verbose ?? false
-    });
-    const sessionMemory = createSessionMemoryBridge(workingDir, sessionId);
-    const responseRequirementsSelector = createDefaultResponseRequirementsSelector();
-    const toolRegistry = createToolRegistry({
-      workingDir,
-      currentTask: body.task,
-      sessionId,
-      verbose: body.verbose,
-      cache: useCache(),
-      sessionMemory,
-      responseRequirementsResolver: async ({ task, kernel }) => responseRequirementsSelector.select({
-        state: kernel,
-        messages: [],
-        task: task ?? body.task
-      })
-    });
-    const agentsConfig = await useConfig();
-    const finalSessionId = sessionId;
-    const traceDir = path.join(workingDir, ".kb", "traces", "incremental");
-    const traceWriter = new IncrementalTraceWriter(runId, {}, traceDir);
-    const agent = new AgentSDK().register(createCoreToolPack(toolRegistry)).createRunner({
-      sessionId: finalSessionId,
-      workingDir,
-      maxIterations: 50,
-      temperature: 0.1,
-      tier: body.tier ?? "medium",
-      tokenBudget: agentsConfig?.tokenBudget,
-      onEvent: (event) => {
-        const seqEvent = RunManager.broadcast(runId, event);
-        void sessionManager.addEvent(finalSessionId, {
-          ...seqEvent,
-          sessionId: finalSessionId,
-          runId,
-          metadata: {
-            ...seqEvent.metadata,
+      ctx.platform.logger.info(`[run-handler] Starting run ${runId} for task: ${body.task}`);
+      await sessionManager.createUserTurn(sessionId, body.task, runId);
+      await analytics?.track(AGENT_ANALYTICS_EVENTS.RUN_STARTED, {
+        runId,
+        sessionId,
+        taskLength: body.task.length,
+        tier: body.tier ?? "medium",
+        enableEscalation: body.enableEscalation ?? true,
+        responseMode: body.responseMode ?? "auto",
+        verbose: body.verbose ?? false
+      });
+      const sessionMemory = createSessionMemoryBridge(workingDir, sessionId);
+      const responseRequirementsSelector = createDefaultResponseRequirementsSelector();
+      const toolRegistry = createToolRegistry({
+        workingDir,
+        currentTask: body.task,
+        sessionId,
+        verbose: body.verbose,
+        cache: useCache(),
+        sessionMemory,
+        responseRequirementsResolver: async ({ task, kernel }) => responseRequirementsSelector.select({
+          state: kernel,
+          messages: [],
+          task: task ?? body.task
+        })
+      });
+      const agentsConfig = await useConfig();
+      const finalSessionId = sessionId;
+      const traceDir = path.join(workingDir, ".kb", "traces", "incremental");
+      const traceWriter = new IncrementalTraceWriter(runId, {}, traceDir);
+      const agent = new AgentSDK().register(createCoreToolPack(toolRegistry)).createRunner({
+        sessionId: finalSessionId,
+        workingDir,
+        maxIterations: 50,
+        temperature: 0.1,
+        tier: body.tier ?? "medium",
+        tokenBudget: agentsConfig?.tokenBudget,
+        onEvent: (event) => {
+          const seqEvent = RunManager.broadcast(runId, event);
+          void sessionManager.addEvent(finalSessionId, {
+            ...seqEvent,
             sessionId: finalSessionId,
             runId,
-            workingDir
-          }
-        });
-      }
-    });
-    const run = await RunManager.register(runId, body.task, agent, sessionManager, finalSessionId);
-    await RunManager.updateStatus(runId, "running");
-    void (async () => {
-      try {
-        const result = await agent.execute(body.task);
-        const durationMs = Date.now() - startTime;
-        const detailedTrace = traceWriter.getEntries();
-        await traceWriter.finalize?.();
-        if (detailedTrace.length > 0) {
-          await sessionManager.storeTraceArtifacts(finalSessionId, runId, detailedTrace);
-        }
-        if (result.fileChanges && result.fileChanges.length > 0) {
-          await sessionManager.attachFileChangesToTurn(finalSessionId, runId, result.fileChanges);
+            metadata: {
+              ...seqEvent.metadata,
+              sessionId: finalSessionId,
+              runId,
+              workingDir
+            }
+          });
         }
-        await RunManager.updateStatus(runId, result.success ? "completed" : "failed", {
-          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          durationMs,
-          summary: result.summary,
-          error: result.error
-        });
-        await analytics?.track(
-          result.success ? AGENT_ANALYTICS_EVENTS.RUN_COMPLETED : AGENT_ANALYTICS_EVENTS.RUN_FAILED,
-          {
-            runId,
+      });
+      const run = await RunManager.register(runId, body.task, agent, sessionManager, finalSessionId);
+      await RunManager.updateStatus(runId, "running");
+      void (async () => {
+        try {
+          const result = await agent.execute(body.task);
+          const durationMs = Date.now() - startTime;
+          const detailedTrace = traceWriter.getEntries();
+          await traceWriter.finalize?.();
+          if (detailedTrace.length > 0) {
+            await sessionManager.storeTraceArtifacts(finalSessionId, runId, detailedTrace);
+          }
+          if (result.fileChanges && result.fileChanges.length > 0) {
+            await sessionManager.attachFileChangesToTurn(finalSessionId, runId, result.fileChanges);
+          }
+          await RunManager.updateStatus(runId, result.success ? "completed" : "failed", {
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
             durationMs,
-            success: result.success,
-            summary: result.summary?.slice(0, 200)
+            summary: result.summary,
+            error: result.error
+          });
+          await analytics?.track(
+            result.success ? AGENT_ANALYTICS_EVENTS.RUN_COMPLETED : AGENT_ANALYTICS_EVENTS.RUN_FAILED,
+            {
+              runId,
+              durationMs,
+              success: result.success,
+              summary: result.summary?.slice(0, 200)
+            }
+          );
+          ctx.platform.logger.info(`[run-handler] Run ${runId} completed: ${result.success}`);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          const durationMs = Date.now() - startTime;
+          const detailedTrace = traceWriter.getEntries();
+          await traceWriter.finalize?.();
+          if (detailedTrace.length > 0) {
+            await sessionManager.storeTraceArtifacts(finalSessionId, runId, detailedTrace);
           }
-        );
-        ctx.platform.logger.info(`[run-handler] Run ${runId} completed: ${result.success}`);
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        const durationMs = Date.now() - startTime;
-        const detailedTrace = traceWriter.getEntries();
-        await traceWriter.finalize?.();
-        if (detailedTrace.length > 0) {
-          await sessionManager.storeTraceArtifacts(finalSessionId, runId, detailedTrace);
+          await RunManager.updateStatus(runId, "failed", {
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            durationMs,
+            error: errorMsg
+          });
+          await analytics?.track(AGENT_ANALYTICS_EVENTS.RUN_FAILED, {
+            runId,
+            durationMs,
+            error: errorMsg.slice(0, 200)
+          });
+          ctx.platform.logger.error(`[run-handler] Run ${runId} failed: ${errorMsg}`);
         }
-        await RunManager.updateStatus(runId, "failed", {
-          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          durationMs,
-          error: errorMsg
-        });
-        await analytics?.track(AGENT_ANALYTICS_EVENTS.RUN_FAILED, {
-          runId,
-          durationMs,
-          error: errorMsg.slice(0, 200)
-        });
-        ctx.platform.logger.error(`[run-handler] Run ${runId} failed: ${errorMsg}`);
-      }
-    })();
-    const wsPath = AGENTS_WS_CHANNELS.SESSION_STREAM.replace(":sessionId", finalSessionId);
-    const eventsPath = `${AGENTS_WS_BASE_PATH}${wsPath}`;
-    return {
-      runId,
-      sessionId: finalSessionId,
-      eventsPath,
-      status: "started",
-      startedAt: run.startedAt
-    };
+      })();
+      const wsPath = AGENTS_WS_CHANNELS.SESSION_STREAM.replace(":sessionId", finalSessionId);
+      const eventsPath = `${AGENTS_WS_BASE_PATH}${wsPath}`;
+      return {
+        runId,
+        sessionId: finalSessionId,
+        eventsPath,
+        status: "started",
+        startedAt: run.startedAt
+      };
+    } catch (err) {
+      rethrowForRest(err);
+    }
   }
 });
 
@@ -564,69 +568,73 @@ function buildExecutionTaskWithSpec(plan, spec) {
 }
 var execute_session_plan_handler_default = defineHandler({
   async execute(ctx, input) {
-    const params = input.params;
-    const sessionId = params?.sessionId;
-    const body = input.body ?? {};
-    if (!sessionId) {
-      throw new Error("Session ID is required");
-    }
-    const baseManager = new SessionManager(ctx.cwd);
-    const session = await baseManager.loadSession(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const workingDir = session.workingDir || ctx.cwd;
-    const sessionManager = new SessionManager(workingDir);
-    const planPath = sessionManager.getSessionPlanPath(sessionId);
-    let plan;
-    try {
-      plan = await loadPlan(planPath);
-    } catch {
-      throw new Error(`Plan not found for session ${sessionId}`);
-    }
-    if (plan.status !== "approved" && plan.status !== "spec_ready") {
-      throw new Error(`Plan must be approved before execution (current status: ${plan.status})`);
-    }
-    let spec = null;
     try {
-      const specPath = sessionManager.getSessionSpecPath(sessionId);
-      const specContent = await promises.readFile(specPath, "utf-8");
-      spec = JSON.parse(specContent);
-    } catch {
-    }
-    const executionTask = spec?.markdown ? buildExecutionTaskWithSpec(plan, spec) : buildExecutionTask(plan);
-    const runInput = {
-      body: {
-        task: executionTask,
-        sessionId,
-        workingDir,
-        tier: body.tier,
-        responseMode: body.responseMode,
-        verbose: body.verbose,
-        enableEscalation: body.enableEscalation
+      const params = input.params;
+      const sessionId = params?.sessionId;
+      const body = input.body ?? {};
+      if (!sessionId) {
+        throw new Error("Session ID is required");
       }
-    };
-    const runResponse = await run_handler_default.execute(ctx, runInput);
-    const inProgressPlan = {
-      ...plan,
-      status: "in_progress",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await promises.writeFile(planPath, JSON.stringify(inProgressPlan, null, 2), "utf-8");
-    const documentService = new PlanDocumentService(workingDir);
-    const markdownPath = documentService.getPlanPath(plan);
-    await documentService.appendExecutionLog(
-      markdownPath,
-      `- ${(/* @__PURE__ */ new Date()).toISOString()}: Execution started (runId: ${runResponse.runId}).`
-    );
-    return {
-      sessionId,
-      planId: plan.id,
-      runId: runResponse.runId,
-      eventsPath: runResponse.eventsPath,
-      status: runResponse.status,
-      startedAt: runResponse.startedAt
-    };
+      const baseManager = new SessionManager(ctx.cwd);
+      const session = await baseManager.loadSession(sessionId);
+      if (!session) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const workingDir = session.workingDir || ctx.cwd;
+      const sessionManager = new SessionManager(workingDir);
+      const planPath = sessionManager.getSessionPlanPath(sessionId);
+      let plan;
+      try {
+        plan = await loadPlan(planPath);
+      } catch {
+        throw new Error(`Plan not found for session ${sessionId}`);
+      }
+      if (plan.status !== "approved" && plan.status !== "spec_ready") {
+        throw new Error(`Plan must be approved before execution (current status: ${plan.status})`);
+      }
+      let spec = null;
+      try {
+        const specPath = sessionManager.getSessionSpecPath(sessionId);
+        const specContent = await promises.readFile(specPath, "utf-8");
+        spec = JSON.parse(specContent);
+      } catch {
+      }
+      const executionTask = spec?.markdown ? buildExecutionTaskWithSpec(plan, spec) : buildExecutionTask(plan);
+      const runInput = {
+        body: {
+          task: executionTask,
+          sessionId,
+          workingDir,
+          tier: body.tier,
+          responseMode: body.responseMode,
+          verbose: body.verbose,
+          enableEscalation: body.enableEscalation
+        }
+      };
+      const runResponse = await run_handler_default.execute(ctx, runInput);
+      const inProgressPlan = {
+        ...plan,
+        status: "in_progress",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await promises.writeFile(planPath, JSON.stringify(inProgressPlan, null, 2), "utf-8");
+      const documentService = new PlanDocumentService(workingDir);
+      const markdownPath = documentService.getPlanPath(plan);
+      await documentService.appendExecutionLog(
+        markdownPath,
+        `- ${(/* @__PURE__ */ new Date()).toISOString()}: Execution started (runId: ${runResponse.runId}).`
+      );
+      return {
+        sessionId,
+        planId: plan.id,
+        runId: runResponse.runId,
+        eventsPath: runResponse.eventsPath,
+        status: runResponse.status,
+        startedAt: runResponse.startedAt
+      };
+    } catch (err) {
+      rethrowForRest(err);
+    }
   }
 });