@lvce-editor/chat-view 7.10.0 → 7.12.0

package/dist/chatViewWorkerMain.js

@@ -2283,7 +2283,7 @@ const getVisibleModels = (models, modelPickerSearchValue) => {
 };
 
 const reasoningEfforts = ['extra-high', 'high', 'medium', 'low'];
-const defaultReasoningEffort = 'high';
+const defaultReasoningEffort = 'medium';
 const isReasoningEffort = value => {
   return reasoningEfforts.includes(value);
 };
@@ -4365,6 +4365,7 @@ const getBackendAuthUrl = (backendUrl, path) => {
   return `${trimTrailingSlashes(backendUrl)}${path}`;
 };
 
+const PlatformTypeElectron$1 = 2;
 const getCurrentHref = async () => {
   try {
     return await invoke('Layout.getHref');
@@ -4376,11 +4377,20 @@ const getCurrentHref = async () => {
   }
   return globalThis.location.href;
 };
-const getBackendLoginUrl = async backendUrl => {
-  const loginUrl = new URL(getBackendAuthUrl(backendUrl, '/login'));
-  const redirectUri = await getCurrentHref();
+const getEffectiveRedirectUri = async (platform, uid, redirectUri) => {
   if (redirectUri) {
-    loginUrl.searchParams.set('redirect_uri', redirectUri);
+    return redirectUri;
+  }
+  if (platform === PlatformTypeElectron$1) {
+    return `http://localhost:${await invoke('OAuthServer.create', String(uid))}`;
+  }
+  return getCurrentHref();
+};
+const getBackendLoginUrl = async (backendUrl, platform = 0, uid = 0, redirectUri = '') => {
+  const loginUrl = new URL(getBackendAuthUrl(backendUrl, '/login'));
+  const effectiveRedirectUri = await getEffectiveRedirectUri(platform, uid, redirectUri);
+  if (effectiveRedirectUri) {
+    loginUrl.searchParams.set('redirect_uri', effectiveRedirectUri);
   }
   return loginUrl.toString();
 };
@@ -4561,6 +4571,25 @@ const waitForBackendLogin = async (backendUrl, timeoutMs = 30_000, pollIntervalM
   return getLoggedOutBackendAuthState(lastErrorMessage);
 };
 
+const hasAuthorizationCode = value => {
+  return typeof value === 'string' && value.length > 0;
+};
+const waitForElectronBackendLogin = async (backendUrl, uid, timeoutMs = 30_000, pollIntervalMs = 1000) => {
+  const started = Date.now();
+  const deadline = started + timeoutMs;
+  while (Date.now() < deadline) {
+    const authorizationCode = await invoke('OAuthServer.getCode', String(uid));
+    if (hasAuthorizationCode(authorizationCode)) {
+      const elapsed = Date.now() - started;
+      const remainingTime = Math.max(0, timeoutMs - elapsed);
+      return waitForBackendLogin(backendUrl, remainingTime, pollIntervalMs);
+    }
+    await delay(pollIntervalMs);
+  }
+  return getLoggedOutBackendAuthState('Timed out waiting for backend login.');
+};
+
+const PlatformTypeElectron = 2;
 const isLoginResponse = value => {
   if (!value || typeof value !== 'object') {
     return false;
@@ -4568,19 +4597,29 @@ const isLoginResponse = value => {
   return true;
 };
 const getLoggedInState = (state, response) => {
+  const {
+    userName,
+    userSubscriptionPlan,
+    userUsedTokens
+  } = state;
   const accessToken = typeof response.accessToken === 'string' ? response.accessToken : '';
   return {
     ...state,
     authAccessToken: accessToken,
     authErrorMessage: '',
-    userName: typeof response.userName === 'string' ? response.userName : state.userName,
+    userName: typeof response.userName === 'string' ? response.userName : userName,
     userState: accessToken ? 'loggedIn' : 'loggedOut',
-    userSubscriptionPlan: typeof response.subscriptionPlan === 'string' ? response.subscriptionPlan : state.userSubscriptionPlan,
-    userUsedTokens: typeof response.usedTokens === 'number' ? response.usedTokens : state.userUsedTokens
+    userSubscriptionPlan: typeof response.subscriptionPlan === 'string' ? response.subscriptionPlan : userSubscriptionPlan,
+    userUsedTokens: typeof response.usedTokens === 'number' ? response.usedTokens : userUsedTokens
   };
 };
 const handleClickLogin = async state => {
-  if (!state.backendUrl) {
+  const {
+    backendUrl,
+    platform,
+    uid
+  } = state;
+  if (!backendUrl) {
     return {
       ...state,
       authErrorMessage: 'Backend URL is missing.',
@@ -4592,8 +4631,8 @@ const handleClickLogin = async state => {
     authErrorMessage: '',
     userState: 'loggingIn'
   };
-  if (state.uid) {
-    set(state.uid, state, signingInState);
+  if (uid) {
+    set(uid, state, signingInState);
     await invoke('Chat.rerender');
   }
   try {
@@ -4615,9 +4654,9 @@ const handleClickLogin = async state => {
       }
       return getLoggedInState(signingInState, response);
     }
-    const url = await getBackendLoginUrl(state.backendUrl);
-    await openUrl(url, state.platform);
-    const authState = await waitForBackendLogin(state.backendUrl);
+    const url = await getBackendLoginUrl(backendUrl, platform, uid);
+    await openUrl(url, platform);
+    const authState = platform === PlatformTypeElectron ? await waitForElectronBackendLogin(backendUrl, uid) : await waitForBackendLogin(backendUrl);
     return {
       ...signingInState,
       ...authState
@@ -4999,8 +5038,22 @@ const getBackendErrorMessage = errorResult => {
         }
         return backendCompletionFailedMessage;
       }
+    case 'invalid-response':
+      {
+        const errorMessage = errorResult.errorMessage?.trim();
+        if (errorMessage) {
+          return `Backend completion request failed. ${errorMessage}`;
+        }
+        return 'Backend completion request failed. Unexpected backend response format.';
+      }
     case 'request-failed':
-      return backendCompletionFailedMessage;
+      {
+        const errorMessage = errorResult.errorMessage?.trim();
+        if (errorMessage) {
+          return `Backend completion request failed. ${errorMessage}`;
+        }
+        return backendCompletionFailedMessage;
+      }
   }
 };
 
@@ -7173,6 +7226,7 @@ const isOpenRouterModel = (selectedModelId, models) => {
 };
 
 let errorResponse;
+let successResponse;
 const setHttpErrorResponse = (statusCode, body) => {
   errorResponse = {
     body,
@@ -7180,11 +7234,22 @@ const setHttpErrorResponse = (statusCode, body) => {
     type: 'http-error'
   };
 };
+const setResponse = body => {
+  successResponse = {
+    body,
+    type: 'success'
+  };
+};
 const takeErrorResponse = () => {
   const response = errorResponse;
   errorResponse = undefined;
   return response;
 };
+const takeResponse = () => {
+  const response = successResponse;
+  successResponse = undefined;
+  return response;
+};
 
 /* eslint-disable prefer-destructuring */
 
@@ -7230,6 +7295,109 @@ const getBackendStatusCodeFromBody = body => {
   }
   return undefined;
 };
+const getBackendResponseId = body => {
+  if (!isObject$2(body)) {
+    return undefined;
+  }
+  const id = Reflect.get(body, 'id');
+  return typeof id === 'string' && id ? id : undefined;
+};
+const getBackendResponseStatus = body => {
+  if (!isObject$2(body)) {
+    return undefined;
+  }
+  const status = Reflect.get(body, 'status');
+  return typeof status === 'string' && status ? status : undefined;
+};
+const getBackendIncompleteMessage = body => {
+  if (!isObject$2(body)) {
+    return undefined;
+  }
+  const incompleteDetails = Reflect.get(body, 'incomplete_details');
+  if (!isObject$2(incompleteDetails)) {
+    return undefined;
+  }
+  const reason = Reflect.get(incompleteDetails, 'reason');
+  if (typeof reason === 'string' && reason) {
+    return `Backend response was incomplete (${reason}).`;
+  }
+  return undefined;
+};
+const getBackendResponseFunctionCalls = body => {
+  if (!isObject$2(body)) {
+    return [];
+  }
+  const output = Reflect.get(body, 'output');
+  if (!Array.isArray(output)) {
+    return [];
+  }
+  const calls = [];
+  for (const outputItem of output) {
+    if (!isObject$2(outputItem)) {
+      continue;
+    }
+    if (Reflect.get(outputItem, 'type') !== 'function_call') {
+      continue;
+    }
+    const callId = Reflect.get(outputItem, 'call_id');
+    const name = Reflect.get(outputItem, 'name');
+    const rawArguments = Reflect.get(outputItem, 'arguments');
+    if (typeof callId !== 'string' || !callId || typeof name !== 'string' || !name) {
+      continue;
+    }
+    calls.push({
+      arguments: typeof rawArguments === 'string' ? rawArguments : '',
+      callId,
+      name
+    });
+  }
+  return calls;
+};
+const getErrorMessage = error => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return typeof error === 'string' && error ? error : undefined;
+};
+const getBackendInvalidResponseDetails = body => {
+  const errorMessage = getBackendErrorMessageFromBody(body);
+  if (errorMessage) {
+    return errorMessage;
+  }
+  const incompleteMessage = getBackendIncompleteMessage(body);
+  if (incompleteMessage) {
+    return incompleteMessage;
+  }
+  const status = getBackendResponseStatus(body);
+  if (status && status !== 'completed') {
+    return `Backend response status was "${status}".`;
+  }
+  if (isObject$2(body) && Array.isArray(Reflect.get(body, 'output'))) {
+    return 'Unexpected backend response format: no assistant text or tool calls were returned.';
+  }
+  return 'Unexpected backend response format.';
+};
+const toExecutedToolCall = (toolCall, content) => {
+  const executionStatus = getToolCallExecutionStatus(content);
+  const toolCallResult = getToolCallResult(toolCall.name, content);
+  return {
+    arguments: toolCall.arguments,
+    ...(executionStatus.errorMessage ? {
+      errorMessage: executionStatus.errorMessage
+    } : {}),
+    ...(executionStatus.errorStack ? {
+      errorStack: executionStatus.errorStack
+    } : {}),
+    id: toolCall.callId,
+    name: toolCall.name,
+    ...(toolCallResult ? {
+      result: toolCallResult
+    } : {}),
+    ...(executionStatus.status ? {
+      status: executionStatus.status
+    } : {})
+  };
+};
 const getBackendResponseOutputText = body => {
   if (!isObject$2(body)) {
     return '';
@@ -7291,14 +7459,29 @@ const getBackendResponseOutputText = body => {
   }
   return chunks.join('');
 };
-const getBackendResponsesBody = (messages, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, reasoningEffort, supportsReasoningEffort = false) => {
-  const input = messages.map(message => ({
-    content: getChatMessageOpenAiContent(message),
-    role: message.role
-  }));
-  return getOpenAiParams(input, modelId, false, false, tools, webSearchEnabled, maxToolCalls, systemPrompt, undefined, reasoningEffort, supportsReasoningEffort);
+const getBackendResponsesBody = (input, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, previousResponseId, reasoningEffort, supportsReasoningEffort = false) => {
+  return getOpenAiParams(input, modelId, false, false, tools, webSearchEnabled, maxToolCalls, systemPrompt, previousResponseId, reasoningEffort, supportsReasoningEffort);
 };
-const getBackendAssistantText = async (messages, modelId, backendUrl, authAccessToken, systemPrompt, agentMode = defaultAgentMode, questionToolEnabled = false, toolEnablement, maxToolCalls = defaultMaxToolCalls, webSearchEnabled = false, reasoningEffort, supportsReasoningEffort = false) => {
+const getBackendAssistantText = async ({
+  agentMode = defaultAgentMode,
+  assetDir,
+  authAccessToken,
+  backendUrl,
+  maxToolCalls = defaultMaxToolCalls,
+  messages,
+  modelId,
+  onToolCallsChunk,
+  platform,
+  questionToolEnabled = false,
+  reasoningEffort,
+  sessionId,
+  supportsReasoningEffort = false,
+  systemPrompt,
+  toolEnablement,
+  useChatToolWorker,
+  webSearchEnabled = false,
+  workspaceUri
+}) => {
   const mockError = takeErrorResponse();
   if (mockError) {
     const errorMessage = getBackendErrorMessageFromBody(mockError.body);
@@ -7312,45 +7495,115 @@ const getBackendAssistantText = async (messages, modelId, backendUrl, authAccess
       } : {})
     });
   }
-  let response;
-  try {
-    const tools = await getBasicChatTools(agentMode, questionToolEnabled, toolEnablement);
-    response = await fetch(getBackendResponsesEndpoint(backendUrl), {
-      body: JSON.stringify(getBackendResponsesBody(messages, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, reasoningEffort, supportsReasoningEffort)),
-      headers: {
-        Authorization: `Bearer ${authAccessToken}`,
-        'Content-Type': 'application/json',
-        ...getClientRequestIdHeader()
-      },
-      method: 'POST'
-    });
-  } catch {
-    return getBackendErrorMessage({
-      details: 'request-failed'
-    });
-  }
-  if (!response.ok) {
-    const payload = await response.json().catch(() => undefined);
-    const errorMessage = getBackendErrorMessageFromBody(payload);
-    const statusCode = response.status || getBackendStatusCodeFromBody(payload);
+  const mockResponse = takeResponse();
+  const tools = await getBasicChatTools(agentMode, questionToolEnabled, toolEnablement);
+  const input = messages.map(message => ({
+    content: getChatMessageOpenAiContent(message),
+    role: message.role
+  }));
+  let previousResponseId;
+  const maxToolIterations = Math.max(0, maxToolCalls - 1);
+  for (let index = 0; index <= maxToolIterations; index++) {
+    let json;
+    if (index === 0 && mockResponse) {
+      json = mockResponse.body;
+    } else {
+      let response;
+      try {
+        response = await fetch(getBackendResponsesEndpoint(backendUrl), {
+          body: JSON.stringify(getBackendResponsesBody(input, modelId, systemPrompt, tools, maxToolCalls, webSearchEnabled, previousResponseId, reasoningEffort, supportsReasoningEffort)),
+          headers: {
+            Authorization: `Bearer ${authAccessToken}`,
+            'Content-Type': 'application/json',
+            ...getClientRequestIdHeader()
+          },
+          method: 'POST'
+        });
+      } catch (error) {
+        const errorMessage = getErrorMessage(error);
+        return getBackendErrorMessage({
+          details: 'request-failed',
+          ...(errorMessage ? {
+            errorMessage
+          } : {})
+        });
+      }
+      if (!response.ok) {
+        const payload = await response.json().catch(() => undefined);
+        const errorMessage = getBackendErrorMessageFromBody(payload);
+        const statusCode = response.status || getBackendStatusCodeFromBody(payload);
+        return getBackendErrorMessage({
+          details: 'http-error',
+          ...(typeof statusCode === 'number' ? {
+            statusCode
+          } : {}),
+          ...(errorMessage ? {
+            errorMessage
+          } : {})
+        });
+      }
+      try {
+        json = await response.json();
+      } catch {
+        return getBackendErrorMessage({
+          details: 'invalid-response',
+          errorMessage: 'Backend returned invalid JSON.'
+        });
+      }
+    }
+    const responseFunctionCalls = getBackendResponseFunctionCalls(json);
+    if (responseFunctionCalls.length > 0) {
+      const responseId = getBackendResponseId(json);
+      if (!responseId) {
+        return getBackendErrorMessage({
+          details: 'invalid-response',
+          errorMessage: 'Unexpected backend response format: tool calls were returned without a response id.'
+        });
+      }
+      previousResponseId = responseId;
+      input.length = 0;
+      const executedToolCalls = [];
+      for (const toolCall of responseFunctionCalls) {
+        const content = await executeChatTool(toolCall.name, toolCall.arguments, {
+          assetDir,
+          platform,
+          ...(sessionId ? {
+            sessionId
+          } : {}),
+          toolCallId: toolCall.callId,
+          ...(toolEnablement ? {
+            toolEnablement
+          } : {}),
+          useChatToolWorker,
+          ...(workspaceUri ? {
+            workspaceUri
+          } : {})
+        });
+        executedToolCalls.push(toExecutedToolCall(toolCall, content));
+        input.push({
+          call_id: toolCall.callId,
+          output: content,
+          type: 'function_call_output'
+        });
+      }
+      if (onToolCallsChunk && executedToolCalls.length > 0) {
+        await onToolCallsChunk(executedToolCalls);
+      }
+      continue;
+    }
+    const content = getBackendResponseOutputText(json);
+    if (content) {
+      return content;
+    }
     return getBackendErrorMessage({
-      details: 'http-error',
-      ...(typeof statusCode === 'number' ? {
-        statusCode
-      } : {}),
-      ...(errorMessage ? {
-        errorMessage
-      } : {})
+      details: 'invalid-response',
+      errorMessage: getBackendInvalidResponseDetails(json)
     });
   }
-  let json;
-  try {
-    json = await response.json();
-  } catch {
-    return backendCompletionFailedMessage;
-  }
-  const content = getBackendResponseOutputText(json);
-  return typeof content === 'string' && content ? content : backendCompletionFailedMessage;
+  return getBackendErrorMessage({
+    details: 'invalid-response',
+    errorMessage: `Backend request ended after ${maxToolCalls} tool-call rounds without a final assistant response. This usually means the model got stuck in a tool loop.`
+  });
 };
 const getAiResponse = async ({
   agentMode = defaultAgentMode,
@@ -7458,7 +7711,30 @@ const getAiResponse = async ({
     if (!backendUrl) {
       text = backendUrlRequiredMessage;
     } else if (authAccessToken) {
-      text = await getBackendAssistantText(messages, getOpenApiModelId(selectedModelId), backendUrl, authAccessToken, systemPrompt, agentMode, questionToolEnabled, toolEnablement, safeMaxToolCalls, agentMode === 'plan' ? false : webSearchEnabled, reasoningEffort, supportsReasoningEffort);
+      text = await getBackendAssistantText({
+        agentMode,
+        assetDir,
+        authAccessToken,
+        backendUrl,
+        maxToolCalls: safeMaxToolCalls,
+        messages,
+        modelId: getOpenApiModelId(selectedModelId),
+        onToolCallsChunk,
+        platform,
+        questionToolEnabled,
+        reasoningEffort,
+        supportsReasoningEffort,
+        systemPrompt,
+        toolEnablement,
+        useChatToolWorker,
+        webSearchEnabled: agentMode === 'plan' ? false : webSearchEnabled,
+        ...(sessionId ? {
+          sessionId
+        } : {}),
+        ...(workspaceUri ? {
+          workspaceUri
+        } : {})
+      });
     } else {
       text = backendAccessTokenRequiredMessage;
     }
@@ -10802,6 +11078,11 @@ const mockBackendSetHttpErrorResponse = (state, statusCode, body) => {
   return state;
 };
 
+const mockBackendSetResponse = (state, body) => {
+  setResponse(body);
+  return state;
+};
+
 const mockOpenApiRequestGetAll = _state => {
   return getAll();
 };
@@ -15888,6 +16169,7 @@ const commandMap = {
   'Chat.loadContent2': wrapCommand(loadContent),
   'Chat.mockBackendAuthResponse': wrapCommand(mockBackendAuthResponse),
   'Chat.mockBackendSetHttpErrorResponse': wrapCommand(mockBackendSetHttpErrorResponse),
+  'Chat.mockBackendSetResponse': wrapCommand(mockBackendSetResponse),
   'Chat.mockOpenApiRequestGetAll': wrapGetter(mockOpenApiRequestGetAll),
   'Chat.mockOpenApiRequestReset': wrapCommand(mockOpenApiRequestReset),
   'Chat.mockOpenApiSetHttpErrorResponse': wrapCommand(mockOpenApiSetHttpErrorResponse),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-view",
-  "version": "7.10.0",
+  "version": "7.12.0",
   "description": "Chat View Worker",
   "repository": {
     "type": "git",