neoagent 2.5.2-beta.1 → 2.5.2-beta.10

package/server/services/ai/loop/run_state.js

@@ -0,0 +1,356 @@
+'use strict';
+
+const { v4: uuidv4 } = require('uuid');
+const db = require('../../../db/database');
+const { activateTools } = require('../toolSelector');
+const { recordRunEvent } = require('../runEvents');
+const { parseMaybeJson } = require('../logFormat');
+const { mergeGoalContracts } = require('./completion_judge');
+const { buildInitialProgressLedger } = require('./progress_monitor');
+const {
+  createDeliveryState,
+  markInterimDelivered,
+  markFinalDelivered,
+} = require('./delivery_state');
+
+function isoNow() {
+  return new Date().toISOString();
+}
+
+function persistRunMetadata(_engine, runId, patch = {}) {
+  if (!runId || !patch || typeof patch !== 'object') return;
+  const existing = db.prepare('SELECT metadata_json FROM agent_runs WHERE id = ?').get(runId);
+  const current = parseMaybeJson(existing?.metadata_json, {}) || {};
+  const next = { ...current, ...patch };
+  db.prepare('UPDATE agent_runs SET metadata_json = ? WHERE id = ?')
+    .run(JSON.stringify(next), runId);
+}
+
+function updateRunGoalContract(engine, runId, patch = {}, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  runMeta.goalContract = mergeGoalContracts(runMeta.goalContract, patch);
+  if (options.persist !== false) {
+    persistRunMetadata(engine, runId, {
+      goalContract: runMeta.goalContract,
+    });
+  }
+  return runMeta.goalContract;
+}
+
+function buildProgressLedgerSnapshot(_engine, runMeta) {
+  if (!runMeta?.progressLedger) return null;
+  return {
+    currentStep: runMeta.progressLedger.currentStep || null,
+    currentTool: runMeta.progressLedger.currentTool || null,
+    currentStepStartedAt: runMeta.progressLedger.currentStepStartedAt || null,
+    lastVerifiedProgressAt: runMeta.progressLedger.lastVerifiedProgressAt || null,
+    lastUserVisibleUpdateAt: runMeta.progressLedger.lastUserVisibleUpdateAt || null,
+    lastFinalDeliveryAt: runMeta.progressLedger.lastFinalDeliveryAt || null,
+    heartbeatCount: Number(runMeta.progressLedger.heartbeatCount || 0),
+    stallNotifiedAt: runMeta.progressLedger.stallNotifiedAt || null,
+    progressState: runMeta.progressLedger.progressState || 'active',
+    currentPhase: runMeta.progressLedger.currentPhase || 'idle',
+  };
+}
+
+function persistProgressLedger(engine, runId) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.progressLedger) return;
+  persistRunMetadata(engine, runId, {
+    progressLedger: buildProgressLedgerSnapshot(engine, runMeta),
+  });
+}
+
+function updateRunProgress(engine, runId, patch = {}, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.progressLedger) {
+    runMeta.progressLedger = buildInitialProgressLedger({
+      startedAt: runMeta.startedAtIso || isoNow(),
+    });
+  }
+
+  const previousState = runMeta.progressLedger.progressState || 'active';
+  runMeta.progressLedger = {
+    ...runMeta.progressLedger,
+    ...patch,
+  };
+
+  if (options.verified === true) {
+    runMeta.progressLedger.lastVerifiedProgressAt = options.timestamp || isoNow();
+    runMeta.progressLedger.progressState = 'active';
+    runMeta.progressLedger.stallNotifiedAt = null;
+    recordRunEventSafe(engine, runMeta.userId, runId, 'progress_verified', {
+      phase: runMeta.progressLedger.currentPhase || 'idle',
+      currentStep: runMeta.progressLedger.currentStep || null,
+      currentTool: runMeta.progressLedger.currentTool || null,
+    }, { agentId: runMeta.agentId, stepId: options.stepId || null });
+    if (previousState === 'stalled') {
+      recordRunEventSafe(engine, runMeta.userId, runId, 'progress_resumed', {
+        phase: runMeta.progressLedger.currentPhase || 'idle',
+        currentStep: runMeta.progressLedger.currentStep || null,
+        currentTool: runMeta.progressLedger.currentTool || null,
+      }, { agentId: runMeta.agentId, stepId: options.stepId || null });
+    }
+  }
+
+  if (options.persist !== false) {
+    persistProgressLedger(engine, runId);
+  }
+  return runMeta.progressLedger;
+}
+
+function markRunVisibleProgress(engine, runId, timestamp = isoNow()) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.deliveryState) runMeta.deliveryState = createDeliveryState();
+  markInterimDelivered(runMeta.deliveryState);
+  const ledger = updateRunProgress(engine, runId, {
+    lastUserVisibleUpdateAt: timestamp,
+  }, {
+    persist: false,
+  });
+  persistProgressLedger(engine, runId);
+  return ledger;
+}
+
+function markRunFinalDelivery(engine, runId, content = '', timestamp = isoNow()) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.deliveryState) runMeta.deliveryState = createDeliveryState();
+  markFinalDelivered(runMeta.deliveryState);
+  runMeta.messagingSent = true;
+  runMeta.finalDeliverySent = true;
+  runMeta.lastSentMessage = String(content || '').trim() || runMeta.lastSentMessage || '';
+  const ledger = updateRunProgress(engine, runId, {
+    lastUserVisibleUpdateAt: timestamp,
+    lastFinalDeliveryAt: timestamp,
+    progressState: 'complete',
+  }, {
+    persist: false,
+  });
+  persistProgressLedger(engine, runId);
+  return ledger;
+}
+
+function recordRunEventSafe(_engine, userId, runId, eventType, payload = {}, options = {}) {
+  try {
+    return recordRunEvent({
+      runId,
+      userId,
+      agentId: options.agentId || null,
+      eventType,
+      requestId: options.requestId || null,
+      stepId: options.stepId || null,
+      payload,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function initializeToolRuntime(engine, runId, allTools, initialTools, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return;
+  runMeta.toolCatalog = Array.isArray(allTools) ? allTools : [];
+  runMeta.activeTools = Array.isArray(initialTools) ? initialTools : [];
+  runMeta.toolSelectionOptions = {
+    widgetId: options.widgetId || null,
+  };
+}
+
+function getActiveTools(engine, runId) {
+  return engine.getRunMeta(runId)?.activeTools || [];
+}
+
+function activateToolsForRun(engine, runId, names = []) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) throw new Error('Run is not active.');
+  const result = activateTools(
+    runMeta.activeTools,
+    runMeta.toolCatalog,
+    names,
+    runMeta.toolSelectionOptions,
+  );
+  runMeta.activeTools = result.tools;
+  recordRunEventSafe(engine, runMeta.userId, runId, 'tools_activated', {
+    activated: result.activated,
+    evicted: result.evicted,
+    unknown: result.unknown,
+    notActivated: result.notActivated,
+    activeToolNames: result.tools.map((tool) => tool.name),
+  }, { agentId: runMeta.agentId });
+  return {
+    success: result.unknown.length === 0 && result.notActivated.length === 0,
+    activated: result.activated,
+    evicted: result.evicted,
+    unknown: result.unknown,
+    not_activated: result.notActivated,
+    active_tools: result.tools.map((tool) => tool.name),
+  };
+}
+
+function findActiveRunForUser(engine, userId, predicate = null) {
+  let candidate = null;
+  for (const [runId, runMeta] of engine.activeRuns.entries()) {
+    if (runMeta.userId !== userId || runMeta.aborted) continue;
+    if (typeof predicate === 'function' && !predicate(runMeta, runId)) continue;
+    if (!candidate || (runMeta.startedAt || 0) >= (candidate.startedAt || 0)) {
+      candidate = { runId, ...runMeta };
+    }
+  }
+  return candidate;
+}
+
+function findSteerableRunForUser(engine, userId, triggerSource = 'web') {
+  return findActiveRunForUser(
+    engine,
+    userId,
+    (runMeta) => runMeta.triggerSource === triggerSource && runMeta.triggerType === 'user'
+  );
+}
+
+function enqueueSteering(engine, runId, content, metadata = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  const trimmed = typeof content === 'string' ? content.trim() : '';
+  if (!runMeta || runMeta.aborted || !trimmed) return null;
+
+  const item = {
+    id: uuidv4(),
+    content: trimmed,
+    metadata,
+    createdAt: isoNow(),
+  };
+
+  runMeta.steeringQueue.push(item);
+  engine.emit(runMeta.userId, 'run:steer_queued', {
+    runId,
+    content: item.content,
+    pendingCount: runMeta.steeringQueue.length,
+  });
+
+  return {
+    runId,
+    pendingCount: runMeta.steeringQueue.length,
+    item,
+  };
+}
+
+function enqueueSystemSteering(engine, runId, content, metadata = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  const trimmed = typeof content === 'string' ? content.trim() : '';
+  if (!runMeta || runMeta.aborted || !trimmed) return null;
+  if (!Array.isArray(runMeta.systemSteeringQueue)) {
+    runMeta.systemSteeringQueue = [];
+  }
+  const signature = JSON.stringify({
+    content: trimmed,
+    reason: metadata.reason || '',
+  });
+  if (runMeta.systemSteeringQueue.some((item) => item.signature === signature)) {
+    return null;
+  }
+  const item = {
+    id: uuidv4(),
+    content: trimmed,
+    metadata,
+    signature,
+    createdAt: isoNow(),
+  };
+  runMeta.systemSteeringQueue.push(item);
+  return item;
+}
+
+function applyQueuedSystemSteering(engine, runId, messages) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.systemSteeringQueue?.length) {
+    return { messages, appliedCount: 0 };
+  }
+
+  const queued = runMeta.systemSteeringQueue.splice(0, runMeta.systemSteeringQueue.length);
+  for (const entry of queued) {
+    messages.push({ role: 'system', content: entry.content });
+  }
+
+  return { messages, appliedCount: queued.length };
+}
+
+function applyQueuedSteering(engine, runId, messages, { userId, conversationId }) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.steeringQueue?.length) {
+    return { messages, appliedCount: 0 };
+  }
+
+  const queued = runMeta.steeringQueue.splice(0, runMeta.steeringQueue.length);
+  messages.push({
+    role: 'system',
+    content: [
+      'The user sent follow-up messages while you were already working.',
+      'Treat them as steering or next-up context for the same conversation.',
+      'If a message materially changes the active task, incorporate it now.',
+      'If it is unrelated or better handled after the current task, finish the current work first and then address it.',
+    ].join(' '),
+  });
+
+  for (const entry of queued) {
+    messages.push({ role: 'user', content: entry.content });
+    if (conversationId) {
+      db.prepare('INSERT INTO conversation_messages (conversation_id, role, content) VALUES (?, ?, ?)')
+        .run(conversationId, 'user', entry.content);
+    }
+  }
+
+  engine.emit(userId, 'run:steer_applied', {
+    runId,
+    count: queued.length,
+    pendingCount: runMeta.steeringQueue.length,
+    latestContent: queued[queued.length - 1]?.content || '',
+  });
+
+  return { messages, appliedCount: queued.length };
+}
+
+function isRunStopped(engine, runId) {
+  return engine.getRunMeta(runId)?.aborted === true;
+}
+
+function attachProcessToRun(engine, runId, pid) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta || !pid) return;
+  runMeta.toolPids.add(pid);
+  if (runMeta.aborted) {
+    if (engine.runtimeManager && typeof engine.runtimeManager.killCommand === 'function') {
+      void engine.runtimeManager.killCommand(runMeta.userId, pid, 'aborted');
+    }
+  }
+}
+
+function detachProcessFromRun(engine, runId, pid) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta || !pid) return;
+  runMeta.toolPids.delete(pid);
+}
+
+module.exports = {
+  activateToolsForRun,
+  applyQueuedSteering,
+  applyQueuedSystemSteering,
+  attachProcessToRun,
+  buildProgressLedgerSnapshot,
+  detachProcessFromRun,
+  enqueueSteering,
+  enqueueSystemSteering,
+  findActiveRunForUser,
+  findSteerableRunForUser,
+  getActiveTools,
+  initializeToolRuntime,
+  isRunStopped,
+  markRunFinalDelivery,
+  markRunVisibleProgress,
+  persistProgressLedger,
+  persistRunMetadata,
+  recordRunEventSafe,
+  updateRunGoalContract,
+  updateRunProgress,
+};

