nextclaw 0.8.62 → 0.9.1

package/dist/cli/index.js

@@ -14,7 +14,7 @@ import {
   getWorkspacePath as getWorkspacePath6,
   expandHome as expandHome2,
   MessageBus as MessageBus2,
-  AgentLoop as AgentLoop2,
+  AgentLoop,
   ProviderManager as ProviderManager2,
   resolveConfigSecrets as resolveConfigSecrets3,
   APP_NAME as APP_NAME4,
@@ -598,6 +598,7 @@ function loadPluginRegistry(config2, workspaceDir) {
     ],
     reservedChannelIds: [],
     reservedProviderIds: PROVIDERS.map((provider) => provider.name),
+    reservedEngineKinds: ["native"],
     logger: {
       info: (message) => console.log(message),
       warn: (message) => console.warn(message),
@@ -620,6 +621,12 @@ function toExtensionRegistry(pluginRegistry) {
       channel: channel.channel,
       source: channel.source
     })),
+    engines: pluginRegistry.engines.map((engine) => ({
+      extensionId: engine.pluginId,
+      kind: engine.kind,
+      factory: engine.factory,
+      source: engine.source
+    })),
     diagnostics: pluginRegistry.diagnostics.map((diag) => ({
       level: diag.level,
       message: diag.message,
@@ -685,7 +692,8 @@ var PluginCommands = class {
       config: config2,
       workspaceDir,
       reservedChannelIds: [],
-      reservedProviderIds: PROVIDERS.map((provider) => provider.name)
+      reservedProviderIds: PROVIDERS.map((provider) => provider.name),
+      reservedEngineKinds: ["native"]
     });
     const list = opts.enabled ? report.plugins.filter((plugin) => plugin.status === "loaded") : report.plugins;
     if (opts.json) {
@@ -729,6 +737,9 @@ var PluginCommands = class {
       if (plugin.providerIds.length > 0) {
         console.log(`  providers: ${plugin.providerIds.join(", ")}`);
       }
+      if (plugin.engineKinds.length > 0) {
+        console.log(`  engines: ${plugin.engineKinds.join(", ")}`);
+      }
       if (plugin.error) {
         console.log(`  error: ${plugin.error}`);
       }
@@ -742,7 +753,8 @@ var PluginCommands = class {
       config: config2,
       workspaceDir,
       reservedChannelIds: [],
-      reservedProviderIds: PROVIDERS.map((provider) => provider.name)
+      reservedProviderIds: PROVIDERS.map((provider) => provider.name),
+      reservedEngineKinds: ["native"]
     });
     const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
     if (!plugin) {
@@ -778,6 +790,9 @@ var PluginCommands = class {
     if (plugin.providerIds.length > 0) {
       lines.push(`Providers: ${plugin.providerIds.join(", ")}`);
     }
+    if (plugin.engineKinds.length > 0) {
+      lines.push(`Engines: ${plugin.engineKinds.join(", ")}`);
+    }
     if (plugin.error) {
       lines.push(`Error: ${plugin.error}`);
     }
@@ -823,7 +838,8 @@ var PluginCommands = class {
       config: config2,
       workspaceDir,
       reservedChannelIds: [],
-      reservedProviderIds: PROVIDERS.map((provider) => provider.name)
+      reservedProviderIds: PROVIDERS.map((provider) => provider.name),
+      reservedEngineKinds: ["native"]
     });
     const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);
     if (opts.keepConfig) {
@@ -1005,7 +1021,8 @@ var PluginCommands = class {
       config: config2,
       workspaceDir,
       reservedChannelIds: [],
-      reservedProviderIds: PROVIDERS.map((provider) => provider.name)
+      reservedProviderIds: PROVIDERS.map((provider) => provider.name),
+      reservedEngineKinds: ["native"]
     });
     const pluginErrors = report.plugins.filter((plugin) => plugin.status === "error");
     const diagnostics = report.diagnostics.filter((diag) => diag.level === "error");
@@ -2230,6 +2247,8 @@ import { startUiServer } from "@nextclaw/server";
 import { closeSync, cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, openSync, rmSync as rmSync3 } from "fs";
 import { dirname, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve7 } from "path";
 import { spawn as spawn2 } from "child_process";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chokidar from "chokidar";
 
@@ -2676,7 +2695,7 @@ var MissingProvider = class extends LLMProvider {
   setDefaultModel(model) {
     this.defaultModel = model;
   }
-  async chat() {
+  async chat(_params) {
     throw new Error("No API key configured yet. Configure provider credentials in UI and retry.");
   }
   getDefaultModel() {
@@ -2686,7 +2705,7 @@ var MissingProvider = class extends LLMProvider {
 
 // src/cli/commands/agent-runtime-pool.ts
 import {
-  AgentLoop,
+  NativeAgentEngine,
   AgentRouteResolver,
   getWorkspacePath as getWorkspacePath4,
   parseAgentScopedSessionKey
@@ -2695,6 +2714,19 @@ function normalizeAgentId(value) {
   const text = (value ?? "").trim().toLowerCase();
   return text || "main";
 }
+function normalizeEngineKind(value) {
+  if (typeof value !== "string") {
+    return "native";
+  }
+  const kind = value.trim().toLowerCase();
+  return kind || "native";
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
 function resolveAgentProfiles(config2) {
   const defaults = config2.agents.defaults;
   const listed = Array.isArray(config2.agents.list) ? config2.agents.list.map((entry) => ({
@@ -2702,6 +2734,8 @@ function resolveAgentProfiles(config2) {
     default: entry.default,
     workspace: entry.workspace,
     model: entry.model,
+    engine: entry.engine,
+    engineConfig: toRecord(entry.engineConfig),
     maxToolIterations: entry.maxToolIterations,
     contextTokens: entry.contextTokens
   })).filter((entry) => Boolean(entry.id)) : [];
@@ -2720,6 +2754,8 @@ function resolveAgentProfiles(config2) {
     id: entry.id,
     workspace: getWorkspacePath4(entry.workspace ?? defaults.workspace),
     model: entry.model ?? defaults.model,
+    engine: normalizeEngineKind(entry.engine ?? defaults.engine),
+    engineConfig: entry.engineConfig ?? toRecord(defaults.engineConfig),
     maxIterations: entry.maxToolIterations ?? defaults.maxToolIterations,
     contextTokens: entry.contextTokens ?? defaults.contextTokens
   }));
@@ -2751,32 +2787,48 @@ var GatewayAgentRuntimePool = class {
     this.rebuild(this.options.config);
   }
   async processDirect(params) {
-    const message = {
-      channel: params.channel ?? "cli",
-      senderId: "user",
-      chatId: params.chatId ?? "direct",
+    const { message, route } = this.resolveDirectRoute({
       content: params.content,
-      timestamp: /* @__PURE__ */ new Date(),
-      attachments: [],
-      metadata: params.metadata ?? {}
-    };
-    const forcedAgentId = this.readString(params.agentId) ?? parseAgentScopedSessionKey(params.sessionKey)?.agentId ?? void 0;
-    const route = this.routeResolver.resolveInbound({
-      message,
-      forcedAgentId,
-      sessionKeyOverride: params.sessionKey
+      sessionKey: params.sessionKey,
+      channel: params.channel,
+      chatId: params.chatId,
+      metadata: params.metadata,
+      agentId: params.agentId
     });
     const runtime2 = this.resolveRuntime(route.agentId);
-    return runtime2.loop.processDirect({
+    return runtime2.engine.processDirect({
       content: params.content,
       sessionKey: route.sessionKey,
       channel: message.channel,
       chatId: message.chatId,
       metadata: message.metadata,
+      abortSignal: params.abortSignal,
       onAssistantDelta: params.onAssistantDelta,
       onSessionEvent: params.onSessionEvent
     });
   }
+  supportsTurnAbort(params) {
+    const { route } = this.resolveDirectRoute({
+      content: "",
+      sessionKey: params.sessionKey,
+      channel: params.channel,
+      chatId: params.chatId,
+      metadata: params.metadata,
+      agentId: params.agentId
+    });
+    const runtime2 = this.resolveRuntime(route.agentId);
+    if (runtime2.engine.kind !== "native") {
+      return {
+        supported: false,
+        agentId: route.agentId,
+        reason: `engine "${runtime2.engine.kind}" does not support server-side stop yet`
+      };
+    }
+    return {
+      supported: true,
+      agentId: route.agentId
+    };
+  }
   async run() {
     this.running = true;
     while (this.running) {
@@ -2790,7 +2842,7 @@ var GatewayAgentRuntimePool = class {
           sessionKeyOverride: explicitSessionKey
         });
         const runtime2 = this.resolveRuntime(route.agentId);
-        await runtime2.loop.handleInbound({
+        await runtime2.engine.handleInbound({
           message,
           sessionKey: route.sessionKey,
           publishResponse: true
@@ -2813,6 +2865,27 @@ var GatewayAgentRuntimePool = class {
     const trimmed = value.trim();
     return trimmed || void 0;
   }
+  resolveDirectRoute(params) {
+    const message = {
+      channel: params.channel ?? "cli",
+      senderId: "user",
+      chatId: params.chatId ?? "direct",
+      content: params.content,
+      timestamp: /* @__PURE__ */ new Date(),
+      attachments: [],
+      metadata: params.metadata ?? {}
+    };
+    const forcedAgentId = this.readString(params.agentId) ?? parseAgentScopedSessionKey(params.sessionKey)?.agentId ?? void 0;
+    const route = this.routeResolver.resolveInbound({
+      message,
+      forcedAgentId,
+      sessionKeyOverride: params.sessionKey
+    });
+    return {
+      message,
+      route
+    };
+  }
   resolveRuntime(agentId) {
     const normalized = normalizeAgentId(agentId);
     const runtime2 = this.runtimes.get(normalized);
@@ -2825,34 +2898,82 @@ var GatewayAgentRuntimePool = class {
     }
     throw new Error("No agent runtime available");
   }
+  createNativeEngineFactory() {
+    return (context) => new NativeAgentEngine({
+      bus: context.bus,
+      providerManager: context.providerManager,
+      workspace: context.workspace,
+      model: context.model,
+      maxIterations: context.maxIterations,
+      contextTokens: context.contextTokens,
+      braveApiKey: context.braveApiKey,
+      execConfig: context.execConfig,
+      cronService: context.cronService,
+      restrictToWorkspace: context.restrictToWorkspace,
+      sessionManager: context.sessionManager,
+      contextConfig: context.contextConfig,
+      gatewayController: context.gatewayController,
+      config: context.config,
+      extensionRegistry: context.extensionRegistry,
+      resolveMessageToolHints: context.resolveMessageToolHints,
+      agentId: context.agentId
+    });
+  }
+  resolveEngineFactory(kind) {
+    if (kind === "native") {
+      return this.createNativeEngineFactory();
+    }
+    const registrations = this.options.extensionRegistry?.engines ?? [];
+    const matched = registrations.find((entry) => normalizeEngineKind(entry.kind) === kind);
+    if (matched) {
+      return matched.factory;
+    }
+    console.warn(`[engine] unknown engine "${kind}", fallback to "native"`);
+    return this.createNativeEngineFactory();
+  }
+  createEngine(profile, config2) {
+    const kind = normalizeEngineKind(profile.engine);
+    const factory = this.resolveEngineFactory(kind);
+    const context = {
+      agentId: profile.id,
+      workspace: profile.workspace,
+      model: profile.model,
+      maxIterations: profile.maxIterations,
+      contextTokens: profile.contextTokens,
+      engineConfig: profile.engineConfig,
+      bus: this.options.bus,
+      providerManager: this.options.providerManager,
+      sessionManager: this.options.sessionManager,
+      cronService: this.options.cronService,
+      restrictToWorkspace: this.options.restrictToWorkspace,
+      braveApiKey: this.options.braveApiKey,
+      execConfig: this.options.execConfig,
+      contextConfig: this.options.contextConfig,
+      gatewayController: this.options.gatewayController,
+      config: config2,
+      extensionRegistry: this.options.extensionRegistry,
+      resolveMessageToolHints: this.options.resolveMessageToolHints
+    };
+    try {
+      return factory(context);
+    } catch (error) {
+      if (kind === "native") {
+        throw error;
+      }
+      console.warn(`[engine] failed to create "${kind}" for agent "${profile.id}": ${String(error)}`);
+      return this.createNativeEngineFactory()(context);
+    }
+  }
   rebuild(config2) {
     const profiles = resolveAgentProfiles(config2);
     const configuredDefault = this.readString(config2.agents.list.find((entry) => entry.default)?.id);
     this.defaultAgentId = configuredDefault ?? profiles[0]?.id ?? "main";
     const nextRuntimes = /* @__PURE__ */ new Map();
     for (const profile of profiles) {
-      const loop = new AgentLoop({
-        bus: this.options.bus,
-        providerManager: this.options.providerManager,
-        workspace: profile.workspace,
-        model: profile.model,
-        maxIterations: profile.maxIterations,
-        contextTokens: profile.contextTokens,
-        braveApiKey: this.options.braveApiKey,
-        execConfig: this.options.execConfig,
-        cronService: this.options.cronService,
-        restrictToWorkspace: this.options.restrictToWorkspace,
-        sessionManager: this.options.sessionManager,
-        contextConfig: this.options.contextConfig,
-        gatewayController: this.options.gatewayController,
-        config: config2,
-        extensionRegistry: this.options.extensionRegistry,
-        resolveMessageToolHints: this.options.resolveMessageToolHints,
-        agentId: profile.id
-      });
+      const engine = this.createEngine(profile, config2);
       nextRuntimes.set(profile.id, {
         id: profile.id,
-        loop
+        engine
       });
     }
     this.runtimes = nextRuntimes;
@@ -2887,6 +3008,21 @@ function createSkillsLoader(workspace) {
   }
   return new ctor(workspace);
 }
+function isAbortError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error) {
+    if (error.name === "AbortError") {
+      return true;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("aborted") || message.includes("abort")) {
+      return true;
+    }
+  }
+  return false;
+}
 var ServiceCommands = class {
   constructor(deps) {
     this.deps = deps;
@@ -3279,7 +3415,7 @@ var ServiceCommands = class {
       }
       await this.printPublicUiUrls(parsedUi.host, parsedUi.port);
       console.log(`Logs: ${existing.logPath}`);
-      console.log(`Stop: ${APP_NAME2} stop`);
+      this.printServiceControlHints();
       return;
     }
     if (existing) {
@@ -3306,12 +3442,20 @@ var ServiceCommands = class {
       return;
     }
     const healthUrl = `${apiUrl}/health`;
-    const started = await this.waitForBackgroundServiceReady({
+    let readiness = await this.waitForBackgroundServiceReady({
       pid: child.pid,
       healthUrl,
       timeoutMs: 8e3
     });
-    if (!started) {
+    if (!readiness.ready && process.platform === "win32" && isProcessRunning(child.pid)) {
+      console.warn("Warning: Background service is still running but not ready after 8s; waiting up to 20s more on Windows.");
+      readiness = await this.waitForBackgroundServiceReady({
+        pid: child.pid,
+        healthUrl,
+        timeoutMs: 2e4
+      });
+    }
+    if (!readiness.ready) {
       if (isProcessRunning(child.pid)) {
         try {
           process.kill(child.pid, "SIGTERM");
@@ -3320,7 +3464,8 @@ var ServiceCommands = class {
         }
       }
       clearServiceState();
-      console.error(`Error: Failed to start background service. Check logs: ${logPath}`);
+      const hint = readiness.lastProbeError ? ` Last probe error: ${readiness.lastProbeError}` : "";
+      console.error(`Error: Failed to start background service. Check logs: ${logPath}.${hint}`);
       return;
     }
     child.unref();
@@ -3339,7 +3484,7 @@ var ServiceCommands = class {
     console.log(`API: ${apiUrl}`);
     await this.printPublicUiUrls(uiConfig.host, uiConfig.port);
     console.log(`Logs: ${logPath}`);
-    console.log(`Stop: ${APP_NAME2} stop`);
+    this.printServiceControlHints();
     if (options.open) {
       openBrowser(uiUrl);
     }
@@ -3377,31 +3522,80 @@ var ServiceCommands = class {
   }
   async waitForBackgroundServiceReady(params) {
     const startedAt = Date.now();
+    let lastProbeError = null;
     while (Date.now() - startedAt < params.timeoutMs) {
       if (!isProcessRunning(params.pid)) {
-        return false;
+        return { ready: false, lastProbeError };
       }
-      try {
-        const response = await fetch(params.healthUrl, { method: "GET" });
-        if (!response.ok) {
-          await new Promise((resolve10) => setTimeout(resolve10, 200));
-          continue;
-        }
-        const payload = await response.json();
-        const healthy = payload?.ok === true && payload?.data?.status === "ok";
-        if (!healthy) {
-          await new Promise((resolve10) => setTimeout(resolve10, 200));
-          continue;
-        }
-        await new Promise((resolve10) => setTimeout(resolve10, 300));
-        if (isProcessRunning(params.pid)) {
-          return true;
-        }
-      } catch {
+      const probe = await this.probeHealthEndpoint(params.healthUrl);
+      if (!probe.healthy) {
+        lastProbeError = probe.error;
+        await new Promise((resolve10) => setTimeout(resolve10, 200));
+        continue;
+      }
+      await new Promise((resolve10) => setTimeout(resolve10, 300));
+      if (isProcessRunning(params.pid)) {
+        return { ready: true, lastProbeError: null };
       }
       await new Promise((resolve10) => setTimeout(resolve10, 200));
     }
-    return false;
+    return { ready: false, lastProbeError };
+  }
+  async probeHealthEndpoint(healthUrl) {
+    let parsed;
+    try {
+      parsed = new URL(healthUrl);
+    } catch {
+      return { healthy: false, error: "invalid health URL" };
+    }
+    const requestImpl = parsed.protocol === "https:" ? httpsRequest : httpRequest;
+    return new Promise((resolve10) => {
+      const req = requestImpl(
+        {
+          protocol: parsed.protocol,
+          hostname: parsed.hostname,
+          port: parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80,
+          method: "GET",
+          path: `${parsed.pathname}${parsed.search}`,
+          timeout: 1e3,
+          headers: { Accept: "application/json" }
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => {
+            if (typeof chunk === "string") {
+              chunks.push(Buffer.from(chunk));
+              return;
+            }
+            chunks.push(chunk);
+          });
+          res.on("end", () => {
+            if ((res.statusCode ?? 0) < 200 || (res.statusCode ?? 0) >= 300) {
+              resolve10({ healthy: false, error: `http ${res.statusCode ?? "unknown"}` });
+              return;
+            }
+            try {
+              const payload = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+              const healthy = payload?.ok === true && payload?.data?.status === "ok";
+              if (!healthy) {
+                resolve10({ healthy: false, error: "health payload not ok" });
+                return;
+              }
+              resolve10({ healthy: true, error: null });
+            } catch {
+              resolve10({ healthy: false, error: "invalid health JSON response" });
+            }
+          });
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy(new Error("probe timeout"));
+      });
+      req.on("error", (error) => {
+        resolve10({ healthy: false, error: error.message || String(error) });
+      });
+      req.end();
+    });
   }
   createMissingProvider(config2) {
     return this.makeMissingProvider(config2);
@@ -3449,10 +3643,23 @@ var ServiceCommands = class {
     console.log(`Public UI (if firewall/NAT allows): ${publicBase}`);
     console.log(`Public API (if firewall/NAT allows): ${publicBase}/api`);
   }
+  printServiceControlHints() {
+    console.log("Service controls:");
+    console.log(`  - Check status: ${APP_NAME2} status`);
+    console.log(`  - If you need to stop the service, run: ${APP_NAME2} stop`);
+  }
   startUiIfEnabled(uiConfig, uiStaticDir, cronService, runtimePool) {
     if (!uiConfig.enabled) {
       return;
     }
+    const activeTurnRuns = /* @__PURE__ */ new Map();
+    const resolveStopCapability = (params) => runtimePool.supportsTurnAbort({
+      sessionKey: params.sessionKey,
+      agentId: params.agentId,
+      channel: params.channel,
+      chatId: params.chatId,
+      metadata: params.metadata
+    });
     const resolveChatTurnParams = (params) => {
       const sessionKey = typeof params.sessionKey === "string" && params.sessionKey.trim().length > 0 ? params.sessionKey.trim() : `ui:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
       const inferredAgentId = typeof params.agentId === "string" && params.agentId.trim().length > 0 ? params.agentId.trim() : parseAgentScopedSessionKey2(sessionKey)?.agentId;
@@ -3461,7 +3668,9 @@ var ServiceCommands = class {
       if (model) {
         metadata.model = model;
       }
+      const runId = typeof params.runId === "string" && params.runId.trim().length > 0 ? params.runId.trim() : void 0;
       return {
+        runId,
         sessionKey,
         inferredAgentId,
         model,
@@ -3494,6 +3703,20 @@ var ServiceCommands = class {
         }
       },
       chatRuntime: {
+        getCapabilities: async (params) => {
+          const sessionKey = typeof params.sessionKey === "string" && params.sessionKey.trim().length > 0 ? params.sessionKey.trim() : `ui:capability:${Date.now().toString(36)}`;
+          const capability = resolveStopCapability({
+            sessionKey,
+            agentId: typeof params.agentId === "string" ? params.agentId : void 0,
+            channel: "ui",
+            chatId: "web-ui",
+            metadata: {}
+          });
+          return {
+            stopSupported: capability.supported,
+            ...capability.reason ? { stopReason: capability.reason } : {}
+          };
+        },
         processTurn: async (params) => {
           const resolved = resolveChatTurnParams(params);
           const reply = await runtimePool.processDirect({
@@ -3511,9 +3734,60 @@ var ServiceCommands = class {
             model: resolved.model
           });
         },
+        stopTurn: async (params) => {
+          const runId = typeof params.runId === "string" ? params.runId.trim() : "";
+          if (!runId) {
+            return {
+              stopped: false,
+              runId: "",
+              reason: "runId is required"
+            };
+          }
+          const active = activeTurnRuns.get(runId);
+          if (!active) {
+            return {
+              stopped: false,
+              runId,
+              ...typeof params.sessionKey === "string" && params.sessionKey.trim().length > 0 ? { sessionKey: params.sessionKey.trim() } : {},
+              reason: "run not found or already completed"
+            };
+          }
+          const requestedSessionKey = typeof params.sessionKey === "string" ? params.sessionKey.trim() : "";
+          if (requestedSessionKey && requestedSessionKey !== active.sessionKey) {
+            return {
+              stopped: false,
+              runId,
+              sessionKey: active.sessionKey,
+              reason: "session key mismatch"
+            };
+          }
+          active.controller.abort(new Error("chat turn stopped by user"));
+          return {
+            stopped: true,
+            runId,
+            sessionKey: active.sessionKey
+          };
+        },
         processTurnStream: async function* (params) {
           const resolved = resolveChatTurnParams(params);
+          const runId = resolved.runId ?? `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+          const stopCapability = resolveStopCapability({
+            sessionKey: resolved.sessionKey,
+            agentId: resolved.inferredAgentId,
+            channel: resolved.channel,
+            chatId: resolved.chatId,
+            metadata: resolved.metadata
+          });
+          const controller = stopCapability.supported ? new AbortController() : null;
+          if (controller) {
+            activeTurnRuns.set(runId, {
+              controller,
+              sessionKey: resolved.sessionKey,
+              ...resolved.inferredAgentId ? { agentId: resolved.inferredAgentId } : {}
+            });
+          }
           const queue = [];
+          const assistantDeltaParts = [];
           let waiter = null;
           const push = (event) => {
             queue.push(event);
@@ -3528,10 +3802,12 @@ var ServiceCommands = class {
             chatId: resolved.chatId,
             agentId: resolved.inferredAgentId,
             metadata: resolved.metadata,
+            ...controller ? { abortSignal: controller.signal } : {},
             onAssistantDelta: (delta) => {
               if (typeof delta !== "string" || delta.length === 0) {
                 return;
               }
+              assistantDeltaParts.push(delta);
               push({ type: "delta", delta });
             },
             onSessionEvent: (event) => {
@@ -3567,7 +3843,22 @@ var ServiceCommands = class {
               })
             });
           }).catch((error) => {
+            if ((controller?.signal.aborted ?? false) || isAbortError(error)) {
+              const partialReply = assistantDeltaParts.join("");
+              push({
+                type: "final",
+                result: buildTurnResult({
+                  reply: partialReply,
+                  sessionKey: resolved.sessionKey,
+                  inferredAgentId: resolved.inferredAgentId,
+                  model: resolved.model
+                })
+              });
+              return;
+            }
             push({ type: "error", error: String(error) });
+          }).finally(() => {
+            activeTurnRuns.delete(runId);
           });
           while (true) {
             if (queue.length === 0) {
@@ -4455,7 +4746,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
         defaultProvider: provider,
         config: config2
       });
-      const agentLoop = new AgentLoop2({
+      const agentLoop = new AgentLoop({
         bus,
         providerManager,
         workspace,