oomi-ai 0.2.13 → 0.2.15

package/bin/oomi-ai.js

@@ -8,7 +8,7 @@ import net from 'net';
 import { lookup as dnsLookup } from 'dns/promises';
 import { fileURLToPath } from 'url';
 import WebSocket from 'ws';
-import { ensureSessionBridge, forwardFrameToSession, flushSessionQueue } from './sessionBridgeState.js';
+import { ensureSessionBridge, flushSessionQueue, flushWaitingForConnect, forwardFrameToSession } from './sessionBridgeState.js';
 
 const MARKER_START = '<oomi-agent-instructions>';
 const MARKER_END = '</oomi-agent-instructions>';
@@ -637,6 +637,59 @@ function updateBridgeStatus(partial) {
   return next;
 }
 
+function resolveBridgeStatusForBrokerOpen({ actionCableMode, deviceSubscribed }) {
+  if (!actionCableMode) {
+    return 'connected';
+  }
+  return deviceSubscribed ? 'connected' : 'starting';
+}
+
+function classifyBridgeSessionScope(sessionId) {
+  const normalized = String(sessionId || '').trim();
+  return normalized.startsWith('voice_session_') ? 'voice' : 'default';
+}
+
+function resolveBridgeStatusForRuntimeFault({ currentStatus, sessionId }) {
+  if (classifyBridgeSessionScope(sessionId) === 'voice') {
+    return currentStatus === 'connected' ? 'connected' : currentStatus || 'starting';
+  }
+  if (currentStatus === 'connected' || currentStatus === 'reconnecting' || currentStatus === 'degraded') {
+    return 'degraded';
+  }
+  return 'error';
+}
+
+function runBridgeCallbackSafely(callback, onError) {
+  return (...args) => {
+    try {
+      return callback(...args);
+    } catch (err) {
+      onError(err instanceof Error ? err : new Error(String(err)));
+      return undefined;
+    }
+  };
+}
+
+function createBridgeProcessFaultHandler({ readStatus, onReport, onExit }) {
+  return ({ phase, error }) => {
+    const normalizedError = error instanceof Error ? error : new Error(String(error || 'unknown process fault'));
+    const currentStatus = String(readStatus?.()?.status || '').trim();
+    const nextStatus = resolveBridgeStatusForRuntimeFault({ currentStatus, sessionId: '' });
+
+    onReport?.({
+      phase,
+      status: nextStatus,
+      error: normalizedError,
+      currentStatus,
+      shouldExit: nextStatus === 'error',
+    });
+
+    if (nextStatus === 'error') {
+      onExit?.(1);
+    }
+  };
+}
+
 function normalizeBridgeMetrics(value) {
   if (!value || typeof value !== 'object') return {};
   const next = {};
@@ -954,25 +1007,55 @@ function prepareGatewayFrameForLocalGateway(frameText, gatewayAuth, options = {}
     }
 
     if (method !== 'connect') {
-      const shouldStripBridgeOnlyParams = method === 'chat.send' || method === 'chat.history';
-      if (!shouldStripBridgeOnlyParams) {
-        return { frameText, waitForChallenge: false };
-      }
       const rawParams = frame.params && typeof frame.params === 'object' ? frame.params : {};
-      const sanitized = { ...rawParams };
-      let changed = false;
-      if (Object.prototype.hasOwnProperty.call(sanitized, 'correlationId')) {
-        delete sanitized.correlationId;
-        changed = true;
-      }
-      if (Object.prototype.hasOwnProperty.call(sanitized, 'metadata')) {
-        delete sanitized.metadata;
-        changed = true;
+      if (method === 'chat.send') {
+        const sanitized = {};
+        if (typeof rawParams.sessionKey === 'string' && rawParams.sessionKey.trim()) {
+          sanitized.sessionKey = rawParams.sessionKey.trim();
+        }
+        if (typeof rawParams.message === 'string') {
+          sanitized.message = rawParams.message;
+        }
+        if (typeof rawParams.thinking === 'boolean') {
+          sanitized.thinking = rawParams.thinking;
+        }
+        if (typeof rawParams.deliver === 'string' && rawParams.deliver.trim()) {
+          sanitized.deliver = rawParams.deliver.trim();
+        }
+        if (Array.isArray(rawParams.attachments)) {
+          sanitized.attachments = rawParams.attachments;
+        }
+        if (Number.isFinite(rawParams.timeoutMs) && rawParams.timeoutMs > 0) {
+          sanitized.timeoutMs = Math.floor(rawParams.timeoutMs);
+        }
+
+        const idempotencyKeyCandidates = [
+          rawParams.idempotencyKey,
+          rawParams.requestId,
+          rawParams.correlationId,
+          frame.id,
+        ];
+        const idempotencyKey = idempotencyKeyCandidates.find((value) => typeof value === 'string' && value.trim());
+        if (typeof idempotencyKey === 'string' && idempotencyKey.trim()) {
+          sanitized.idempotencyKey = idempotencyKey.trim();
+        }
+
+        frame.params = sanitized;
+        return { frameText: JSON.stringify(frame), waitForChallenge: false };
       }
-      if (changed) {
+
+      if (method === 'chat.history') {
+        const sanitized = {};
+        if (typeof rawParams.sessionKey === 'string' && rawParams.sessionKey.trim()) {
+          sanitized.sessionKey = rawParams.sessionKey.trim();
+        }
+        if (Number.isFinite(rawParams.limit) && rawParams.limit > 0) {
+          sanitized.limit = Math.floor(rawParams.limit);
+        }
         frame.params = sanitized;
         return { frameText: JSON.stringify(frame), waitForChallenge: false };
       }
+
       return { frameText, waitForChallenge: false };
     }
 
@@ -1747,6 +1830,82 @@ async function startOpenclawBridge(flags) {
   })();
   const actionCableMode = brokerPath.endsWith('/cable');
   const deviceChannelIdentifier = JSON.stringify({ channel: 'DeviceChannel' });
+  let deviceChannelSubscribed = false;
+
+  const reportBridgeRuntimeFault = ({ phase, sessionId = '', error }) => {
+    const message = error instanceof Error ? error.message : String(error || 'unknown bridge callback error');
+    const currentStatus = String(readBridgeStatus().status || '').trim();
+    const nextStatus = resolveBridgeStatusForRuntimeFault({ currentStatus, sessionId });
+    incrementBridgeMetric('bridge_callback_error_count');
+    console.error(
+      `[bridge] callback.error phase=${phase}${sessionId ? ` session=${sessionId}` : ''}: ${message}`
+    );
+    updateBridgeStatus({
+      status: nextStatus,
+      deviceId,
+      brokerWs,
+      brokerHttp,
+      gatewayUrl: gateway.gatewayUrl,
+      lastDisconnectAt: bridgeNowIso(),
+      lastErrorCode: 'bridge_callback_error',
+      lastErrorClass: 'internal',
+      lastErrorMessage: `${phase}: ${message}`,
+      hint:
+        classifyBridgeSessionScope(sessionId) === 'voice'
+          ? 'A voice-session bridge callback failed, but provider health remains available for normal chat.'
+          : 'The bridge caught an internal callback error and kept running.',
+      pid: process.pid,
+    });
+  };
+
+  const reportBridgeProcessFault = ({ phase, status, error }) => {
+    const message = error instanceof Error ? error.message : String(error || 'unknown bridge process fault');
+    incrementBridgeMetric('bridge_process_fault_count');
+    console.error(`[bridge] process.error phase=${phase}: ${message}`);
+    updateBridgeStatus({
+      status,
+      deviceId,
+      brokerWs,
+      brokerHttp,
+      gatewayUrl: gateway.gatewayUrl,
+      lastDisconnectAt: bridgeNowIso(),
+      lastErrorCode: 'bridge_process_fault',
+      lastErrorClass: 'internal',
+      lastErrorMessage: `${phase}: ${message}`,
+      hint:
+        status === 'error'
+          ? 'The bridge hit a runtime fault before it was fully connected and will restart.'
+          : 'The bridge caught a process-level runtime fault and stayed alive in degraded mode.',
+      pid: process.pid,
+    });
+  };
+
+  const handleBridgeProcessFault = createBridgeProcessFaultHandler({
+    readStatus: readBridgeStatus,
+    onReport: ({ phase, status, error }) => {
+      reportBridgeProcessFault({ phase, status, error });
+    },
+    onExit: (code) => {
+      reconnectState.stopped = true;
+      if (reconnectState.timer) {
+        clearTimeout(reconnectState.timer);
+        reconnectState.timer = null;
+      }
+      releaseBridgeLock();
+      process.exit(code);
+    },
+  });
+
+  const uncaughtExceptionHandler = (error) => {
+    handleBridgeProcessFault({ phase: 'process.uncaughtException', error });
+  };
+
+  const unhandledRejectionHandler = (reason) => {
+    handleBridgeProcessFault({ phase: 'process.unhandledRejection', error: reason });
+  };
+
+  process.on('uncaughtException', uncaughtExceptionHandler);
+  process.on('unhandledRejection', unhandledRejectionHandler);
 
   const sendBrokerPayload = (brokerSocket, payload) => {
     if (brokerSocket.readyState !== WebSocket.OPEN) return;
@@ -2184,6 +2343,12 @@ async function startOpenclawBridge(flags) {
       if (!(sessionBridge.pendingRequestTimers instanceof Map)) {
         sessionBridge.pendingRequestTimers = new Map();
       }
+      if (sessionBridge.connectAccepted !== true) {
+        sessionBridge.connectAccepted = false;
+      }
+      if (!Array.isArray(sessionBridge.waitingForConnect)) {
+        sessionBridge.waitingForConnect = [];
+      }
       if (typeof sessionBridge.lastChatCorrelationId !== 'string') {
         sessionBridge.lastChatCorrelationId = '';
       }
@@ -2216,7 +2381,7 @@ async function startOpenclawBridge(flags) {
         flushSessionQueue(sessionBridge);
       });
 
-      gatewaySocket.on('message', (gatewayRaw) => {
+      gatewaySocket.on('message', runBridgeCallbackSafely((gatewayRaw) => {
         const frame = typeof gatewayRaw === 'string' ? gatewayRaw : gatewayRaw.toString();
         const gatewayPayload = parseJsonPayload(frame);
         if (gatewayPayload?.event === 'connect.challenge') {
@@ -2257,6 +2422,86 @@ async function startOpenclawBridge(flags) {
               correlationId: requestMeta.correlationId,
               stage: responseMeta.ok ? 'gateway.accepted' : 'gateway.rejected',
             });
+            if (requestMeta.method === 'connect' && responseMeta.ok) {
+              const releasedFrames = flushWaitingForConnect(sessionBridge);
+              for (const released of releasedFrames) {
+                const releasedMeta = extractGatewayRequestMeta(released.frameText);
+                if (!releasedMeta) continue;
+
+                if (released.result === 'queued') {
+                  startPendingRequestTimeout(brokerSocket, sessionId, sessionBridge, releasedMeta);
+                  sendGatewayAck(brokerSocket, {
+                    sessionId,
+                    requestId: releasedMeta.requestId,
+                    method: releasedMeta.method,
+                    correlationId: releasedMeta.correlationId,
+                    stage: 'bridge.queued',
+                  });
+                } else if (released.result === 'dropped') {
+                  const pending = sessionBridge.pendingRequests.get(releasedMeta.requestId);
+                  const lastSuccessfulHop =
+                    pending && typeof pending.lastSuccessfulHop === 'string' && pending.lastSuccessfulHop
+                      ? pending.lastSuccessfulHop
+                      : 'bridge.waiting_for_connect';
+                  clearPendingRequestTimeout(sessionBridge, releasedMeta.requestId);
+                  sessionBridge.pendingRequests.delete(releasedMeta.requestId);
+                  sendGatewayErrorResponse(brokerSocket, {
+                    sessionId,
+                    requestMeta: releasedMeta,
+                    code: 'bridge_dropped',
+                    message: 'Bridge dropped deferred request because gateway socket is not open.',
+                    lastSuccessfulHop,
+                    retryable: true,
+                  });
+                  sendGatewayAck(brokerSocket, {
+                    sessionId,
+                    requestId: releasedMeta.requestId,
+                    method: releasedMeta.method,
+                    correlationId: releasedMeta.correlationId,
+                    stage: 'bridge.dropped',
+                  });
+                } else {
+                  startPendingRequestTimeout(brokerSocket, sessionId, sessionBridge, releasedMeta);
+                  sendGatewayAck(brokerSocket, {
+                    sessionId,
+                    requestId: releasedMeta.requestId,
+                    method: releasedMeta.method,
+                    correlationId: releasedMeta.correlationId,
+                    stage: 'bridge.forwarded',
+                  });
+                }
+              }
+            } else if (requestMeta.method === 'connect' && !responseMeta.ok) {
+              const deferredFrames = Array.isArray(sessionBridge.waitingForConnect)
+                ? sessionBridge.waitingForConnect.splice(0, sessionBridge.waitingForConnect.length)
+                : [];
+              for (const deferredFrame of deferredFrames) {
+                const deferredMeta = extractGatewayRequestMeta(deferredFrame);
+                if (!deferredMeta) continue;
+                const pending = sessionBridge.pendingRequests.get(deferredMeta.requestId);
+                const lastSuccessfulHop =
+                  pending && typeof pending.lastSuccessfulHop === 'string' && pending.lastSuccessfulHop
+                    ? pending.lastSuccessfulHop
+                    : 'bridge.waiting_for_connect';
+                clearPendingRequestTimeout(sessionBridge, deferredMeta.requestId);
+                sessionBridge.pendingRequests.delete(deferredMeta.requestId);
+                sendGatewayErrorResponse(brokerSocket, {
+                  sessionId,
+                  requestMeta: deferredMeta,
+                  code: 'gateway_connect_failed',
+                  message: 'Bridge could not forward request because gateway connect did not complete.',
+                  lastSuccessfulHop,
+                  retryable: true,
+                });
+                sendGatewayAck(brokerSocket, {
+                  sessionId,
+                  requestId: deferredMeta.requestId,
+                  method: deferredMeta.method,
+                  correlationId: deferredMeta.correlationId,
+                  stage: 'gateway.rejected',
+                });
+              }
+            }
             if (!responseMeta.ok) {
               incrementBridgeMetric('gateway_rejected_count');
             }
@@ -2274,9 +2519,11 @@ async function startOpenclawBridge(flags) {
         }
 
         sendBrokerPayload(brokerSocket, { action: 'gateway_frame', type: 'gateway.frame', sessionId, frame });
-      });
+      }, (error) => {
+        reportBridgeRuntimeFault({ phase: 'gateway.message', sessionId, error });
+      }));
 
-      gatewaySocket.on('close', (code, reason) => {
+      gatewaySocket.on('close', runBridgeCallbackSafely((code, reason) => {
         if (connectTimeout) {
           clearTimeout(connectTimeout);
           connectTimeout = null;
@@ -2326,9 +2573,11 @@ async function startOpenclawBridge(flags) {
           code,
           reason: reasonText,
         });
-      });
+      }, (error) => {
+        reportBridgeRuntimeFault({ phase: 'gateway.close', sessionId, error });
+      }));
 
-      gatewaySocket.on('error', (err) => {
+      gatewaySocket.on('error', runBridgeCallbackSafely((err) => {
         if (connectTimeout && gatewaySocket.readyState !== WebSocket.CONNECTING) {
           clearTimeout(connectTimeout);
           connectTimeout = null;
@@ -2341,7 +2590,9 @@ async function startOpenclawBridge(flags) {
           level: 'error',
           message: `Gateway socket error (${sessionId}): ${String(err)}`,
         });
-      });
+      }, (error) => {
+        reportBridgeRuntimeFault({ phase: 'gateway.error', sessionId, error });
+      }));
     };
 
     const getOrCreateGatewaySession = (sessionId) => {
@@ -2360,18 +2611,22 @@ async function startOpenclawBridge(flags) {
       console.log('[bridge] Connected to managed broker.');
       reconnectState.attempt = 0;
       reconnectState.lastFailure = null;
-      if (!actionCableMode) return;
-      brokerSocket.send(
-        JSON.stringify({
-          command: 'subscribe',
-          identifier: deviceChannelIdentifier,
-        })
-      );
-      actionCableHeartbeat = setInterval(() => {
-        sendBrokerPayload(brokerSocket, { action: 'heartbeat' });
-      }, 15000);
+      if (actionCableMode) {
+        brokerSocket.send(
+          JSON.stringify({
+            command: 'subscribe',
+            identifier: deviceChannelIdentifier,
+          })
+        );
+        actionCableHeartbeat = setInterval(() => {
+          sendBrokerPayload(brokerSocket, { action: 'heartbeat' });
+        }, 15000);
+      }
       updateBridgeStatus({
-        status: 'connected',
+        status: resolveBridgeStatusForBrokerOpen({
+          actionCableMode,
+          deviceSubscribed: deviceChannelSubscribed,
+        }),
         deviceId,
         brokerWs,
         brokerHttp,
@@ -2386,12 +2641,27 @@ async function startOpenclawBridge(flags) {
       });
     });
 
-    brokerSocket.on('message', (rawData) => {
+    brokerSocket.on('message', runBridgeCallbackSafely((rawData) => {
       const text = typeof rawData === 'string' ? rawData : rawData.toString();
       const payload = parseBrokerEnvelope(text);
       if (!payload || typeof payload.type !== 'string') return;
 
       if (payload.type === 'device.subscribed') {
+        deviceChannelSubscribed = true;
+        updateBridgeStatus({
+          status: 'connected',
+          deviceId,
+          brokerWs,
+          brokerHttp,
+          gatewayUrl: gateway.gatewayUrl,
+          lastConnectedAt: bridgeNowIso(),
+          lastErrorCode: '',
+          lastErrorClass: '',
+          lastErrorMessage: '',
+          hint: '',
+          consecutiveFailures: 0,
+          pid: process.pid,
+        });
         return;
       }
 
@@ -2538,7 +2808,22 @@ async function startOpenclawBridge(flags) {
           }
           return;
         }
-        const result = forwardFrameToSession(sessionBridge, prepared.frameText);
+        const result = forwardFrameToSession(sessionBridge, prepared.frameText, {
+          requiresConnectAccepted: Boolean(requestMeta && requestMeta.method !== 'connect'),
+        });
+        if (result === 'waiting_for_connect') {
+          console.log(`[bridge] client.frame waiting for connect ${sessionId}`);
+          if (requestMeta) {
+            sendGatewayAck(brokerSocket, {
+              sessionId,
+              requestId: requestMeta.requestId,
+              method: requestMeta.method,
+              correlationId: requestMeta.correlationId,
+              stage: 'bridge.waiting_for_connect',
+            });
+          }
+          return;
+        }
         if (result === 'queued') {
           console.log(`[bridge] client.frame queued ${sessionId}`);
           if (requestMeta) {
@@ -2613,9 +2898,11 @@ async function startOpenclawBridge(flags) {
         }
         return;
       }
-    });
+    }, (error) => {
+      reportBridgeRuntimeFault({ phase: 'broker.message', error });
+    }));
 
-    brokerSocket.on('close', (code, reason) => {
+    brokerSocket.on('close', runBridgeCallbackSafely((code, reason) => {
       if (actionCableHeartbeat) {
         clearInterval(actionCableHeartbeat);
         actionCableHeartbeat = null;
@@ -2647,16 +2934,20 @@ async function startOpenclawBridge(flags) {
         });
       }
       scheduleReconnect();
-    });
+    }, (error) => {
+      reportBridgeRuntimeFault({ phase: 'broker.close', error });
+    }));
 
-    brokerSocket.on('error', (err) => {
+    brokerSocket.on('error', runBridgeCallbackSafely((err) => {
       incrementBridgeMetric('bridge_socket_error_count');
       reconnectState.lastFailure = classifyBridgeFailure({ err });
       console.error(
         `[bridge] Broker socket error [${reconnectState.lastFailure.failureClass}/${reconnectState.lastFailure.errorCode}]: ${reconnectState.lastFailure.message}`
       );
       console.error(`[bridge] ${reconnectState.lastFailure.hint}`);
-    });
+    }, (error) => {
+      reportBridgeRuntimeFault({ phase: 'broker.error', error });
+    }));
   };
 
   const markStopped = (signal) => {
@@ -2665,6 +2956,8 @@ async function startOpenclawBridge(flags) {
       clearTimeout(reconnectState.timer);
       reconnectState.timer = null;
     }
+    process.off('uncaughtException', uncaughtExceptionHandler);
+    process.off('unhandledRejection', unhandledRejectionHandler);
     updateBridgeStatus({
       status: 'stopped',
       deviceId,
@@ -3246,7 +3539,12 @@ if (__isDirectExecution) {
 export {
   prepareGatewayFrameForLocalGateway,
   classifyBridgeFailure,
+  classifyBridgeSessionScope,
+  createBridgeProcessFaultHandler,
   computeReconnectDelayMs,
+  resolveBridgeStatusForBrokerOpen,
+  resolveBridgeStatusForRuntimeFault,
+  runBridgeCallbackSafely,
   extractGatewayRequestMeta,
   extractGatewayResponseMeta,
   isGatewayRunStartedFrame,

package/bin/sessionBridgeState.js

@@ -12,7 +12,12 @@ export function ensureSessionBridge({ sessions, sessionId, createSocket }) {
   if (existing) return existing;
 
   const socket = createSocket(id);
-  const next = { socket, queue: [] };
+  const next = {
+    socket,
+    queue: [],
+    connectAccepted: false,
+    waitingForConnect: [],
+  };
   sessions.set(id, next);
   return next;
 }
@@ -20,11 +25,19 @@ export function ensureSessionBridge({ sessions, sessionId, createSocket }) {
 /**
  * Forward a frame to the gateway socket or queue it while connecting.
  */
-export function forwardFrameToSession(sessionBridge, frameText) {
+export function forwardFrameToSession(sessionBridge, frameText, options = {}) {
   if (!sessionBridge || !sessionBridge.socket || typeof frameText !== 'string' || !frameText) {
     return 'dropped';
   }
 
+  if (options.requiresConnectAccepted === true && sessionBridge.connectAccepted !== true) {
+    if (!Array.isArray(sessionBridge.waitingForConnect)) {
+      sessionBridge.waitingForConnect = [];
+    }
+    sessionBridge.waitingForConnect.push(frameText);
+    return 'waiting_for_connect';
+  }
+
   const { socket } = sessionBridge;
   if (socket.readyState === WS_OPEN) {
     socket.send(frameText);
@@ -39,6 +52,20 @@ export function forwardFrameToSession(sessionBridge, frameText) {
   return 'dropped';
 }
 
+export function flushWaitingForConnect(sessionBridge) {
+  if (!sessionBridge) return [];
+
+  sessionBridge.connectAccepted = true;
+  const pending = Array.isArray(sessionBridge.waitingForConnect)
+    ? sessionBridge.waitingForConnect.splice(0, sessionBridge.waitingForConnect.length)
+    : [];
+
+  return pending.map((frameText) => ({
+    frameText,
+    result: forwardFrameToSession(sessionBridge, frameText),
+  }));
+}
+
 export function flushSessionQueue(sessionBridge) {
   if (!sessionBridge || !sessionBridge.socket) return;
   const socket = sessionBridge.socket;

package/openclaw.extension.js

@@ -178,6 +178,45 @@ function extractCorrelationId(payload) {
   return '';
 }
 
+function normalizeSpokenMetadata(spoken) {
+  if (!spoken || typeof spoken !== 'object' || Array.isArray(spoken)) return null;
+
+  const text = toString(spoken.text);
+  if (!text) return null;
+
+  const normalized = { text };
+  const instructions = toString(spoken.instructions);
+  if (instructions) normalized.instructions = instructions;
+  if (spoken.style && typeof spoken.style === 'object' && !Array.isArray(spoken.style)) {
+    normalized.style = spoken.style;
+  }
+
+  return normalized;
+}
+
+function normalizeOutgoingMetadata(payloadMetadata, { accountId, correlationId }) {
+  const metadata =
+    payloadMetadata && typeof payloadMetadata === 'object' && !Array.isArray(payloadMetadata)
+      ? { ...payloadMetadata }
+      : {};
+
+  const spoken = normalizeSpokenMetadata(metadata.spoken);
+  if (spoken) {
+    metadata.spoken = spoken;
+  } else {
+    delete metadata.spoken;
+  }
+
+  metadata.accountId = accountId;
+  if (correlationId) {
+    metadata.correlationId = correlationId;
+  } else {
+    delete metadata.correlationId;
+  }
+
+  return metadata;
+}
+
 async function postJson({ url, token, body, timeoutMs }) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -289,10 +328,10 @@ const oomiChannelPlugin = {
           sessionKey,
           content,
           source: 'openclaw.channel',
-          metadata: {
+          metadata: normalizeOutgoingMetadata(payload?.metadata, {
             accountId: resolvedAccountId,
             correlationId,
-          },
+          }),
         },
       });
 

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oomi-ai",
   "name": "Oomi Channel Plugin",
   "description": "Managed Oomi channel integration for OpenClaw.",
-  "version": "0.2.6",
+  "version": "0.2.15",
   "author": "Oomi",
   "license": "MIT",
   "openclawVersion": ">=0.5.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oomi-ai",
-  "version": "0.2.13",
-  "description": "Oomi CLI for OpenClaw setup",
+  "version": "0.2.15",
+  "description": "Oomi OpenClaw channel plugin and bridge tooling",
   "bin": {
     "oomi": "bin/oomi-ai.js"
   },