@nextclaw/ui 0.9.10 → 0.9.12

package/src/lib/i18n.remote.ts

@@ -40,23 +40,34 @@ export const REMOTE_LABELS: Record<string, { zh: string; en: string }> = {
     zh: '远程访问已经开启，但后台服务没有运行。拉起后才会真正连到网页版。',
     en: 'Remote access is enabled, but the managed service is not running yet. Start it to connect to the web app.'
   },
-  remoteStatusIssueTitle: { zh: '远程连接当前有异常', en: 'The remote connection needs attention' },
+  remoteStatusReauthorizationTitle: { zh: '登录已过期，请重新登录 NextClaw', en: 'Your sign-in expired. Sign in to NextClaw again.' },
+  remoteStatusReauthorizationDescription: {
+    zh: '为了保护你的账号安全，远程访问已暂停。重新登录后会自动恢复，不需要重新配置设备。',
+    en: 'Remote access is paused to protect your account. Sign in again and it will recover automatically without reconfiguring this device.'
+  },
+  remoteStatusIssueTitle: { zh: '远程访问暂时没有连上', en: 'Remote access is temporarily offline' },
   remoteStatusIssueDescription: {
-    zh: '账号和设备配置都还在，但当前没有稳定连上平台。你可以重新连接，或先去设备列表确认这台设备的状态。',
-    en: 'Your account and device settings are still there, but this device is not stably connected to the platform right now. Reconnect it or check the device list first.'
+    zh: '设备配置还在，但当前没有稳定连上平台。你可以先重新连接；如果问题持续，再重新登录或稍后再试。',
+    en: 'Your device settings are still there, but this device is not stably connected to the platform right now. Reconnect first, then sign in again or try later if it keeps happening.'
   },
-  remoteStatusIssueDetailTitle: { zh: '当前提示', en: 'Current Hint' },
+  remoteStatusIssueDetailTitle: { zh: '下一步', en: 'Next Step' },
+  remoteStatusRecoveryTitle: { zh: '推荐操作', en: 'Recommended Next Step' },
   remoteStatusIssueDetailGeneric: {
-    zh: '连接曾经建立，但随后被平台侧主动关闭。常见原因包括登录态失效、平台侧中继不可用，或云端配额暂时触顶。',
-    en: 'The connection was established and then closed by the platform. Common causes include an expired session, an unavailable relay, or a temporary cloud quota limit.'
+    zh: '远程访问暂时不可用。你可以先重新连接；如果问题持续，再重新登录或稍后再试。',
+    en: 'Remote access is temporarily unavailable. Reconnect first, then sign in again or try later if the issue continues.'
   },
   remoteStatusIssueDetailServiceStopped: {
-    zh: '本地托管服务没有在运行，所以远程连接不会保持在线。',
-    en: 'The local managed service is not running, so the remote connection cannot stay online.'
+    zh: '后台服务当前没有运行。启动后，这台设备才会重新出现在网页版设备列表里。',
+    en: 'The managed service is not running right now. Start it so this device can show up in the web device list again.'
+  },
+  remoteStatusReauthorizationHint: {
+    zh: '点击下方按钮后会打开登录页。完成登录后，这台设备会自动恢复远程访问，不需要重新配置。',
+    en: 'Use the button below to open the sign-in page. Once you finish signing in, this device will recover remote access automatically.'
   },
   remoteSignInAndEnable: { zh: '登录并开启远程访问', en: 'Sign In and Enable Remote Access' },
   remoteEnableNow: { zh: '开启远程访问', en: 'Enable Remote Access' },
   remoteReconnectNow: { zh: '重新连接', en: 'Reconnect' },
+  remoteReauthorizeNow: { zh: '重新登录并恢复远程访问', en: 'Sign In Again and Restore Remote Access' },
   remoteDisable: { zh: '关闭远程访问', en: 'Disable Remote Access' },
   remoteDeviceSummaryTitle: { zh: '当前设备', en: 'This Device' },
   remoteDeviceSummaryDescription: {
@@ -114,6 +125,7 @@ export const REMOTE_LABELS: Record<string, { zh: string; en: string }> = {
   remoteStateError: { zh: '连接异常', en: 'Error' },
   remoteStateDisconnected: { zh: '已断开', en: 'Disconnected' },
   remoteStateDisabled: { zh: '未启用', en: 'Disabled' },
+  remoteStateReauthorizationRequired: { zh: '需要重新登录', en: 'Sign-In Required' },
   remoteLocalOrigin: { zh: '本地服务地址', en: 'Local Origin' },
   remotePublicPlatform: { zh: '平台地址', en: 'Platform Base' },
   remoteDeviceId: { zh: '设备 ID', en: 'Device ID' },

package/src/remote/managers/remote-access.manager.ts

@@ -79,6 +79,15 @@ export class RemoteAccessManager {
     });
   };
 
