neoagent 3.0.1-beta.8 → 3.1.0

package/server/services/manager.js

@@ -32,10 +32,7 @@ const { registerToolSecurityHooks } = require('./security/tool_security_hook');
 const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
-const {
-  ScreenRecorder,
-  hasOpenConnectionForUser,
-} = require('./desktop/screenRecorder');
+const { TimelineService } = require('./timeline/service');
 const { WearableService } = require('./wearable/service');
 const { getRuntimeValidation } = require('./runtime/validation');
 const {
@@ -96,6 +93,16 @@ function createDesktopCompanionRegistry(app) {
   return registry;
 }
 
+function createTimelineService(app, io) {
+  const timelineService = registerLocal(
+    app,
+    'timelineService',
+    new TimelineService({ io }),
+  );
+  logServiceReady('Timeline service ready');
+  return timelineService;
+}
+
 function createMemoryManager(app) {
   const memoryManager = registerLocal(app, 'memoryManager', new MemoryManager());
   memoryManager.startEmbeddingIndexBackfill();
@@ -406,30 +413,6 @@ function createWearableService(app) {
   return wearableService;
 }
 
-function createScreenRecorder(app) {
-  const hasActiveCaptureSessionForUser = (userId) => {
-    return (
-      hasOpenConnectionForUser(app.locals.desktopCompanionRegistry, userId)
-      || hasOpenConnectionForUser(app.locals.browserExtensionRegistry, userId)
-    );
-  };
-
-  const screenRecorder = registerLocal(
-    app,
-    'screenRecorder',
-    new ScreenRecorder({ hasActiveCaptureSessionForUser }),
-  );
-  const status = screenRecorder.start();
-  if (status.state === 'running') {
-    logServiceReady(
-      `Screen recorder started for user ${status.ownerUserId} (${status.intervalMs}ms interval)`,
-    );
-  } else {
-    logServiceReady(`Screen recorder ${status.state}: ${status.reason}`);
-  }
-  return screenRecorder;
-}
-
 function restoreMessagingConnections(messagingManager) {
   void runBackgroundTask('[Messaging] Restore error:', () =>
     messagingManager.restoreConnections(),
@@ -486,6 +469,7 @@ async function startServices(app, io) {
     createWorkspaceManager(app);
     createBrowserExtensionRegistry(app);
     createDesktopCompanionRegistry(app);
+    createTimelineService(app, io);
     const memoryManager = createMemoryManager(app);
     const mcpClient = createMcpClient(app);
     createAuthProviderManager(app);
@@ -531,7 +515,6 @@ async function startServices(app, io) {
     createSocialVideoService(app);
     createWidgetService(app);
     createWearableService(app);
-    createScreenRecorder(app);
 
     restoreMessagingConnections(messagingManager);
     restoreMcpClients(mcpClient);
@@ -710,19 +693,6 @@ async function stopServices(app) {
     }
   }
 
-  if (app.locals.screenRecorder) {
-    tasks.push(
-      Promise.resolve()
-        .then(() => app.locals.screenRecorder.stop())
-        .then((status) => {
-          logServiceReady(`Screen recorder shutdown complete (${status.state})`);
-        })
-        .catch((err) => {
-          console.error('[ScreenRecorder] Stop error:', getErrorMessage(err));
-        }),
-    );
-  }
-
   if (app.locals.browserExtensionRegistry) {
     try {
       app.locals.browserExtensionRegistry.closeAll();

package/server/services/memory/ingestion_chunking.js

@@ -4,6 +4,47 @@ const crypto = require('node:crypto');
 
 const TARGET_CHARS = 1400;
 const MAX_CHARS = 2200;
+const TARGET_SEGMENT_WORDS = 260;
+
+const SEGMENT_TYPES = new Set([
+  'Caption',
+  'Footnote',
+  'Formula',
+  'ListItem',
+  'Page',
+  'PageFooter',
+  'PageHeader',
+  'Picture',
+  'SectionHeader',
+  'Table',
+  'Text',
+  'Title',
+]);
+
+const SEGMENT_ALIASES = Object.freeze({
+  caption: 'Caption',
+  footnote: 'Footnote',
+  formula: 'Formula',
+  listitem: 'ListItem',
+  list_item: 'ListItem',
+  'list item': 'ListItem',
+  page: 'Page',
+  pagefooter: 'PageFooter',
+  page_footer: 'PageFooter',
+  'page footer': 'PageFooter',
+  pageheader: 'PageHeader',
+  page_header: 'PageHeader',
+  'page header': 'PageHeader',
+  picture: 'Picture',
+  image: 'Picture',
+  figure: 'Picture',
+  sectionheader: 'SectionHeader',
+  section_header: 'SectionHeader',
+  'section header': 'SectionHeader',
+  table: 'Table',
+  text: 'Text',
+  title: 'Title',
+});
 
 function contentHash(content) {
   return crypto.createHash('sha256').update(content).digest('hex');
@@ -107,10 +148,237 @@ function packBlocksWithPositions(blocksWithPos) {
   }));
 }
 
+function wordCount(text) {
+  return (String(text || '').trim().match(/\S+/g) || []).length;
+}
+
+function normalizeSegmentType(value) {
+  const raw = String(value || '').trim();
+  if (SEGMENT_TYPES.has(raw)) return raw;
+  return SEGMENT_ALIASES[raw.toLowerCase()] || 'Text';
+}
+
+function normalizeNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function normalizeBoundingBox(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const left = normalizeNumber(value.left ?? value.x ?? value.x1);
+  const top = normalizeNumber(value.top ?? value.y ?? value.y1);
+  const width = normalizeNumber(value.width ?? (
+    value.x2 != null && left != null ? Number(value.x2) - left : null
+  ));
+  const height = normalizeNumber(value.height ?? (
+    value.y2 != null && top != null ? Number(value.y2) - top : null
+  ));
+  if ([left, top, width, height].some((number) => number == null)) return null;
+  return { left, top, width, height };
+}
+
+function segmentEmbedContent(segment) {
+  return [
+    segment.llm,
+    segment.markdown,
+    segment.html,
+    segment.text,
+    segment.content,
+  ].map((value) => String(value || '').trim()).find(Boolean) || '';
+}
+
+function normalizeLayoutSegments(document) {
+  const segments = Array.isArray(document?.payload?.segments)
+    ? document.payload.segments
+    : [];
+  const normalized = [];
+  for (const segment of segments) {
+    if (!segment || typeof segment !== 'object' || Array.isArray(segment)) continue;
+    const content = segmentEmbedContent(segment);
+    if (!content) continue;
+    const segmentType = normalizeSegmentType(segment.type || segment.segmentType || segment.segment_type);
+    normalized.push({
+      id: String(segment.id || segment.segmentId || segment.segment_id || '').trim() || null,
+      type: segmentType,
+      content,
+      wordCount: wordCount(content),
+      pageNumber: normalizeNumber(segment.pageNumber ?? segment.page_number),
+      pageWidth: normalizeNumber(segment.pageWidth ?? segment.page_width),
+      pageHeight: normalizeNumber(segment.pageHeight ?? segment.page_height),
+      bbox: normalizeBoundingBox(segment.bbox || segment.boundingBox || segment.bounding_box),
+      confidence: normalizeNumber(segment.confidence),
+    });
+  }
+  return normalized;
+}
+
+function segmentHierarchyLevel(type) {
+  if (type === 'Title') return 3;
+  if (type === 'SectionHeader') return 2;
+  return 1;
+}
+
+function isAssetType(type) {
+  return type === 'Picture' || type === 'Table';
+}
+
+function hasAdjacentAssetCaptionPair(segments) {
+  return segments.some((segment, index) => {
+    const nextType = segments[index + 1]?.type;
+    return (isAssetType(segment.type) && nextType === 'Caption')
+      || (segment.type === 'Caption' && isAssetType(nextType));
+  });
+}
+
+function findSegmentPosition(content, rendered, searchOffset) {
+  const pos = content.indexOf(rendered, searchOffset);
+  if (pos >= 0) return { charStart: pos, charEnd: pos + rendered.length };
+
+  const compactRendered = String(rendered || '').replace(/\s+/g, ' ').trim();
+  if (compactRendered && compactRendered.length <= 160) {
+    const compactContent = content.replace(/\s+/g, ' ');
+    const compactPos = compactContent.indexOf(compactRendered);
+    if (compactPos >= 0) {
+      return {
+        charStart: Math.min(compactPos, content.length),
+        charEnd: Math.min(compactPos + compactRendered.length, content.length),
+      };
+    }
+  }
+
+  return {
+    charStart: Math.min(searchOffset, content.length),
+    charEnd: Math.min(searchOffset + rendered.length, content.length),
+  };
+}
+
+function metadataForSegments(segments, boundary = 'layout_segments') {
+  const pageNumbers = [...new Set(
+    segments.map((segment) => segment.pageNumber).filter((number) => number != null),
+  )];
+  const segmentTypes = [...new Set(segments.map((segment) => segment.type))];
+  const resolvedBoundary = boundary === 'layout_segments' && hasAdjacentAssetCaptionPair(segments)
+    ? 'asset_caption_pair'
+    : boundary;
+  return {
+    boundary: resolvedBoundary,
+    segmentTypes,
+    segmentIds: segments.map((segment) => segment.id).filter(Boolean),
+    segments: segments.map((segment) => ({
+      id: segment.id,
+      type: segment.type,
+      pageNumber: segment.pageNumber,
+      pageWidth: segment.pageWidth,
+      pageHeight: segment.pageHeight,
+      confidence: segment.confidence,
+    })),
+    pageNumbers,
+    pages: pageNumbers,
+    bboxes: segments
+      .map((segment) => segment.bbox && {
+        segmentId: segment.id,
+        type: segment.type,
+        pageNumber: segment.pageNumber,
+        bbox: segment.bbox,
+      })
+      .filter(Boolean),
+  };
+}
+
+function finalizeSegmentChunk(chunks, group, content, searchState, boundary = 'layout_segments') {
+  if (!group.length) return;
+  const rendered = group.map((segment) => segment.content).join('\n\n');
+  const position = findSegmentPosition(content, rendered, searchState.offset);
+  searchState.offset = Math.max(searchState.offset, position.charEnd);
+  const metadata = metadataForSegments(group, boundary);
+  for (const part of splitOversizedWithPos({
+    content: rendered,
+    charStart: position.charStart,
+  })) {
+    chunks.push({
+      content: part.content,
+      charStart: part.charStart,
+      charEnd: Math.min(part.charEnd, position.charEnd),
+      metadata,
+    });
+  }
+}
+
+function chunkLayoutSegments(document, content) {
+  const segments = normalizeLayoutSegments(document);
+  if (!segments.length) return null;
+
+  const chunks = [];
+  let group = [];
+  let groupWordCount = 0;
+  let previousHierarchyLevel = 1;
+  const searchState = { offset: 0 };
+
+  const finalize = (boundary = 'layout_segments') => {
+    finalizeSegmentChunk(chunks, group, content, searchState, boundary);
+    group = [];
+    groupWordCount = 0;
+  };
+
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    if (segment.type === 'PageHeader' || segment.type === 'PageFooter') {
+      continue;
+    }
+
+    const hierarchyLevel = segmentHierarchyLevel(segment.type);
+    if (segment.type === 'Title' || segment.type === 'SectionHeader') {
+      if (group.length && hierarchyLevel > previousHierarchyLevel) {
+        finalize('section');
+      }
+      group.push(segment);
+      groupWordCount += segment.wordCount;
+      previousHierarchyLevel = hierarchyLevel;
+      continue;
+    }
+
+    let keepWithNext = false;
+    if (isAssetType(segment.type)) {
+      keepWithNext = segments[i + 1]?.type === 'Caption';
+    } else if (segment.type === 'Caption') {
+      keepWithNext = isAssetType(segments[i + 1]?.type);
+    }
+
+    const nextSegment = keepWithNext ? segments[i + 1] : null;
+    const pairedWordCount = segment.wordCount + (nextSegment?.wordCount || 0);
+    const wouldOverflow = group.length && groupWordCount + pairedWordCount > TARGET_SEGMENT_WORDS;
+
+    if (wouldOverflow) finalize('layout_segments');
+
+    group.push(segment);
+    groupWordCount += segment.wordCount;
+
+    if (groupWordCount > TARGET_SEGMENT_WORDS && !keepWithNext) {
+      finalize('layout_segments');
+    }
+
+    previousHierarchyLevel = hierarchyLevel;
+  }
+
+  finalize('layout_segments');
+
+  return chunks.map((chunk, chunkIndex) => ({
+    chunkIndex,
+    charStart: chunk.charStart,
+    charEnd: chunk.charEnd,
+    content: chunk.content,
+    contentHash: contentHash(chunk.content),
+    metadata: chunk.metadata,
+  }));
+}
+
 function chunkDocument(document) {
   const content = String(document?.content || '').trim();
   if (!content) return [];
 
+  const layoutChunks = chunkLayoutSegments(document, content);
+  if (layoutChunks) return layoutChunks;
+
   const messages = messageBlocks(document);
   if (messages.length) {
     let searchOffset = 0;

package/server/services/messaging/telnyx.js

@@ -78,11 +78,12 @@ class TelnyxVoicePlatform extends BasePlatform {
     const token = process.env.TELNYX_WEBHOOK_TOKEN;
     this._webhookToken = token || null;
     const inboundUrl = `${this.webhookUrl}/api/telnyx/webhook${token ? `?token=${token}` : ''}`;
-    console.log(`[TelnyxVoice] Inbound webhook URL (configure this in the Telnyx portal): ${inboundUrl}`);
+    // Log only the base path — the token is a secret and must not appear in logs
+    console.log(`[TelnyxVoice] Inbound webhook URL (configure this in the Telnyx portal): ${this.webhookUrl}/api/telnyx/webhook`);
 
     this.status = 'connected';
     this.emit('connected');
-    console.log(`[TelnyxVoice] Connected — phone: ${this.phoneNumber}`);
+    console.log('[TelnyxVoice] Connected');
     return { status: 'connected', inboundWebhookUrl: inboundUrl };
   }
 
@@ -223,7 +224,7 @@ class TelnyxVoicePlatform extends BasePlatform {
   _banNumber(number, durationMs = 10 * 60 * 1000) {
     const key = this._normalizeNumber(number);
     this._bannedNumbers.set(key, Date.now() + durationMs);
-    console.log(`[TelnyxVoice] Banned ${number} for ${durationMs / 60000} min`);
+    console.log(`[TelnyxVoice] Banned a number for ${durationMs / 60000} min`);
   }
 
   _startSecretTimer(ccId) {
@@ -444,18 +445,18 @@ class TelnyxVoicePlatform extends BasePlatform {
               }],
             };
             if (this._isBanned(caller)) {
-              console.log(`[TelnyxVoice] Rejecting banned caller: ${caller}`);
+              console.log('[TelnyxVoice] Rejecting banned caller');
               await this._rejectCall(ccId);
               this.emit('blocked_caller', blockedInfo);
               break;
             }
             if (!this.voiceSecret) {
-              console.log(`[TelnyxVoice] Blocked non-whitelisted caller (no secret set): ${caller}`);
+              console.log('[TelnyxVoice] Blocked non-whitelisted caller (no secret set)');
               await this._rejectCall(ccId);
               this.emit('blocked_caller', blockedInfo);
               break;
             }
-            console.log(`[TelnyxVoice] Non-whitelisted caller ${caller} — awaiting secret code`);
+            console.log('[TelnyxVoice] Non-whitelisted caller — awaiting secret code');
             this._initSession(ccId, caller);
             this._session(ccId).awaitingSecret = true;
             await this._answerCall(ccId);
@@ -463,7 +464,7 @@ class TelnyxVoicePlatform extends BasePlatform {
           }
           this._initSession(ccId, caller);
           await this._answerCall(ccId);
-          console.log(`[TelnyxVoice] Answered inbound call from ${caller}`);
+          console.log(`[TelnyxVoice] Answered inbound call (${ccId.slice(-8)})`);
           break;
         }
         case 'call.answered': {
@@ -542,7 +543,7 @@ class TelnyxVoicePlatform extends BasePlatform {
                   sess.awaitingUserInput = true;
                   await this._sayText(ccId, 'Hello! I am your AI assistant. How can I help you?');
                 } else {
-                  console.log(`[TelnyxVoice] Wrong secret from ${sess.callerNumber}, banning`);
+                  console.log('[TelnyxVoice] Wrong secret, banning caller');
                   this._banNumber(sess.callerNumber);
                   this._endSession(ccId);
                   try { await this._hangupCall(ccId); } catch {}

package/server/services/recordings/manager.js

@@ -261,18 +261,11 @@ class RecordingManager {
       throw new Error('sequenceIndex must be a non-negative integer.');
     }
 
-    const maxSequence = db.prepare(`
-      SELECT MAX(sequence_index) AS maxSequence
-      FROM recording_chunks
-      WHERE source_id = ?
-    `).get(source.id)?.maxSequence;
-    const expectedNextSequence = maxSequence == null ? 0 : Number(maxSequence) + 1;
-    if (sequenceIndex > expectedNextSequence) {
-      throw new Error(
-        `Invalid chunk sequence for source "${source.source_key}": got ${sequenceIndex}, expected ${expectedNextSequence}. Sequence must be contiguous per source.`
-      );
-    }
-
+    // Accept chunks even when an earlier sequence number never arrived (e.g. a
+    // chunk upload was permanently dropped by a flaky network). A gap only
+    // costs the audio in the missing chunk; every later chunk is still stored
+    // and transcribed. Rejecting non-contiguous sequences here would instead
+    // cascade a single lost chunk into total loss of the rest of the source.
     const existing = db.prepare(`
       SELECT id
       FROM recording_chunks
@@ -481,10 +474,10 @@ class RecordingManager {
           continue;
         }
 
-        this.#assertSequentialChunks(source.source_key, chunks);
-        const sourceDuration = Math.max(
+        this.#warnOnChunkGaps(source.source_key, chunks);
+        const sourceDuration = this.#maxOf(
+          chunks.map((chunk) => Number(chunk.end_ms) || 0),
           Number(source.duration_ms) || 0,
-          ...chunks.map((chunk) => Number(chunk.end_ms) || 0),
         );
         maxDuration = Math.max(maxDuration, sourceDuration);
 
@@ -505,11 +498,11 @@ class RecordingManager {
         const sourceSegments = await this.#transcribeSourceChunks(source, chunks, {
           transcriptionModel: recordingTranscriptionModel,
         });
-        maxDuration = Math.max(
-          maxDuration,
-          ...sourceSegments.map((segment) => Number(segment.endMs) || 0),
+        const sourceSegmentEnd = this.#maxOf(
+          sourceSegments.map((segment) => Number(segment.endMs) || 0),
           sourceDuration,
         );
+        maxDuration = Math.max(maxDuration, sourceSegmentEnd);
         collectedSegments.push(...sourceSegments);
 
         db.prepare(`
@@ -518,7 +511,7 @@ class RecordingManager {
           WHERE id = ?
         `).run(
           SESSION_STATUS.completed,
-          Math.max(sourceDuration, ...sourceSegments.map((segment) => Number(segment.endMs) || 0)),
+          sourceSegmentEnd,
           new Date().toISOString(),
           source.id,
         );
@@ -839,20 +832,38 @@ class RecordingManager {
     });
   }
 
+  // Streaming recorders (browser MediaRecorder, native MPEG encoders) split a
+  // single media stream across many timeslice chunks where only the first
+  // chunk carries the container header (EBML for WebM/Ogg, ftyp/moov for MP4,
+  // frame sync for MPEG). The later chunks cannot be decoded on their own, so
+  // they MUST be concatenated back into one container before transcription.
+  // Sending them to Deepgram individually only ever decodes the first ~chunk.
+  #isConcatenableContainerMime(mime) {
+    const value = `${mime || ''}`.toLowerCase();
+    return (
+      value.includes('mpeg') ||
+      value.includes('mp3') ||
+      value.includes('webm') ||
+      value.includes('ogg') ||
+      value.includes('opus') ||
+      value.includes('mp4') ||
+      value.includes('m4a') ||
+      value.includes('aac')
+    );
+  }
+
   #canTranscribeAsMergedBinary(source, chunks) {
     if (!Array.isArray(chunks) || chunks.length === 0) {
       return false;
     }
 
-    const sourceMime = `${source.mime_type || ''}`.toLowerCase();
-    const sourceSeemsMpeg = sourceMime.includes('mpeg') || sourceMime.includes('mp3');
-    if (!sourceSeemsMpeg) {
+    if (!this.#isConcatenableContainerMime(source.mime_type)) {
       return false;
     }
 
     return chunks.every((chunk) => {
       const mime = `${chunk.mime_type || source.mime_type || ''}`.toLowerCase();
-      return mime.includes('mpeg') || mime.includes('mp3') || mime.includes('octet-stream');
+      return this.#isConcatenableContainerMime(mime) || mime.includes('octet-stream');
     });
   }
 
@@ -1056,12 +1067,34 @@ class RecordingManager {
     });
   }
 
-  #assertSequentialChunks(sourceKey, chunks) {
-    for (let index = 0; index < chunks.length; index += 1) {
-      if (Number(chunks[index].sequence_index) !== index) {
-        throw new Error(`Recording source "${sourceKey}" is missing chunk ${index}.`);
+  #warnOnChunkGaps(sourceKey, chunks) {
+    const missing = [];
+    let expected = 0;
+    for (const chunk of chunks) {
+      const sequence = Number(chunk.sequence_index) || 0;
+      while (expected < sequence) {
+        missing.push(expected);
+        expected += 1;
+      }
+      expected = sequence + 1;
+    }
+    if (missing.length > 0) {
+      console.warn(
+        `[Recordings] Source "${sourceKey}" is missing chunk(s) ${missing.slice(0, 20).join(', ')}` +
+          `${missing.length > 20 ? ', …' : ''}; transcribing the audio that did arrive.`,
+      );
+    }
+  }
+
+  #maxOf(values, seed = 0) {
+    let max = Number(seed) || 0;
+    for (const value of (Array.isArray(values) ? values : [])) {
+      const num = Number(value) || 0;
+      if (num > max) {
+        max = num;
       }
     }
+    return max;
   }
 
   #shouldTranscribeSource(source, metadata = {}) {

package/server/services/runtime/backends/local-vm.js

@@ -131,32 +131,50 @@ class RuntimeHttpClient {
   }
 
   async requestStream(method, pathname, stream, options = {}) {
-    const response = await fetch(`${this.baseUrl}${pathname}`, {
-      method,
-      headers: {
-        ...(options.contentType ? { 'content-type': options.contentType } : {}),
-        ...(options.contentLength != null ? { 'content-length': String(options.contentLength) } : {}),
-        ...(options.headers || {}),
-        ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
-      },
-      body: stream,
-      duplex: 'half',
-    });
+    const retryCount = Math.max(0, Number(options.retryCount ?? 6));
+    const retryDelayMs = Math.max(100, Number(options.retryDelayMs ?? 1000));
+    let lastError = null;
 
-    if (response.ok && typeof this.onActivity === 'function') {
-      this.onActivity();
-    }
+    for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+      try {
+        const response = await fetch(`${this.baseUrl}${pathname}`, {
+          method,
+          headers: {
+            ...(options.contentType ? { 'content-type': options.contentType } : {}),
+            ...(options.contentLength != null ? { 'content-length': String(options.contentLength) } : {}),
+            ...(options.headers || {}),
+            ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+          },
+          body: stream,
+          duplex: 'half',
+        });
 
-    const contentType = response.headers.get('content-type') || '';
-    const payload = contentType.includes('application/json')
-      ? await response.json().catch(() => ({}))
-      : { text: await response.text().catch(() => '') };
+        if (response.ok && typeof this.onActivity === 'function') {
+          this.onActivity();
+        }
+
+        const contentType = response.headers.get('content-type') || '';
+        const payload = contentType.includes('application/json')
+          ? await response.json().catch(() => ({}))
+          : { text: await response.text().catch(() => '') };
 
-    if (!response.ok) {
-      const errorMessage = payload?.error || payload?.text || `Runtime request failed: ${response.status}`;
-      throw new Error(errorMessage);
+        if (!response.ok) {
+          const errorMessage = payload?.error || payload?.text || `Runtime request failed: ${response.status}`;
+          throw new Error(errorMessage);
+        }
+        return payload;
+      } catch (error) {
+        lastError = error;
+        const message = String(error?.message || error);
+        const retryable = /fetch failed|ECONNREFUSED|ECONNRESET|socket hang up|timed out/i.test(message);
+        if (!retryable || attempt === retryCount) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
     }
-    return payload;
+
+    throw lastError || new Error('Runtime request failed.');
   }
 }