@loxia-labs/loxia-autopilot-one 5.0.1 → 5.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loxia-labs/loxia-autopilot-one",
-  "version": "5.0.1",
+  "version": "5.0.2",
   "description": "Loxia AI Agents System - No-code/vibe-code/companion-coder platform",
   "type": "module",
   "main": "src/index.js",
@@ -134,7 +134,7 @@
       {
         "provider": "github",
         "owner": "Loxia-ai",
-        "repo": "autopilot"
+        "repo": "autopilot-releases"
       }
     ],
     "directories": {

package/src/__tests__/autoUpdateConfig.test.js

@@ -63,6 +63,19 @@ describe('package.json — auto-update presence', () => {
     expect(github.repo).not.toMatch(/^(your-repo|TODO|placeholder)$/i);
   });
 
+  test('GitHub publish repo matches the release workflow target (autopilot-releases)', () => {
+    // build-binaries.yml's create-release job uploads assets (and the
+    // electron-updater latest.yml feed) to `Loxia-ai/autopilot-releases`.
+    // If build.publish.repo drifts back to `autopilot`, electron-updater
+    // polls a repo with no release feed and the desktop app never updates.
+    const entries = Array.isArray(pkg.build.publish) ? pkg.build.publish : [pkg.build.publish];
+    const github = entries.find(e => e.provider === 'github');
+    expect(github).toBeTruthy();
+    expect(github.repo).toBe('autopilot-releases');
+    const workflow = readFileSync(join(REPO_ROOT, '.github/workflows/build-binaries.yml'), 'utf8');
+    expect(workflow).toMatch(new RegExp(`${github.owner}/${github.repo}`));
+  });
+
   test('update-notifier source file exists and is referenced by the CLI entry point', () => {
     // Tripwire against accidental file deletion. The runtime is
     // tolerant of missing dependencies (dynamic import), but if the

package/src/core/__tests__/agentScheduler.emptyConversation.test.js

@@ -0,0 +1,132 @@
+/**
+ * Empty-conversation guard on AgentScheduler.
+ *
+ * Repro for the recurring "No messages to send - messages array is empty"
+ * error stream: an AGENT-mode agent can be scheduled active (pending tasks,
+ * or residual TTL) while its PERSISTED conversation is empty — history was
+ * cleared, an imported/seeded agent, or tasks that outlived their messages.
+ * getMessagesForAI() then returns [], the AI service rejects the empty
+ * array, and the scheduler burns a cycle EVERY tick logging the same error.
+ *
+ * The fix resolves the empty case deterministically:
+ *   - AGENT mode + an actionable (pending/in-progress) task → seed a
+ *     transient kickoff user turn so the model can start its task list.
+ *   - otherwise → skip the AI request entirely (return null) and stay idle.
+ *
+ * Two layers are covered:
+ *   1. _resolveEmptyConversationMessages() — the pure decision (all branches).
+ *   2. getAgentAIResponse() — proves the AI service is NEVER called when the
+ *      conversation is empty and there's no actionable task (no error stream).
+ */
+import { jest, describe, test, expect } from '@jest/globals';
+
+// Stub the activity service so importing the scheduler doesn't drag in the
+// full agent dependency graph.
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: () => ({ active: false, reason: 'stub' }),
+  getActiveAgents: () => [],
+  shouldSkipIteration: () => false,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+
+function makeScheduler({ agentPool = {}, aiService = {}, logger = null } = {}) {
+  const pool = {
+    getAllAgents: async () => new Map(),
+    getAgent: async () => null,
+    getMessagesForAI: async () => [],
+    persistAgentState: async () => {},
+    getCompactionMetadata: async () => null,
+    ...agentPool,
+  };
+  const log = logger || { info() {}, warn() {}, error() {}, debug() {} };
+  return new AgentScheduler(pool, {}, aiService, log, null, null, null);
+}
+
+// ─── 1. Pure decision: _resolveEmptyConversationMessages ────────────────
+
+describe('_resolveEmptyConversationMessages', () => {
+  const scheduler = makeScheduler();
+
+  test('AGENT mode + a pending task → seeds a single user kickoff turn', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'pending' }] },
+    });
+    expect(Array.isArray(out)).toBe(true);
+    expect(out).toHaveLength(1);
+    expect(out[0].role).toBe('user');
+    expect(out[0].content.length).toBeGreaterThan(0);
+  });
+
+  test('AGENT mode + an in-progress task → also seeds a kickoff turn', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'in_progress' }] },
+    });
+    expect(out).toHaveLength(1);
+    expect(out[0].role).toBe('user');
+  });
+
+  test('AGENT mode + only completed/cancelled tasks → null (idle)', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'completed' }, { status: 'cancelled' }] },
+    });
+    expect(out).toBeNull();
+  });
+
+  test('AGENT mode + no taskList → null (e.g. residual TTL, no work)', () => {
+    expect(scheduler._resolveEmptyConversationMessages({ mode: 'agent' })).toBeNull();
+  });
+
+  test('CHAT mode + a pending task → null (only AGENT mode kicks off)', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'chat',
+      taskList: { tasks: [{ status: 'pending' }] },
+    });
+    expect(out).toBeNull();
+  });
+
+  test('null/undefined agent → null (defensive, no throw)', () => {
+    expect(scheduler._resolveEmptyConversationMessages(null)).toBeNull();
+    expect(scheduler._resolveEmptyConversationMessages(undefined)).toBeNull();
+  });
+});
+
+// ─── 2. getAgentAIResponse never calls the AI service when empty+idle ────
+
+describe('getAgentAIResponse — empty conversation, no actionable task', () => {
+  test('returns null and NEVER calls the AI service (no error stream)', async () => {
+    const agent = {
+      id: 'a1',
+      name: 'Idle Agent',
+      mode: 'agent',
+      currentModel: 'model-x',
+      sessionId: 'sess-1',
+      dynamicModelRouting: false,
+      taskList: { tasks: [] },               // no actionable work
+      conversations: { full: { messages: [] } },
+    };
+
+    const sendMessage = jest.fn();
+    const sendMessageStream = jest.fn();
+
+    const scheduler = makeScheduler({
+      agentPool: { getAgent: async () => agent, getMessagesForAI: async () => [] },
+      aiService: { sendMessage, sendMessageStream },
+    });
+
+    // Skip the compaction subsystem — not under test here.
+    scheduler.checkAndPerformCompaction = async () => ({
+      shouldContinue: true,
+      compactionPerformed: false,
+    });
+
+    const result = await scheduler.getAgentAIResponse('a1');
+
+    expect(result).toBeNull();
+    expect(sendMessage).not.toHaveBeenCalled();
+    expect(sendMessageStream).not.toHaveBeenCalled();
+  });
+});

