@browser-ai/web-llm 2.1.3 → 2.1.5

package/dist/index.js

@@ -804,7 +804,267 @@ var ToolCallFenceDetector = class {
   }
 };
 
-// src/convert-to-webllm-messages.tsx
+// ../shared/src/streaming/tool-call-stream-utils.ts
+function extractToolName(content) {
+  const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
+  if (jsonMatch) {
+    return jsonMatch[1];
+  }
+  return null;
+}
+var ARGUMENTS_FIELD_REGEX = /"arguments"\s*:\s*/g;
+var ARGUMENTS_SEARCH_OVERLAP = 32;
+function createArgumentsStreamState() {
+  return {
+    searchFrom: 0,
+    valueStartIndex: null,
+    parseIndex: 0,
+    started: false,
+    depth: 0,
+    inString: false,
+    escaped: false,
+    complete: false
+  };
+}
+function extractArgumentsDelta(content, state) {
+  if (state.complete) {
+    return "";
+  }
+  if (state.valueStartIndex === null) {
+    ARGUMENTS_FIELD_REGEX.lastIndex = state.searchFrom;
+    const match = ARGUMENTS_FIELD_REGEX.exec(content);
+    ARGUMENTS_FIELD_REGEX.lastIndex = 0;
+    if (!match || match.index === void 0) {
+      state.searchFrom = Math.max(0, content.length - ARGUMENTS_SEARCH_OVERLAP);
+      return "";
+    }
+    state.valueStartIndex = match.index + match[0].length;
+    state.parseIndex = state.valueStartIndex;
+    state.searchFrom = state.valueStartIndex;
+  }
+  if (state.parseIndex >= content.length) {
+    return "";
+  }
+  let delta = "";
+  for (let i = state.parseIndex; i < content.length; i++) {
+    const char = content[i];
+    delta += char;
+    if (!state.started) {
+      if (!/\s/.test(char)) {
+        state.started = true;
+        if (char === "{" || char === "[") {
+          state.depth = 1;
+        }
+      }
+      continue;
+    }
+    if (state.escaped) {
+      state.escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      state.escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      state.inString = !state.inString;
+      continue;
+    }
+    if (!state.inString) {
+      if (char === "{" || char === "[") {
+        state.depth += 1;
+      } else if (char === "}" || char === "]") {
+        if (state.depth > 0) {
+          state.depth -= 1;
+          if (state.depth === 0) {
+            state.parseIndex = i + 1;
+            state.complete = true;
+            return delta;
+          }
+        }
+      }
+    }
+  }
+  state.parseIndex = content.length;
+  return delta;
+}
+
+// ../shared/src/streaming/stream-processor.ts
+function generateToolCallId2() {
+  return `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function processToolCallStream(chunks, emitTextDelta, controller, options) {
+  const fenceDetector = new ToolCallFenceDetector();
+  let currentToolCallId = null;
+  let toolInputStartEmitted = false;
+  let accumulatedFenceContent = "";
+  let argumentsStreamState = createArgumentsStreamState();
+  let insideFence = false;
+  let toolCallDetected = false;
+  let toolCalls = [];
+  let trailingText = "";
+  const resetFenceState = () => {
+    currentToolCallId = null;
+    toolInputStartEmitted = false;
+    accumulatedFenceContent = "";
+    argumentsStreamState = createArgumentsStreamState();
+    insideFence = false;
+  };
+  for await (const chunk of chunks) {
+    if (toolCallDetected) {
+      continue;
+    }
+    fenceDetector.addChunk(chunk);
+    while (fenceDetector.hasContent()) {
+      const wasInsideFence = insideFence;
+      const result = fenceDetector.detectStreamingFence();
+      insideFence = result.inFence;
+      let madeProgress = false;
+      if (!wasInsideFence && result.inFence) {
+        if (result.safeContent) {
+          emitTextDelta(result.safeContent);
+          madeProgress = true;
+        }
+        currentToolCallId = generateToolCallId2();
+        toolInputStartEmitted = false;
+        accumulatedFenceContent = "";
+        argumentsStreamState = createArgumentsStreamState();
+        insideFence = true;
+        continue;
+      }
+      if (result.completeFence) {
+        madeProgress = true;
+        if (result.safeContent) {
+          accumulatedFenceContent += result.safeContent;
+        }
+        if (toolInputStartEmitted && currentToolCallId) {
+          const delta = extractArgumentsDelta(
+            accumulatedFenceContent,
+            argumentsStreamState
+          );
+          if (delta.length > 0) {
+            controller.enqueue({
+              type: "tool-input-delta",
+              id: currentToolCallId,
+              delta
+            });
+          }
+        }
+        const parsed = parseJsonFunctionCalls(result.completeFence);
+        const selectedToolCalls = parsed.toolCalls.slice(0, 1);
+        if (selectedToolCalls.length === 0) {
+          emitTextDelta(result.completeFence);
+          if (result.textAfterFence) {
+            emitTextDelta(result.textAfterFence);
+          }
+          resetFenceState();
+          continue;
+        }
+        if (currentToolCallId) {
+          selectedToolCalls[0].toolCallId = currentToolCallId;
+        }
+        for (const [index, call] of selectedToolCalls.entries()) {
+          const toolCallId = index === 0 && currentToolCallId ? currentToolCallId : call.toolCallId;
+          const toolName = call.toolName;
+          const argsJson = JSON.stringify(call.args ?? {});
+          if (toolCallId === currentToolCallId) {
+            if (!toolInputStartEmitted) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: toolCallId,
+                toolName
+              });
+              toolInputStartEmitted = true;
+            }
+            const delta = extractArgumentsDelta(
+              accumulatedFenceContent,
+              argumentsStreamState
+            );
+            if (delta.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCallId,
+                delta
+              });
+            }
+          } else {
+            controller.enqueue({
+              type: "tool-input-start",
+              id: toolCallId,
+              toolName
+            });
+            if (argsJson.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCallId,
+                delta: argsJson
+              });
+            }
+          }
+          controller.enqueue({ type: "tool-input-end", id: toolCallId });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: argsJson,
+            providerExecuted: false
+          });
+        }
+        trailingText = result.textAfterFence ?? "";
+        toolCalls = selectedToolCalls;
+        toolCallDetected = true;
+        resetFenceState();
+        break;
+      }
+      if (insideFence) {
+        if (result.safeContent) {
+          accumulatedFenceContent += result.safeContent;
+          madeProgress = true;
+          const toolName = extractToolName(accumulatedFenceContent);
+          if (toolName && !toolInputStartEmitted && currentToolCallId) {
+            controller.enqueue({
+              type: "tool-input-start",
+              id: currentToolCallId,
+              toolName
+            });
+            toolInputStartEmitted = true;
+          }
+          if (toolInputStartEmitted && currentToolCallId) {
+            const delta = extractArgumentsDelta(
+              accumulatedFenceContent,
+              argumentsStreamState
+            );
+            if (delta.length > 0) {
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: currentToolCallId,
+                delta
+              });
+            }
+          }
+        }
+        continue;
+      }
+      if (!insideFence && result.safeContent) {
+        emitTextDelta(result.safeContent);
+        madeProgress = true;
+      }
+      if (!madeProgress) {
+        break;
+      }
+    }
+    if (toolCallDetected && options?.stopEarlyOnToolCall) {
+      break;
+    }
+  }
+  if (!toolCallDetected && fenceDetector.hasContent()) {
+    emitTextDelta(fenceDetector.getBuffer());
+    fenceDetector.clearBuffer();
+  }
+  return { toolCallDetected, toolCalls, trailingText };
+}
+
+// src/utils/convert-to-webllm-messages.tsx
 function convertToolResultOutput(output) {
   switch (output.type) {
     case "text":
@@ -943,7 +1203,7 @@ function convertToWebLLMMessages(prompt) {
   return messages;
 }
 
-// src/web-llm-language-model.ts
+// src/chat/web-llm-language-model.ts
 var import_web_llm = require("@mlc-ai/web-llm");
 
 // src/utils/prompt-utils.ts
@@ -1003,64 +1263,7 @@ function doesBrowserSupportWebLLM() {
   return checkWebGPU();
 }
 
-// src/web-llm-language-model.ts
-function extractToolName(content) {
-  const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
-  if (jsonMatch) {
-    return jsonMatch[1];
-  }
-  return null;
-}
-function extractArgumentsContent(content) {
-  const match = content.match(/"arguments"\s*:\s*/);
-  if (!match || match.index === void 0) {
-    return "";
-  }
-  const startIndex = match.index + match[0].length;
-  let result = "";
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  let started = false;
-  for (let i = startIndex; i < content.length; i++) {
-    const char = content[i];
-    result += char;
-    if (!started) {
-      if (!/\s/.test(char)) {
-        started = true;
-        if (char === "{" || char === "[") {
-          depth = 1;
-        }
-      }
-      continue;
-    }
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (!inString) {
-      if (char === "{" || char === "[") {
-        depth += 1;
-      } else if (char === "}" || char === "]") {
-        if (depth > 0) {
-          depth -= 1;
-          if (depth === 0) {
-            break;
-          }
-        }
-      }
-    }
-  }
-  return result;
-}
+// src/chat/web-llm-language-model.ts
 var WebLLMLanguageModel = class {
   constructor(modelId, options = {}) {
     this.specificationVersion = "v3";
@@ -1504,208 +1707,27 @@ var WebLLMLanguageModel = class {
             ...options.abortSignal && !useWorker && { signal: options.abortSignal }
           };
           const response = await engine.chat.completions.create(streamingRequest);
-          const fenceDetector = new ToolCallFenceDetector();
-          let accumulatedText = "";
-          let currentToolCallId = null;
-          let toolInputStartEmitted = false;
-          let accumulatedFenceContent = "";
-          let streamedArgumentsLength = 0;
-          let insideFence = false;
-          for await (const chunk of response) {
-            const choice = chunk.choices[0];
-            if (!choice) continue;
-            if (choice.delta.content) {
-              const delta = choice.delta.content;
-              accumulatedText += delta;
-              fenceDetector.addChunk(delta);
-              while (fenceDetector.hasContent()) {
-                const wasInsideFence = insideFence;
-                const result = fenceDetector.detectStreamingFence();
-                insideFence = result.inFence;
-                let madeProgress = false;
-                if (!wasInsideFence && result.inFence) {
-                  if (result.safeContent) {
-                    emitTextDelta(result.safeContent);
-                    madeProgress = true;
-                  }
-                  currentToolCallId = `call_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-                  toolInputStartEmitted = false;
-                  accumulatedFenceContent = "";
-                  streamedArgumentsLength = 0;
-                  insideFence = true;
-                  continue;
-                }
-                if (result.completeFence) {
-                  madeProgress = true;
-                  if (result.safeContent) {
-                    accumulatedFenceContent += result.safeContent;
-                  }
-                  if (toolInputStartEmitted && currentToolCallId) {
-                    const argsContent = extractArgumentsContent(
-                      accumulatedFenceContent
-                    );
-                    if (argsContent.length > streamedArgumentsLength) {
-                      const delta2 = argsContent.slice(streamedArgumentsLength);
-                      streamedArgumentsLength = argsContent.length;
-                      if (delta2.length > 0) {
-                        controller.enqueue({
-                          type: "tool-input-delta",
-                          id: currentToolCallId,
-                          delta: delta2
-                        });
-                      }
-                    }
-                  }
-                  const parsed = parseJsonFunctionCalls(result.completeFence);
-                  const parsedToolCalls = parsed.toolCalls;
-                  const selectedToolCalls = parsedToolCalls.slice(0, 1);
-                  if (selectedToolCalls.length === 0) {
-                    emitTextDelta(result.completeFence);
-                    if (result.textAfterFence) {
-                      emitTextDelta(result.textAfterFence);
-                    }
-                    currentToolCallId = null;
-                    toolInputStartEmitted = false;
-                    accumulatedFenceContent = "";
-                    streamedArgumentsLength = 0;
-                    insideFence = false;
-                    continue;
-                  }
-                  if (selectedToolCalls.length > 0 && currentToolCallId) {
-                    selectedToolCalls[0].toolCallId = currentToolCallId;
-                  }
-                  for (const [index, call] of selectedToolCalls.entries()) {
-                    const toolCallId = index === 0 && currentToolCallId ? currentToolCallId : call.toolCallId;
-                    const toolName = call.toolName;
-                    const argsJson = JSON.stringify(call.args ?? {});
-                    if (toolCallId === currentToolCallId) {
-                      if (!toolInputStartEmitted) {
-                        controller.enqueue({
-                          type: "tool-input-start",
-                          id: toolCallId,
-                          toolName
-                        });
-                        toolInputStartEmitted = true;
-                      }
-                      const argsContent = extractArgumentsContent(
-                        accumulatedFenceContent
-                      );
-                      if (argsContent.length > streamedArgumentsLength) {
-                        const delta2 = argsContent.slice(
-                          streamedArgumentsLength
-                        );
-                        streamedArgumentsLength = argsContent.length;
-                        if (delta2.length > 0) {
-                          controller.enqueue({
-                            type: "tool-input-delta",
-                            id: toolCallId,
-                            delta: delta2
-                          });
-                        }
-                      }
-                    } else {
-                      controller.enqueue({
-                        type: "tool-input-start",
-                        id: toolCallId,
-                        toolName
-                      });
-                      if (argsJson.length > 0) {
-                        controller.enqueue({
-                          type: "tool-input-delta",
-                          id: toolCallId,
-                          delta: argsJson
-                        });
-                      }
-                    }
-                    controller.enqueue({
-                      type: "tool-input-end",
-                      id: toolCallId
-                    });
-                    controller.enqueue({
-                      type: "tool-call",
-                      toolCallId,
-                      toolName,
-                      input: argsJson,
-                      providerExecuted: false
-                    });
-                  }
-                  if (result.textAfterFence) {
-                    emitTextDelta(result.textAfterFence);
-                  }
-                  madeProgress = true;
-                  currentToolCallId = null;
-                  toolInputStartEmitted = false;
-                  accumulatedFenceContent = "";
-                  streamedArgumentsLength = 0;
-                  insideFence = false;
-                  continue;
-                }
-                if (insideFence) {
-                  if (result.safeContent) {
-                    accumulatedFenceContent += result.safeContent;
-                    madeProgress = true;
-                    const toolName = extractToolName(accumulatedFenceContent);
-                    if (toolName && !toolInputStartEmitted && currentToolCallId) {
-                      controller.enqueue({
-                        type: "tool-input-start",
-                        id: currentToolCallId,
-                        toolName
-                      });
-                      toolInputStartEmitted = true;
-                    }
-                    if (toolInputStartEmitted && currentToolCallId) {
-                      const argsContent = extractArgumentsContent(
-                        accumulatedFenceContent
-                      );
-                      if (argsContent.length > streamedArgumentsLength) {
-                        const delta2 = argsContent.slice(
-                          streamedArgumentsLength
-                        );
-                        streamedArgumentsLength = argsContent.length;
-                        if (delta2.length > 0) {
-                          controller.enqueue({
-                            type: "tool-input-delta",
-                            id: currentToolCallId,
-                            delta: delta2
-                          });
-                        }
-                      }
-                    }
-                  }
-                  continue;
-                }
-                if (!insideFence && result.safeContent) {
-                  emitTextDelta(result.safeContent);
-                  madeProgress = true;
-                }
-                if (!madeProgress) {
-                  break;
-                }
-              }
-            }
-            if (choice.finish_reason) {
-              if (fenceDetector.hasContent()) {
-                emitTextDelta(fenceDetector.getBuffer());
-                fenceDetector.clearBuffer();
-              }
-              let finishReason = {
-                unified: "stop",
-                raw: "stop"
-              };
-              if (choice.finish_reason === "abort") {
-                finishReason = { unified: "other", raw: "abort" };
-              } else {
-                const { toolCalls } = parseJsonFunctionCalls(accumulatedText);
-                if (toolCalls.length > 0) {
-                  finishReason = { unified: "tool-calls", raw: "tool-calls" };
-                }
-              }
-              finishStream(finishReason, chunk.usage);
+          let lastUsage;
+          let isAbort = false;
+          const chunks = (async function* () {
+            for await (const chunk of response) {
+              const choice = chunk.choices[0];
+              if (!choice) continue;
+              if (choice.delta.content) yield choice.delta.content;
+              if (chunk.usage) lastUsage = chunk.usage;
+              if (choice.finish_reason === "abort") isAbort = true;
             }
+          })();
+          const result = await processToolCallStream(
+            chunks,
+            emitTextDelta,
+            controller
+          );
+          if (result.trailingText) {
+            emitTextDelta(result.trailingText);
           }
-          if (!finished) {
-            finishStream({ unified: "stop", raw: "stop" });
-          }
+          const finishReason = isAbort ? { unified: "other", raw: "abort" } : result.toolCallDetected ? { unified: "tool-calls", raw: "tool-calls" } : { unified: "stop", raw: "stop" };
+          finishStream(finishReason, lastUsage);
         } catch (error) {
           controller.error(error);
         } finally {
@@ -1725,7 +1747,7 @@ var WebLLMLanguageModel = class {
   }
 };
 
-// src/web-llm-embedding-model.ts
+// src/embedding/web-llm-embedding-model.ts
 var import_web_llm2 = require("@mlc-ai/web-llm");
 var WebLLMEmbeddingModel = class {
   constructor(modelId, options = {}) {