@lvce-editor/static-server 0.81.6 → 0.81.7

package/static/{c086cea → 5daed27}/manifest.json

@@ -11,13 +11,13 @@
   "display_override": ["window-controls-overlay", "minimal-ui"],
   "icons": [
     {
-      "src": "/c086cea/icons/pwa-icon-192.png",
+      "src": "/5daed27/icons/pwa-icon-192.png",
       "type": "image/png",
       "sizes": "192x192",
       "purpose": "any maskable"
     },
     {
-      "src": "/c086cea/icons/pwa-icon-512.png",
+      "src": "/5daed27/icons/pwa-icon-512.png",
       "type": "image/png",
       "sizes": "512x512",
       "purpose": "any maskable"

package/static/{c086cea → 5daed27}/packages/about-view-worker/dist/aboutWorkerMain.js

@@ -1281,9 +1281,9 @@ const handleFocusIn = async state => {
   };
 };
 
-const commit = 'c086cea';
+const commit = '5daed27';
 
-const commitDate = '2026-05-18T21:30:28.000Z';
+const commitDate = '2026-05-19T15:11:20.000Z';
 
 const OneSecondAgo = '1 second ago';
 const SomeSecondsAgo = '{PH1} seconds ago';
@@ -1572,7 +1572,7 @@ const getBrowser = () => {
   return `${navigator.userAgent}`;
 };
 
-const version = '0.81.6';
+const version = '0.81.7';
 
 const getDetailStringWeb = () => {
   const now = Date.now();

package/static/{c086cea → 5daed27}/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js

@@ -476,7 +476,7 @@ const register = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-const execute = (command, ...args) => {
+const execute$1 = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -896,7 +896,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
+  const actualExecute = event?.target?.execute || execute$1;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
@@ -1027,7 +1027,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1060,7 +1060,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$3(rpcId, mockRpc);
+      set$4(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1069,22 +1069,25 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
 const {
   invoke: invoke$2,
-  set: set$2
+  set: set$3
 } = create(6010);
 
+const Web = 1;
+
 const ChatStorageWorker = 6003;
+const ChatToolWorker = 6005;
 const RendererWorker = 1;
 
 const {
   invoke: invoke$1,
-  set: set$1
+  set: set$2
 } = create(ChatStorageWorker);
 const appendEvent = async event => {
   return invoke$1('ChatStorage.appendEvent', event);
@@ -1092,6 +1095,13 @@ const appendEvent = async event => {
 
 const {
   invoke,
+  set: set$1
+} = create(ChatToolWorker);
+const execute = async (name, rawArguments, options) => {
+  return invoke('ChatTool.execute', name, rawArguments, options);
+};
+
+const {
   invokeAndTransfer,
   set
 } = create(RendererWorker);
@@ -1099,18 +1109,12 @@ const sendMessagePortToAuthWorker$1 = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker', port, command, rpcId);
 };
-const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
+const sendMessagePortToChatToolWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatToolWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 const sendMessagePortToChatStorageWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort', rpcId);
 };
-const writeFile = async (uri, text) => {
-  await invoke('FileSystem.writeFile', uri, text);
-};
-const getWorkspacePath = () => {
-  return invoke('Workspace.getPath');
-};
 
 const createSession = async options => {
   const {
@@ -1757,6 +1761,12 @@ const getCreatedAt = seed => {
   const suffix = Number.parseInt(getDeterministicHex(`created:${seed}`, 6), 16);
   return mockCreatedAtBase + suffix % 1000;
 };
+const getFunctionCallId = (seed, index) => {
+  return `fc_${getDeterministicHex(`function-call:${seed}:${index}`, 24)}`;
+};
+const getCallId = (seed, index) => {
+  return `call_${getDeterministicHex(`call:${seed}:${index}`, 24)}`;
+};
 const getLastRequestSummary = body => {
   if (!body || typeof body !== 'object') {
     return 'mock-request-summary images=0 text-files=0';
@@ -1805,6 +1815,103 @@ const getModel = body => {
   }
   return model;
 };
+const getToolCallArguments = value => {
+  if (typeof value === 'string') {
+    return value;
+  }
+  return JSON.stringify(value ?? {});
+};
+const parseToolCallDescriptor = value => {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const name = Reflect.get(value, 'name');
+  if (typeof name !== 'string' || !name) {
+    return undefined;
+  }
+  const argumentsValue = Reflect.get(value, 'arguments');
+  const id = Reflect.get(value, 'id');
+  const callId = Reflect.get(value, 'call_id');
+  return {
+    arguments: argumentsValue ?? {},
+    ...(typeof callId === 'string' && callId ? {
+      callId
+    } : {}),
+    ...(typeof id === 'string' && id ? {
+      id
+    } : {}),
+    name
+  };
+};
+const parseMockResponseDescriptor = text => {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return undefined;
+  }
+  const parsedText = Reflect.get(parsed, 'text');
+  const rawToolCall = Reflect.get(parsed, 'toolCall');
+  const rawToolCalls = Reflect.get(parsed, 'toolCalls');
+  const toolCalls = [];
+  const toolCall = parseToolCallDescriptor(rawToolCall);
+  if (toolCall) {
+    toolCalls.push(toolCall);
+  }
+  if (Array.isArray(rawToolCalls)) {
+    for (const rawToolCall of rawToolCalls) {
+      const parsedToolCall = parseToolCallDescriptor(rawToolCall);
+      if (parsedToolCall) {
+        toolCalls.push(parsedToolCall);
+      }
+    }
+  }
+  if (typeof parsedText !== 'string' && toolCalls.length === 0) {
+    return undefined;
+  }
+  return {
+    ...(typeof parsedText === 'string' ? {
+      text: parsedText
+    } : {}),
+    ...(toolCalls.length > 0 ? {
+      toolCalls
+    } : {})
+  };
+};
+const getResponseOutputItems = (seed, outputText, descriptor) => {
+  const outputItems = [];
+  if (descriptor?.toolCalls) {
+    for (let index = 0; index < descriptor.toolCalls.length; index += 1) {
+      const toolCall = descriptor.toolCalls[index];
+      outputItems.push({
+        arguments: getToolCallArguments(toolCall.arguments),
+        call_id: toolCall.callId || getCallId(seed, index),
+        id: toolCall.id || getFunctionCallId(seed, index),
+        name: toolCall.name,
+        status: 'completed',
+        type: 'function_call'
+      });
+    }
+  }
+  if (descriptor?.text !== undefined || outputItems.length === 0) {
+    outputItems.push({
+      content: [{
+        annotations: [],
+        logprobs: [],
+        text: outputText,
+        type: 'output_text'
+      }],
+      id: getMessageId(seed),
+      role: 'assistant',
+      status: 'completed',
+      type: 'message'
+    });
+  }
+  return outputItems;
+};
 const parseSseDataLines = text => {
   const rawEvents = text.split('\n\n');
   const dataLines = [];
@@ -1875,9 +1982,10 @@ const createMockOpenAiResponse = (body, text) => {
       return parsedSseResponse;
     }
   }
+  const descriptor = parseMockResponseDescriptor(text);
   const model = getModel(body);
-  const resolvedText = text === lastRequestSummaryToken ? getLastRequestSummary(body) : text;
-  const seed = getResponseSeed(body, resolvedText);
+  const resolvedText = text === lastRequestSummaryToken ? getLastRequestSummary(body) : descriptor?.text || text;
+  const seed = getResponseSeed(body, descriptor ? JSON.stringify(descriptor) : resolvedText);
   const createdAt = getCreatedAt(seed);
   return {
     background: false,
@@ -1897,18 +2005,7 @@ const createMockOpenAiResponse = (body, text) => {
     model,
     moderation: null,
     object: 'response',
-    output: [{
-      content: [{
-        annotations: [],
-        logprobs: [],
-        text: resolvedText,
-        type: 'output_text'
-      }],
-      id: getMessageId(seed),
-      role: 'assistant',
-      status: 'completed',
-      type: 'message'
-    }],
+    output: getResponseOutputItems(seed, resolvedText, descriptor),
     parallel_tool_calls: true,
     presence_penalty: 0,
     previous_response_id: null,
@@ -1965,60 +2062,96 @@ const takeResponse = () => {
   return response;
 };
 
-let queue = [];
-let waiters = [];
-let finished = false;
-const reset = () => {
-  queue = [];
-  waiters = [];
-  finished = false;
+const defaultRequestId = 'default';
+let streamStates = new Map();
+let preparedRequestIds = [];
+const createState = () => {
+  return {
+    errorResult: undefined,
+    finished: false,
+    queue: [],
+    waiters: []
+  };
+};
+const getOrCreateState = requestId => {
+  const existing = streamStates.get(requestId);
+  if (existing) {
+    return existing;
+  }
+  const state = createState();
+  streamStates.set(requestId, state);
+  return state;
+};
+const enqueuePreparedRequest = requestId => {
+  if (preparedRequestIds.includes(requestId)) {
+    return;
+  }
+  preparedRequestIds.push(requestId);
 };
-const pushChunk = chunk => {
-  if (waiters.length > 0) {
-    const resolve = waiters.shift();
+const getNextPreparedRequestId = () => {
+  return preparedRequestIds.shift() || defaultRequestId;
+};
+const reset = (requestId = defaultRequestId) => {
+  if (requestId === defaultRequestId) {
+    streamStates = new Map();
+    preparedRequestIds = [];
+    streamStates.set(defaultRequestId, createState());
+    return;
+  }
+  streamStates.set(requestId, createState());
+  enqueuePreparedRequest(requestId);
+};
+const pushChunk = (chunk, requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  if (state.waiters.length > 0) {
+    const resolve = state.waiters.shift();
     resolve?.(chunk);
     return;
   }
-  queue.push(chunk);
+  state.queue.push(chunk);
 };
-const finish = () => {
-  finished = true;
-  if (waiters.length === 0) {
+const finish = (requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  state.finished = true;
+  if (state.waiters.length === 0) {
     return;
   }
-  const activeWaiters = waiters;
-  waiters = [];
+  const activeWaiters = [...state.waiters];
+  state.waiters.length = 0;
   for (const resolve of activeWaiters) {
     resolve(undefined);
   }
 };
-const readNextChunk = async () => {
-  if (queue.length > 0) {
-    return queue.shift();
+const readNextChunk = async (requestId = defaultRequestId) => {
+  const state = getOrCreateState(requestId);
+  if (state.queue.length > 0) {
+    return state.queue.shift();
   }
-  if (finished) {
+  if (state.finished) {
     return undefined;
   }
   const {
     promise,
     resolve
   } = Promise.withResolvers();
-  waiters.push(resolve);
+  state.waiters.push(resolve);
   return promise;
 };
 const consumeResponseText = async () => {
-  if (queue.length === 0 && !finished) {
+  const requestId = getNextPreparedRequestId();
+  const state = getOrCreateState(requestId);
+  if (state.queue.length === 0 && !state.finished) {
     return undefined;
   }
   const chunks = [];
   while (true) {
-    const chunk = await readNextChunk();
+    const chunk = await readNextChunk(requestId);
     if (chunk === undefined) {
       break;
     }
     chunks.push(chunk);
   }
-  reset();
+  streamStates.delete(requestId);
   return chunks.join('');
 };
 
@@ -2442,91 +2575,51 @@ const aiLoopIterationAiRequest = async options => {
 const isRecord = value => {
   return !!value && typeof value === 'object';
 };
-const isAbsoluteUri = value => {
-  return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
-};
 const getErrorMessage = error => {
   if (error instanceof Error) {
     return error.message;
   }
   return String(error);
 };
-const executeReadFile = async args => {
-  const uri = typeof args.uri === 'string' ? args.uri : '';
-  if (uri) {
-    const content = await readFile(uri);
-    return {
-      content,
-      uri
-    };
-  }
-  const path = typeof args.path === 'string' ? args.path : '';
-  if (!path) {
-    throw new Error('Missing argument: expected uri or path.');
+const defaultToolOptions = {
+  assetDir: '',
+  platform: Web
+};
+const serializeToolArguments = args => {
+  const serialized = JSON.stringify(args);
+  if (typeof serialized === 'string') {
+    return serialized;
   }
-  const content = await readFile(path);
-  return {
-    content,
-    path
-  };
+  return '{}';
 };
-const executeWriteFile = async args => {
-  const content = typeof args.content === 'string' ? args.content : '';
-  const uri = typeof args.uri === 'string' ? args.uri : '';
-  if (uri) {
-    await writeFile(uri, content);
-    return {
-      ok: true,
-      uri
-    };
+const getToolResponseError = value => {
+  if (!isRecord(value)) {
+    return undefined;
   }
-  const path = typeof args.path === 'string' ? args.path : '';
-  if (!path) {
-    throw new Error('Missing argument: expected uri or path.');
+  if (typeof value.error === 'string' && value.error) {
+    return value.error;
   }
-  await writeFile(path, content);
-  return {
-    ok: true,
-    path
-  };
-};
-const executeListFiles = async args => {
-  const uri = typeof args.uri === 'string' ? args.uri : '';
-  if (!uri || !isAbsoluteUri(uri)) {
-    throw new Error('Invalid argument: uri must be an absolute URI.');
+  if (typeof value.errorMessage === 'string' && value.errorMessage) {
+    return value.errorMessage;
   }
-  const entries = await invoke('FileSystem.readDirWithFileTypes', uri);
-  return {
-    entries,
-    uri
-  };
-};
-const executeGetWorkspaceUri = async () => {
-  const workspaceUri = await getWorkspacePath();
-  return {
-    workspaceUri
-  };
+  return undefined;
 };
 const executeToolCall = async toolCall => {
-  const args = isRecord(toolCall.args) ? toolCall.args : {};
-  switch (toolCall.name) {
-    case 'get_workspace_uri':
-    case 'getWorkspaceUri':
-      return executeGetWorkspaceUri();
-    case 'list_files':
-      return executeListFiles(args);
-    case 'read_file':
-      return executeReadFile(args);
-    case 'write_file':
-      return executeWriteFile(args);
-    default:
-      return toolCall.args;
-  }
+  const rawArguments = serializeToolArguments(toolCall.args);
+  return execute(toolCall.name, rawArguments, defaultToolOptions);
 };
 const getToolCallResults = async toolCalls => {
   return Promise.all(toolCalls.map(async toolCall => {
     try {
       const value = await executeToolCall(toolCall);
+      const error = getToolResponseError(value);
+      if (error) {
+        return {
+          callId: toolCall.id,
+          error,
+          type: 'error'
+        };
+      }
       return {
         callId: toolCall.id,
         type: 'success',
@@ -3166,6 +3259,26 @@ const mockBackendSetResponse = body => {
   setResponse(body);
 };
 
+const mockOpenApiSetResponse = body => {
+  const responses = Array.isArray(body) ? body : [body];
+  if (responses.length === 1) {
+    const serialized = typeof responses[0] === 'string' ? responses[0] : JSON.stringify(responses[0]) || 'null';
+    reset();
+    pushChunk(serialized);
+    finish();
+    return;
+  }
+  reset();
+  for (let index = 0; index < responses.length; index += 1) {
+    const response = responses[index];
+    const requestId = `mock-response-${index + 1}`;
+    const serialized = typeof response === 'string' ? response : JSON.stringify(response) || 'null';
+    reset(requestId);
+    pushChunk(serialized, requestId);
+    finish(requestId);
+  }
+};
+
 const registerMockResponse = mockResponse => {
   reset();
   pushChunk(mockResponse.text);
@@ -3177,6 +3290,7 @@ const commandMap = {
   'ChatCoordinator.handleSubmit': handleSubmit,
   'ChatCoordinator.mockBackendSetHttpErrorResponse': mockBackendSetHttpErrorResponse,
   'ChatCoordinator.mockBackendSetResponse': mockBackendSetResponse,
+  'ChatCoordinator.mockOpenApiSetResponse': mockOpenApiSetResponse,
   'ChatCoordinator.mockOpenApiStreamFinish': finish,
   'ChatCoordinator.mockOpenApiStreamPushChunk': pushChunk,
   'ChatCoordinator.mockOpenApiStreamReset': reset,
@@ -3194,7 +3308,7 @@ const initializeAuthWorker = async () => {
     commandMap: {},
     send: sendMessagePortToAuthWorker
   });
-  set$2(rpc);
+  set$3(rpc);
 };
 
 const listen = async () => {
@@ -3208,7 +3322,14 @@ const listen = async () => {
       return sendMessagePortToChatStorageWorker(port);
     }
   });
-  set$1(s);
+  set$2(s);
+  const t = await create$2({
+    commandMap: {},
+    send(port) {
+      return sendMessagePortToChatToolWorker(port);
+    }
+  });
+  set$1(t);
   await initializeAuthWorker();
 };
 

package/static/{c086cea → 5daed27}/packages/chat-tool-worker/dist/chatToolWorkerMain.js

@@ -2433,7 +2433,7 @@ const executeWriteFileTool = async (args, _options) => {
 
 const parseToolArguments = rawArguments => {
   if (typeof rawArguments !== 'string') {
-    return {};
+    return rawArguments;
   }
   try {
     const parsed = JSON.parse(rawArguments);

package/static/{c086cea → 5daed27}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -2865,7 +2865,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/c086cea/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/5daed27/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -3085,9 +3085,9 @@ const getJson = async url => {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/c086cea' !== 'undefined') {
+  if (typeof '/5daed27' !== 'undefined') {
     // @ts-ignore
-    return '/c086cea';
+    return '/5daed27';
   }
   if (platform === Electron) {
     return '../../../../..';