@lvce-editor/static-server 0.77.10 → 0.77.11

package/static/{2374597 → c0b16fe}/packages/chat-view/dist/chatViewWorkerMain.js

@@ -2280,7 +2280,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);
 };
@@ -2365,6 +2365,7 @@ const createDefaultState = () => {
     authAccessToken: '',
     authEnabled: false,
     authErrorMessage: '',
+    authUseRedirect: false,
     backendUrl: '',
     chatFocusContentMaxWidth: 700,
     chatHistoryEnabled: true,
@@ -2402,6 +2403,7 @@ const createDefaultState = () => {
     gitBranchPickerVisible: false,
     headerHeight: 50,
     height: 0,
+    useOwnBackend: false,
     ...responsivePickerState,
     initial: true,
     inputSource: 'script',
@@ -4361,8 +4363,37 @@ const getBackendAuthUrl = (backendUrl, path) => {
   return `${trimTrailingSlashes(backendUrl)}${path}`;
 };
 
-const getBackendLoginUrl = backendUrl => {
-  return getBackendAuthUrl(backendUrl, '/auth/login');
+const PlatformTypeElectron$1 = 2;
+const getCurrentHref = async () => {
+  try {
+    return await invoke('Layout.getHref');
+  } catch {
+    // ignore
+  }
+  if (!globalThis.location || typeof globalThis.location.href !== 'string' || !globalThis.location.href) {
+    return '';
+  }
+  return globalThis.location.href;
+};
+const getEffectiveRedirectUri = async (platform, uid, redirectUri) => {
+  if (redirectUri) {
+    return redirectUri;
+  }
+  if (platform === PlatformTypeElectron$1) {
+    return `http://localhost:${await invoke('OAuthServer.create', String(uid))}`;
+  }
+  return getCurrentHref();
+};
+const getBackendLoginRequest = 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: loginUrl.toString(),
+    redirectUri: effectiveRedirectUri
+  };
 };
 
 const getLoggedOutBackendAuthState = (authErrorMessage = '') => {
@@ -4397,16 +4428,59 @@ const logoutFromBackend = async backendUrl => {
   }
 };
 
+let nextLoginResponse;
+let nextRefreshResponse;
+const setNextLoginResponse = response => {
+  nextLoginResponse = response;
+};
+const setNextRefreshResponse = response => {
+  nextRefreshResponse = response;
+};
+const hasPendingMockLoginResponse = () => {
+  return !!nextLoginResponse;
+};
+const hasPendingMockRefreshResponse = () => {
+  return !!nextRefreshResponse;
+};
+const consumeNextLoginResponse = async () => {
+  if (!nextLoginResponse) {
+    return undefined;
+  }
+  const response = nextLoginResponse;
+  nextLoginResponse = undefined;
+  if (response.delay > 0) {
+    await new Promise(resolve => setTimeout(resolve, response.delay));
+  }
+  if (response.type === 'error') {
+    throw new Error(response.message);
+  }
+  return response.response;
+};
+const consumeNextRefreshResponse = async () => {
+  if (!nextRefreshResponse) {
+    return undefined;
+  }
+  const response = nextRefreshResponse;
+  nextRefreshResponse = undefined;
+  if (response.delay > 0) {
+    await new Promise(resolve => setTimeout(resolve, response.delay));
+  }
+  if (response.type === 'error') {
+    throw new Error(response.message);
+  }
+  return response.response;
+};
+
 const getBackendRefreshUrl = backendUrl => {
   return getBackendAuthUrl(backendUrl, '/auth/refresh');
 };
 
-const isObject$2 = value => {
+const isObject$3 = value => {
   return !!value && typeof value === 'object';
 };
 
 const isBackendAuthResponse = value => {
-  return isObject$2(value);
+  return isObject$3(value);
 };
 
 const getNumber = (value, fallback = 0) => {
@@ -4440,6 +4514,10 @@ const syncBackendAuth = async backendUrl => {
     return getLoggedOutBackendAuthState('Backend URL is missing.');
   }
   try {
+    if (hasPendingMockRefreshResponse()) {
+      const mockResponse = await consumeNextRefreshResponse();
+      return parseBackendAuthResponse(mockResponse);
+    }
     const response = await fetch(getBackendRefreshUrl(backendUrl), {
       credentials: 'include',
       headers: {
@@ -4478,6 +4556,39 @@ const delay = async ms => {
   await new Promise(resolve => setTimeout(resolve, ms));
 };
 
+const getBackendNativeExchangeUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/native/exchange');
+};
+
+const getExchangeErrorMessage = async response => {
+  try {
+    const payload = await response.json();
+    if (payload && typeof payload === 'object' && typeof payload.error === 'string' && payload.error) {
+      return payload.error;
+    }
+  } catch {
+    // ignore
+  }
+  return 'Backend authentication failed.';
+};
+const exchangeElectronAuthorizationCode = async (backendUrl, code, redirectUri) => {
+  const response = await fetch(getBackendNativeExchangeUrl(backendUrl), {
+    body: JSON.stringify({
+      code,
+      redirectUri
+    }),
+    credentials: 'include',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    },
+    method: 'POST'
+  });
+  if (!response.ok) {
+    throw new Error(await getExchangeErrorMessage(response));
+  }
+};
+
 const waitForBackendLogin = async (backendUrl, timeoutMs = 30_000, pollIntervalMs = 1000) => {
   const deadline = Date.now() + timeoutMs;
   let lastErrorMessage = '';
@@ -4494,28 +4605,26 @@ const waitForBackendLogin = async (backendUrl, timeoutMs = 30_000, pollIntervalM
   return getLoggedOutBackendAuthState(lastErrorMessage);
 };
 
-let nextLoginResponse;
-const setNextLoginResponse = response => {
-  nextLoginResponse = response;
+const hasAuthorizationCode = value => {
+  return typeof value === 'string' && value.length > 0;
 };
-const hasPendingMockLoginResponse = () => {
-  return !!nextLoginResponse;
-};
-const consumeNextLoginResponse = async () => {
-  if (!nextLoginResponse) {
-    return undefined;
-  }
-  const response = nextLoginResponse;
-  nextLoginResponse = undefined;
-  if (response.delay > 0) {
-    await new Promise(resolve => setTimeout(resolve, response.delay));
-  }
-  if (response.type === 'error') {
-    throw new Error(response.message);
+const waitForElectronBackendLogin = async (backendUrl, uid, redirectUri, 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);
+      await exchangeElectronAuthorizationCode(backendUrl, authorizationCode, redirectUri);
+      return waitForBackendLogin(backendUrl, remainingTime, pollIntervalMs);
+    }
+    await delay(pollIntervalMs);
   }
-  return response.response;
+  return getLoggedOutBackendAuthState('Timed out waiting for backend login.');
 };
 
+const PlatformTypeElectron = 2;
 const isLoginResponse = value => {
   if (!value || typeof value !== 'object') {
     return false;
@@ -4523,19 +4632,30 @@ 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 {
+    authUseRedirect,
+    backendUrl,
+    platform,
+    uid
+  } = state;
+  if (!backendUrl) {
     return {
       ...state,
       authErrorMessage: 'Backend URL is missing.',
@@ -4547,8 +4667,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 {
@@ -4570,8 +4690,12 @@ const handleClickLogin = async state => {
       }
       return getLoggedInState(signingInState, response);
     }
-    await invoke('Main.openUri', getBackendLoginUrl(state.backendUrl));
-    const authState = await waitForBackendLogin(state.backendUrl);
+    const {
+      loginUrl,
+      redirectUri
+    } = await getBackendLoginRequest(backendUrl, platform, uid);
+    await invoke$1('Open.openUrl', loginUrl, platform, authUseRedirect);
+    const authState = platform === PlatformTypeElectron ? await waitForElectronBackendLogin(backendUrl, uid, redirectUri) : await waitForBackendLogin(backendUrl);
     return {
       ...signingInState,
       ...authState
@@ -4936,6 +5060,42 @@ const getBasicChatTools = async (agentMode = defaultAgentMode, questionToolEnabl
   }
 };
 
+const getBackendErrorMessage = errorResult => {
+  switch (errorResult.details) {
+    case 'http-error':
+      {
+        const errorMessage = errorResult.errorMessage?.trim();
+        if (typeof errorResult.statusCode === 'number') {
+          const prefix = `Backend completion request failed (status ${errorResult.statusCode}).`;
+          if (!errorMessage) {
+            return prefix;
+          }
+          return `${prefix} ${errorMessage}`;
+        }
+        if (errorMessage) {
+          return `Backend completion request failed. ${errorMessage}`;
+        }
+        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':
+      {
+        const errorMessage = errorResult.errorMessage?.trim();
+        if (errorMessage) {
+          return `Backend completion request failed. ${errorMessage}`;
+        }
+        return backendCompletionFailedMessage;
+      }
+  }
+};
+
 const getAttachmentTextPart = attachment => {
   switch (attachment.displayType) {
     case 'file':
@@ -5019,7 +5179,7 @@ const reset$1 = () => {
   finished = false;
   errorResult = undefined;
 };
-const setHttpErrorResponse = (statusCode, body) => {
+const setHttpErrorResponse$1 = (statusCode, body) => {
   const rawError = body && typeof body === 'object' ? Reflect.get(body, 'error') : undefined;
   const errorCode = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'code') : undefined;
   const errorMessage = rawError && typeof rawError === 'object' ? Reflect.get(rawError, 'message') : undefined;
@@ -5048,7 +5208,7 @@ const setRequestFailedResponse = (isOffline = false) => {
     type: 'error'
   };
 };
-const takeErrorResponse = () => {
+const takeErrorResponse$1 = () => {
   const error = errorResult;
   errorResult = undefined;
   return error;
@@ -5180,7 +5340,7 @@ const emitToolCalls = async (toolCallAccumulator, onToolCallsChunk) => {
   await onToolCallsChunk(toolCalls);
 };
 const getMockOpenApiAssistantText = async (stream, onTextChunk, onToolCallsChunk, onDataEvent, onEventStreamFinished) => {
-  const error = takeErrorResponse();
+  const error = takeErrorResponse$1();
   if (error) {
     return error;
   }
@@ -7104,60 +7264,390 @@ const isOpenRouterModel = (selectedModelId, models) => {
   return selectedModelId.toLowerCase().startsWith('openrouter/');
 };
 
+let errorResponse;
+let successResponse;
+const setHttpErrorResponse = (statusCode, body) => {
+  errorResponse = {
+    body,
+    statusCode,
+    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 */
 
 const trailingSlashesRegex = /\/+$/;
-const getBackendCompletionsEndpoint = backendUrl => {
+const getBackendResponsesEndpoint = backendUrl => {
   const trimmedBackendUrl = backendUrl.replace(trailingSlashesRegex, '');
-  return `${trimmedBackendUrl}/v1/chat/completions`;
-};
-const getEffectiveBackendModelId = selectedModelId => {
-  const separatorIndex = selectedModelId.indexOf('/');
-  if (separatorIndex === -1) {
-    return selectedModelId;
-  }
-  return selectedModelId.slice(separatorIndex + 1);
+  return `${trimmedBackendUrl}/v1/responses`;
 };
 const hasImageAttachments = messages => {
   return messages.some(message => message.attachments?.some(attachment => attachment.displayType === 'image'));
 };
-const getBackendAssistantText = async (messages, selectedModelId, backendUrl, authAccessToken, systemPrompt) => {
-  let response;
-  try {
-    response = await fetch(getBackendCompletionsEndpoint(backendUrl), {
-      body: JSON.stringify({
-        messages: [...(systemPrompt ? [{
-          content: systemPrompt,
-          role: 'system'
-        }] : []), ...messages.map(message => ({
-          content: message.text,
-          role: message.role
-        }))],
-        model: getEffectiveBackendModelId(selectedModelId),
-        stream: false
-      }),
-      headers: {
-        Authorization: `Bearer ${authAccessToken}`,
-        'Content-Type': 'application/json',
-        ...getClientRequestIdHeader()
-      },
-      method: 'POST'
+const isObject$2 = value => {
+  return !!value && typeof value === 'object';
+};
+const getBackendErrorMessageFromBody = body => {
+  if (!isObject$2(body)) {
+    return undefined;
+  }
+  const directMessage = Reflect.get(body, 'message');
+  if (typeof directMessage === 'string' && directMessage) {
+    return directMessage;
+  }
+  const directError = Reflect.get(body, 'error');
+  if (typeof directError === 'string' && directError) {
+    return directError;
+  }
+  if (!isObject$2(directError)) {
+    return undefined;
+  }
+  const nestedMessage = Reflect.get(directError, 'message');
+  if (typeof nestedMessage === 'string' && nestedMessage) {
+    return nestedMessage;
+  }
+  return undefined;
+};
+const getBackendStatusCodeFromBody = body => {
+  if (!isObject$2(body)) {
+    return undefined;
+  }
+  const statusCode = Reflect.get(body, 'statusCode');
+  if (typeof statusCode === 'number') {
+    return statusCode;
+  }
+  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
     });
-  } catch {
-    return backendCompletionFailedMessage;
   }
-  if (!response.ok) {
-    return backendCompletionFailedMessage;
+  return calls;
+};
+const getErrorMessage = error => {
+  if (error instanceof Error) {
+    return error.message;
   }
-  const json = await response.json();
-  const content = json.choices?.[0]?.message?.content;
-  return typeof content === 'string' && content ? content : backendCompletionFailedMessage;
+  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 '';
+  }
+  const outputText = Reflect.get(body, 'output_text');
+  if (typeof outputText === 'string' && outputText) {
+    return outputText;
+  }
+  const text = Reflect.get(body, 'text');
+  if (typeof text === 'string' && text) {
+    return text;
+  }
+  const message = Reflect.get(body, 'message');
+  if (isObject$2(message)) {
+    const content = Reflect.get(message, 'content');
+    if (typeof content === 'string' && content) {
+      return content;
+    }
+  }
+  const choices = Reflect.get(body, 'choices');
+  if (Array.isArray(choices)) {
+    const firstChoice = choices[0];
+    if (isObject$2(firstChoice)) {
+      const firstMessage = Reflect.get(firstChoice, 'message');
+      if (isObject$2(firstMessage)) {
+        const content = Reflect.get(firstMessage, 'content');
+        if (typeof content === 'string' && content) {
+          return content;
+        }
+      }
+    }
+  }
+  const output = Reflect.get(body, 'output');
+  if (!Array.isArray(output)) {
+    return '';
+  }
+  const chunks = [];
+  for (const outputItem of output) {
+    if (!isObject$2(outputItem)) {
+      continue;
+    }
+    if (Reflect.get(outputItem, 'type') !== 'message') {
+      continue;
+    }
+    const content = Reflect.get(outputItem, 'content');
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const part of content) {
+      if (!isObject$2(part)) {
+        continue;
+      }
+      const type = Reflect.get(part, 'type');
+      const text = Reflect.get(part, 'text');
+      if ((type === 'output_text' || type === 'text') && typeof text === 'string' && text) {
+        chunks.push(text);
+      }
+    }
+  }
+  return chunks.join('');
+};
+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 ({
+  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);
+    return getBackendErrorMessage({
+      details: 'http-error',
+      ...(typeof mockError.statusCode === 'number' ? {
+        statusCode: mockError.statusCode
+      } : {}),
+      ...(errorMessage ? {
+        errorMessage
+      } : {})
+    });
+  }
+  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: 'invalid-response',
+      errorMessage: getBackendInvalidResponseDetails(json)
+    });
+  }
+  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,
   assetDir,
   authAccessToken,
-  authEnabled = false,
   backendUrl = '',
   maxToolCalls = defaultMaxToolCalls,
   messageId,
@@ -7188,12 +7678,13 @@ const getAiResponse = async ({
   useChatNetworkWorkerForRequests = false,
   useChatToolWorker = true,
   useMockApi,
+  useOwnBackend = false,
   userText,
   webSearchEnabled = false,
   workspaceUri
 }) => {
   useChatCoordinatorWorker = false; // TODO enable this
-  if (useChatCoordinatorWorker && !authEnabled) {
+  if (useChatCoordinatorWorker && !useOwnBackend) {
     try {
       const result = await getAiResponse$1({
         agentMode,
@@ -7251,20 +7742,43 @@ const getAiResponse = async ({
   const selectedModel = models.find(model => model.id === selectedModelId);
   const supportsImages = selectedModel?.supportsImages ?? false;
   const supportsReasoningEffort = selectedModel?.supportsReasoningEffort ?? false;
+  const safeMaxToolCalls = Math.max(1, maxToolCalls);
   if (hasImageAttachments(messages) && !supportsImages) {
     text = getImageNotSupportedMessage(selectedModel?.name);
   }
-  if (!text && authEnabled) {
+  if (!text && useOwnBackend) {
     if (!backendUrl) {
       text = backendUrlRequiredMessage;
     } else if (authAccessToken) {
-      text = await getBackendAssistantText(messages, selectedModelId, backendUrl, authAccessToken, systemPrompt);
+      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;
     }
   }
   if (!text && usesOpenApiModel) {
-    const safeMaxToolCalls = Math.max(1, maxToolCalls);
     if (useMockApi) {
       const openAiInput = messages.map(message => ({
         content: getChatMessageOpenAiContent(message),
@@ -7582,6 +8096,7 @@ const handleClickSaveOpenApiApiKey = async state => {
     useChatCoordinatorWorker: updatedState.useChatCoordinatorWorker,
     useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
     useMockApi: updatedState.useMockApi,
+    useOwnBackend: updatedState.useOwnBackend,
     userText: previousUserMessage.text
   });
   const parsedMessages = await parseAndStoreMessageContent(updatedState.parsedMessages, assistantMessage);
@@ -7670,6 +8185,7 @@ const handleClickSaveOpenRouterApiKey = async state => {
     useChatCoordinatorWorker: updatedState.useChatCoordinatorWorker,
     useChatNetworkWorkerForRequests: updatedState.useChatNetworkWorkerForRequests,
     useMockApi: updatedState.useMockApi,
+    useOwnBackend: updatedState.useOwnBackend,
     userText: previousUserMessage.text
   });
   const parsedMessages = await parseAndStoreMessageContent(updatedState.parsedMessages, assistantMessage);
@@ -7781,7 +8297,6 @@ Assistant: ${assistantText}`;
 const getAiSessionTitle = async (state, userText, assistantText) => {
   const {
     authAccessToken,
-    authEnabled,
     backendUrl,
     models,
     openApiApiBaseUrl,
@@ -7789,21 +8304,28 @@ const getAiSessionTitle = async (state, userText, assistantText) => {
     openRouterApiBaseUrl,
     openRouterApiKey,
     selectedModelId,
-    useMockApi
+    useMockApi,
+    useOwnBackend
   } = state;
   if (useMockApi) {
     return '';
   }
   const usesOpenApiModel = isOpenApiModel(selectedModelId, models);
   const usesOpenRouterModel = isOpenRouterModel(selectedModelId, models);
-  if (!authEnabled && usesOpenApiModel && !openApiApiKey) {
-    return '';
-  }
-  if (!authEnabled && usesOpenRouterModel && !openRouterApiKey) {
-    return '';
-  }
-  if (!authEnabled && !usesOpenApiModel && !usesOpenRouterModel) {
-    return '';
+  if (useOwnBackend) {
+    if (!backendUrl || !authAccessToken) {
+      return '';
+    }
+  } else {
+    if (usesOpenApiModel && !openApiApiKey) {
+      return '';
+    }
+    if (usesOpenRouterModel && !openRouterApiKey) {
+      return '';
+    }
+    if (!usesOpenApiModel && !usesOpenRouterModel) {
+      return '';
+    }
   }
   const titlePrompt = getTitlePrompt(userText, assistantText);
   const promptMessage = {
@@ -7818,7 +8340,6 @@ const getAiSessionTitle = async (state, userText, assistantText) => {
   const titleResponse = await getAiResponse({
     assetDir: state.assetDir,
     authAccessToken,
-    authEnabled,
     backendUrl,
     maxToolCalls: state.maxToolCalls,
     messages: [promptMessage],
@@ -7839,6 +8360,7 @@ const getAiSessionTitle = async (state, userText, assistantText) => {
     useChatNetworkWorkerForRequests: state.useChatNetworkWorkerForRequests,
     useChatToolWorker: state.useChatToolWorker,
     useMockApi,
+    useOwnBackend,
     userText: titlePrompt,
     webSearchEnabled: false
   });
@@ -8279,7 +8801,8 @@ const withProvisionedBackgroundSession = async (state, session) => {
   };
 };
 const handleSubmit = async state => {
-  const authState = state.authEnabled && state.backendUrl ? await syncBackendAuth(state.backendUrl) : undefined;
+  const shouldSyncBackendAuth = (state.authEnabled || state.useOwnBackend) && !!state.backendUrl;
+  const authState = shouldSyncBackendAuth ? await syncBackendAuth(state.backendUrl) : undefined;
   const effectiveState = authState ? {
     ...state,
     ...authState
@@ -8315,6 +8838,7 @@ const handleSubmit = async state => {
     useChatNetworkWorkerForRequests,
     useChatToolWorker,
     useMockApi,
+    useOwnBackend,
     viewMode,
     webSearchEnabled
   } = effectiveState;
@@ -8532,6 +9056,7 @@ const handleSubmit = async state => {
     useChatNetworkWorkerForRequests,
     useChatToolWorker,
     useMockApi,
+    useOwnBackend,
     userText,
     webSearchEnabled,
     workspaceUri
@@ -10157,6 +10682,15 @@ const loadAuthEnabled = async () => {
   }
 };
 
+const loadAuthUseRedirect = async () => {
+  try {
+    const savedAuthUseRedirect = await get('chat.authUseRedirect');
+    return typeof savedAuthUseRedirect === 'boolean' ? savedAuthUseRedirect : false;
+  } catch {
+    return false;
+  }
+};
+
 const loadBackendUrl = async () => {
   try {
     const savedBackendUrl = await get('chat.backendUrl');
@@ -10318,6 +10852,15 @@ const loadUseChatToolWorker = async () => {
   }
 };
 
+const loadUseOwnBackend = async () => {
+  try {
+    const savedUseOwnBackend = await get('chat.useOwnBackend');
+    return typeof savedUseOwnBackend === 'boolean' ? savedUseOwnBackend : false;
+  } catch {
+    return false;
+  }
+};
+
 const loadVoiceDictationEnabled = async () => {
   try {
     const savedVoiceDictationEnabled = await get('chatView.voiceDictationEnabled');
@@ -10328,10 +10871,11 @@ const loadVoiceDictationEnabled = async () => {
 };
 
 const loadPreferences = async () => {
-  const [aiSessionTitleGenerationEnabled, authEnabled, backendUrl, chatHistoryEnabled, composerDropEnabled, openApiApiKey, openRouterApiKey, emitStreamingFunctionCallEvents, reasoningPickerEnabled, scrollDownButtonEnabled, searchEnabled, streamingEnabled, todoListToolEnabled, toolEnablement, passIncludeObfuscation, useChatCoordinatorWorker, useChatMathWorker, useChatNetworkWorkerForRequests, useChatToolWorker, voiceDictationEnabled] = await Promise.all([loadAiSessionTitleGenerationEnabled(), loadAuthEnabled(), loadBackendUrl(), loadChatHistoryEnabled(), loadComposerDropEnabled(), loadOpenApiApiKey(), loadOpenRouterApiKey(), loadEmitStreamingFunctionCallEvents(), loadReasoningPickerEnabled(), loadScrollDownButtonEnabled(), loadSearchEnabled(), loadStreamingEnabled(), loadTodoListToolEnabled(), loadToolEnablement(), loadPassIncludeObfuscation(), loadUseChatCoordinatorWorker(), loadUseChatMathWorker(), loadUseChatNetworkWorkerForRequests(), loadUseChatToolWorker(), loadVoiceDictationEnabled()]);
+  const [aiSessionTitleGenerationEnabled, authEnabled, authUseRedirect, backendUrl, chatHistoryEnabled, composerDropEnabled, openApiApiKey, openRouterApiKey, emitStreamingFunctionCallEvents, reasoningPickerEnabled, scrollDownButtonEnabled, searchEnabled, streamingEnabled, todoListToolEnabled, toolEnablement, passIncludeObfuscation, useChatCoordinatorWorker, useChatMathWorker, useChatNetworkWorkerForRequests, useChatToolWorker, useOwnBackend, voiceDictationEnabled] = await Promise.all([loadAiSessionTitleGenerationEnabled(), loadAuthEnabled(), loadAuthUseRedirect(), loadBackendUrl(), loadChatHistoryEnabled(), loadComposerDropEnabled(), loadOpenApiApiKey(), loadOpenRouterApiKey(), loadEmitStreamingFunctionCallEvents(), loadReasoningPickerEnabled(), loadScrollDownButtonEnabled(), loadSearchEnabled(), loadStreamingEnabled(), loadTodoListToolEnabled(), loadToolEnablement(), loadPassIncludeObfuscation(), loadUseChatCoordinatorWorker(), loadUseChatMathWorker(), loadUseChatNetworkWorkerForRequests(), loadUseChatToolWorker(), loadUseOwnBackend(), loadVoiceDictationEnabled()]);
   return {
     aiSessionTitleGenerationEnabled,
     authEnabled,
+    authUseRedirect,
     backendUrl,
     chatHistoryEnabled,
     composerDropEnabled,
@@ -10349,6 +10893,7 @@ const loadPreferences = async () => {
     useChatMathWorker,
     useChatNetworkWorkerForRequests,
     useChatToolWorker,
+    useOwnBackend,
     voiceDictationEnabled
   };
 };
@@ -10403,6 +10948,7 @@ const loadContent = async (state, savedState) => {
   const {
     aiSessionTitleGenerationEnabled,
     authEnabled,
+    authUseRedirect,
     backendUrl,
     chatHistoryEnabled,
     composerDropEnabled,
@@ -10420,9 +10966,10 @@ const loadContent = async (state, savedState) => {
     useChatMathWorker,
     useChatNetworkWorkerForRequests,
     useChatToolWorker,
+    useOwnBackend,
     voiceDictationEnabled
   } = await loadPreferences();
-  const authState = authEnabled && backendUrl ? await syncBackendAuth(backendUrl) : getLoggedOutBackendAuthState();
+  const authState = authEnabled || useOwnBackend ? backendUrl ? await syncBackendAuth(backendUrl) : getLoggedOutBackendAuthState() : getLoggedOutBackendAuthState();
   const legacySavedSessions = getSavedSessions(savedState);
   const storedSessions = await listChatSessions();
   let sessions = storedSessions;
@@ -10482,6 +11029,7 @@ const loadContent = async (state, savedState) => {
     authAccessToken: authState.authAccessToken,
     authEnabled,
     authErrorMessage: authState.authErrorMessage,
+    authUseRedirect,
     backendUrl,
     chatHistoryEnabled,
     chatListScrollTop,
@@ -10530,6 +11078,7 @@ const loadContent = async (state, savedState) => {
     useChatMathWorker,
     useChatNetworkWorkerForRequests,
     useChatToolWorker,
+    useOwnBackend,
     userName: authState.userName,
     userState: authState.userState,
     userSubscriptionPlan: authState.userSubscriptionPlan,
@@ -10555,15 +11104,19 @@ const getDelay = payload => {
 };
 const mockBackendAuthResponse = (state, payload) => {
   const delay = getDelay(payload);
+  const setNextResponse = payload.request === 'refresh' ? setNextRefreshResponse : setNextLoginResponse;
   if (payload.type === 'error') {
-    setNextLoginResponse({
+    setNextResponse({
       delay,
+      ...(payload.errorName ? {
+        errorName: payload.errorName
+      } : {}),
       message: payload.message || 'Backend authentication failed.',
       type: 'error'
     });
     return state;
   }
-  setNextLoginResponse({
+  setNextResponse({
     delay,
     response: payload,
     type: 'success'
@@ -10571,6 +11124,16 @@ const mockBackendAuthResponse = (state, payload) => {
   return state;
 };
 
+const mockBackendSetHttpErrorResponse = (state, statusCode, body) => {
+  setHttpErrorResponse(statusCode, body);
+  return state;
+};
+
+const mockBackendSetResponse = (state, body) => {
+  setResponse(body);
+  return state;
+};
+
 const mockOpenApiRequestGetAll = _state => {
   return getAll();
 };
@@ -10581,7 +11144,7 @@ const mockOpenApiRequestReset = state => {
 };
 
 const mockOpenApiSetHttpErrorResponse = (state, statusCode, body) => {
-  setHttpErrorResponse(statusCode, body);
+  setHttpErrorResponse$1(statusCode, body);
   return state;
 };
 
@@ -15544,6 +16107,18 @@ const setUseChatNetworkWorkerForRequests = async (state, useChatNetworkWorkerFor
   };
 };
 
+const setUseOwnBackend = async (state, useOwnBackend, persist = true) => {
+  if (persist) {
+    await update({
+      'chat.useOwnBackend': useOwnBackend
+    });
+  }
+  return {
+    ...state,
+    useOwnBackend
+  };
+};
+
 const defaultMockApiCommandId = 'ChatE2e.mockApi';
 const useMockApi = (state, value, mockApiCommandId = defaultMockApiCommandId) => {
   if (!value) {
@@ -15644,6 +16219,8 @@ const commandMap = {
   'Chat.loadContent': wrapCommand(loadContent),
   '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),
@@ -15689,6 +16266,7 @@ const commandMap = {
   'Chat.setUseChatCoordinatorWorker': wrapCommand(setUseChatCoordinatorWorker),
   'Chat.setUseChatMathWorker': wrapCommand(setUseChatMathWorker),
   'Chat.setUseChatNetworkWorkerForRequests': wrapCommand(setUseChatNetworkWorkerForRequests),
+  'Chat.setUseOwnBackend': wrapCommand(setUseOwnBackend),
   'Chat.showComposerAttachmentPreviewOverlay': wrapCommand(showComposerAttachmentPreviewOverlay),
   'Chat.terminate': terminate,
   'Chat.useMockApi': wrapCommand(useMockApi)