onbuzz 5.1.0 → 5.3.0

package/src/interfaces/transcribeProxy.js

@@ -0,0 +1,72 @@
+/**
+ * Speech-to-text proxy logic for the web-ui mic / dictation.
+ *
+ * Why this exists: the browser's webkitSpeechRecognition has NO working backend
+ * inside Electron (Chromium's speech service is provisioned only for official
+ * Chrome builds), so dictation silently fails in the desktop binary. The fix is
+ * to record audio in the renderer (MediaRecorder works in Electron) and POST it
+ * here; the local server attaches the platform key and forwards to the remote
+ * Loxia `/llm/transcribe` (Azure AI Foundry STT) — the same endpoint the
+ * Telegram voice-note path uses.
+ *
+ * Kept as a pure, fetch-injectable function so it's fully unit-testable without
+ * standing up the whole web server. Returns { status, body } for the route to
+ * relay verbatim.
+ */
+
+const DEFAULT_BACKEND = 'https://loxia-api-g7hrb8bxdae8a2h7.z02.azurefd.net';
+
+export async function proxyTranscribe({
+  audioBase64,
+  mimeType,
+  filename,
+  durationSeconds,
+  apiKey,
+  backendBaseUrl,
+  fetchImpl = (typeof fetch !== 'undefined' ? fetch : null),
+  logger,
+} = {}) {
+  if (!audioBase64 || typeof audioBase64 !== 'string') {
+    return { status: 400, body: { error: 'audioBase64 (string) is required' } };
+  }
+  if (!apiKey) {
+    return { status: 401, body: { error: 'No API key configured. Please configure your Loxia API key in Settings.' } };
+  }
+  if (typeof fetchImpl !== 'function') {
+    return { status: 500, body: { error: 'No fetch implementation available' } };
+  }
+
+  const base = backendBaseUrl || DEFAULT_BACKEND;
+  let response;
+  try {
+    response = await fetchImpl(`${base}/llm/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        audioBase64,
+        mimeType: mimeType || 'audio/webm',
+        filename: filename || 'dictation.webm',
+        ...(typeof durationSeconds === 'number' && { durationSeconds }),
+      }),
+    });
+  } catch (err) {
+    logger?.error?.('[transcribe] backend request failed', { error: err.message });
+    return { status: 502, body: { error: 'Transcription request failed: ' + err.message } };
+  }
+
+  if (response.status === 503) {
+    return { status: 503, body: { error: 'Voice transcription is not configured on the backend.' } };
+  }
+  if (!response.ok) {
+    let detail = '';
+    try { detail = await response.text(); } catch { /* ignore */ }
+    logger?.warn?.('[transcribe] backend non-OK', { status: response.status });
+    return { status: response.status, body: { error: `Transcription failed (${response.status})`, details: String(detail).slice(0, 300) } };
+  }
+
+  let data = {};
+  try { data = await response.json(); } catch { /* tolerate empty/non-JSON */ }
+  return { status: 200, body: { text: (data?.text || '').trim() } };
+}
+
+export default { proxyTranscribe };

package/src/interfaces/transcribeRoute.js

@@ -0,0 +1,45 @@
+/**
+ * Speech-to-text proxy route (POST /api/llm/transcribe).
+ *
+ * Extracted from webServer.setupRoutes so the API-key resolution ladder
+ * (Bearer header → apiKeyManager → config/env) and the status relay are
+ * unit-testable without standing up the full server. The heavy lifting —
+ * audio validation, backend dispatch, error mapping — lives in
+ * proxyTranscribe (already fully covered); this layer only resolves the key
+ * and forwards.
+ *
+ * apiKeyManager is read through a thunk (getApiKeyManager) because it is
+ * attached after routes are registered at boot.
+ */
+import { proxyTranscribe } from './transcribeProxy.js';
+
+/** Resolve the platform API key for a transcribe request (pure, testable). */
+export function resolveTranscribeApiKey({ authHeader, apiKeyManager, sessionId, config }) {
+  if (authHeader && authHeader.startsWith('Bearer ')) return authHeader.substring(7);
+  if (apiKeyManager) {
+    const keys = apiKeyManager.getKeysForRequest?.(sessionId || null, { platformProvided: true });
+    if (keys?.loxiaApiKey) return keys.loxiaApiKey;
+  }
+  return config?.loxiaApiKey || process.env.LOXIA_API_KEY || null;
+}
+
+export function registerTranscribeRoute(app, { getApiKeyManager, config, logger, proxyImpl = proxyTranscribe } = {}) {
+  if (!app) return;
+  app.post('/api/llm/transcribe', async (req, res) => {
+    const { audioBase64, mimeType, filename, durationSeconds, sessionId } = req.body || {};
+    const apiKeyManager = typeof getApiKeyManager === 'function' ? getApiKeyManager() : null;
+    const apiKey = resolveTranscribeApiKey({
+      authHeader: req.headers.authorization,
+      apiKeyManager, sessionId, config,
+    });
+
+    const result = await proxyImpl({
+      audioBase64, mimeType, filename, durationSeconds, apiKey,
+      backendBaseUrl: config?.backend?.baseUrl,
+      logger,
+    });
+    res.status(result.status).json(result.body);
+  });
+}
+
+export default registerTranscribeRoute;

package/src/interfaces/webServer.js

@@ -33,6 +33,13 @@ import composioService from '../services/composioService.js';
 import { getUserDataPaths } from '../utilities/userDataDir.js';
 import { projectActiveRuns } from '../utilities/flowRunFilters.js';
 import { recordOAuthResult, recordResolvedUser, projectAuthStatus, isAuthExpired } from '../utilities/authCache.js';
+import { registerTranscribeRoute } from './transcribeRoute.js';
+import { registerScheduleRoutes } from './scheduleRoutes.js';
+import { registerAttachmentRoutes } from './attachmentRoutes.js';
+import { AttachmentIngestionService } from '../services/attachments/attachmentIngestionService.js';
+import { DocumentStore } from '../services/documents/documentStore.js';
+import { DocumentMemory } from '../services/documents/documentMemory.js';
+import { DocumentIndexer } from '../services/embeddings/indexers/documentIndexer.js';
 import AuthCacheStore from '../services/authCacheStore.js';
 import { createAccountRouter } from './accountRoutes.js';
 import { createMarketplaceRouter } from './marketplaceRoutes.js';
@@ -1842,6 +1849,16 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // Speech-to-text proxy → remote /llm/transcribe (Azure AI Foundry STT).
+    // Powers web-ui dictation, especially in the Electron build where the
+    // browser's webkitSpeechRecognition has no working backend. Extracted to
+    // transcribeRoute.js so the key-resolution ladder is unit-testable.
+    registerTranscribeRoute(this.app, {
+      getApiKeyManager: () => this.apiKeyManager,
+      config: this.config,
+      logger: this.logger,
+    });
+
     // LLM Models endpoint - proxy to Loxia Azure backend
     this.app.get('/api/llm/models', async (req, res) => {
       try {
@@ -6446,129 +6463,41 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // =====================================================
     // Scheduled Tasks API
     // =====================================================
-
-    // List all schedules
-    this.app.get('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, schedules: [] });
-        }
-        const schedules = this.scheduleService.listSchedules();
-        res.json({ success: true, schedules });
-      } catch (error) {
-        this.logger.error('Failed to list schedules', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get cron presets
-    this.app.get('/api/schedules/presets', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, presets: {} });
-        }
-        res.json({ success: true, presets: this.scheduleService.getPresets() });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Create a schedule
-    this.app.post('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.createSchedule(req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to create schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get a single schedule
-    this.app.get('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(404).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Update a schedule
-    this.app.put('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to update schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Delete a schedule
-    this.app.delete('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        await this.scheduleService.deleteSchedule(req.params.id);
-        res.json({ success: true });
-      } catch (error) {
-        this.logger.error('Failed to delete schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Force-trigger a schedule immediately (used by CLI trigger-schedule command)
-    this.app.post('/api/schedules/:id/trigger', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        // Execute immediately regardless of cron timing
-        await this.scheduleService._executeSchedule(schedule);
-        schedule.lastRun = new Date().toISOString();
-        schedule.runCount++;
-        schedule.updatedAt = new Date().toISOString();
-        await this.scheduleService._saveSchedules();
-        res.json({ success: true, scheduleName: schedule.name, lastRunStatus: schedule.lastRunStatus });
-      } catch (error) {
-        this.logger.error('Failed to trigger schedule', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
+    // Extracted to scheduleRoutes.js so the whole surface is unit-testable.
+    // scheduleService is passed via a thunk: the orchestrator attaches it
+    // after routes are registered at boot.
+    registerScheduleRoutes(this.app, {
+      getScheduleService: () => this.scheduleService,
+      logger: this.logger,
     });
 
-    // Toggle schedule enabled/disabled
-    this.app.post('/api/schedules/:id/toggle', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const current = this.scheduleService.getSchedule(req.params.id);
-        if (!current) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
+    // =====================================================
+    // Chat attachment ingest (binary-safe). The ingestion service is built
+    // lazily from the orchestrator's FileAttachmentService (wired post-boot).
+    // =====================================================
+    registerAttachmentRoutes(this.app, {
+      getIngestionService: () => {
+        const fas = this.orchestrator?.fileAttachmentService;
+        if (!fas) return null;
+        if (!this._attachmentIngestion || this._attachmentIngestion.fileAttachmentService !== fas) {
+          // DocumentMemory lets large text/PDF attachments be indexed for
+          // semantic recall (shares the on-disk store with the agent scheduler's
+          // recall). Best-effort: if embeddings aren't configured the store
+          // still saves and the builder falls back to inline content.
+          let documentMemory = null;
+          try {
+            const embed = this.orchestrator?.aiService?.getEmbeddingService?.() || null;
+            documentMemory = new DocumentMemory({
+              store: new DocumentStore({ logger: this.logger }),
+              indexer: new DocumentIndexer({ embeddingService: embed, logger: this.logger }),
+              logger: this.logger,
+            });
+          } catch { documentMemory = null; }
+          this._attachmentIngestion = new AttachmentIngestionService({ fileAttachmentService: fas, documentMemory, logger: this.logger });
         }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, { enabled: !current.enabled });
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(400).json({ success: false, error: error.message });
-      }
+        return this._attachmentIngestion;
+      },
+      logger: this.logger,
     });
 
     // =====================================================

package/src/services/__tests__/aiService.editImage.test.js

@@ -0,0 +1,69 @@
+/**
+ * aiService.editImage — request payload assembly.
+ *
+ * Covers the single vs multi-reference image edit: imagesBase64[] is included
+ * only when more than one source is supplied; the first image is always sent
+ * positionally as imageBase64 (so an older backend degrades to a single-image
+ * edit). Also locks the endpoint + bearer + response mapping.
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import AIService from '../aiService.js';
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+function svc() {
+  return new AIService({ backend: { baseUrl: 'https://test.example' }, timeout: 1000 }, logger, null, null);
+}
+const bodyOf = (call) => JSON.parse(call[1].body);
+
+let fetchMock;
+beforeEach(() => {
+  fetchMock = jest.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    json: async () => ({ images: [{ b64_json: 'edited' }], model: 'gpt-image-1.5' }),
+  });
+  global.fetch = fetchMock;
+});
+afterEach(() => { delete global.fetch; });
+
+describe('editImage payload', () => {
+  test('single source → imageBase64 set, no imagesBase64', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toBeUndefined();
+  });
+
+  test('multiple sources → imagesBase64 array forwarded, first also positional', async () => {
+    await svc().editImage('compose', 'AAA', { apiKey: 'k', imagesBase64: ['AAA', 'BBB', 'CCC'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toEqual(['AAA', 'BBB', 'CCC']);
+  });
+
+  test('a single-element imagesBase64 is NOT forwarded (legacy single path)', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', imagesBase64: ['AAA'] });
+    expect(bodyOf(fetchMock.mock.calls[0]).imagesBase64).toBeUndefined();
+  });
+
+  test('forwards the mask when provided', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', maskBase64: 'MASK', imagesBase64: ['AAA', 'BBB'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.maskBase64).toBe('MASK');
+    expect(body.imagesBase64).toHaveLength(2);
+  });
+
+  test('POSTs to /llm/edit-image with a bearer token and returns the b64_json', async () => {
+    const res = await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toContain('/llm/edit-image');
+    expect(init.method).toBe('POST');
+    expect(init.headers.Authorization).toBe('Bearer k');
+    expect(res.b64_json).toBe('edited');
+  });
+
+  test('rejects when no source image is supplied', async () => {
+    await expect(svc().editImage('edit', '', { apiKey: 'k' })).rejects.toThrow(/requires a source image/i);
+  });
+});

package/src/services/__tests__/fileAttachmentService.test.js

@@ -121,9 +121,26 @@ describe('FileAttachmentService', () => {
     expect(result.fileId).toBe('test-uuid-1234');
     expect(result.agentId).toBe('agent-1');
     expect(result.mode).toBe('content');
+    expect(result.scope).toBe('agent'); // default scope
+    expect(result.conversationId).toBeNull();
     expect(service.index.attachments['test-uuid-1234']).toBeDefined();
   });
 
+  test('uploadFile records conversation scope when requested', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.getFileStats.mockResolvedValue({ size: 512, modified: new Date() });
+    mockFileProcessor.processFile.mockResolvedValue({ content: 'text content' });
+    mockValidator.validate.mockReturnValue({ valid: true, errors: [], warnings: [], sizeLevel: 'small' });
+
+    const result = await service.uploadFile({
+      agentId: 'agent-1', filePath: '/path/to/file.txt', mode: 'content',
+      scope: 'conversation', conversationId: 'conv-9',
+    });
+    expect(result.scope).toBe('conversation');
+    expect(result.conversationId).toBe('conv-9');
+  });
+
   test('uploadFile throws for non-existent file', async () => {
     service.index = { attachments: {}, agentRefs: {} };
     mockFileProcessor.fileExists.mockResolvedValueOnce(false);
@@ -275,4 +292,20 @@ describe('FileAttachmentService', () => {
     const preview = await service.getAttachmentPreview('f1');
     expect(preview).toBe('[Image content - base64 encoded]');
   });
+
+  test('updateAttachment persists docId + indexed (DocumentStore link)', async () => {
+    service.index = { attachments: { f1: { agentId: 'a1', fileName: 'big.txt', active: true } }, agentRefs: {} };
+    const metadata = { fileId: 'f1', agentId: 'a1', fileName: 'big.txt', active: true };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify(metadata));
+
+    const updated = await service.updateAttachment('f1', { docId: 'doc-1', indexed: true, fileName: 'renamed.txt' });
+
+    expect(updated.docId).toBe('doc-1');
+    expect(updated.indexed).toBe(true);
+    expect(updated.fileName).toBe('renamed.txt');
+    const written = mockFileProcessor.writeFile.mock.calls.find((c) => String(c[0]).endsWith('metadata.json'));
+    expect(written[1]).toContain('"docId": "doc-1"');
+    expect(written[1]).toContain('"indexed": true');
+  });
 });