onbuzz 4.7.2 → 4.8.1

package/src/core/agentScheduler.js

@@ -60,6 +60,19 @@ class AgentScheduler {
     // Initialize ContextInjectionService for file attachments
     this.contextInjectionService = new ContextInjectionService({}, logger);
 
+    // Per-turn system-prompt rebuild cache for native-API models.
+    // Agents persist a `systemPrompt` baked at create-time for the
+    // chat-completion shape (text descriptions of every tool). When a
+    // turn targets a Responses-API model (Codex / o-series / gpt-5-pro),
+    // we want a TRIMMED prompt that omits text docs for tools whose
+    // structured schemas are sent in `tools:`. Rebuilding fresh each
+    // turn would be wasteful — agents typically stay on the same model
+    // for many turns — so we memoize per (agentId, modelName).
+    //
+    // Cleared on process restart and on agent updates that change the
+    // base prompt or capabilities (see `_invalidateNativePromptCache`).
+    this._nativePromptCache = new Map();   // `${agentId}|${modelName}` → string
+
     // Initialize FlowContextService for flow execution context
     this.flowContextService = new FlowContextService({}, logger);
 
@@ -578,10 +591,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 +1861,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) {
@@ -1898,8 +1932,17 @@ class AgentScheduler {
       // After compaction, retrieve messages from AgentPool (will use compacted if available)
       const messagesToSend = await this.agentPool.getMessagesForAI(agentId, targetModel);
 
-      // Inject TaskManager instructions for AGENT mode
-      let enhancedSystemPrompt = agent.systemPrompt;
+      // ── Pick the right system-prompt shape for the target model ──
+      // Default: use the agent's persisted `systemPrompt` (baked at
+      // create-time with full text descriptions for every tool — the
+      // chat-completion shape). For models that use the Responses API
+      // (native function-calling), rebuild a trimmed version that
+      // omits text docs for tools whose structured schemas we send in
+      // `tools:`. Falls back to the persisted prompt whenever the
+      // model's apiType is unknown OR the agent has no stored original
+      // prompt — preserves existing behaviour for old agents and
+      // unknown models. See `_pickSystemPromptForModel`.
+      let enhancedSystemPrompt = await this._pickSystemPromptForModel(agent, targetModel);
       if (agent.mode === AGENT_MODES.AGENT) {
         const taskManagerInstruction = "\n\nIMPORTANT: You are in AGENT mode. The use of TaskManager tool is mandatory.\n\n" +
           "TASK LIFECYCLE (follow this, don't improvise):\n" +
@@ -2029,6 +2072,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');
@@ -2115,6 +2191,156 @@ class AgentScheduler {
     }
   }
 
+  /**
+   * Choose the right base system prompt for the target model.
+   *
+   *   • If the model's catalog entry says it uses the Responses API
+   *     ('responses' in its api_type / capabilities) AND the agent has
+   *     an `originalSystemPrompt` we can rebuild from, return a
+   *     freshly-built prompt that omits text descriptions for tools
+   *     with native function schemas (see baseTool.js — those tools'
+   *     structured schemas in `tools:` are the canonical source for
+   *     these models, so the text docs are pure duplication).
+   *
+   *   • Otherwise return the agent's persisted `systemPrompt` exactly
+   *     as it is today. This covers:
+   *       – chat-completion models (no native function calling)
+   *       – models we can't classify (modelsService offline / catalog
+   *         field missing) — fail safe to old behaviour
+   *       – very old agents persisted before `originalSystemPrompt`
+   *         was stored — fail safe to old behaviour
+   *
+   * Result is memoized per `(agentId, targetModel)` to avoid rebuilding
+   * on every turn. The cache is invalidated whenever the agent's base
+   * prompt or capabilities change (see `_invalidateNativePromptCache`).
+   *
+   * @private
+   * @param {Object} agent - Agent record
+   * @param {string} targetModel - Model name about to be called
+   * @returns {Promise<string>} The prompt to use as the base
+   */
+  async _pickSystemPromptForModel(agent, targetModel) {
+    // 1. Resolve the model's API type. Unknown → use persisted prompt.
+    const apiType = this._resolveModelApiType(targetModel);
+    if (apiType !== 'responses') return agent.systemPrompt;
+
+    // 2. Need the original (un-enhanced) prompt to rebuild from. Without
+    //    it we can't safely re-add the trimmed tool docs — fall back
+    //    to the persisted shape (which works for chat-completion and
+    //    is also accepted by Responses API, just with the duplication
+    //    cost). This is the back-compat path for legacy agents.
+    if (!agent.originalSystemPrompt) return agent.systemPrompt;
+
+    // 3. Cache lookup.
+    const cacheKey = `${agent.id}|${targetModel}`;
+    const cached = this._nativePromptCache.get(cacheKey);
+    if (cached) return cached;
+
+    // 4. Rebuild. The agentPool stores the toolsRegistry — reuse it so
+    //    we go through the exact same code path that built the original
+    //    prompt, just with apiType set. Skills index + the rest of the
+    //    augmentation must be reapplied; mirror what createAgent does.
+    try {
+      const registry = this.agentPool?.toolsRegistry;
+      if (!registry) return agent.systemPrompt;
+
+      let rebuilt = registry.enhanceSystemPrompt(
+        agent.originalSystemPrompt,
+        agent.capabilities || [],
+        { apiType: 'responses' },
+      );
+
+      // Re-inject ASSIGNED SKILLS block if present (createAgent appends
+      // this after enhanceSystemPrompt — see agentPool.js:108).
+      if (Array.isArray(agent.skills) && agent.skills.length > 0) {
+        try {
+          const { getSkillsService } = await import('../services/skillsService.js');
+          const skillsService = getSkillsService(this.logger);
+          await skillsService.initialize();
+          const summaries = await skillsService.getSkillSummaries(agent.skills);
+          if (summaries.length > 0) {
+            rebuilt += '\n\n## ASSIGNED SKILLS\n\n';
+            rebuilt += 'Use the skills tool to browse and load skill content. Use "describe" to see sections, "read-section" to load specific parts.\n\n';
+            for (const s of summaries) {
+              const sections = s.sections?.length ? `\n    Sections: ${s.sections.map(h => h.replace(/^#+\s*/, '')).join(', ')}` : '';
+              rebuilt += `- **${s.name}** (${s.lineCount} lines): ${s.description}${sections}\n`;
+            }
+          }
+        } catch (e) {
+          this.logger?.debug?.('Failed to re-inject skills index for native prompt', { error: e.message });
+        }
+      }
+
+      this._nativePromptCache.set(cacheKey, rebuilt);
+      this.logger?.debug?.('Built native-API system prompt', {
+        agentId: agent.id,
+        targetModel,
+        originalLength: agent.systemPrompt?.length || 0,
+        rebuiltLength: rebuilt.length,
+        savedTokensApprox: Math.round(((agent.systemPrompt?.length || 0) - rebuilt.length) / 4),
+      });
+      return rebuilt;
+    } catch (err) {
+      // Anything goes wrong → fall back to old behaviour. Failing
+      // closed (no prompt) would break the agent's turn; failing open
+      // (use chat-completion shape) just keeps the duplication.
+      this.logger?.warn?.('Native system-prompt rebuild failed — using persisted prompt', {
+        agentId: agent.id,
+        targetModel,
+        error: err.message,
+      });
+      return agent.systemPrompt;
+    }
+  }
+
+  /**
+   * Look up a model's API type from the catalog. Returns 'responses',
+   * 'chat_completion', or undefined when unknown. The catalog exposes
+   * `api_type` as an array and/or `capabilities.responses`/`capabilities.chatCompletion`
+   * — mirror the backend's _inferRouting precedence so the CLI's
+   * classification matches the backend's routing decision exactly.
+   * @private
+   */
+  _resolveModelApiType(modelName) {
+    try {
+      if (!this.modelsService || typeof this.modelsService.getModels !== 'function') return undefined;
+      const models = this.modelsService.getModels();
+      const m = models.find(x => x.name === modelName);
+      if (!m) return undefined;
+
+      const apiType = Array.isArray(m.api_type) ? m.api_type : (m.api_type ? [m.api_type] : []);
+      const caps = m.capabilities || {};
+
+      // Mirrors backend services/llmServiceFactory.js _inferRouting:
+      //   responses if api_type contains 'responses' AND not 'chat_completion'
+      //   OR capabilities.responses === 'true' / chatCompletion === 'false'
+      //   OR explicit useResponsesApi flag
+      if (apiType.includes('responses') && !apiType.includes('chat_completion')) return 'responses';
+      if (caps.chatCompletion === 'false' && (caps.responses === 'true' || apiType.includes('responses'))) return 'responses';
+      if (m.useResponsesApi) return 'responses';
+      // Name-based fallback (last resort — only when catalog has no routing data)
+      if (/codex/i.test(modelName) || /gpt.*-pro$/i.test(modelName)) return 'responses';
+      return 'chat_completion';
+    } catch (err) {
+      // Defensive — never block the turn on a classification failure.
+      this.logger?.debug?.('Model apiType resolution failed', { modelName, error: err.message });
+      return undefined;
+    }
+  }
+
+  /**
+   * Drop cached native prompts for an agent. Called by agentPool when
+   * the base prompt or capabilities change so the next turn rebuilds.
+   * Exposed so agentPool can call it without poking internal state.
+   */
+  _invalidateNativePromptCache(agentId) {
+    for (const key of this._nativePromptCache.keys()) {
+      if (key.startsWith(`${agentId}|`)) {
+        this._nativePromptCache.delete(key);
+      }
+    }
+  }
+
   /**
    * Get AI response using streaming with WebSocket broadcast
    * @param {string} agentId - Agent ID

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 {