+  reauthorizeRemoteAccess = async (status: RemoteAccessView | undefined) => {
+    const currentStatus = status ?? (await refreshRemoteStatus());
+    await this.accountManager?.startBrowserSignIn({
+      status: currentStatus,
+      apiBase: useRemoteAccessStore.getState().platformApiBase,
+      pendingAction: { type: 'repair-remote' }
+    });
+  };
+
   saveAdvancedSettings = async (status: RemoteAccessView | undefined) => {
     const currentStatus = status ?? (await refreshRemoteStatus());
     const draft = useRemoteAccessStore.getState();
@@ -126,6 +135,10 @@ export class RemoteAccessManager {
     }
     if (action.type === 'enable-remote') {
       await this.applyEnabledState(true, status);
+      return;
+    }
+    if (action.type === 'repair-remote') {
+      await this.repairRemoteAccess(status);
     }
   };
 

package/src/remote/remote-access-feedback.service.test.ts

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { RemoteAccessView } from '@/api/remote.types';
+import { setLanguage } from '@/lib/i18n';
+import { buildRemoteAccessFeedbackView, requiresRemoteReauthorization } from '@/remote/remote-access-feedback.service';
+
+function createRemoteAccessView(overrides: Partial<RemoteAccessView> = {}): RemoteAccessView {
+  return {
+    account: {
+      loggedIn: true,
+      email: 'user@example.com',
+      apiBase: 'https://ai-gateway-api.nextclaw.io/v1',
+      platformBase: 'https://ai-gateway-api.nextclaw.io'
+    },
+    settings: {
+      enabled: true,
+      deviceName: 'MacBook Pro',
+      platformApiBase: 'https://ai-gateway-api.nextclaw.io/v1'
+    },
+    service: {
+      running: true,
+      currentProcess: false
+    },
+    localOrigin: 'http://127.0.0.1:55667',
+    configuredEnabled: true,
+    platformBase: 'https://ai-gateway-api.nextclaw.io',
+    runtime: {
+      enabled: true,
+      mode: 'service',
+      state: 'error',
+      deviceName: 'MacBook Pro',
+      lastError: 'Remote relay closed unexpectedly.',
+      updatedAt: '2026-03-23T00:00:00.000Z'
+    },
+    ...overrides
+  };
+}
+
+describe('remote-access-feedback.service', () => {
+  beforeEach(() => {
+    setLanguage('zh');
+  });
+
+  it('turns token errors into a reauthorization experience', () => {
+    const status = createRemoteAccessView({
+      runtime: {
+        enabled: true,
+        mode: 'service',
+        state: 'error',
+        lastError: 'Invalid or expired token.',
+        updatedAt: '2026-03-23T00:00:00.000Z'
+      }
+    });
+
+    expect(requiresRemoteReauthorization(status)).toBe(true);
+
+    const feedback = buildRemoteAccessFeedbackView(status);
+
+    expect(feedback.hero.title).toBe('登录已过期，请重新登录 NextClaw');
+    expect(feedback.primaryAction?.kind).toBe('reauthorize');
+    expect(feedback.primaryAction?.label).toBe('重新登录并恢复远程访问');
+    expect(feedback.issueHint?.body).not.toContain('Invalid or expired token');
+  });
+
+  it('keeps generic reconnect guidance for non-auth runtime errors', () => {
+    const status = createRemoteAccessView();
+
+    expect(requiresRemoteReauthorization(status)).toBe(false);
+
+    const feedback = buildRemoteAccessFeedbackView(status);
+
+    expect(feedback.hero.title).toBe('远程访问暂时没有连上');
+    expect(feedback.primaryAction?.kind).toBe('repair');
+    expect(feedback.issueHint?.body).toBe('远程访问暂时不可用。你可以先重新连接；如果问题持续，再重新登录或稍后再试。');
+  });
+});

package/src/remote/remote-access-feedback.service.ts