package/server/services/ai/loop/tool_dispatch.js

@@ -0,0 +1,230 @@
+'use strict';
+
+const { v4: uuidv4 } = require('uuid');
+const db = require('../../../db/database');
+const { globalHooks } = require('../hooks');
+const { summarizeForLog } = require('../logFormat');
+const { inferToolFailureMessage } = require('../toolEvidence');
+
+function getAvailableTools(_engine, app, options = {}) {
+  const { getAvailableTools: loadAvailableTools } = require('../tools');
+  return loadAvailableTools(app, options);
+}
+
+async function executeTool(engine, toolName, args, context) {
+  const { executeTool: runTool } = require('../tools');
+  return runTool(toolName, args, context, engine);
+}
+
+function isReadOnlyToolCall(toolCall) {
+  const name = String(toolCall?.function?.name || '');
+  const readOnly = new Set([
+    'read_file',
+    'list_directory',
+    'search_files',
+    'code_navigate',
+    'query_structured_data',
+    'memory_recall',
+    'memory_read',
+    'session_search',
+    'web_search',
+    'list_tasks',
+    'list_skills',
+    'list_subagents',
+    'recordings_list',
+    'recordings_get',
+    'recordings_search',
+    'read_health_data',
+  ]);
+  if (name === 'http_request') {
+    try {
+      const args = JSON.parse(toolCall.function.arguments || '{}');
+      return String(args.method || 'GET').toUpperCase() === 'GET';
+    } catch {
+      return false;
+    }
+  }
+  return readOnly.has(name);
+}
+
+async function executeReadOnlyBatch(engine, toolCalls, context = {}) {
+  const {
+    userId,
+    runId,
+    agentId,
+    app,
+    triggerType,
+    triggerSource,
+    conversationId,
+    startingStepIndex,
+    options = {},
+  } = context;
+  const prepared = [];
+  let nextStepIndex = startingStepIndex;
+  for (const toolCall of toolCalls) {
+    nextStepIndex += 1;
+    let toolArgs = {};
+    try { toolArgs = JSON.parse(toolCall.function.arguments || '{}'); } catch {}
+    const toolName = toolCall.function.name;
+    const repetitionGuard = engine.getRunMeta(runId)?.repetitionGuard;
+    if (repetitionGuard?.shouldBlock(toolName, toolArgs)) {
+      const result = {
+        status: 'blocked',
+        reason: 'The same read-only call already returned an unchanged result twice.',
+      };
+      prepared.push({
+        toolCall,
+        toolName,
+        toolArgs,
+        stepIndex: nextStepIndex,
+        blocked: true,
+        result,
+        error: result.reason,
+      });
+      engine.recordRunEvent(userId, runId, 'repetition_blocked', {
+        toolName,
+        toolArgs,
+        parallel: true,
+      }, { agentId });
+      continue;
+    }
+    if (globalHooks.has('before_tool_call')) {
+      const hookResult = await globalHooks.run('before_tool_call', {
+        toolName,
+        toolArgs,
+        runId,
+        userId,
+        agentId,
+        iteration: context.iteration,
+      });
+      if (hookResult.block) {
+        prepared.push({
+          toolCall,
+          toolName,
+          toolArgs,
+          stepIndex: nextStepIndex,
+          blocked: true,
+          result: { status: 'blocked', reason: hookResult.reason || 'Blocked by policy.', blocked_by: hookResult.blocked_by || 'policy' },
+        });
+        continue;
+      }
+      if (hookResult.toolArgs) toolArgs = hookResult.toolArgs;
+    }
+    const stepId = uuidv4();
+    db.prepare(
+      `INSERT INTO agent_steps (
+        id, run_id, step_index, type, description, status, tool_name, tool_input, started_at
+      ) VALUES (?, ?, ?, ?, ?, 'running', ?, ?, datetime('now'))`
+    ).run(
+      stepId,
+      runId,
+      nextStepIndex,
+      engine.getStepType(toolName),
+      `${toolName}: ${JSON.stringify(toolArgs).slice(0, 200)}`,
+      toolName,
+      JSON.stringify(toolArgs),
+    );
+    engine.emit(userId, 'run:tool_start', {
+      runId,
+      stepId,
+      stepIndex: nextStepIndex,
+      toolName,
+      toolArgs,
+      type: engine.getStepType(toolName),
+    });
+    engine.recordRunEvent(userId, runId, 'tool_started', {
+      stepIndex: nextStepIndex,
+      toolName,
+      toolArgs,
+      type: engine.getStepType(toolName),
+      parallel: true,
+    }, { agentId, stepId });
+    prepared.push({ toolCall, toolName, toolArgs, stepId, stepIndex: nextStepIndex });
+  }
+  engine.recordRunEvent(userId, runId, 'parallel_batch_started', {
+    toolNames: prepared.map((item) => item.toolName),
+    count: prepared.length,
+  }, { agentId });
+  const results = await Promise.all(prepared.map(async (item) => {
+    if (item.blocked) return item;
+    const startedAt = Date.now();
+    try {
+      const result = await executeTool(engine, item.toolName, item.toolArgs, {
+        userId,
+        runId,
+        agentId,
+        app,
+        triggerType,
+        triggerSource,
+        conversationId,
+        source: options.source || null,
+        chatId: options.chatId || null,
+        taskId: options.taskId || null,
+        widgetId: options.widgetId || null,
+        deliveryState: options.deliveryState || null,
+        allowMultipleProactiveMessages: options.allowMultipleProactiveMessages === true,
+        allowExternalSideEffects: false,
+      });
+      const error = inferToolFailureMessage(item.toolName, result);
+      const status = error ? 'failed' : 'completed';
+      db.prepare(
+        `UPDATE agent_steps
+         SET status = ?, result = ?, error = ?, screenshot_path = ?, completed_at = datetime('now')
+         WHERE id = ?`
+      ).run(
+        status,
+        JSON.stringify(result).slice(0, 20000),
+        error || null,
+        result?.screenshotPath || null,
+        item.stepId,
+      );
+      engine.emit(userId, 'run:tool_end', {
+        runId,
+        stepId: item.stepId,
+        toolName: item.toolName,
+        result,
+        error: error || undefined,
+        status,
+      });
+      engine.recordRunEvent(userId, runId, error ? 'tool_failed' : 'tool_completed', {
+        toolName: item.toolName,
+        status,
+        durationMs: Date.now() - startedAt,
+        resultPreview: summarizeForLog(result),
+        parallel: true,
+      }, { agentId, stepId: item.stepId });
+      return { ...item, result, error };
+    } catch (err) {
+      db.prepare(
+        `UPDATE agent_steps SET status = 'failed', error = ?, completed_at = datetime('now') WHERE id = ?`
+      ).run(err.message, item.stepId);
+      engine.emit(userId, 'run:tool_end', {
+        runId,
+        stepId: item.stepId,
+        toolName: item.toolName,
+        error: err.message,
+        status: 'failed',
+      });
+      engine.recordRunEvent(userId, runId, 'tool_failed', {
+        toolName: item.toolName,
+        status: 'failed',
+        error: err.message,
+        durationMs: Date.now() - startedAt,
+        parallel: true,
+      }, { agentId, stepId: item.stepId });
+      return { ...item, result: { error: err.message }, error: err.message };
+    }
+  }));
+  engine.recordRunEvent(userId, runId, 'parallel_batch_completed', {
+    toolNames: results.map((item) => item.toolName),
+    failedCount: results.filter((item) => item.error).length,
+  }, { agentId });
+  return { results, endingStepIndex: nextStepIndex };
+}
+
+module.exports = {
+  executeReadOnlyBatch,
+  executeTool,
+  getAvailableTools,
+  isReadOnlyToolCall,
+};

