onbuzz 4.7.1 → 4.8.0

package/src/core/agentScheduler.js

@@ -578,10 +578,31 @@ class AgentScheduler {
 
       // Flip mode → CHAT (records transition + persists + broadcasts
       // agent_mode_changed with humanReason "Stopped by user.")
-      await this._transitionMode(agentId, AGENT_MODES.CHAT, 'user-stop');
-
-      // Clear stop request flag after mode is set (it has been honored).
-      agent.stopRequested = false;
+      // CRITICAL: wrap in try/finally so the stopRequested flag ALWAYS
+      // clears, even if _transitionMode throws or the await is interrupted
+      // (process restart, OOM, etc.). Without this, a stop that fails
+      // mid-flight leaves stopRequested=true forever and the agent never
+      // schedules again — shouldAgentBeActive() permanently returns
+      // {active:false, reason:'stop-requested'}. We've seen this in
+      // production: agent in mode:CHAT but stopRequested:true, completely
+      // wedged with no way out short of manual state surgery.
+      try {
+        await this._transitionMode(agentId, AGENT_MODES.CHAT, 'user-stop');
+      } finally {
+        // Always clear, in-memory + persisted, so a partial stop never
+        // leaves the agent unable to recover. The mode transition is
+        // already idempotent — if it failed, the operator can retry stop.
+        agent.stopRequested = false;
+        try {
+          await this.agentPool.persistAgentState(agentId);
+        } catch (persistErr) {
+          // Persist failures during recovery shouldn't mask the stop;
+          // log and continue. The in-memory flag is cleared either way.
+          this.logger?.warn?.(
+            `Failed to persist cleared stopRequested for ${agentId} after stop: ${persistErr.message}`
+          );
+        }
+      }
 
       // Clean up session tracking.
       this.removeAgent(agentId, 'stopped-by-user');
@@ -1827,7 +1848,7 @@ class AgentScheduler {
                 
                 // Filter to only include models that are available (not router models)
                 availableModels = allModels
-                  .filter(model => model.id !== 'autopilot-model-router' && model.name !== 'autopilot-model-router');
+                  .filter(model => model.id !== 'model-router' && model.name !== 'model-router');
                   
                 this.logger.debug(`Available models for routing: ${availableModels.map(m => m.id || m.name).join(', ')}`);
               } catch (error) {
@@ -2029,6 +2050,39 @@ class AgentScheduler {
         // Continue without flow context if service fails
       }
 
+      // ── Auto-inject `plan/*` memories as AGENT WORKING PLAN ────
+      // Appended AT THE END of the (already-extended) system prompt
+      // so the stable prefix stays cache-friendly. Per-agent only in
+      // this v1; team-shared follow-on is tracked in
+      // src/utilities/planInjection.js as TODO Plan C.
+      //
+      // No throw: if the memory service is offline or returns
+      // garbage, the agent should still get its turn — Dynamic
+      // Routing's degrade-gracefully principle.
+      try {
+        const { getMemoryService } = await import('../services/memoryService.js');
+        const memoryService = getMemoryService(this.logger);
+        await memoryService.initialize();
+        const planMemories = await memoryService.getPlanMemories(agentId);
+        if (planMemories.length > 0) {
+          const { buildPlanBlock } = await import('../utilities/planInjection.js');
+          const { block, truncated } = buildPlanBlock(planMemories);
+          if (block) {
+            enhancedSystemPrompt = (enhancedSystemPrompt || '') + block;
+          }
+          if (truncated.length > 0) {
+            this.logger.warn(`Plan injection truncated for agent ${agentId}`, {
+              truncated,
+              hint: 'Agent should summarize the listed plans on its next turn.',
+            });
+          }
+        }
+      } catch (planErr) {
+        this.logger.warn(`Plan injection failed for agent ${agentId} (continuing without)`, {
+          error: planErr?.message,
+        });
+      }
+
       // Check if streaming is enabled - consider both agent config and user message preference
       // Get the last user message to check for streaming preference
       const lastUserMsg = [...conversationHistory].reverse().find(m => m.role === 'user');

package/src/index.js

@@ -45,6 +45,7 @@ import FileTreeTool from './tools/fileTreeTool.js';
 import FileContentReplaceTool from './tools/fileContentReplaceTool.js';
 import SeekTool from './tools/seekTool.js';
 import WebTool from './tools/webTool.js';
+import FoundryWebSearchTool from './tools/foundryWebSearchTool.js';
 import VisualEditorTool from './tools/visualEditorTool.js';
 import PdfTool from './tools/pdfTool.js';
 import HelpTool from './tools/helpTool.js';
@@ -57,6 +58,7 @@ import UserPromptTool from './tools/userPromptTool.js';
 import CodeMapTool from './tools/codeMapTool.js';
 import WhatsAppTool from './tools/whatsappTool.js';
 import PlatformControlTool from './tools/platformControlTool.js';
+import { DesktopTool } from './tools/desktop/DesktopTool.js';
 import ScheduleService from './services/scheduleService.js';
 import AsyncToolManager from './tools/asyncToolManager.js';
 import WebServer from './interfaces/webServer.js';
@@ -465,6 +467,16 @@ class LoxiaApplication {
     // Register Web Tool
     await this.toolsRegistry.registerTool(WebTool);
 
+    // Register Foundry Web Search Tool (grounded, with citations).
+    // Distinct from WebTool: WebTool drives a real browser (puppeteer)
+    // for raw results / authenticated sites; FoundryWebSearchTool
+    // calls /llm/web-search which uses Azure AI Foundry's
+    // web_search_preview tool — single round-trip, synthesized answer
+    // with citation URLs. See docs/FOUNDRY_WEB_SEARCH_PROVISIONING.md
+    // on the backend side; the tool returns a clear "not provisioned"
+    // error until that's done.
+    await this.toolsRegistry.registerTool(FoundryWebSearchTool);
+
     // Register Visual Editor Tool
     await this.toolsRegistry.registerTool(VisualEditorTool);
 
@@ -498,6 +510,13 @@ class LoxiaApplication {
     // (currently: scheduled tasks; per-agent permission, default DISABLED).
     await this.toolsRegistry.registerTool(PlatformControlTool);
 
+    // Register Desktop Tool — keyboard/mouse/screen/window control with
+    // visual grounding (Kimi K2.6 by default). Per-agent allowlist with
+    // an EMPTY default, so no agent can drive the desktop until the
+    // operator explicitly opts in via toolConfig.desktop.allowedActions.
+    // Global kill switch: LOXIA_DESKTOP_TOOL_DISABLED=1.
+    await this.toolsRegistry.registerTool(DesktopTool);
+
     // widget-module: remove this block if the module is deleted.
     // Registers the WidgetTool for agent-facing custom-UI rendering.
     // Honors LOXIA_DISABLE_WIDGETS=1 env flag for a zero-source kill switch.
@@ -599,6 +618,23 @@ class LoxiaApplication {
       videoTool.setAIService(this.aiService);
       this.logger.info('AIService set for Video Generation Tool');
     }
+
+    // Foundry web search — uses /llm/web-search backed by Azure AI
+    // Foundry + Grounding with Bing Search. Calls aiService.foundryWebSearch
+    // for the auth + URL plumbing.
+    const foundryWebTool = this.toolsRegistry.getTool('foundry_web_search');
+    if (foundryWebTool && typeof foundryWebTool.setAIService === 'function') {
+      foundryWebTool.setAIService(this.aiService);
+      this.logger.info('AIService set for Foundry Web Search Tool');
+    }
+
+    // Desktop tool — needs aiService for proxy-mode grounding auth
+    // (baseUrl + per-session Loxia key from apiKeyManager).
+    const desktopTool = this.toolsRegistry.getTool('desktop');
+    if (desktopTool && typeof desktopTool.setAIService === 'function') {
+      desktopTool.setAIService(this.aiService);
+      this.logger.info('AIService set for Desktop Tool');
+    }
     if (videoTool && typeof videoTool.setAgentPool === 'function') {
       videoTool.setAgentPool(this.agentPool);
       this.logger.info('AgentPool set for Video Generation Tool');

package/src/interfaces/webServer.js

@@ -3505,6 +3505,48 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
     
+    // Clear a wedged stopRequested flag — recovery endpoint for agents
+    // that got stuck mid-stop (process restart, transition throw, etc.).
+    // Idempotent. Returns the resulting agent state. The scheduler bug
+    // that left agents in this state is fixed (try/finally around
+    // _transitionMode in stopAgentExecution), but this endpoint stays
+    // because external systems can ALWAYS find new ways to wedge state
+    // — having an explicit recovery surface is cheaper than restarting
+    // the whole CLI.
+    this.app.post('/api/agents/:agentId/clear-stop-flag', async (req, res) => {
+      try {
+        const { agentId } = req.params;
+        const agentPool = this.orchestrator?.agentPool;
+        if (!agentPool) {
+          return res.status(503).json({ success: false, error: 'agentPool not ready' });
+        }
+        const agent = await agentPool.getAgent(agentId);
+        if (!agent) {
+          return res.status(404).json({ success: false, error: 'Agent not found' });
+        }
+        const wasSet = !!agent.stopRequested;
+        agent.stopRequested = false;
+        await agentPool.persistAgentState(agentId);
+        this.logger.info(`Cleared stopRequested for ${agentId}`, { wasSet });
+        res.json({
+          success: true,
+          wasSet,
+          agent: {
+            id: agent.id,
+            name: agent.name,
+            mode: agent.mode,
+            stopRequested: agent.stopRequested,
+          },
+        });
+      } catch (error) {
+        this.logger.error('clear-stop-flag failed', {
+          agentId: req.params.agentId,
+          error: error.message,
+        });
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // Get agent mode status
     this.app.get('/api/agents/:agentId/mode', async (req, res) => {
       try {