fix(client): surface desktop AI stream request failures

Author: HandSonic

chat2db-community-client/package.json

@@ -63,7 +63,7 @@
     "test:search-result-tab-selection": "tsx src/blocks/SearchResult/tabSelection.test.ts",
     "test:saved-console-tree-refresh": "tsx src/store/tree/savedConsoleTreeRefresh.test.ts",
     "test:saved-console-lifecycle": "tsx src/store/workspace/utils/savedConsoleLifecycle.test.ts && tsx src/store/workspace/utils/workspaceTabPersistence.test.ts",
-    "test:sse-request": "tsx src/components/SSERequest/requestOwnership.test.ts && tsx src/components/SSERequest/requestTransport.test.ts",
+    "test:sse-request": "tsx src/components/SSERequest/requestOwnership.test.ts && tsx src/components/SSERequest/requestTransport.test.ts && tsx src/service/sse/requestFailure.test.ts",
     "test:settings-layout": "tsx src/blocks/Setting/navigation.test.ts && tsx src/blocks/Setting/search.test.ts && tsx src/blocks/Setting/BaseSetting/model.test.ts && tsx src/client-extension/settingMenus.test.ts && tsx src/blocks/Setting/settingsLayout.test.ts",
     "test:shortcut": "tsx src/constants/shortcut.test.ts && tsx src/utils/appTitleBarAction.test.ts && tsx src/layouts/GlobalLayout/AppTitleBar/platform.test.ts && tsx src/utils/jcefZoom.test.ts && tsx src/utils/shortcutDispatch.test.ts",
     "test:sql-execution-log": "tsx src/service/sqlExecutionLog.test.ts",

chat2db-community-client/src/service/sse/index.tsx

@@ -1,5 +1,7 @@
 import { useGlobalStore } from '@/store/global';
+import { JcefEventBus } from '@/jcef/eventBus';
 import { v4 as uuidv4 } from 'uuid';
+import { dispatchDesktopStreamRequest } from './requestFailure';
 
 export interface IJcefSseRequest {
   requestId: string;
@@ -35,10 +37,11 @@ const sendClientSSERequest = (baseURL, message) => {
     }),
   );
 