package/server/services/ai/tools.js

@@ -9,6 +9,7 @@ const {
     normalizeOutgoingMessageForPlatform,
 } = require('../messaging/formatting_guides');
 const { INTERIM_KINDS, normalizeInterimKind } = require('./interim');
+const { normalizeWhatsAppId } = require('../../utils/whatsapp');
 const {
     executeIntegratedTool,
     getIntegratedToolDefinitions,
@@ -320,6 +321,31 @@ function normalizeMessagingTarget(target = {}) {
     return { platform, to };
 }
 
+function canonicalMessagingAddress(platform, value) {
+    const normalizedPlatform = String(platform || '').trim().toLowerCase();
+    const raw = String(value || '').trim();
+    if (!normalizedPlatform || !raw) return '';
+    if (normalizedPlatform !== 'whatsapp') return raw;
+
+    const lower = raw.toLowerCase();
+    const normalizedId = normalizeWhatsAppId(lower);
+    if (!normalizedId) return '';
+    if (lower.includes('@g.us')) return `group:${normalizedId}`;
+    if (lower.includes('@lid')) return `lid:${normalizedId}`;
+    return `direct:${normalizedId}`;
+}
+
+function isOriginMessagingDelivery({ triggerSource, source, chatId, platform, to }) {
+    if (triggerSource !== 'messaging') return true;
+    const originPlatform = String(source || '').trim().toLowerCase();
+    const targetPlatform = String(platform || '').trim().toLowerCase();
+    if (!originPlatform || !targetPlatform || originPlatform !== targetPlatform) return false;
+
+    const originAddress = canonicalMessagingAddress(originPlatform, chatId);
+    const targetAddress = canonicalMessagingAddress(targetPlatform, to);
+    return Boolean(originAddress && targetAddress && originAddress === targetAddress);
+}
+
 function buildAndroidUiMatchProperties(extra = {}) {
     return {
         x: { type: 'number', description: 'Absolute X coordinate' },
@@ -1623,6 +1649,7 @@ async function executeTool(toolName, args, context, engine) {
         case 'browser_extract': {
             const { provider, backend } = await bc();
             if (!provider) return { error: 'Browser controller not available' };
+            if (!args.selector) return { error: 'browser_extract requires a "selector" argument' };
             return { ...await provider.extract(args.selector, args.attribute, args.all), backend };
         }
 
@@ -1635,7 +1662,9 @@ async function executeTool(toolName, args, context, engine) {
         case 'browser_evaluate': {
             const { provider, backend } = await bc();
             if (!provider) return { error: 'Browser controller not available' };
-            return { ...await provider.evaluate(args.script), backend };
+            const script = args.script ?? args.javascript;
+            if (!script) return { error: 'browser_evaluate requires a "script" argument' };
+            return { ...await provider.evaluate(script), backend };
         }
 
         case 'android_start_emulator': {
@@ -2244,7 +2273,18 @@ async function executeTool(toolName, args, context, engine) {
                 persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks'
             });
             // Track that the agent explicitly sent a message during this run
-            if (!suppressReply && sendResult?.suppressed !== true) {
+            if (
+                !suppressReply
+                && sendResult?.success === true
+                && sendResult?.suppressed !== true
+                && isOriginMessagingDelivery({
+                    triggerSource,
+                    source: context.source,
+                    chatId: context.chatId,
+                    platform: args.platform,
+                    to: args.to,
+                })
+            ) {
                 markProactiveMessageSent({ runState, deliveryState, content: normalizedMessage });
                 if (runState && triggerSource === 'messaging') {
                     runState.explicitMessageSent = true;

package/server/services/messaging/manager.js

@@ -515,6 +515,13 @@ class MessagingManager extends EventEmitter {
     }
 
     const result = await platform.sendMessage(to, normalizedContent, sendOptions);
+    if (result?.success === false) {
+      const reason = result.error || result.reason || 'platform rejected the message';
+      const error = new Error(`Platform ${platformName} delivery failed: ${reason}`);
+      error.code = 'MESSAGING_DELIVERY_FAILED';
+      error.deliveryResult = result;
+      throw error;
+    }
 
     db.prepare('INSERT INTO messages (user_id, agent_id, run_id, role, content, platform, platform_chat_id, media_path, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
       .run(userId, agentId, runId, 'assistant', normalizedContent, platformName, to, mediaPath, metadata ? JSON.stringify(metadata) : null);