@nextclaw/ui 0.9.14 → 0.9.15

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;
 };
 

package/src/components/config/ModelConfig.test.tsx

@@ -1,78 +0,0 @@
-import { render, screen, waitFor } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { ModelConfig } from '@/components/config/ModelConfig';
-
-const mocks = vi.hoisted(() => ({
-  mutate: vi.fn(),
-  configQuery: {
-    data: {
-      agents: {
-        defaults: {
-          model: 'openai/gpt-5.2',
-          workspace: '~/old-workspace'
-        }
-      },
-      providers: {
-        openai: {
-          enabled: true,
-          apiKeySet: true,
-          models: ['gpt-5.2']
-        }
-      }
-    },
-    isLoading: false
-  },
-  metaQuery: {
-    data: {
-      providers: [
-        {
-          name: 'openai',
-          displayName: 'OpenAI',
-          modelPrefix: 'openai',
-          defaultModels: ['openai/gpt-5.2'],
-          keywords: [],
-          envKey: 'OPENAI_API_KEY'
-        }
-      ]
-    }
-  },
-  schemaQuery: {
-    data: {
-      uiHints: {}
-    }
-  }
-}));
-
-vi.mock('@/hooks/useConfig', () => ({
-  useConfig: () => mocks.configQuery,
-  useConfigMeta: () => mocks.metaQuery,
-  useConfigSchema: () => mocks.schemaQuery,
-  useUpdateModel: () => ({
-    mutate: mocks.mutate,
-    isPending: false
-  })
-}));
-
-describe('ModelConfig', () => {
-  beforeEach(() => {
-    mocks.mutate.mockReset();
-  });
-
-  it('submits the workspace together with the selected model', async () => {
-    const user = userEvent.setup();
-
-    render(<ModelConfig />);
-
-    const workspaceInput = await screen.findByLabelText('Default Path');
-    await user.clear(workspaceInput);
-    await user.type(workspaceInput, '~/new-workspace');
-    await user.click(screen.getByRole('button', { name: /save/i }));
-
-    await waitFor(() => {
-      expect(mocks.mutate).toHaveBeenCalledWith({
-        model: 'openai/gpt-5.2',
-        workspace: '~/new-workspace'
-      });
-    });
-  });
-});