@lvce-editor/static-server 0.80.15 → 0.80.17

package/static/{8c8a3a0 → a3a3cca}/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js

@@ -1127,6 +1127,9 @@ const appendChatEvent = async event => {
     await invoke('ChatStorage.appendDebugEvent', event);
     await appendEvent({
       message: {
+        ...(event.message.attachments && event.message.attachments.length > 0 ? {
+          attachments: event.message.attachments
+        } : {}),
         id: event.id,
         role: event.message.role || 'assistant',
         text: getMessageText(event.message),
@@ -1141,6 +1144,45 @@ const appendChatEvent = async event => {
   await appendEvent(event);
 };
 
+const getAttachmentTextPart = attachment => {
+  switch (attachment.displayType) {
+    case 'file':
+      return {
+        text: `Attached file "${attachment.name}" (${attachment.mimeType || 'application/octet-stream'}, ${attachment.size} bytes).`,
+        type: 'input_text'
+      };
+    case 'image':
+      return {
+        text: `Attached image "${attachment.name}" could not be encoded for the AI request.`,
+        type: 'input_text'
+      };
+    case 'invalid-image':
+      return {
+        text: `Attached file "${attachment.name}" could not be processed as a valid image.`,
+        type: 'input_text'
+      };
+    case 'text-file':
+      return {
+        text: attachment.textContent ? `Attached text file "${attachment.name}" (${attachment.mimeType || 'text/plain'}):\n\n${attachment.textContent}` : `Attached text file "${attachment.name}" (${attachment.mimeType || 'text/plain'}).`,
+        type: 'input_text'
+      };
+  }
+};
+const getAttachmentParts = attachments => {
+  const parts = [];
+  for (const attachment of attachments) {
+    if (attachment.displayType === 'image' && attachment.previewSrc) {
+      parts.push({
+        image_url: attachment.previewSrc,
+        type: 'input_image'
+      });
+      continue;
+    }
+    parts.push(getAttachmentTextPart(attachment));
+  }
+  return parts;
+};
+
 const pendingSessionIds = [];
 const pendingSessionWorkBySessionId = new Map();
 let pendingWorkPromise;
@@ -1179,37 +1221,6 @@ const appendChatDebugEvent = async event => {
   await invoke('ChatStorage.appendDebugEvent', event);
 };
 
-const isAiRequestInput = value => {
-  return !!value && typeof value === 'object' && 'content' in value && 'role' in value;
-};
-const getAiRequestBody = (systemPrompt, text) => {
-  const messages = typeof text === 'string' ? [{
-    content: text,
-    role: 'user'
-  }] : text.map(message => isAiRequestInput(message) ? message : {
-    content: message,
-    role: 'user'
-  });
-  return {
-    input: [{
-      content: systemPrompt,
-      role: 'system'
-    }, ...messages]
-  };
-};
-
-const getRedactedHeaders = headers => {
-  const redactedHeaders = {};
-  for (const [headerName, headerValue] of Object.entries(headers)) {
-    if (headerName.toLowerCase() === 'authorization') {
-      redactedHeaders[headerName] = headerValue.toLowerCase().startsWith('bearer ') ? 'Bearer [redacted]' : '[redacted]';
-    } else {
-      redactedHeaders[headerName] = headerValue;
-    }
-  }
-  return redactedHeaders;
-};
-
 const getOutputText = outputText => {
   if (typeof outputText === 'string') {
     return outputText || undefined;
@@ -1248,36 +1259,192 @@ const getToolCall = item => {
 const extractAiResponse = data => {
   if (!data || typeof data !== 'object') {
     return {
-      text: undefined,
-      toolCalls: []
+      newToolCalls: [],
+      text: undefined
     };
   }
   const response = data;
   const outputText = getOutputText(response.output_text);
   if (outputText) {
     return {
-      text: outputText,
-      toolCalls: []
+      newToolCalls: [],
+      text: outputText
     };
   }
   if (!Array.isArray(response.output)) {
     return {
-      text: undefined,
-      toolCalls: []
+      newToolCalls: [],
+      text: undefined
     };
   }
   const text = response.output.map(getOutputItemText).join('');
   const toolCalls = response.output.map(getToolCall).filter(toolCall => !!toolCall);
   return {
-    text: text || undefined,
-    toolCalls
+    newToolCalls: toolCalls,
+    text: text || undefined
+  };
+};
+
+const isAiRequestInput = value => {
+  return !!value && typeof value === 'object' && 'content' in value && 'role' in value;
+};
+const getAiRequestBody = (systemPrompt, text) => {
+  const messages = typeof text === 'string' ? [{
+    content: text,
+    role: 'user'
+  }] : text.map(message => isAiRequestInput(message) ? message : {
+    content: message,
+    role: 'user'
+  });
+  return {
+    input: [{
+      content: systemPrompt,
+      role: 'system'
+    }, ...messages]
   };
 };
 
+const backendCompletionFailedMessage = 'Backend completion request failed.';
+const getBackendModelNotAllowedForFreePlanMessage = statusCode => {
+  if (typeof statusCode === 'number') {
+    return `Backend completion request failed (status ${statusCode}). The selected model is not available on the Free plan. Choose a lower-cost LVCE model such as Claude Haiku or GPT-5.4 Mini, or upgrade your plan and try again.`;
+  }
+  return 'Backend completion request failed. The selected model is not available on the Free plan. Choose a lower-cost LVCE model such as Claude Haiku or GPT-5.4 Mini, or upgrade your plan and try again.';
+};
+const getBackendHttpErrorDetails = (errorCode, errorMessage) => {
+  const trimmedErrorCode = errorCode?.trim();
+  const trimmedErrorMessage = errorMessage?.trim();
+  if (trimmedErrorCode && trimmedErrorMessage) {
+    return `Error code: ${trimmedErrorCode}. ${trimmedErrorMessage}`;
+  }
+  if (trimmedErrorCode) {
+    return `Error code: ${trimmedErrorCode}.`;
+  }
+  return trimmedErrorMessage;
+};
+const getBackendErrorMessage = errorResult => {
+  switch (errorResult.details) {
+    case 'http-error':
+      {
+        if (errorResult.errorCode === 'E_LVCE_MODEL_NOT_ALLOWED_FOR_FREE_PLAN') {
+          return getBackendModelNotAllowedForFreePlanMessage(errorResult.statusCode);
+        }
+        const details = getBackendHttpErrorDetails(errorResult.errorCode, errorResult.errorMessage);
+        if (typeof errorResult.statusCode === 'number') {
+          const prefix = `Backend completion request failed (status ${errorResult.statusCode}).`;
+          if (!details) {
+            return prefix;
+          }
+          return `${prefix} ${details}`;
+        }
+        if (details) {
+          return `Backend completion request failed. ${details}`;
+        }
+        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 getError = error => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+};
+
+const getRedactedHeaders = headers => {
+  const redactedHeaders = {};
+  for (const [headerName, headerValue] of Object.entries(headers)) {
+    if (headerName.toLowerCase() === 'authorization') {
+      redactedHeaders[headerName] = headerValue.toLowerCase().startsWith('bearer ') ? 'Bearer [redacted]' : '[redacted]';
+    } else {
+      redactedHeaders[headerName] = headerValue;
+    }
+  }
+  return redactedHeaders;
+};
+
+const getStatusCodeMessage = statusCode => {
+  switch (statusCode) {
+    case 401:
+      return 'The AI request was rejected. Check the API key and try again.';
+    case 403:
+      return 'The AI request was rejected. Check your permissions and try again.';
+    case 408:
+      return 'The AI request timed out. Please try again.';
+    case 429:
+      return 'The AI request was rate limited. Please try again.';
+    default:
+      if (statusCode >= 500) {
+        return 'The AI provider is temporarily unavailable. Please try again.';
+      }
+      return 'The AI request failed. Please try again.';
+  }
+};
+const getBackendErrorCodeFromBody = body => {
+  if (!body || typeof body !== 'object') {
+    return undefined;
+  }
+  const code = Reflect.get(body, 'code');
+  return typeof code === 'string' ? code : undefined;
+};
+const getBackendErrorMessageFromBody = body => {
+  if (!body || typeof body !== 'object') {
+    return undefined;
+  }
+  const error = Reflect.get(body, 'error');
+  return typeof error === 'string' ? error : undefined;
+};
+const getVisibleAiErrorMessage = (_error, statusCode, providerId = 'openai') => {
+  if (providerId === 'backend') {
+    const errorCode = getBackendErrorCodeFromBody(_error);
+    const errorMessage = _error instanceof Error ? _error.message : typeof _error === 'object' && _error ? getBackendErrorMessageFromBody(_error) : undefined;
+    if (typeof statusCode === 'number') {
+      return getBackendErrorMessage({
+        details: 'http-error',
+        ...(errorCode ? {
+          errorCode
+        } : {}),
+        ...(errorMessage ? {
+          errorMessage
+        } : {}),
+        statusCode
+      });
+    }
+    return getBackendErrorMessage({
+      details: 'request-failed',
+      ...(errorMessage ? {
+        errorMessage
+      } : {})
+    });
+  }
+  if (typeof statusCode === 'number') {
+    return getStatusCodeMessage(statusCode);
+  }
+  return 'The AI request failed. Please try again.';
+};
+
 const getAiRequestOptions = options => {
   const {
     headers,
     modelId,
+    providerId,
     systemPrompt,
     text: inputText,
     url
@@ -1289,6 +1456,7 @@ const getAiRequestOptions = options => {
     },
     headers,
     method: 'POST',
+    providerId,
     url
   };
 };
@@ -1311,6 +1479,45 @@ const getInitData = options => {
   return requestInit;
 };
 
+const lastRequestSummaryToken = '__MOCK_OPENAPI_LAST_REQUEST_SUMMARY__';
+const getLastRequestSummary = body => {
+  if (!body || typeof body !== 'object') {
+    return 'mock-request-summary images=0 text-files=0';
+  }
+  const input = Reflect.get(body, 'input');
+  if (!Array.isArray(input) || input.length === 0) {
+    return 'mock-request-summary images=0 text-files=0';
+  }
+  let imageCount = 0;
+  let textFileCount = 0;
+  for (const item of input) {
+    if (!item || typeof item !== 'object') {
+      continue;
+    }
+    const content = Reflect.get(item, 'content');
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const part of content) {
+      if (!part || typeof part !== 'object') {
+        continue;
+      }
+      const type = Reflect.get(part, 'type');
+      if (type === 'input_image') {
+        imageCount++;
+        continue;
+      }
+      if (type !== 'input_text') {
+        continue;
+      }
+      const text = Reflect.get(part, 'text');
+      if (typeof text === 'string' && text.startsWith('Attached text file "')) {
+        textFileCount++;
+      }
+    }
+  }
+  return `mock-request-summary images=${imageCount} text-files=${textFileCount}`;
+};
 const getModel = body => {
   if (!body || typeof body !== 'object') {
     return 'mock-model';
@@ -1323,6 +1530,7 @@ const getModel = body => {
 };
 const createMockOpenAiResponse = (body, text) => {
   const model = getModel(body);
+  const resolvedText = text === lastRequestSummaryToken ? getLastRequestSummary(body) : text;
   return {
     created_at: 0,
     id: 'resp_mock_0001',
@@ -1331,7 +1539,7 @@ const createMockOpenAiResponse = (body, text) => {
     output: [{
       content: [{
         annotations: [],
-        text,
+        text: resolvedText,
         type: 'output_text'
       }],
       id: 'msg_mock_0001',
@@ -1339,13 +1547,39 @@ const createMockOpenAiResponse = (body, text) => {
       status: 'completed',
       type: 'message'
     }],
-    output_text: text,
+    output_text: resolvedText,
     parallel_tool_calls: true,
     status: 'completed',
     tools: []
   };
 };
 
+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;
+};
+
 let queue = [];
 let waiters = [];
 let finished = false;
@@ -1403,20 +1637,34 @@ const consumeResponseText = async () => {
   return chunks.join('');
 };
 
+const createParsedResponse = (ok, status, body) => {
+  return {
+    headers: new Headers(),
+    json: async () => body,
+    ok,
+    status
+  };
+};
 const getNetworkResponse = async (options, requestInit) => {
   const {
     body,
+    providerId,
     url
   } = options;
+  if (providerId === 'backend') {
+    const mockErrorResponse = takeErrorResponse();
+    if (mockErrorResponse) {
+      return createParsedResponse(false, mockErrorResponse.statusCode, mockErrorResponse.body);
+    }
+    const mockResponse = takeResponse();
+    if (mockResponse) {
+      return createParsedResponse(true, 200, mockResponse.body);
+    }
+  }
   const mockResponseText = await consumeResponseText();
   if (mockResponseText !== undefined) {
     const data = createMockOpenAiResponse(body, mockResponseText);
-    return {
-      headers: new Headers(),
-      json: async () => data,
-      ok: true,
-      status: 200
-    };
+    return createParsedResponse(true, 200, data);
   }
   return fetch(url, requestInit);
 };
@@ -1430,6 +1678,7 @@ const parseNetworkResponse = async response => {
   if (!response.ok) {
     return {
       error: json,
+      headers: serializeHeaders(response.headers),
       statusCode: response.status,
       type: 'error'
     };
@@ -1452,6 +1701,7 @@ const makeAiRequest = async options => {
   const {
     headers,
     modelId,
+    providerId,
     systemPrompt,
     text: inputText,
     url
@@ -1459,6 +1709,7 @@ const makeAiRequest = async options => {
   const requestOptions = getAiRequestOptions({
     headers,
     modelId,
+    providerId,
     systemPrompt,
     text: inputText,
     url
@@ -1471,29 +1722,82 @@ const makeAiRequest = async options => {
       type: 'error'
     };
   }
-  const {
-    text,
-    toolCalls
-  } = extractAiResponse(response.data);
   return {
     data: response.data,
     headers: response.headers,
     statusCode: response.statusCode,
-    text,
-    toolCalls,
     type: 'success'
   };
 };
 
+const appendVisibleAiErrorMessage = async options => {
+  const {
+    error,
+    providerId,
+    requestId,
+    sessionId,
+    statusCode,
+    timestamp
+  } = options;
+  const text = getVisibleAiErrorMessage(error, statusCode, providerId);
+  await appendChatEvent({
+    id: requestId,
+    message: {
+      content: [{
+        text,
+        type: 'text'
+      }],
+      role: 'assistant'
+    },
+    requestId,
+    sessionId,
+    timestamp,
+    type: Message
+  });
+};
+const getBackendInvalidResponseDetails = data => {
+  if (!data || typeof data !== 'object') {
+    return 'Unexpected backend response format: no assistant text or tool calls were returned.';
+  }
+  const output = Reflect.get(data, 'output');
+  if (Array.isArray(output) && output.length === 0) {
+    return 'Unexpected backend response format: no assistant text or tool calls were returned.';
+  }
+  return 'Unexpected backend response format.';
+};
+const appendAiErrorResponse = async options => {
+  const {
+    error,
+    requestId,
+    sessionId,
+    statusCode,
+    timestamp,
+    turnId
+  } = options;
+  await appendChatDebugEvent({
+    ...(typeof statusCode === 'number' ? {
+      statusCode
+    } : {}),
+    requestId,
+    sessionId,
+    timestamp,
+    turnId,
+    type: AiResponse,
+    value: error
+  });
+};
 const aiLoopIterationAiRequest = async options => {
   const {
     headers,
     messages,
     modelId,
+    providerId,
     requestId,
     sessionId,
     systemPrompt,
     timestamp,
+    toolCallResults,
+    toolCalls,
     turnId,
     url
   } = options;
@@ -1511,34 +1815,106 @@ const aiLoopIterationAiRequest = async options => {
     turnId,
     type: AiRequest
   });
-  const result = await makeAiRequest({
-    headers,
-    modelId,
-    systemPrompt,
-    text: messages,
-    url
-  });
+  let result;
+  try {
+    result = await makeAiRequest({
+      headers,
+      modelId,
+      providerId,
+      systemPrompt,
+      text: messages,
+      toolCallResults,
+      toolCalls,
+      url
+    });
+  } catch (error) {
+    const normalizedError = getError(error);
+    await appendVisibleAiErrorMessage({
+      error: normalizedError,
+      providerId,
+      requestId,
+      sessionId,
+      timestamp
+    });
+    await appendAiErrorResponse({
+      error: normalizedError,
+      requestId,
+      sessionId,
+      timestamp,
+      turnId
+    });
+    return {
+      error: normalizedError,
+      type: 'error'
+    };
+  }
   if (result.type === 'error') {
+    await appendVisibleAiErrorMessage({
+      error: result.error,
+      providerId,
+      requestId,
+      sessionId,
+      statusCode: result.statusCode,
+      timestamp
+    });
+    await appendAiErrorResponse({
+      error: result.error,
+      requestId,
+      sessionId,
+      statusCode: result.statusCode,
+      timestamp,
+      turnId
+    });
+    return {
+      error: result.error,
+      type: 'error'
+    };
+  }
+  const {
+    newToolCalls,
+    text
+  } = extractAiResponse(result.data);
+  if (!text && newToolCalls.length === 0 && providerId === 'backend') {
+    const error = new Error(getBackendErrorMessage({
+      details: 'invalid-response',
+      errorMessage: getBackendInvalidResponseDetails(result.data)
+    }));
+    await appendChatEvent({
+      id: requestId,
+      message: {
+        content: [{
+          text: error.message,
+          type: 'text'
+        }],
+        role: 'assistant'
+      },
+      requestId,
+      sessionId,
+      timestamp,
+      type: Message
+    });
     await appendChatDebugEvent({
+      headers: result.headers,
       requestId,
       sessionId,
       statusCode: result.statusCode,
       timestamp,
+      toolCalls: newToolCalls,
       turnId,
       type: AiResponse,
-      value: result.error
+      value: result.data
     });
     return {
-      error: result.error,
+      error,
       type: 'error'
     };
   }
-  if (result.text) {
+  if (text) {
     await appendChatEvent({
       id: requestId,
       message: {
         content: [{
-          text: result.text,
+          text: text,
           type: 'text'
         }],
         role: 'assistant'
@@ -1555,7 +1931,7 @@ const aiLoopIterationAiRequest = async options => {
     sessionId,
     statusCode: result.statusCode,
     timestamp,
-    toolCalls: result.toolCalls,
+    toolCalls: newToolCalls,
     turnId,
     type: AiResponse,
     value: result.data
@@ -1563,7 +1939,7 @@ const aiLoopIterationAiRequest = async options => {
   return {
     data: result.data,
     toolCallResults: [],
-    toolCalls: result.toolCalls,
+    toolCalls: newToolCalls,
     type: 'success'
   };
 };
@@ -1618,6 +1994,7 @@ const getStoredMessage = event => {
     return undefined;
   }
   const {
+    attachments = [],
     content = [],
     role
   } = event.message;
@@ -1625,11 +2002,28 @@ const getStoredMessage = event => {
     return undefined;
   }
   const text = content.filter(part => part.type === 'text' && typeof part.text === 'string').map(part => part.text).join('');
-  if (!text) {
+  if (attachments.length === 0) {
+    if (!text) {
+      return undefined;
+    }
+    return {
+      content: text,
+      role
+    };
+  }
+  const parts = [];
+  if (text) {
+    parts.push({
+      text,
+      type: 'input_text'
+    });
+  }
+  parts.push(...getAttachmentParts(attachments));
+  if (parts.length === 0) {
     return undefined;
   }
   return {
-    content: text,
+    content: parts,
     role
   };
 };
@@ -1666,10 +2060,14 @@ const getStoredAiLoopState = async (sessionId, fallbackText, fallbackToolCalls,
     }
   }
   if (messages.length === 0) {
-    messages.push({
-      content: fallbackText,
-      role: 'user'
-    });
+    if (typeof fallbackText === 'string') {
+      messages.push({
+        content: fallbackText,
+        role: 'user'
+      });
+    } else {
+      messages.push(...fallbackText);
+    }
   }
   return {
     messages,
@@ -1686,6 +2084,7 @@ const aiLoopIteration = async loopOptions => {
   const {
     headers,
     modelId,
+    providerId,
     sessionId,
     systemPrompt,
     text,
@@ -1715,10 +2114,13 @@ const aiLoopIteration = async loopOptions => {
     headers,
     messages,
     modelId,
+    providerId,
     requestId,
     sessionId,
     systemPrompt,
     timestamp,
+    toolCallResults,
+    toolCalls,
     turnId,
     url
   });
@@ -1730,6 +2132,7 @@ const aiLoop = async loopOptions => {
   const {
     headers,
     modelId,
+    providerId,
     sessionId,
     systemPrompt,
     text,
@@ -1742,6 +2145,7 @@ const aiLoop = async loopOptions => {
     const result = await aiLoopIteration({
       headers,
       modelId,
+      providerId,
       sessionId,
       systemPrompt,
       text,
@@ -1769,13 +2173,6 @@ const aiLoop = async loopOptions => {
   };
 };
 
-const getError = error => {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
-};
-
 const settleRejectedWaiters = (pendingSessionWork, processedVersion, error) => {
   const remainingWaiters = [];
   for (const waiter of pendingSessionWork.waiters) {
@@ -1818,11 +2215,12 @@ const runQueue = async () => {
         enqueueSessionId(sessionId, pendingSessionWork);
         continue;
       }
+      pendingSessionWork.processedVersion = targetVersion;
       if (result.type === 'error') {
-        throw getError(result.error);
+        settleResolvedWaiters(pendingSessionWork, targetVersion);
+      } else {
+        settleResolvedWaiters(pendingSessionWork, targetVersion);
       }
-      pendingSessionWork.processedVersion = targetVersion;
-      settleResolvedWaiters(pendingSessionWork, targetVersion);
     } catch (error) {
       const normalizedError = getError(error);
       pendingSessionWork.processedVersion = targetVersion;
@@ -1861,8 +2259,42 @@ const processQueue = async sessionId => {
   await promise;
 };
 
+const openApiApiKeyRequiredMessage = 'OpenAI API key is not configured. Enter your OpenAI API key below and click Save.';
+const getBackendResponsesEndpoint = backendUrl => {
+  return backendUrl.endsWith('/') ? `${backendUrl}v1/responses` : `${backendUrl}/v1/responses`;
+};
+const normalizeOpenAiModelId = modelId => {
+  const normalizedModelId = modelId.toLowerCase();
+  if (normalizedModelId.startsWith('openapi/')) {
+    return modelId.slice('openapi/'.length);
+  }
+  if (normalizedModelId.startsWith('openai/')) {
+    return modelId.slice('openai/'.length);
+  }
+  return modelId;
+};
+const isTestModel = modelId => {
+  return modelId === 'test';
+};
+const getQueuedText = (text, role, attachments) => {
+  const content = [];
+  if (text) {
+    content.push({
+      text,
+      type: 'input_text'
+    });
+  }
+  content.push(...getAttachmentParts(attachments));
+  return [{
+    content,
+    role
+  }];
+};
 const handleSubmit = async options => {
   const {
+    attachments = [],
+    authAccessToken = '',
+    backendUrl = '',
     id,
     modelId,
     openAiKey,
@@ -1870,13 +2302,17 @@ const handleSubmit = async options => {
     role,
     sessionId,
     systemPrompt,
-    text
+    text,
+    useOwnBackend = false
   } = options;
   const date = new Date();
   const timestamp = date.toISOString();
   await appendChatEvent({
     id,
     message: {
+      ...(attachments.length > 0 ? {
+        attachments
+      } : {}),
       content: [{
         text,
         type: 'text'
@@ -1888,22 +2324,47 @@ const handleSubmit = async options => {
     timestamp,
     type: Message
   });
+  if (!isTestModel(modelId) && !useOwnBackend && !openAiKey.trim()) {
+    await appendChatEvent({
+      id: requestId,
+      message: {
+        content: [{
+          text: openApiApiKeyRequiredMessage,
+          type: 'text'
+        }],
+        role: 'assistant'
+      },
+      requestId,
+      sessionId,
+      timestamp,
+      type: Message
+    });
+    return;
+  }
   addPendingSessionWork({
     headers: {
-      Authorization: `Bearer ${openAiKey}`,
+      Authorization: `Bearer ${useOwnBackend ? authAccessToken : openAiKey}`,
       'Content-Type': 'application/json'
     },
-    modelId,
-    providerId: 'openai',
+    modelId: normalizeOpenAiModelId(modelId),
+    providerId: useOwnBackend ? 'backend' : 'openai',
     sessionId,
     systemPrompt,
-    text,
+    text: getQueuedText(text, role, attachments),
     turnId: requestId,
-    url: 'https://api.openai.com/v1/responses'
+    url: useOwnBackend ? getBackendResponsesEndpoint(backendUrl) : 'https://api.openai.com/v1/responses'
   });
   await processQueue(sessionId);
 };
 
+const mockBackendSetHttpErrorResponse = (statusCode, body) => {
+  setHttpErrorResponse(statusCode, body);
+};
+
+const mockBackendSetResponse = body => {
+  setResponse(body);
+};
+
 const registerMockResponse = mockResponse => {
   reset();
   pushChunk(mockResponse.text);
@@ -1912,6 +2373,11 @@ const registerMockResponse = mockResponse => {
 
 const commandMap = {
   'ChatCoordinator.handleSubmit': handleSubmit,
+  'ChatCoordinator.mockBackendSetHttpErrorResponse': mockBackendSetHttpErrorResponse,
+  'ChatCoordinator.mockBackendSetResponse': mockBackendSetResponse,
+  'ChatCoordinator.mockOpenApiStreamFinish': finish,
+  'ChatCoordinator.mockOpenApiStreamPushChunk': pushChunk,
+  'ChatCoordinator.mockOpenApiStreamReset': reset,
   'ChatCoordinator.registerMockResponse': registerMockResponse,
   'ChatCoordinator.submit': handleSubmit,
   'HandleMessagePort.handleMessagePort': handleMessagePort,