@@ -0,0 +1,195 @@
+import type { RemoteAccessView } from '@/api/remote.types';
+import { t } from '@/lib/i18n';
+
+type RemoteHeroView = {
+  badgeStatus: 'active' | 'inactive' | 'ready' | 'setup' | 'warning';
+  badgeLabel: string;
+  title: string;
+  description: string;
+};
+
+type RemotePrimaryAction =
+  | {
+      kind: 'sign-in-enable' | 'enable' | 'repair' | 'reauthorize';
+      label: string;
+      showRefreshIcon: boolean;
+    }
+  | null;
+
+type RemoteIssueHint = {
+  title: string;
+  body: string;
+};
+
+export type RemoteAccessFeedbackView = {
+  hero: RemoteHeroView;
+  primaryAction: RemotePrimaryAction;
+  issueHint: RemoteIssueHint | null;
+  shouldShowIssueHint: boolean;
+  requiresReauthorization: boolean;
+};
+
+const AUTH_EXPIRED_PATTERNS = [
+  /invalid or expired token/i,
+  /missing bearer token/i,
+  /token expired/i,
+  /token is invalid/i,
+  /run "nextclaw login"/i,
+  /browser sign-in again/i
+];
+
+function readRuntimeError(status: RemoteAccessView | undefined): string {
+  return status?.runtime?.lastError?.trim() || '';
+}
+
+export function requiresRemoteReauthorization(status: RemoteAccessView | undefined): boolean {
+  if (!status?.settings.enabled) {
+    return false;
+  }
+  const error = readRuntimeError(status);
+  return AUTH_EXPIRED_PATTERNS.some((pattern) => pattern.test(error));
+}
+
+export function buildRemoteAccessFeedbackView(status: RemoteAccessView | undefined): RemoteAccessFeedbackView {
+  const reauthorizationRequired = requiresRemoteReauthorization(status);
+
+  if (reauthorizationRequired) {
+    return {
+      hero: {
+        badgeStatus: 'warning',
+        badgeLabel: t('remoteStateReauthorizationRequired'),
+        title: t('remoteStatusReauthorizationTitle'),
+        description: t('remoteStatusReauthorizationDescription')
+      },
+      primaryAction: {
+        kind: 'reauthorize',
+        label: t('remoteReauthorizeNow'),
+        showRefreshIcon: false
+      },
+      issueHint: {
+        title: t('remoteStatusRecoveryTitle'),
+        body: t('remoteStatusReauthorizationHint')
+      },
+      shouldShowIssueHint: true,
+      requiresReauthorization: true
+    };
+  }
+
+  if (!status?.account.loggedIn) {
+    return {
+      hero: {
+        badgeStatus: 'setup',
+        badgeLabel: t('statusSetup'),
+        title: t('remoteStatusNeedsSignIn'),
+        description: t('remoteStatusNeedsSignInDescription')
+      },
+      primaryAction: {
+        kind: 'sign-in-enable',
+        label: t('remoteSignInAndEnable'),
+        showRefreshIcon: false
+      },
+      issueHint: null,
+      shouldShowIssueHint: false,
+      requiresReauthorization: false
+    };
+  }
+
+  if (!status.settings.enabled) {
+    return {
+      hero: {
+        badgeStatus: 'inactive',
+        badgeLabel: t('statusInactive'),
+        title: t('remoteStatusNeedsEnable'),
+        description: t('remoteStatusNeedsEnableDescription')
+      },
+      primaryAction: {
+        kind: 'enable',
+        label: t('remoteEnableNow'),
+        showRefreshIcon: false
+      },
+      issueHint: null,
+      shouldShowIssueHint: false,
+      requiresReauthorization: false
+    };
+  }
+
+  if (!status.service.running) {
+    return {
+      hero: {
+        badgeStatus: 'warning',
+        badgeLabel: t('remoteServiceStopped'),
+        title: t('remoteStatusNeedsServiceTitle'),
+        description: t('remoteStatusNeedsServiceDescription')
+      },
+      primaryAction: {
+        kind: 'repair',
+        label: t('remoteReconnectNow'),
+        showRefreshIcon: true
+      },
+      issueHint: {
+        title: t('remoteStatusRecoveryTitle'),
+        body: t('remoteStatusIssueDetailServiceStopped')
+      },
+      shouldShowIssueHint: true,
+      requiresReauthorization: false
+    };
+  }
+
+  if (status.runtime?.state === 'connected') {
+    return {
+      hero: {
+        badgeStatus: 'ready',
+        badgeLabel: t('statusReady'),
+        title: t('remoteStatusReadyTitle'),
+        description: t('remoteStatusReadyDescription')
+      },
+      primaryAction: {
+        kind: 'repair',
+        label: t('remoteReconnectNow'),
+        showRefreshIcon: true
+      },
+      issueHint: null,
+      shouldShowIssueHint: false,
+      requiresReauthorization: false
+    };
+  }
+
+  if (status.runtime?.state === 'connecting') {
+    return {
+      hero: {
+        badgeStatus: 'active',
+        badgeLabel: t('connecting'),
+        title: t('remoteStatusConnectingTitle'),
+        description: t('remoteStatusConnectingDescription')
+      },
+      primaryAction: {
+        kind: 'repair',
+        label: t('remoteReconnectNow'),
+        showRefreshIcon: true
+      },
+      issueHint: null,
+      shouldShowIssueHint: false,
+      requiresReauthorization: false
+    };
+  }
+
+  return {
+    hero: {
+      badgeStatus: 'warning',
+      badgeLabel: t('remoteStateDisconnected'),
+      title: t('remoteStatusIssueTitle'),
+      description: t('remoteStatusIssueDescription')
+    },
+    primaryAction: {
+      kind: 'repair',
+      label: t('remoteReconnectNow'),
+      showRefreshIcon: true
+    },
+    issueHint: {
+      title: t('remoteStatusRecoveryTitle'),
+      body: t('remoteStatusIssueDetailGeneric')
+    },
+    shouldShowIssueHint: Boolean(status.settings.enabled && status.account.loggedIn),
+    requiresReauthorization: false
+  };
+}