package/src/core/__tests__/agentScheduler.errorCategorisation.test.js

@@ -102,6 +102,13 @@ const errorClasses = [
   // -- PERSISTENT: genuinely unknown → server-error --
   { name: 'unknown: random 500',     msg: 'Random 500 Internal Server Error from the AI', expectBroadcast: true, label: 'server-error' },
   { name: 'unknown: weird shape',    msg: 'Provider returned malformed JSON',   expectBroadcast: true, label: 'server-error' },
+
+  // -- INTERNAL client-side payload error → internal-empty-payload (silent).
+  // Our OWN empty-array guard, NOT a model fault. Must NOT broadcast (no
+  // user alarm) and must NOT be misclassified as server-error (which would
+  // blame the model). See the dedicated "model not blamed" block below.
+  { name: 'empty payload: no messages to send', msg: 'No messages to send - messages array is empty', expectBroadcast: false, label: 'internal-empty-payload' },
+  { name: 'empty payload: array is empty',      msg: 'messages array is empty', expectBroadcast: false, label: 'internal-empty-payload' },
 ];
 
 describe('handleAIServiceFailure: error categorisation', () => {
@@ -194,6 +201,33 @@ describe('handleAIServiceFailure: diagnostic conversation turn + lastError snaps
   });
 });
 
