@nextclaw/ui 0.9.14 → 0.9.16

package/src/components/config/weixin-channel-auth-section.tsx

@@ -0,0 +1,242 @@
+import { useEffect, useMemo, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { Button } from '@/components/ui/button';
+import { formatDateTime, t } from '@/lib/i18n';
+import { cn } from '@/lib/utils';
+import { toast } from 'sonner';
+import { ExternalLink, Loader2, MessageCircleMore, QrCode } from 'lucide-react';
+import { usePollChannelAuth, useStartChannelAuth } from '@/hooks/use-channel-auth';
+import type { ChannelAuthPollResult, ChannelAuthStartResult } from '@/api/channel-auth.types';
+
+type WeixinChannelAuthSectionProps = {
+  channelConfig: Record<string, unknown>;
+  formData: Record<string, unknown>;
+  disabled?: boolean;
+};
+
+function resolveConnectedAccountIds(channelConfig: Record<string, unknown>): string[] {
+  const accounts = channelConfig.accounts;
+  const ids = new Set<string>();
+  if (typeof channelConfig.defaultAccountId === 'string' && channelConfig.defaultAccountId.trim()) {
+    ids.add(channelConfig.defaultAccountId.trim());
+  }
+  if (accounts && typeof accounts === 'object' && !Array.isArray(accounts)) {
+    for (const accountId of Object.keys(accounts)) {
+      const trimmed = accountId.trim();
+      if (trimmed) {
+        ids.add(trimmed);
+      }
+    }
+  }
+  return [...ids];
+}
+
+function resolveBaseUrl(formData: Record<string, unknown>, channelConfig: Record<string, unknown>): string | undefined {
+  if (typeof formData.baseUrl === 'string' && formData.baseUrl.trim()) {
+    return formData.baseUrl.trim();
+  }
+  if (typeof channelConfig.baseUrl === 'string' && channelConfig.baseUrl.trim()) {
+    return channelConfig.baseUrl.trim();
+  }
+  return undefined;
+}
+
+export function WeixinChannelAuthSection({
+  channelConfig,
+  formData,
+  disabled = false
+}: WeixinChannelAuthSectionProps) {
+  const queryClient = useQueryClient();
+  const startChannelAuth = useStartChannelAuth();
+  const pollChannelAuth = usePollChannelAuth();
+  const [activeSession, setActiveSession] = useState<ChannelAuthStartResult | null>(null);
+  const [authState, setAuthState] = useState<ChannelAuthPollResult | null>(null);
+
+  const connectedAccountIds = useMemo(() => resolveConnectedAccountIds(channelConfig), [channelConfig]);
+  const primaryAccountId = connectedAccountIds[0];
+  const baseUrl = resolveBaseUrl(formData, channelConfig);
+  const hasConnectedAccount = connectedAccountIds.length > 0;
+
+  useEffect(() => {
+    if (!activeSession) {
+      return;
+    }
+
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    const runPoll = async () => {
+      try {
+        const result = await pollChannelAuth.mutateAsync({
+          channel: 'weixin',
+          data: { sessionId: activeSession.sessionId }
+        });
+        if (cancelled) {
+          return;
+        }
+
+        setAuthState(result);
+
+        if (result.status === 'authorized') {
+          await queryClient.invalidateQueries({ queryKey: ['config'] });
+          await queryClient.invalidateQueries({ queryKey: ['config-meta'] });
+          toast.success(result.message || t('weixinAuthAuthorized'));
+          setActiveSession(null);
+          return;
+        }
+
+        if (result.status === 'expired' || result.status === 'error') {
+          toast.error(result.message || t('weixinAuthRetryRequired'));
+          setActiveSession(null);
+          return;
+        }
+
+        timer = setTimeout(runPoll, result.nextPollMs ?? activeSession.intervalMs);
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        toast.error(`${t('error')}: ${message}`);
+        setActiveSession(null);
+      }
+    };
+
+    timer = setTimeout(runPoll, activeSession.intervalMs);
+
+    return () => {
+      cancelled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+    };
+  }, [activeSession, pollChannelAuth, queryClient]);
+
+  const handleStartAuth = async () => {
+    try {
+      const result = await startChannelAuth.mutateAsync({
+        channel: 'weixin',
+        data: {
+          baseUrl,
+          accountId:
+            typeof formData.defaultAccountId === 'string' && formData.defaultAccountId.trim()
+              ? formData.defaultAccountId.trim()
+              : undefined
+        }
+      });
+      setActiveSession(result);
+      setAuthState({
+        channel: 'weixin',
+        status: 'pending',
+        message: result.note,
+        nextPollMs: result.intervalMs
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      toast.error(`${t('error')}: ${message}`);
+    }
+  };
+
+  const statusLabel = activeSession
+    ? authState?.status === 'scanned'
+      ? t('weixinAuthScanned')
+      : t('weixinAuthWaiting')
+    : hasConnectedAccount
+      ? t('weixinAuthAuthorized')
+      : t('weixinAuthNotConnected');
+
+  const connectButtonLabel = startChannelAuth.isPending
+    ? t('weixinAuthStarting')
+    : activeSession
+      ? t('weixinAuthWaiting')
+      : hasConnectedAccount
+        ? t('weixinAuthReconnect')
+        : t('weixinAuthConnect');
+
+  return (
+    <section className="rounded-2xl border border-primary/20 bg-gradient-to-br from-primary-50/70 via-white to-emerald-50/60 p-5">
+      <div className="flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
+        <div className="space-y-3">
+          <div className="inline-flex items-center gap-2 rounded-full bg-white/90 px-3 py-1 text-xs font-medium text-primary shadow-sm">
+            <QrCode className="h-3.5 w-3.5" />
+            {t('weixinAuthTitle')}
+          </div>
+          <div>
+            <h4 className="text-base font-semibold text-gray-900">{t('weixinAuthDescription')}</h4>
+            <p className="mt-1 text-sm text-gray-600">{t('weixinAuthHint')}</p>
+          </div>
+          <div
+            className={cn(
+              'inline-flex w-fit items-center gap-2 rounded-full px-3 py-1 text-xs font-medium',
+              activeSession
+                ? 'bg-amber-50 text-amber-700'
+                : hasConnectedAccount
+                  ? 'bg-emerald-50 text-emerald-700'
+                  : 'bg-gray-100 text-gray-600'
+            )}
+          >
+            {activeSession ? <Loader2 className="h-3.5 w-3.5 animate-spin" /> : <MessageCircleMore className="h-3.5 w-3.5" />}
+            {statusLabel}
+          </div>
+          <div className="space-y-1 text-sm text-gray-600">
+            <p>{t('weixinAuthCapabilityHint')}</p>
+            {primaryAccountId ? (
+              <p>
+                {t('weixinAuthPrimaryAccount')}: <span className="font-mono text-xs text-gray-900">{primaryAccountId}</span>
+              </p>
+            ) : null}
+            {connectedAccountIds.length > 1 ? (
+              <p>
+                {t('weixinAuthConnectedAccounts')}: <span className="font-mono text-xs text-gray-900">{connectedAccountIds.join(', ')}</span>
+              </p>
+            ) : null}
+            {baseUrl ? (
+              <p>
+                {t('weixinAuthBaseUrl')}: <span className="font-mono text-xs text-gray-900">{baseUrl}</span>
+              </p>
+            ) : null}
+          </div>
+          <Button
+            type="button"
+            onClick={handleStartAuth}
+            disabled={disabled || startChannelAuth.isPending || Boolean(activeSession)}
+            className="rounded-xl"
+          >
+            {connectButtonLabel}
+          </Button>
+        </div>
+
+        <div className="w-full max-w-sm rounded-2xl border border-dashed border-primary/25 bg-white/85 p-4 shadow-sm">
+          {activeSession ? (
+            <div className="space-y-3">
+              <div className="overflow-hidden rounded-2xl border border-gray-100 bg-white p-3">
+                <img src={activeSession.qrCodeUrl} alt={t('weixinAuthQrAlt')} className="mx-auto aspect-square w-full max-w-[240px] object-contain" />
+              </div>
+              <div className="space-y-1 text-xs text-gray-500">
+                <p>{authState?.message || activeSession.note || t('weixinAuthScanPrompt')}</p>
+                <p>
+                  {t('weixinAuthExpiresAt')}: {formatDateTime(activeSession.expiresAt)}
+                </p>
+              </div>
+              <a
+                href={activeSession.qrCodeUrl}
+                target="_blank"
+                rel="noreferrer"
+                className="inline-flex items-center gap-1.5 text-xs text-primary transition-colors hover:text-primary-hover"
+              >
+                <ExternalLink className="h-3.5 w-3.5" />
+                {t('weixinAuthOpenQr')}
+              </a>
+            </div>
+          ) : (
+            <div className="flex min-h-[280px] flex-col items-center justify-center rounded-2xl bg-gray-50/80 px-6 text-center">
+              <QrCode className="h-9 w-9 text-gray-300" />
+              <p className="mt-3 text-sm font-medium text-gray-700">{t('weixinAuthReadyTitle')}</p>
+              <p className="mt-1 text-xs leading-5 text-gray-500">{t('weixinAuthReadyDescription')}</p>
+            </div>
+          )}
+        </div>
+      </div>
+    </section>
+  );
+}

package/src/hooks/use-channel-auth.ts

@@ -0,0 +1,16 @@
+import { useMutation } from '@tanstack/react-query';
+import { pollChannelAuth, startChannelAuth } from '@/api/channel-auth';
+
+export function useStartChannelAuth() {
+  return useMutation({
+    mutationFn: ({ channel, data }: { channel: string; data?: unknown }) =>
+      startChannelAuth(channel, data as Parameters<typeof startChannelAuth>[1])
+  });
+}
+
+export function usePollChannelAuth() {
+  return useMutation({
+    mutationFn: ({ channel, data }: { channel: string; data: unknown }) =>
+      pollChannelAuth(channel, data as Parameters<typeof pollChannelAuth>[1])
+  });
+}

package/src/lib/i18n.channel-auth.ts

@@ -0,0 +1,37 @@
+export const CHANNEL_AUTH_LABELS: Record<string, { zh: string; en: string }> = {
+  weixinAuthTitle: { zh: '扫码连接微信', en: 'Connect Weixin by QR' },
+  weixinAuthDescription: { zh: '微信渠道现在以扫码连接为主流程。', en: 'Weixin now uses QR login as the primary setup flow.' },
+  weixinAuthHint: {
+    zh: '通常只需要点击按钮并扫码确认，连接成功后会自动写入配置。',
+    en: 'In most cases you only need to start the flow, scan the QR code, and confirm on your phone. The config will be saved automatically.'
+  },
+  weixinAuthCapabilityHint: {
+    zh: '连接成功后，Agent 可以通过微信渠道向已知微信用户主动发消息。',
+    en: 'After connecting, the agent can proactively message known Weixin users through this channel.'
+  },
+  weixinAuthPrimaryAccount: { zh: '当前默认账号', en: 'Current default account' },
+  weixinAuthConnectedAccounts: { zh: '已连接账号', en: 'Connected accounts' },
+  weixinAuthBaseUrl: { zh: '当前接口地址', en: 'Current API base URL' },
+  weixinAuthConnect: { zh: '扫码连接微信', en: 'Scan QR to connect Weixin' },
+  weixinAuthReconnect: { zh: '重新扫码连接', en: 'Reconnect with QR' },
+  weixinAuthStarting: { zh: '正在生成二维码...', en: 'Generating QR code...' },
+  weixinAuthWaiting: { zh: '等待扫码确认', en: 'Waiting for scan confirmation' },
+  weixinAuthScanned: { zh: '已扫码，等待确认', en: 'Scanned, waiting for confirmation' },
+  weixinAuthAuthorized: { zh: '已连接', en: 'Connected' },
+  weixinAuthNotConnected: { zh: '未连接', en: 'Not connected' },
+  weixinAuthRetryRequired: { zh: '二维码已失效，请重新扫码。', en: 'QR session expired. Please start again.' },
+  weixinAuthQrAlt: { zh: '微信登录二维码', en: 'Weixin login QR code' },
+  weixinAuthScanPrompt: { zh: '请用微信扫码，并在手机上确认登录。', en: 'Scan with Weixin and confirm the login on your phone.' },
+  weixinAuthExpiresAt: { zh: '二维码过期时间', en: 'QR expires at' },
+  weixinAuthOpenQr: { zh: '新窗口打开二维码', en: 'Open QR code in new tab' },
+  weixinAuthReadyTitle: { zh: '准备连接微信', en: 'Ready to connect Weixin' },
+  weixinAuthReadyDescription: {
+    zh: '点击左侧按钮后，这里会显示二维码。整个首配流程默认不需要手动填写底层参数。',
+    en: 'After you start the flow, the QR code will appear here. Most first-time setups do not require filling low-level fields manually.'
+  },
+  weixinAuthAdvancedTitle: { zh: '高级设置', en: 'Advanced settings' },
+  weixinAuthAdvancedDescription: {
+    zh: '仅在你需要自定义接口地址、账号映射或白名单时再展开这些字段。',
+    en: 'Expand these fields only when you need to customize the API base URL, account mapping, or allowlist.'
+  }
+};

package/src/lib/i18n.ts

@@ -1,16 +1,13 @@
 import { CHANNEL_LABELS } from './i18n.channels';
+import { CHANNEL_AUTH_LABELS } from './i18n.channel-auth';
 import { MARKETPLACE_LABELS } from './i18n.marketplace';
 import { REMOTE_LABELS } from './i18n.remote';
-
 export type I18nLanguage = 'zh' | 'en';
-
 const I18N_STORAGE_KEY = 'nextclaw.ui.language';
-
 export const LANGUAGE_OPTIONS: Array<{ value: I18nLanguage; label: string }> = [
   { value: 'en', label: 'English' },
   { value: 'zh', label: '中文' }
 ];
-
 const LANGUAGE_TO_LOCALE: Record<I18nLanguage, string> = {
   en: 'en-US',
   zh: 'zh-CN'
@@ -737,6 +734,7 @@ export const LABELS: Record<string, { zh: string; en: string }> = {
   docBrowserNewTab: { zh: '新建标签', en: 'New Tab' },
   docBrowserCloseTab: { zh: '关闭标签', en: 'Close Tab' },
   docBrowserTabUntitled: { zh: '未命名', en: 'Untitled' },
+  ...CHANNEL_AUTH_LABELS,
 };
 
 export function t(key: string, lang: I18nLanguage = getLanguage()): string {

package/src/transport/local.transport.ts

@@ -101,6 +101,7 @@ class LocalRealtimeGateway {
 
 export class LocalAppTransport implements AppTransport {
   private readonly realtimeGateway: LocalRealtimeGateway;
+  private readonly apiBase: string;
 
   constructor(
     private readonly options: {
@@ -108,8 +109,8 @@ export class LocalAppTransport implements AppTransport {
       wsPath?: string;
     } = {}
   ) {
-    const apiBase = options.apiBase ?? API_BASE;
-    this.realtimeGateway = new LocalRealtimeGateway(resolveTransportWebSocketUrl(apiBase, options.wsPath ?? '/ws'));
+    this.apiBase = options.apiBase ?? API_BASE;
+    this.realtimeGateway = new LocalRealtimeGateway(resolveTransportWebSocketUrl(this.apiBase, options.wsPath ?? '/ws'));
   }
 
   async request<T>(input: RequestInput): Promise<T> {
@@ -135,7 +136,7 @@ export class LocalAppTransport implements AppTransport {
     }
 
     const finished = (async () => {
-      const response = await fetch(`${API_BASE}${input.path}`, {
+      const response = await fetch(`${this.apiBase}${input.path}`, {
         method: input.method,
         credentials: 'include',
         headers: {
@@ -151,10 +152,7 @@ export class LocalAppTransport implements AppTransport {
         throw new Error(text.trim() || `HTTP ${response.status}`);
       }
       try {
-        return await readSseStreamResult<TFinal>(response, input.onEvent, {
-          terminalEventNames: input.terminalEventNames,
-          terminalEventPayloadTypes: input.terminalEventPayloadTypes
-        });
+        return await readSseStreamResult<TFinal>(response, input.onEvent);
       } finally {
         input.signal?.removeEventListener('abort', abort);
       }

package/src/transport/remote.transport.ts

@@ -7,8 +7,6 @@ type RemoteTarget = {
   method: string;
   path: string;
   body?: unknown;
-  terminalEventNames?: readonly string[];
-  terminalEventPayloadTypes?: Partial<Record<string, readonly string[]>>;
 };
 
 type RemoteBrowserFrame =
@@ -16,7 +14,7 @@ type RemoteBrowserFrame =
   | { type: 'response'; id: string; status: number; body?: unknown }
   | { type: 'request.error'; id: string; message: string; code?: string }
   | { type: 'stream.event'; streamId: string; event: string; payload?: unknown }
-  | { type: 'stream.end'; streamId: string; result?: unknown }
+  | { type: 'stream.end'; streamId: string }
   | { type: 'stream.error'; streamId: string; message: string; code?: string }
   | { type: 'event'; event: AppEvent }
   | { type: 'connection.error'; message: string; code?: string };
@@ -33,6 +31,7 @@ type PendingRequest = {
 
 type PendingStream = {
   onEvent: StreamInput['onEvent'];
+  finalResult: unknown;
   resolve: (value: unknown) => void;
   reject: (error: Error) => void;
 };
@@ -133,6 +132,7 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
 
     this.pendingStreams.set(streamId, {
       onEvent: input.onEvent,
+      finalResult: undefined,
       resolve: (value) => {
         if (settled) {
           return;
@@ -169,9 +169,7 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
           target: {
             method: input.method,
             path: input.path,
-            ...(input.body !== undefined ? { body: input.body } : {}),
-            ...(input.terminalEventNames ? { terminalEventNames: input.terminalEventNames } : {}),
-            ...(input.terminalEventPayloadTypes ? { terminalEventPayloadTypes: input.terminalEventPayloadTypes } : {})
+            ...(input.body !== undefined ? { body: input.body } : {})
           }
         });
       })
@@ -355,6 +353,9 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
     }
     if (frame.type === 'stream.event') {
       try {
+        if (frame.event === 'final') {
+          pending.finalResult = frame.payload;
+        }
         pending.onEvent({ name: frame.event, payload: frame.payload });
       } catch (error) {
         this.pendingStreams.delete(frame.streamId);
@@ -364,7 +365,7 @@ export class RemoteSessionMultiplexTransport implements AppTransport {
     }
     this.pendingStreams.delete(frame.streamId);
     if (frame.type === 'stream.end') {
-      pending.resolve(frame.result);
+      pending.resolve(pending.finalResult);
       return;
     }
     pending.reject(new Error(frame.message));

package/src/transport/sse-stream.test.ts

@@ -22,24 +22,22 @@ function encodeFrame(event: string, payload: unknown): string {
 }
 
 describe('readSseStreamResult', () => {
-  it('accepts terminal-event streams without final frame when configured', async () => {
+  it('preserves final frames for callers while still resolving with the final payload', async () => {
     const events: Array<{ name: string; payload?: unknown }> = [];
     const response = createSseResponse([
       encodeFrame('ncp-event', { type: 'message.text-delta', payload: { delta: 'hello' } }),
-      encodeFrame('run.finished', { sessionId: 's1' })
+      encodeFrame('final', { sessionId: 's1', reply: 'hello' })
     ]);
 
     const result = await readSseStreamResult(response, (event) => {
       events.push(event);
-    }, {
-      terminalEventNames: ['run.finished']
     });
 
-    expect(result).toBeUndefined();
-    expect(events.map((event) => event.name)).toEqual(['ncp-event', 'run.finished']);
+    expect(result).toEqual({ sessionId: 's1', reply: 'hello' });
+    expect(events.map((event) => event.name)).toEqual(['ncp-event', 'final']);
   });
 
-  it('accepts terminal payload-type streams without final frame when configured', async () => {
+  it('allows passthrough SSE streams to end without a final frame', async () => {
     const events: Array<{ name: string; payload?: unknown }> = [];
     const response = createSseResponse([
       encodeFrame('ncp-event', { type: 'message.text-delta', payload: { delta: 'hello' } }),
@@ -48,21 +46,9 @@ describe('readSseStreamResult', () => {
 
     const result = await readSseStreamResult(response, (event) => {
       events.push(event);
-    }, {
-      terminalEventPayloadTypes: {
-        'ncp-event': ['run.finished']
-      }
     });
 
     expect(result).toBeUndefined();
     expect(events.map((event) => event.name)).toEqual(['ncp-event', 'ncp-event']);
   });
-
-  it('still rejects streams that end without final or configured terminal event', async () => {
-    const response = createSseResponse([
-      encodeFrame('ncp-event', { type: 'message.text-delta', payload: { delta: 'hello' } })
-    ]);
-
-    await expect(readSseStreamResult(response, () => undefined)).rejects.toThrow('stream ended without final event');
-  });
 });

package/src/transport/sse-stream.ts

@@ -1,12 +1,6 @@
 import type { StreamEvent } from './transport.types';
 
-type SseErrorPayload = { message?: string } | string | undefined;
 type FinalResultSink = (value: unknown) => void;
-type TerminalEventSink = (frame: StreamEvent) => void;
-type TerminalDetectionOptions = {
-  terminalEventNames?: readonly string[];
-  terminalEventPayloadTypes?: Partial<Record<string, readonly string[]>>;
-};
 
 function parseSseFrame(frame: string): StreamEvent | null {
   const lines = frame.split('\n');
@@ -42,35 +36,10 @@ function parseSseFrame(frame: string): StreamEvent | null {
   return { name, payload };
 }
 
-function readSseErrorMessage(payload: SseErrorPayload, fallback: string): string {
-  return typeof payload === 'string'
-    ? payload
-    : payload?.message ?? fallback;
-}
-
-function matchesTerminalFrame(frame: StreamEvent, options: TerminalDetectionOptions): boolean {
-  if ((options.terminalEventNames ?? []).includes(frame.name)) {
-    return true;
-  }
-  const payloadTypes = options.terminalEventPayloadTypes?.[frame.name];
-  if (!payloadTypes || payloadTypes.length === 0) {
-    return false;
-  }
-  const payloadType =
-    typeof frame.payload === 'object' &&
-    frame.payload &&
-    'type' in frame.payload &&
-    typeof (frame.payload as { type?: unknown }).type === 'string'
-      ? (frame.payload as { type: string }).type
-      : null;
-  return payloadType !== null && payloadTypes.includes(payloadType);
-}
-
 function processSseFrame(
   rawFrame: string,
   onEvent: (event: StreamEvent) => void,
-  setFinalResult: FinalResultSink,
-  setTerminalEvent: TerminalEventSink
+  setFinalResult: FinalResultSink
 ): void {
   const frame = parseSseFrame(rawFrame);
   if (!frame) {
@@ -78,24 +47,18 @@ function processSseFrame(
   }
   if (frame.name === 'final') {
     setFinalResult(frame.payload);
-    return;
-  }
-  if (frame.name === 'error') {
-    throw new Error(readSseErrorMessage(frame.payload as SseErrorPayload, 'chat stream failed'));
   }
-  setTerminalEvent(frame);
   onEvent(frame);
 }
 
 function flushBufferedFrames(
   bufferState: { value: string },
   onEvent: (event: StreamEvent) => void,
-  setFinalResult: FinalResultSink,
-  setTerminalEvent: TerminalEventSink
+  setFinalResult: FinalResultSink
 ): void {
   let boundary = bufferState.value.indexOf('\n\n');
   while (boundary !== -1) {
-    processSseFrame(bufferState.value.slice(0, boundary), onEvent, setFinalResult, setTerminalEvent);
+    processSseFrame(bufferState.value.slice(0, boundary), onEvent, setFinalResult);
     bufferState.value = bufferState.value.slice(boundary + 2);
     boundary = bufferState.value.indexOf('\n\n');
   }
@@ -103,8 +66,7 @@ function flushBufferedFrames(
 
 export async function readSseStreamResult<TFinal>(
   response: Response,
-  onEvent: (event: StreamEvent) => void,
-  options: TerminalDetectionOptions = {}
+  onEvent: (event: StreamEvent) => void
 ): Promise<TFinal> {
   const reader = response.body?.getReader();
   if (!reader) {
@@ -114,7 +76,6 @@ export async function readSseStreamResult<TFinal>(
   const decoder = new TextDecoder();
   const bufferState = { value: '' };
   let finalResult: unknown = undefined;
-  let sawTerminalEvent = false;
   try {
     while (true) {
       const { value, done } = await reader.read();
@@ -124,32 +85,16 @@ export async function readSseStreamResult<TFinal>(
       bufferState.value += decoder.decode(value, { stream: true });
       flushBufferedFrames(bufferState, onEvent, (nextValue) => {
         finalResult = nextValue;
-      }, (event) => {
-        if (matchesTerminalFrame(event, options)) {
-          sawTerminalEvent = true;
-        }
       });
     }
     if (bufferState.value.trim()) {
-      processSseFrame(bufferState.value, (event) => {
-        if (matchesTerminalFrame(event, options)) {
-          sawTerminalEvent = true;
-        }
-        onEvent(event);
-      }, (nextValue) => {
+      processSseFrame(bufferState.value, onEvent, (nextValue) => {
         finalResult = nextValue;
-      }, (event) => {
-        if (matchesTerminalFrame(event, options)) {
-          sawTerminalEvent = true;
-        }
       });
     }
   } finally {
     reader.releaseLock();
   }
 
-  if (finalResult === undefined && !sawTerminalEvent) {
-    throw new Error('stream ended without final event');
-  }
   return finalResult as TFinal;
 }

package/src/transport/transport.types.ts

@@ -18,8 +18,6 @@ export type StreamInput = {
   path: string;
   body?: unknown;
   signal?: AbortSignal;
-  terminalEventNames?: readonly string[];
-  terminalEventPayloadTypes?: Partial<Record<string, readonly string[]>>;
   onEvent: (event: StreamEvent) => void;
 };