@lvce-editor/static-server 0.80.19 → 0.81.1

package/static/{26e5d0f → d0836a7}/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js

@@ -1127,23 +1127,22 @@ const isRawMessageEvent = event => {
   const value = event;
   return value.type === Message && typeof value.id === 'string' && typeof value.sessionId === 'string' && typeof value.timestamp === 'string';
 };
-const getMessageText = message => {
-  return (message.content || []).filter(part => part.type === 'text' && typeof part.text === 'string').map(part => part.text || '').join('');
-};
-const getMessageTime = timestamp => {
-  return timestamp.slice(11, 16);
+const getMessageContent = message => {
+  return (message.content || []).filter(part => (part.type === 'text' || part.type === 'input_text') && typeof part.text === 'string');
 };
 const appendChatEvent = async event => {
   if (isRawMessageEvent(event)) {
-    await appendEvent({
+    const content = getMessageContent(event.message);
+    await invoke('ChatStorage.appendEvent', {
       message: {
         ...(event.message.attachments && event.message.attachments.length > 0 ? {
           attachments: event.message.attachments
         } : {}),
+        ...(content.length > 0 ? {
+          content
+        } : {}),
         id: event.id,
-        role: event.message.role || 'assistant',
-        text: getMessageText(event.message),
-        time: getMessageTime(event.timestamp)
+        role: event.message.role || 'assistant'
       },
       sessionId: event.sessionId,
       timestamp: event.timestamp,
@@ -1255,7 +1254,7 @@ const getToolCallArgs = serializedArguments => {
   }
 };
 const isResponseToolCallItem = item => {
-  return item.type === 'function_call' && typeof item.arguments === 'string' && (typeof item.call_id === 'string' || typeof item.id === 'string');
+  return item.type === 'function_call' && typeof item.arguments === 'string' && typeof item.name === 'string' && (typeof item.call_id === 'string' || typeof item.id === 'string');
 };
 const getToolCall = item => {
   if (!isResponseToolCallItem(item)) {
@@ -1263,7 +1262,8 @@ const getToolCall = item => {
   }
   return {
     args: getToolCallArgs(item.arguments),
-    id: item.call_id || item.id || ''
+    id: item.call_id || item.id || '',
+    name: item.name
   };
 };
 const extractAiResponse = data => {
@@ -1298,7 +1298,40 @@ const extractAiResponse = data => {
 const isAiRequestInput = value => {
   return !!value && typeof value === 'object' && 'content' in value && 'role' in value;
 };
-const getAiRequestBody = (systemPrompt, text) => {
+const serializeToolCallOutput = value => {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  if (value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'symbol') {
+    return value.description ? `Symbol(${value.description})` : 'Symbol()';
+  }
+  if (typeof value === 'function') {
+    return '[function]';
+  }
+  const serialized = JSON.stringify(value);
+  if (typeof serialized === 'string') {
+    return serialized;
+  }
+  return '[unserializable]';
+};
+const getToolCallOutput = toolCallResult => {
+  if (toolCallResult.type === 'success') {
+    return serializeToolCallOutput(toolCallResult.value);
+  }
+  return serializeToolCallOutput({
+    error: toolCallResult.error
+  });
+};
+const getAiRequestBody = (systemPrompt, text, toolCallResults = []) => {
   const messages = typeof text === 'string' ? [{
     content: text,
     role: 'user'
@@ -1306,11 +1339,16 @@ const getAiRequestBody = (systemPrompt, text) => {
     content: message,
     role: 'user'
   });
+  const outputs = toolCallResults.map(toolCallResult => ({
+    call_id: toolCallResult.callId,
+    output: getToolCallOutput(toolCallResult),
+    type: 'function_call_output'
+  }));
   return {
     input: [{
       content: systemPrompt,
       role: 'system'
-    }, ...messages]
+    }, ...messages, ...outputs]
   };
 };
 
@@ -1457,11 +1495,12 @@ const getAiRequestOptions = options => {
     providerId,
     systemPrompt,
     text: inputText,
+    toolCallResults,
     url
   } = options;
   return {
     body: {
-      ...getAiRequestBody(systemPrompt, inputText),
+      ...getAiRequestBody(systemPrompt, inputText, toolCallResults),
       model: modelId
     },
     headers,
@@ -1489,7 +1528,111 @@ const getInitData = options => {
   return requestInit;
 };
 
+// cspell:ignore logprobs
+
 const lastRequestSummaryToken = '__MOCK_OPENAPI_LAST_REQUEST_SUMMARY__';
+const mockCreatedAtBase = 1_778_610_258;
+const getHashRound = value => {
+  let hash = 2_166_136_261;
+  for (const character of value) {
+    hash ^= character.codePointAt(0) ?? 0;
+    hash = Math.imul(hash, 16_777_619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0');
+};
+const getDeterministicHex = (seed, length) => {
+  let result = '';
+  let index = 0;
+  while (result.length < length) {
+    result += getHashRound(`${seed}:${index}`);
+    index++;
+  }
+  return result.slice(0, length);
+};
+const getInputTexts = body => {
+  if (!body || typeof body !== 'object') {
+    return [];
+  }
+  const input = Reflect.get(body, 'input');
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  const parts = [];
+  for (const item of input) {
+    if (typeof item === 'string') {
+      parts.push(item);
+      continue;
+    }
+    if (!item || typeof item !== 'object') {
+      continue;
+    }
+    const content = Reflect.get(item, 'content');
+    if (typeof content === 'string') {
+      parts.push(content);
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const contentPart of content) {
+      if (typeof contentPart === 'string') {
+        parts.push(contentPart);
+        continue;
+      }
+      if (!contentPart || typeof contentPart !== 'object') {
+        continue;
+      }
+      const text = Reflect.get(contentPart, 'text');
+      if (typeof text !== 'string' || !text) {
+        continue;
+      }
+      const type = Reflect.get(contentPart, 'type');
+      if (type === undefined || type === 'input_text') {
+        parts.push(text);
+      }
+    }
+  }
+  return parts;
+};
+const estimateTokens = text => {
+  const trimmedText = text.trim();
+  if (!trimmedText) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(trimmedText.length / 5));
+};
+const getUsage = (body, outputText) => {
+  const inputText = getInputTexts(body).join('\n');
+  const inputTokens = estimateTokens(inputText);
+  const outputTokens = estimateTokens(outputText);
+  return {
+    input_tokens: inputTokens,
+    input_tokens_details: {
+      cached_tokens: 0
+    },
+    output_tokens: outputTokens,
+    output_tokens_details: {
+      reasoning_tokens: 0
+    },
+    total_tokens: inputTokens + outputTokens
+  };
+};
+const getResponseSeed = (body, text) => {
+  const serializedBody = body === undefined ? 'undefined' : JSON.stringify(body);
+  return `${serializedBody}:${text}`;
+};
+const getResponseId = seed => {
+  const responseSeed = `response:${seed}`;
+  return `resp_${getDeterministicHex(responseSeed, 32)}`;
+};
+const getMessageId = seed => {
+  const messageSeed = `message:${seed}`;
+  return `msg_${getDeterministicHex(messageSeed, 32)}`;
+};
+const getCreatedAt = seed => {
+  const suffix = Number.parseInt(getDeterministicHex(`created:${seed}`, 6), 16);
+  return mockCreatedAtBase + suffix % 1000;
+};
 const getLastRequestSummary = body => {
   if (!body || typeof body !== 'object') {
     return 'mock-request-summary images=0 text-files=0';
@@ -1538,29 +1681,137 @@ const getModel = body => {
   }
   return model;
 };
+const parseSseDataLines = text => {
+  const rawEvents = text.split('\n\n');
+  const dataLines = [];
+  for (const rawEvent of rawEvents) {
+    if (!rawEvent) {
+      continue;
+    }
+    const lines = rawEvent.split('\n');
+    for (const line of lines) {
+      if (!line.startsWith('data:')) {
+        continue;
+      }
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  return dataLines;
+};
+const isSseMockResponse = text => {
+  return text.includes('\ndata:') || text.startsWith('data:');
+};
+const parseSseMockResponse = (body, text) => {
+  const dataLines = parseSseDataLines(text);
+  if (dataLines.length === 0) {
+    return undefined;
+  }
+  let accumulatedText = '';
+  let completedResponse;
+  for (const line of dataLines) {
+    if (line === '[DONE]') {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+      continue;
+    }
+    const eventType = Reflect.get(parsed, 'type');
+    if (eventType === 'response.output_text.delta') {
+      const delta = Reflect.get(parsed, 'delta');
+      if (typeof delta === 'string') {
+        accumulatedText += delta;
+      }
+      continue;
+    }
+    if (eventType === 'response.completed') {
+      const response = Reflect.get(parsed, 'response');
+      if (response && typeof response === 'object') {
+        completedResponse = response;
+      }
+    }
+  }
+  if (completedResponse) {
+    return completedResponse;
+  }
+  if (accumulatedText) {
+    return createMockOpenAiResponse(body, accumulatedText);
+  }
+  return undefined;
+};
 const createMockOpenAiResponse = (body, text) => {
+  if (isSseMockResponse(text)) {
+    const parsedSseResponse = parseSseMockResponse(body, text);
+    if (parsedSseResponse) {
+      return parsedSseResponse;
+    }
+  }
   const model = getModel(body);
   const resolvedText = text === lastRequestSummaryToken ? getLastRequestSummary(body) : text;
+  const seed = getResponseSeed(body, resolvedText);
+  const createdAt = getCreatedAt(seed);
   return {
-    created_at: 0,
-    id: 'resp_mock_0001',
+    background: false,
+    billing: {
+      payer: 'openai'
+    },
+    completed_at: createdAt + 2,
+    created_at: createdAt,
+    error: null,
+    frequency_penalty: 0,
+    id: getResponseId(seed),
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    max_tool_calls: null,
+    metadata: {},
     model,
+    moderation: null,
     object: 'response',
     output: [{
       content: [{
         annotations: [],
+        logprobs: [],
         text: resolvedText,
         type: 'output_text'
       }],
-      id: 'msg_mock_0001',
+      id: getMessageId(seed),
       role: 'assistant',
       status: 'completed',
       type: 'message'
     }],
-    output_text: resolvedText,
     parallel_tool_calls: true,
+    presence_penalty: 0,
+    previous_response_id: null,
+    prompt_cache_key: null,
+    prompt_cache_retention: 'in_memory',
+    reasoning: {
+      effort: null,
+      summary: null
+    },
+    safety_identifier: null,
+    service_tier: 'default',
     status: 'completed',
-    tools: []
+    store: true,
+    temperature: 1,
+    text: {
+      format: {
+        type: 'text'
+      },
+      verbosity: 'medium'
+    },
+    tool_choice: 'auto',
+    tools: [],
+    top_logprobs: 0,
+    top_p: 1,
+    truncation: 'disabled',
+    usage: getUsage(body, resolvedText),
+    user: null
   };
 };
 
@@ -1647,11 +1898,35 @@ const consumeResponseText = async () => {
   return chunks.join('');
 };
 
+const parseContentLength = headers => {
+  const contentLength = headers.get('content-length');
+  if (!contentLength) {
+    return -1;
+  }
+  const parsed = Number.parseInt(contentLength, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return -1;
+  }
+  return parsed;
+};
+const getResponseSize = async response => {
+  const parsedContentLength = parseContentLength(response.headers);
+  if (parsedContentLength !== -1) {
+    return parsedContentLength;
+  }
+  try {
+    const blob = await response.clone().blob();
+    return blob.size;
+  } catch {
+    return 0;
+  }
+};
 const createParsedResponse = (ok, status, body) => {
   return {
     headers: new Headers(),
     json: async () => body,
     ok,
+    size: 0,
     status
   };
 };
@@ -1676,7 +1951,15 @@ const getNetworkResponse = async (options, requestInit) => {
     const data = createMockOpenAiResponse(body, mockResponseText);
     return createParsedResponse(true, 200, data);
   }
-  return fetch(url, requestInit);
+  const response = await fetch(url, requestInit);
+  const size = await getResponseSize(response);
+  return {
+    headers: response.headers,
+    json: response.json.bind(response),
+    ok: response.ok,
+    size,
+    status: response.status
+  };
 };
 
 const serializeHeaders = headers => {
@@ -1689,6 +1972,7 @@ const parseNetworkResponse = async response => {
     return {
       error: json,
       headers: serializeHeaders(response.headers),
+      size: response.size,
       statusCode: response.status,
       type: 'error'
     };
@@ -1696,6 +1980,7 @@ const parseNetworkResponse = async response => {
   return {
     data: json,
     headers: serializeHeaders(response.headers),
+    size: response.size,
     statusCode: response.status,
     type: 'success'
   };
@@ -1714,6 +1999,7 @@ const makeAiRequest = async options => {
     providerId,
     systemPrompt,
     text: inputText,
+    toolCallResults,
     url
   } = options;
   const requestOptions = getAiRequestOptions({
@@ -1722,12 +2008,14 @@ const makeAiRequest = async options => {
     providerId,
     systemPrompt,
     text: inputText,
+    toolCallResults,
     url
   });
   const response = await makeNetworkRequest(requestOptions);
   if (response.type === 'error') {
     return {
       error: response.error,
+      size: response.size,
       statusCode: response.statusCode,
       type: 'error'
     };
@@ -1735,6 +2023,7 @@ const makeAiRequest = async options => {
   return {
     data: response.data,
     headers: response.headers,
+    size: response.size,
     statusCode: response.statusCode,
     type: 'success'
   };
@@ -1780,6 +2069,7 @@ const appendAiErrorResponse = async options => {
     error,
     requestId,
     sessionId,
+    size = 0,
     statusCode,
     timestamp,
     turnId
@@ -1790,6 +2080,7 @@ const appendAiErrorResponse = async options => {
     } : {}),
     requestId,
     sessionId,
+    size,
     timestamp,
     turnId,
     type: AiResponse,
@@ -1812,7 +2103,7 @@ const aiLoopIterationAiRequest = async options => {
     url
   } = options;
   const requestBody = {
-    ...getAiRequestBody(systemPrompt, messages),
+    ...getAiRequestBody(systemPrompt, messages, toolCallResults),
     model: modelId
   };
   await appendChatDebugEvent({
@@ -1823,7 +2114,8 @@ const aiLoopIterationAiRequest = async options => {
     sessionId,
     timestamp,
     turnId,
-    type: AiRequest
+    type: AiRequest,
+    url
   });
   let result;
   try {
@@ -1838,19 +2130,20 @@ const aiLoopIterationAiRequest = async options => {
       url
     });
   } catch (error) {
+    const endTimestamp = new Date().toISOString();
     const normalizedError = getError(error);
     await appendVisibleAiErrorMessage({
       error: normalizedError,
       providerId,
       requestId,
       sessionId,
-      timestamp
+      timestamp: endTimestamp
     });
     await appendAiErrorResponse({
       error: normalizedError,
       requestId,
       sessionId,
-      timestamp,
+      timestamp: endTimestamp,
       turnId
     });
     return {
@@ -1858,21 +2151,23 @@ const aiLoopIterationAiRequest = async options => {
       type: 'error'
     };
   }
+  const endTimestamp = new Date().toISOString();
   if (result.type === 'error') {
+    // TODO do this in parallel
     await appendVisibleAiErrorMessage({
       error: result.error,
       providerId,
       requestId,
       sessionId,
       statusCode: result.statusCode,
-      timestamp
+      timestamp: endTimestamp
     });
     await appendAiErrorResponse({
       error: result.error,
       requestId,
       sessionId,
       statusCode: result.statusCode,
-      timestamp,
+      timestamp: endTimestamp,
       turnId
     });
     return {
@@ -1900,15 +2195,16 @@ const aiLoopIterationAiRequest = async options => {
       },
       requestId,
       sessionId,
-      timestamp,
+      timestamp: endTimestamp,
       type: Message
     });
     await appendChatDebugEvent({
       headers: result.headers,
       requestId,
       sessionId,
+      size: result.size,
       statusCode: result.statusCode,
-      timestamp,
+      timestamp: endTimestamp,
       toolCalls: newToolCalls,
       turnId,
       type: AiResponse,
@@ -1931,7 +2227,7 @@ const aiLoopIterationAiRequest = async options => {
       },
       requestId,
       sessionId,
-      timestamp,
+      timestamp: endTimestamp,
       type: Message
     });
   }
@@ -1939,8 +2235,9 @@ const aiLoopIterationAiRequest = async options => {
     headers: result.headers,
     requestId,
     sessionId,
+    size: result.size,
     statusCode: result.statusCode,
-    timestamp,
+    timestamp: endTimestamp,
     toolCalls: newToolCalls,
     turnId,
     type: AiResponse,
@@ -1956,6 +2253,7 @@ const aiLoopIterationAiRequest = async options => {
 
 const getToolCallResults = async toolCalls => {
   return toolCalls.map(toolCall => ({
+    callId: toolCall.id,
     type: 'success',
     value: toolCall.args
   }));
@@ -1990,13 +2288,53 @@ const getRequestId = () => {
   return crypto.randomUUID();
 };
 
-const isHandleSubmitEvent = event => {
-  return event.type === Message || event.type === 'handle-submit';
+const getStoredMessageText = message => {
+  const contentText = (message.content || []).filter(part => (part.type === 'text' || part.type === 'input_text') && typeof part.text === 'string' && part.text.length > 0).map(part => part.text).join('');
+  if (contentText) {
+    return contentText;
+  }
+  if (typeof message.text === 'string') {
+    return message.text;
+  }
+  return '';
+};
+const getStoredMessageParts = message => {
+  const text = getStoredMessageText(message);
+  if (!text) {
+    return [];
+  }
+  return [{
+    text,
+    type: 'input_text'
+  }];
+};
+const isKnownStoredEventType = type => {
+  return type === Message || type === 'chat-message-added' || type === 'handle-submit' || type === AiResponse || type === ToolCallsFinished;
+};
+const getNormalizedStoredEvent = event => {
+  if (!event || typeof event !== 'object') {
+    return undefined;
+  }
+  const type = Reflect.get(event, 'type');
+  if (isKnownStoredEventType(type)) {
+    return event;
+  }
+  const nestedMessage = Reflect.get(event, 'message');
+  if (!nestedMessage || typeof nestedMessage !== 'object' || nestedMessage === event) {
+    return undefined;
+  }
+  return getNormalizedStoredEvent(nestedMessage);
+};
+const isStoredMessageEvent = event => {
+  return event.type === Message || event.type === 'chat-message-added' || event.type === 'handle-submit';
 };
 const getStoredMessage = event => {
   if ('value' in event && typeof event.value === 'string') {
     return {
-      content: event.value,
+      content: [{
+        text: event.value,
+        type: 'input_text'
+      }],
       role: 'user'
     };
   }
@@ -2005,30 +2343,22 @@ const getStoredMessage = event => {
   }
   const {
     attachments = [],
-    content = [],
     role
   } = event.message;
   if (role !== 'assistant' && role !== 'user') {
     return undefined;
   }
-  const text = content.filter(part => part.type === 'text' && typeof part.text === 'string').map(part => part.text).join('');
+  const textParts = getStoredMessageParts(event.message);
   if (attachments.length === 0) {
-    if (!text) {
+    if (textParts.length === 0) {
       return undefined;
     }
     return {
-      content: text,
+      content: textParts,
       role
     };
   }
-  const parts = [];
-  if (text) {
-    parts.push({
-      text,
-      type: 'input_text'
-    });
-  }
-  parts.push(...getAttachmentParts(attachments));
+  const parts = [...textParts, ...getAttachmentParts(attachments)];
   if (parts.length === 0) {
     return undefined;
   }
@@ -2048,8 +2378,12 @@ const getStoredAiLoopState = async (sessionId, fallbackText, fallbackToolCalls,
   const messages = [];
   let toolCalls = fallbackToolCalls;
   let toolCallResults = fallbackToolCallResults;
-  for (const event of events) {
-    if (isHandleSubmitEvent(event)) {
+  for (const storedEvent of events) {
+    const event = getNormalizedStoredEvent(storedEvent);
+    if (!event) {
+      continue;
+    }
+    if (isStoredMessageEvent(event)) {
       const message = getStoredMessage(event);
       if (message) {
         messages.push(message);
@@ -2072,7 +2406,10 @@ const getStoredAiLoopState = async (sessionId, fallbackText, fallbackToolCalls,
   if (messages.length === 0) {
     if (typeof fallbackText === 'string') {
       messages.push({
-        content: fallbackText,
+        content: [{
+          text: fallbackText,
+          type: 'input_text'
+        }],
         role: 'user'
       });
     } else {