package/src/transport/app-client.ts

@@ -1,4 +1,4 @@
-import { API_BASE } from '@/api/client';
+import { API_BASE } from '@/api/api-base';
 import { LocalAppTransport } from './local.transport';
 import { RemoteSessionMultiplexTransport } from './remote.transport';
 import type { AppTransport, RemoteRuntimeInfo, RequestInput, StreamInput, StreamSession } from './transport.types';

package/src/transport/local.transport.ts

@@ -1,34 +1,12 @@
-import { API_BASE, requestApiResponse } from '@/api/client';
+import { API_BASE } from '@/api/api-base';
+import { requestRawApiResponse } from '@/api/raw-client';
 import type { ApiResponse } from '@/api/types';
-import type { AppEvent, AppTransport, RequestInput, StreamEvent, StreamInput, StreamSession } from './transport.types';
+import type { AppEvent, AppTransport, RequestInput, StreamInput, StreamSession } from './transport.types';
+import { readSseStreamResult } from './sse-stream';
+import { resolveTransportWebSocketUrl } from './transport-websocket-url';
 
 type EventHandler = (event: AppEvent) => void;
 
-function toWebSocketUrl(base: string, path: string): string {
-  const normalizedBase = base.replace(/\/$/, '');
-  try {
-    const resolved = new URL(normalizedBase, window.location.origin);
-    const protocol =
-      resolved.protocol === 'https:'
-        ? 'wss:'
-        : resolved.protocol === 'http:'
-          ? 'ws:'
-          : resolved.protocol;
-    return `${protocol}//${resolved.host}${path}`;
-  } catch {
-    if (normalizedBase.startsWith('wss://') || normalizedBase.startsWith('ws://')) {
-      return `${normalizedBase}${path}`;
-    }
-    if (normalizedBase.startsWith('https://')) {
-      return `${normalizedBase.replace(/^https:/, 'wss:')}${path}`;
-    }
-    if (normalizedBase.startsWith('http://')) {
-      return `${normalizedBase.replace(/^http:/, 'ws:')}${path}`;
-    }
-    return `${normalizedBase}${path}`;
-  }
-}
-
 function createTransportError(response: ApiResponse<unknown>, fallback: string): Error {
   if (!response.ok) {
     return new Error(response.error.message);
@@ -36,43 +14,6 @@ function createTransportError(response: ApiResponse<unknown>, fallback: string):
   return new Error(fallback);
 }
 
-function parseSseFrame(frame: string): StreamEvent | null {
-  const lines = frame.split('\n');
-  let name = '';
-  const dataLines: string[] = [];
-  for (const raw of lines) {
-    const line = raw.trimEnd();
-    if (!line || line.startsWith(':')) {
-      continue;
-    }
-    if (line.startsWith('event:')) {
-      name = line.slice(6).trim();
-      continue;
-    }
-    if (line.startsWith('data:')) {
-      dataLines.push(line.slice(5).trimStart());
-    }
-  }
-  if (!name) {
-    return null;
-  }
-
-  let payload: unknown = undefined;
-  const data = dataLines.join('\n');
-  if (data) {
-    try {
-      payload = JSON.parse(data);
-    } catch {
-      payload = data;
-    }
-  }
-
-  return {
-    name,
-    payload
-  };
-}
-
 class LocalRealtimeGateway {
   private socket: WebSocket | null = null;
   private reconnectTimer: number | null = null;
@@ -168,11 +109,11 @@ export class LocalAppTransport implements AppTransport {
     } = {}
   ) {
     const apiBase = options.apiBase ?? API_BASE;
-    this.realtimeGateway = new LocalRealtimeGateway(toWebSocketUrl(apiBase, options.wsPath ?? '/ws'));
+    this.realtimeGateway = new LocalRealtimeGateway(resolveTransportWebSocketUrl(apiBase, options.wsPath ?? '/ws'));
   }
 
   async request<T>(input: RequestInput): Promise<T> {
-    const response = await requestApiResponse<T>(input.path, {
+    const response = await requestRawApiResponse<T>(input.path, {
       method: input.method,
       ...(input.body !== undefined ? { body: JSON.stringify(input.body) } : {})
     });
@@ -209,69 +150,11 @@ export class LocalAppTransport implements AppTransport {
         const text = await response.text();
         throw new Error(text.trim() || `HTTP ${response.status}`);
       }
-
-      const reader = response.body?.getReader();
-      if (!reader) {
-        throw new Error('SSE response body unavailable');
-      }
-
-      const decoder = new TextDecoder();
-      let buffer = '';
-      let finalResult: unknown;
-
       try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) {
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          let boundary = buffer.indexOf('\n\n');
-          while (boundary !== -1) {
-            const frame = parseSseFrame(buffer.slice(0, boundary));
-            buffer = buffer.slice(boundary + 2);
-            if (frame) {
-              if (frame.name === 'final') {
-                finalResult = frame.payload;
-              } else if (frame.name === 'error') {
-                const errorPayload = frame.payload as { message?: string } | string | undefined;
-                const message = typeof errorPayload === 'string'
-                  ? errorPayload
-                  : errorPayload?.message ?? 'chat stream failed';
-                throw new Error(message);
-              } else {
-                input.onEvent(frame);
-              }
-            }
-            boundary = buffer.indexOf('\n\n');
-          }
-        }
-
-        if (buffer.trim()) {
-          const frame = parseSseFrame(buffer);
-          if (frame) {
-            if (frame.name === 'final') {
-              finalResult = frame.payload;
-            } else if (frame.name === 'error') {
-              const errorPayload = frame.payload as { message?: string } | string | undefined;
-              const message = typeof errorPayload === 'string'
-                ? errorPayload
-                : errorPayload?.message ?? 'chat stream failed';
-              throw new Error(message);
-            } else {
-              input.onEvent(frame);
-            }
-          }
-        }
+        return await readSseStreamResult<TFinal>(response, input.onEvent);
       } finally {
-        reader.releaseLock();
         input.signal?.removeEventListener('abort', abort);
       }
-
-      if (finalResult === undefined) {
-        throw new Error('stream ended without final event');
-      }
-      return finalResult as TFinal;
     })();
 
     return {

package/src/transport/remote.transport.ts

@@ -1,6 +1,7 @@
-import { API_BASE } from '@/api/client';
+import { API_BASE } from '@/api/api-base';
 import type { ApiError } from '@/api/types';
 import type { AppEvent, AppTransport, RemoteRuntimeInfo, RequestInput, StreamInput, StreamSession } from './transport.types';
+import { resolveTransportWebSocketUrl } from './transport-websocket-url';
 
 type RemoteTarget = {
   method: string;
@@ -34,31 +35,6 @@ type PendingStream = {
   reject: (error: Error) => void;
 };
 
-function createWsUrl(apiBase: string, wsPath: string): string {
-  const normalizedBase = apiBase.replace(/\/$/, '');
-  try {
-    const resolved = new URL(normalizedBase, window.location.origin);
-    const protocol =
-      resolved.protocol === 'https:'
-        ? 'wss:'
-        : resolved.protocol === 'http:'
-          ? 'ws:'
-          : resolved.protocol;
-    return `${protocol}//${resolved.host}${wsPath}`;
-  } catch {
-    if (normalizedBase.startsWith('wss://') || normalizedBase.startsWith('ws://')) {
-      return `${normalizedBase}${wsPath}`;
-    }
-    if (normalizedBase.startsWith('https://')) {
-      return `${normalizedBase.replace(/^https:/, 'wss:')}${wsPath}`;
-    }
-    if (normalizedBase.startsWith('http://')) {
-      return `${normalizedBase.replace(/^http:/, 'ws:')}${wsPath}`;
-    }
-    return `${normalizedBase}${wsPath}`;
-  }
-}
-
 function normalizeApiError(body: unknown, status: number, fallback: string): Error {
   if (typeof body === 'object' && body && 'ok' in body) {
     const typed = body as { ok?: boolean; error?: ApiError; data?: unknown };
@@ -243,7 +219,7 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
       return await this.connectPromise;
     }
 
-    const wsUrl = createWsUrl(this.apiBase, this.runtime.wsPath);
+    const wsUrl = resolveTransportWebSocketUrl(this.apiBase, this.runtime.wsPath);
     this.manualClose = false;
     this.connectPromise = new Promise<void>((innerResolve, innerReject) => {
         const socket = new WebSocket(wsUrl);
@@ -330,69 +306,63 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
   }
 
   private handleFrame(frame: RemoteBrowserFrame): void {
-    if (frame.type === 'response') {
-      const pending = this.pendingRequests.get(frame.id);
-      if (!pending) {
-        return;
-      }
-      this.pendingRequests.delete(frame.id);
-      if (frame.status >= 400) {
-        pending.reject(normalizeApiError(frame.body, frame.status, 'Remote request failed.'));
-        return;
-      }
-      try {
-        pending.resolve(unwrapApiBody(frame.body));
-      } catch (error) {
-        pending.reject(error instanceof Error ? error : new Error(String(error)));
-      }
+    if (frame.type === 'response' || frame.type === 'request.error') {
+      this.handleRequestFrame(frame);
       return;
     }
+    if (frame.type === 'stream.event' || frame.type === 'stream.end' || frame.type === 'stream.error') {
+      this.handleStreamFrame(frame);
+      return;
+    }
+    if (frame.type === 'event') {
+      this.emit(frame.event);
+      return;
+    }
+    if (frame.type === 'connection.error') {
+      this.emit({ type: 'connection.error', payload: { message: frame.message } });
+    }
+  }
 
+  private handleRequestFrame(frame: Extract<RemoteBrowserFrame, { type: 'response' | 'request.error' }>): void {
+    const pending = this.pendingRequests.get(frame.id);
+    if (!pending) {
+      return;
+    }
+    this.pendingRequests.delete(frame.id);
     if (frame.type === 'request.error') {
-      const pending = this.pendingRequests.get(frame.id);
-      if (!pending) {
-        return;
-      }
-      this.pendingRequests.delete(frame.id);
       pending.reject(new Error(frame.message));
       return;
     }
-
-    if (frame.type === 'stream.event') {
-      this.pendingStreams.get(frame.streamId)?.onEvent({
-        name: frame.event,
-        payload: frame.payload
-      });
+    if (frame.status >= 400) {
+      pending.reject(normalizeApiError(frame.body, frame.status, 'Remote request failed.'));
       return;
     }
+    try {
+      pending.resolve(unwrapApiBody(frame.body));
+    } catch (error) {
+      pending.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
 
-    if (frame.type === 'stream.end') {
-      const pending = this.pendingStreams.get(frame.streamId);
-      if (!pending) {
-        return;
-      }
-      this.pendingStreams.delete(frame.streamId);
-      pending.resolve(frame.result);
+  private handleStreamFrame(frame: Extract<RemoteBrowserFrame, { type: 'stream.event' | 'stream.end' | 'stream.error' }>): void {
+    const pending = this.pendingStreams.get(frame.streamId);
+    if (!pending) {
       return;
     }
-
-    if (frame.type === 'stream.error') {
-      const pending = this.pendingStreams.get(frame.streamId);
-      if (!pending) {
-        return;
+    if (frame.type === 'stream.event') {
+      try {
+        pending.onEvent({ name: frame.event, payload: frame.payload });
+      } catch (error) {
+        this.pendingStreams.delete(frame.streamId);
+        pending.reject(error instanceof Error ? error : new Error(String(error)));
       }
-      this.pendingStreams.delete(frame.streamId);
-      pending.reject(new Error(frame.message));
       return;
     }
-
-    if (frame.type === 'event') {
-      this.emit(frame.event);
+    this.pendingStreams.delete(frame.streamId);
+    if (frame.type === 'stream.end') {
+      pending.resolve(frame.result);
       return;
     }
-
-    if (frame.type === 'connection.error') {
-      this.emit({ type: 'connection.error', payload: { message: frame.message } });
-    }
+    pending.reject(new Error(frame.message));
   }
 }