-  window.javaQuery({
-    request: JSON.stringify(res),
-    onSuccess: function () {},
-    onFailure: function () {},
+  dispatchDesktopStreamRequest({
+    requestId,
+    serializedRequest: JSON.stringify(res),
+    javaQuery: typeof window.javaQuery === 'function' ? (request) => window.javaQuery(request) : undefined,
+    publish: (eventName, output) => JcefEventBus.publish(eventName, output),
   });
 
   return {

chat2db-community-client/src/service/sse/requestFailure.test.ts

@@ -0,0 +1,174 @@
+import assert from 'node:assert/strict';
+import { JcefEventBus } from '@/jcef/eventBus';
+import { createClientRequestHandle } from '@/components/SSERequest/clientRequestHandle';
+import type { SSERequestCallbacks } from '@/components/SSERequest';
+import {
+  buildStreamErrorOutput,
+  dispatchDesktopStreamRequest,
+  describeRequestFailure,
+  extractEnvelopeErrorMessage,
+  streamEventName,
+} from './requestFailure';
+
+const testExtractEnvelopeErrorMessage = () => {
+  const errorEnvelope = JSON.stringify({
+    actionType: 'error',
+    uuid: 'req-1',
+    message: { success: false, errorCode: 'model.invalid', errorMessage: 'AI model is not available' },
+  });
+  assert.equal(extractEnvelopeErrorMessage(errorEnvelope), 'AI model is not available');
+
+  assert.equal(
+    extractEnvelopeErrorMessage({ actionType: 'error', message: { success: false } }),
+    'AI stream request failed',
+  );
+
+  const failedActionResultOnly = { actionType: 'execute', message: { success: false, errorMessage: 'boom' } };
+  assert.equal(extractEnvelopeErrorMessage(failedActionResultOnly), 'boom');
+
+  assert.equal(extractEnvelopeErrorMessage(JSON.stringify({ actionType: 'execute', uuid: 'req-1' })), undefined);
+  assert.equal(extractEnvelopeErrorMessage({ actionType: 'execute', message: { success: true } }), undefined);
+  assert.equal(extractEnvelopeErrorMessage('not json'), undefined);
+  assert.equal(extractEnvelopeErrorMessage(undefined), undefined);
+  assert.equal(extractEnvelopeErrorMessage(42), undefined);
+};
+
+const testDescribeRequestFailure = () => {
+  assert.equal(describeRequestFailure(500, 'bridge unavailable'), 'bridge unavailable');
+  assert.equal(describeRequestFailure(500, '   '), 'AI stream request failed (500)');
+  assert.equal(describeRequestFailure(undefined, undefined), 'AI stream request failed');
+};
+
+const testPublishedFailureSettlesStreamHandle = async () => {
+  const eventName = streamEventName('failed-before-stream');
+  const errors: Error[] = [];
+  const successes: unknown[][] = [];
+  const callbacks: SSERequestCallbacks<any> = {
+    onSuccess: (chunks) => successes.push(chunks),
+    onError: (error) => errors.push(error),
+    onUpdate: () => {},
+  };
+  const handle = createClientRequestHandle({
+    callbacks,
+    eventBus: JcefEventBus,
+    eventName,
+    handleErrorPayload: () => false,
+  });
+
+  JcefEventBus.publish(eventName, buildStreamErrorOutput('AI model is not available'));
+
+  await assert.rejects(handle.done, /AI model is not available/);
+  assert.equal(errors.length, 1);
+  assert.equal(successes.length, 0);
+
+  // The listener must be removed once settled: a late event changes nothing.
+  JcefEventBus.publish(eventName, buildStreamErrorOutput('late'));
+  assert.equal(errors.length, 1);
+};
+
+const createFailureHandle = (requestId: string) => {
+  const errors: Error[] = [];
+  const updates: unknown[] = [];
+  const handle = createClientRequestHandle({
+    callbacks: {
+      onSuccess: () => assert.fail('failed stream must not succeed'),
+      onError: (error) => errors.push(error),
+      onUpdate: (output) => updates.push(output),
+    },
+    eventBus: JcefEventBus,
+    eventName: streamEventName(requestId),
+    handleErrorPayload: () => false,
+  });
+  return { handle, errors, updates };
+};
+
+const testSynchronousErrorEnvelopeWaitsForListener = async () => {
+  const requestId = 'sync-error-envelope';
+  dispatchDesktopStreamRequest({
+    requestId,
+    serializedRequest: '{}',
+    javaQuery: ({ onSuccess }) => {
+      onSuccess(
+        JSON.stringify({
+          actionType: 'error',
+          message: { success: false, errorMessage: 'model unavailable' },
+        }),
+      );
+    },
+    publish: JcefEventBus.publish,
+  });
+  const { handle, errors, updates } = createFailureHandle(requestId);
+
+  await assert.rejects(handle.done, /model unavailable/);
+  assert.equal(errors.length, 1);
+  assert.equal(updates.length, 1);
+};
+
+const testSynchronousNativeFailureWaitsForListener = async () => {
+  const requestId = 'sync-native-failure';
+  dispatchDesktopStreamRequest({
+    requestId,
+    serializedRequest: '{}',
+    javaQuery: ({ onFailure }) => onFailure(503, 'bridge unavailable'),
+    publish: JcefEventBus.publish,
+  });
+  const { handle, errors } = createFailureHandle(requestId);
+
+  await assert.rejects(handle.done, /bridge unavailable/);
+  assert.equal(errors.length, 1);
+  JcefEventBus.publish(streamEventName(requestId), buildStreamErrorOutput('late'));
+  assert.equal(errors.length, 1);
+};
+
+const testMissingAndThrowingBridgePublishFailures = async () => {
+  const published: Array<{ eventName: string; output: ReturnType<typeof buildStreamErrorOutput> }> = [];
+  const publish = (eventName: string, output: ReturnType<typeof buildStreamErrorOutput>) => {
+    published.push({ eventName, output });
+  };
+
+  dispatchDesktopStreamRequest({ requestId: 'missing', serializedRequest: '{}', publish });
+  dispatchDesktopStreamRequest({
+    requestId: 'throwing',
+    serializedRequest: '{}',
+    javaQuery: () => {
+      throw new Error('bridge threw');
+    },
+    publish,
+  });
+  await Promise.resolve();
+
+  assert.deepEqual(
+    published.map(({ eventName }) => eventName),
+    [streamEventName('missing'), streamEventName('throwing')],
+  );
+  assert.match(published[0].output.data, /Java Query is not available/);
+  assert.match(published[1].output.data, /bridge threw/);
+};
+
+const testNormalAcknowledgementDoesNotPublish = async () => {
+  const published: unknown[] = [];
+  dispatchDesktopStreamRequest({
+    requestId: 'normal-ack',
+    serializedRequest: '{}',
+    javaQuery: ({ onSuccess }) => onSuccess(JSON.stringify({ actionType: 'execute', message: { success: true } })),
+    publish: (...args) => published.push(args),
+  });
+  await Promise.resolve();
+  assert.deepEqual(published, []);
+};
+
+const main = async () => {
+  testExtractEnvelopeErrorMessage();
+  testDescribeRequestFailure();
+  await testPublishedFailureSettlesStreamHandle();
+  await testSynchronousErrorEnvelopeWaitsForListener();
+  await testSynchronousNativeFailureWaitsForListener();
+  await testMissingAndThrowingBridgePublishFailures();
+  await testNormalAcknowledgementDoesNotPublish();
+  console.log('sse request failure tests passed');
+};
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

chat2db-community-client/src/service/sse/requestFailure.ts

@@ -0,0 +1,115 @@
+import { JavaPushActionType } from '@/jcef/eventBus';
+
+const DEFAULT_FAILURE_MESSAGE = 'AI stream request failed';
+
+export const streamEventName = (requestId: string) => `${JavaPushActionType.AI_SSE_MESSAGE}_${requestId}`;
+
+/**
+ * Shapes a request-level failure like a stream error event so the stream listener
+ * settles through its existing error path (onError + rejected done + cleanup)
+ * instead of waiting forever for stream events that will never arrive.
+ */
+export const buildStreamErrorOutput = (message: string) => ({
+  event: 'error',
+  data: JSON.stringify({ content: message }),
+});
+
+export const describeRequestFailure = (errorCode: unknown, errorMessage: unknown): string => {
+  if (typeof errorMessage === 'string' && errorMessage.trim()) {
+    return errorMessage;
+  }
+  if (errorCode === undefined || errorCode === null || `${errorCode}`.trim() === '') {
+    return DEFAULT_FAILURE_MESSAGE;
+  }
+  return `${DEFAULT_FAILURE_MESSAGE} (${errorCode})`;
+};
+
+interface JavaQueryRequest {
+  request: string;
+  onSuccess: (data: unknown) => void;
+  onFailure: (errorCode: unknown, errorMessage: unknown) => void;
+}
+
+interface DispatchDesktopStreamRequestOptions {
+  requestId: string;
+  serializedRequest: string;
+  javaQuery?: (request: JavaQueryRequest) => unknown;
+  publish: (eventName: string, output: ReturnType<typeof buildStreamErrorOutput>) => void;
+  schedule?: (callback: () => void) => void;
+}
+
+const thrownFailureMessage = (error: unknown) => {
+  if (error instanceof Error && error.message.trim()) {
+    return error.message;
+  }
+  return describeRequestFailure(undefined, error);
+};
+
+export const dispatchDesktopStreamRequest = ({
+  requestId,
+  serializedRequest,
+  javaQuery,
+  publish,
+  schedule = queueMicrotask,
+}: DispatchDesktopStreamRequestOptions) => {
+  const publishFailure = (message: string) => {
+    schedule(() => publish(streamEventName(requestId), buildStreamErrorOutput(message)));
+  };
+
+  if (!javaQuery) {
+    publishFailure('Java Query is not available');
+    return;
+  }
+
+  try {
+    javaQuery({
+      request: serializedRequest,
+      onSuccess: (data) => {
+        const errorMessage = extractEnvelopeErrorMessage(data);
+        if (errorMessage !== undefined) {
+          publishFailure(errorMessage);
+        }
+      },
+      onFailure: (errorCode, errorMessage) => {
+        publishFailure(describeRequestFailure(errorCode, errorMessage));
+      },
+    });
+  } catch (error) {
+    publishFailure(thrownFailureMessage(error));
+  }
+};
+
+const parseJsonObject = (value: unknown): Record<string, any> | undefined => {
+  if (typeof value === 'object' && value !== null) {
+    return value as Record<string, any>;
+  }
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === 'object' && parsed !== null ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Detects the ConsoleResult error envelope that the JCEF bridge returns through the
+ * success callback when the controller fails before the stream is subscribed
+ * (ConsoleHelper.error: actionType "error" + ActionResult {success: false}).
+ * Returns undefined for regular acknowledgements.
+ */
+export const extractEnvelopeErrorMessage = (rawResponse: unknown): string | undefined => {
+  const envelope = parseJsonObject(rawResponse);
+  if (!envelope) {
+    return undefined;
+  }
+  const actionResult = parseJsonObject(envelope.message);
+  const failed = envelope.actionType === 'error' || actionResult?.success === false;
+  if (!failed) {
+    return undefined;
+  }
+  const errorMessage = actionResult?.errorMessage;
+  return typeof errorMessage === 'string' && errorMessage.trim() ? errorMessage : DEFAULT_FAILURE_MESSAGE;
+};