@browser-ai/web-llm 2.1.4 → 2.1.6

package/dist/index.mjs

@@ -858,7 +858,182 @@ function extractArgumentsDelta(content, state) {
   return delta;
 }
 
-// src/convert-to-webllm-messages.tsx
+// ../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":
@@ -997,7 +1172,7 @@ function convertToWebLLMMessages(prompt) {
   return messages;
 }
 
-// src/web-llm-language-model.ts
+// src/chat/web-llm-language-model.ts
 import {
   CreateWebWorkerMLCEngine,
   MLCEngine
@@ -1060,7 +1235,7 @@ function doesBrowserSupportWebLLM() {
   return checkWebGPU();
 }
 
-// src/web-llm-language-model.ts
+// src/chat/web-llm-language-model.ts
 var WebLLMLanguageModel = class {
   constructor(modelId, options = {}) {
     this.specificationVersion = "v3";
@@ -1214,10 +1389,12 @@ var WebLLMLanguageModel = class {
       top_p: topP,
       seed
     };
-    if (providerOptions?.extra_body) {
+    const webLLMOptions = providerOptions?.[this.provider];
+    const extraBody = webLLMOptions?.extra_body;
+    if (extraBody) {
       requestOptions.extra_body = {
-        enable_thinking: providerOptions.extra_body.enable_thinking,
-        enable_latency_breakdown: providerOptions.extra_body.enable_latency_breakdown
+        enable_thinking: extraBody.enable_thinking,
+        enable_latency_breakdown: extraBody.enable_latency_breakdown
       };
     }
     if (responseFormat?.type === "json") {
@@ -1313,7 +1490,7 @@ var WebLLMLanguageModel = class {
               reasoning: void 0
             }
           },
-          request: { body: { messages: promptMessages, ...requestOptions } },
+          request: { body: { ...requestOptions, messages: promptMessages } },
           warnings
         };
       }
@@ -1349,7 +1526,7 @@ var WebLLMLanguageModel = class {
             total: response.usage?.total_tokens
           }
         },
-        request: { body: { messages: promptMessages, ...requestOptions } },
+        request: { body: { ...requestOptions, messages: promptMessages } },
         warnings
       };
     } catch (error) {
@@ -1504,195 +1681,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 argumentsStreamState = createArgumentsStreamState();
-          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 = "";
-                  argumentsStreamState = createArgumentsStreamState();
-                  insideFence = true;
-                  continue;
-                }
-                if (result.completeFence) {
-                  madeProgress = true;
-                  if (result.safeContent) {
-                    accumulatedFenceContent += result.safeContent;
-                  }
-                  if (toolInputStartEmitted && currentToolCallId) {
-                    const delta2 = extractArgumentsDelta(
-                      accumulatedFenceContent,
-                      argumentsStreamState
-                    );
-                    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 = "";
-                    argumentsStreamState = createArgumentsStreamState();
-                    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 delta2 = extractArgumentsDelta(
-                        accumulatedFenceContent,
-                        argumentsStreamState
-                      );
-                      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 = "";
-                  argumentsStreamState = createArgumentsStreamState();
-                  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 delta2 = extractArgumentsDelta(
-                        accumulatedFenceContent,
-                        argumentsStreamState
-                      );
-                      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;
-                }
-              }
+          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;
             }
-            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);
-            }
-          }
-          if (!finished) {
-            finishStream({ unified: "stop", raw: "stop" });
+          })();
+          const result = await processToolCallStream(
+            chunks,
+            emitTextDelta,
+            controller
+          );
+          if (result.trailingText) {
+            emitTextDelta(result.trailingText);
           }
+          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 {
@@ -1707,12 +1716,12 @@ var WebLLMLanguageModel = class {
     });
     return {
       stream,
-      request: { body: { messages: promptMessages, ...requestOptions } }
+      request: { body: { ...requestOptions, messages: promptMessages } }
     };
   }
 };
 
-// src/web-llm-embedding-model.ts
+// src/embedding/web-llm-embedding-model.ts
 import {
   CreateWebWorkerMLCEngine as CreateWebWorkerMLCEngine2,
   MLCEngine as MLCEngine2