+describe('handleAIServiceFailure: internal empty-payload does NOT blame the model', () => {
+  // Regression guard for the "burned model" symptom: an internal empty-array
+  // error must never be attributed to agent.currentModel.
+  const messages = [
+    'No messages to send - messages array is empty',
+    'messages array is empty',
+  ];
+
+  describe.each(messages)('"%s"', (msg) => {
+    test('records NO model-attributed failure turn and sets no lastError', async () => {
+      const { scheduler, agent, broadcasts } = makeScheduler();
+      await scheduler.handleAIServiceFailure('a1', new Error(msg));
+
+      // The whole point: no error turn stamped with `model`, no lastError.
+      expect(agent.conversations.full.messages.length).toBe(0);
+      expect(agent.conversations['test-model'].messages.length).toBe(0);
+      expect(agent.lastError).toBeUndefined();
+
+      // No user-facing alarm.
+      expect(broadcasts.filter(b => b.payload?.type === 'agent_error').length).toBe(0);
+
+      // Quiet state hint with the dedicated label (not 'server-error').
+      expect(scheduler.broadcastAgentStateUpdate).toHaveBeenCalledWith('a1', 'internal-empty-payload');
+    });
+  });
+});
+
 describe('handleAIServiceFailure: gateway 503 takes the network delay, not the rate-limit delay', () => {
   test('uses NETWORK_ERROR_DELAY_MS for 503 errors', async () => {
     const { scheduler, agentPool, agent } = makeScheduler();

package/src/core/agentScheduler.js

@@ -1777,6 +1777,41 @@ class AgentScheduler {
    * @returns {Promise<Object|null>} AI response or null if failed
    * @private
    */
+  /**
+   * Decide what to send when an agent's PERSISTED conversation is empty
+   * but the scheduler still picked it up (AGENT mode with pending tasks, or
+   * residual TTL). Without this, getMessagesForAI() returns [] and the AI
+   * service throws "No messages to send - messages array is empty" every
+   * cycle — a visible, recurring error stream that never makes progress.
+   *
+   * Returns:
+   *   - a one-element kickoff message array (transient, NOT persisted) when
+   *     the agent is in AGENT mode and has at least one actionable
+   *     (pending/in-progress) task — so the model can start its task list;
+   *   - null otherwise, signalling the caller to skip the AI request and
+   *     leave the agent idle until real work arrives.
+   *
+   * Pure + side-effect-free → unit-testable in isolation.
+   *
+   * @param {Object} agent
+   * @returns {Array<{role:string,content:string}>|null}
+   */
+  _resolveEmptyConversationMessages(agent) {
+    const tasks = agent?.taskList?.tasks || [];
+    const hasActionableTask = tasks.some(
+      (t) => t && (t.status === 'pending' || t.status === 'in_progress')
+    );
+    if (agent?.mode === AGENT_MODES.AGENT && hasActionableTask) {
+      return [{
+        role: MESSAGE_ROLES.USER,
+        content:
+          'Begin working on your pending tasks. Review your task list with the ' +
+          'TaskManager tool and proceed with the next actionable task.',
+      }];
+    }
+    return null;
+  }
+
   async getAgentAIResponse(agentId) {
     try {
       const agent = await this.agentPool.getAgent(agentId);
@@ -1965,7 +2000,28 @@ class AgentScheduler {
       }
 
       // After compaction, retrieve messages from AgentPool (will use compacted if available)
-      const messagesToSend = await this.agentPool.getMessagesForAI(agentId, targetModel);
+      let messagesToSend = await this.agentPool.getMessagesForAI(agentId, targetModel);
+
+      // Empty-conversation guard. The agent can be scheduled active while its
+      // persisted conversation is empty (history cleared, imported/seeded
+      // agent, or tasks that outlived their messages). Sending [] makes the
+      // AI service throw "messages array is empty" on EVERY cycle. Resolve it
+      // deterministically: seed a transient kickoff turn when there's still
+      // actionable work, otherwise skip the doomed request and stay idle.
+      if (!messagesToSend || messagesToSend.length === 0) {
+        const seeded = this._resolveEmptyConversationMessages(agent);
+        if (!seeded) {
+          this.logger.debug(
+            `Skipping AI request for agent ${agentId}: empty conversation and no actionable tasks`
+          );
+          return null;
+        }
+        this.logger.info(
+          `Seeding kickoff turn for agent ${agentId} (empty conversation, actionable task pending)`,
+          { agentName: agent.name }
+        );
+        messagesToSend = seeded;
+      }
 
       // ── Pick the right system-prompt shape for the target model ──
       // Default: use the agent's persisted `systemPrompt` (baked at
@@ -2965,6 +3021,33 @@ class AgentScheduler {
       || errorMessage.includes('enotfound')
       || errorMessage.includes('fetch failed');
 
+    // INTERNAL client-side payload-validation failure — NOT a model/provider
+    // fault. The AI service throws "No messages to send - messages array is
+    // empty" from its own pre-flight guard when we hand it an empty array.
+    // If this falls through to the `else` (unknown) branch it gets recorded
+    // as a 'server-error' turn ATTRIBUTED TO agent.currentModel (and stamped
+    // into agent.lastError.model) and broadcast to the UI/Telegram — i.e. a
+    // perfectly good model gets "burned" for our bug. Detect it here and
+    // handle it quietly: no model-blaming failure turn, no user alarm.
+    const isInternalEmptyPayload =
+         errorMessage.includes('no messages to send')
+      || errorMessage.includes('messages array is empty');
+
+    if (isInternalEmptyPayload) {
+      // Quiet, model-agnostic handling. Deliberately does NOT call
+      // _recordAgentFailure (which would attribute the error to the model)
+      // and does NOT broadcast agent_error. A short delay prevents a hot
+      // loop if some upstream path keeps producing an empty payload.
+      this.logger.warn(
+        `Agent ${agentId} skipped a cycle: empty AI payload (internal, not a model error)`,
+        { errorMessage: error.message }
+      );
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.NETWORK_ERROR_DELAY_MS).toISOString();
+      await this.agentPool.persistAgentState(agentId);
+      await this.broadcastAgentStateUpdate(agentId, 'internal-empty-payload');
+      return;
+    }
+
     if (isAuthError) {
       // PERSISTENT — only the user can resolve. Long pause + broadcast so
       // the Telegram fanout (and UI banner) tell them what's wrong.

package/src/index.js

@@ -47,7 +47,6 @@ 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';
@@ -494,16 +493,6 @@ 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);
 
@@ -665,15 +654,6 @@ class LoxiaApplication {
       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');
@@ -707,7 +687,7 @@ class LoxiaApplication {
     //
     // We sweep every registered tool here, AFTER the explicit per-tool
     // wiring above. Tools that already have aiService set (image, vision,
-    // video, foundry-web-search, desktop) are skipped; everyone else
+    // video, desktop) are skipped; everyone else
     // gets it now. The assignment is harmless for tools that ignore the
     // property.
     {

package/src/interfaces/webServer.js

@@ -37,6 +37,7 @@ import AuthCacheStore from '../services/authCacheStore.js';
 import { createAccountRouter } from './accountRoutes.js';
 import { createMarketplaceRouter } from './marketplaceRoutes.js';
 import { getBrand } from '../utilities/brand.js';
+import { getDistribution } from '../utilities/updateNotifier.js';
 
 // Connect visual editor server to bridge (enables element selection forwarding)
 setBridgeGetter(getVisualEditorBridge);
@@ -1089,16 +1090,30 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // System Update API
     // =====================================================
 
-    // Check update status
+    // Check update status — brand + distribution aware. The package
+    // name, bin name and update command are ALL derived from the running
+    // package.json so OnBuzz reports `npm i -g onbuzz` and Autopilot
+    // reports `npm i -g @loxia-labs/loxia-autopilot-one`. canSelfUpdate
+    // is false for electron (self-updates via electron-updater) and pkg
+    // (standalone binary) so the UI can hide the in-app "Auto-update".
     this.app.get('/api/system/update-status', async (req, res) => {
       try {
         const packageJsonPath = path.join(__dirname, '../../package.json');
         const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
 
+        const packageName = packageJson.name || '@loxia-labs/loxia-autopilot-one';
+        const binName = Object.keys(packageJson.bin || {})[0] || 'loxia';
+        const distribution = getDistribution(process, process.env);
+        const canSelfUpdate = distribution === 'npm';
+
         res.json({
           success: true,
           currentVersion: packageJson.version || '1.0.0',
-          updateCommand: 'npm i -g @loxia-labs/loxia-autopilot-one@latest'
+          packageName,
+          binName,
+          distribution,
+          canSelfUpdate,
+          updateCommand: `npm i -g ${packageName}@latest`
         });
       } catch (error) {
         res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
@@ -1138,13 +1153,39 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
         });
       }
 
-      const { restartCommand = 'loxia web', restartDelay = 5000 } = req.body || {};
+      // Derive brand-correct package + bin names from the running manifest.
+      let packageName = '@loxia-labs/loxia-autopilot-one';
+      let binName = 'loxia';
+      try {
+        const packageJsonPath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+        packageName = packageJson.name || packageName;
+        binName = Object.keys(packageJson.bin || {})[0] || binName;
+      } catch { /* fall back to autopilot defaults */ }
+
+      // Refuse self-update for distributions that can't be npm-updated:
+      // electron self-updates via electron-updater; pkg is a standalone
+      // binary. Doing `npm i -g` there would be a no-op at best.
+      const distribution = getDistribution(process, process.env);
+      if (distribution !== 'npm') {
+        return res.status(HTTP_STATUS.BAD_REQUEST).json({
+          success: false,
+          error: distribution === 'electron'
+            ? 'This desktop app updates itself automatically — no manual update needed.'
+            : 'This standalone build cannot self-update. Download the latest release instead.',
+          distribution,
+          canSelfUpdate: false
+        });
+      }
+
+      const updateCommand = `npm i -g ${packageName}@latest`;
+      const { restartCommand = `${binName} web`, restartDelay = 5000 } = req.body || {};
 
       try {
-        this.logger.info('Starting system update...');
+        this.logger.info('Starting system update...', { packageName, distribution });
 
         // Run npm install
-        const updateOutput = execSync('npm i -g @loxia-labs/loxia-autopilot-one@latest', {
+        const updateOutput = execSync(updateCommand, {
           encoding: 'utf8',
           timeout: 120000, // 2 minute timeout
           stdio: ['pipe', 'pipe', 'pipe']
@@ -1205,7 +1246,7 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
         res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
           success: false,
           error: error.message,
-          hint: 'Try running manually: npm i -g @loxia-labs/loxia-autopilot-one@latest'
+          hint: `Try running manually: ${updateCommand}`
         });
       }
     });