assistant-stream 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -7,127 +7,13 @@ import {
   PipeableTransformStream,
   createAssistantStream,
   createAssistantStreamResponse,
-  generateId
-} from "./chunk-OONTWUTM.mjs";
+  generateId,
+  promiseWithResolvers
+} from "./chunk-EDE6WQ2R.mjs";
 import {
-  parsePartialJson
-} from "./chunk-C7JS3OBQ.mjs";
-
-// src/core/effects/ToolExecutionStream.ts
-import sjson from "secure-json-parse";
-
-// src/core/utils/withPromiseOrValue.ts
-function withPromiseOrValue(callback, thenHandler, catchHandler) {
-  try {
-    const promiseOrValue = callback();
-    if (typeof promiseOrValue === "object" && promiseOrValue !== null && "then" in promiseOrValue) {
-      return promiseOrValue.then(thenHandler, catchHandler);
-    } else {
-      thenHandler(promiseOrValue);
-    }
-  } catch (e) {
-    catchHandler(e);
-  }
-}
-
-// src/core/effects/ToolExecutionStream.ts
-var ToolExecutionStream = class extends PipeableTransformStream {
-  constructor(toolCallback) {
-    const toolCallPromises = /* @__PURE__ */ new Map();
-    const toolCallArgsText = {};
-    super((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          if (chunk.type !== "part-finish" || chunk.meta.type !== "tool-call") {
-            controller.enqueue(chunk);
-          }
-          const type = chunk.type;
-          switch (type) {
-            case "text-delta": {
-              if (chunk.meta.type === "tool-call") {
-                const toolCallId = chunk.meta.toolCallId;
-                if (toolCallArgsText[toolCallId] === void 0) {
-                  toolCallArgsText[toolCallId] = chunk.textDelta;
-                } else {
-                  toolCallArgsText[toolCallId] += chunk.textDelta;
-                }
-              }
-              break;
-            }
-            case "tool-call-args-text-finish": {
-              if (chunk.meta.type !== "tool-call") break;
-              const { toolCallId, toolName } = chunk.meta;
-              const argsText = toolCallArgsText[toolCallId];
-              const promise = withPromiseOrValue(
-                () => {
-                  if (!argsText) {
-                    console.log(
-                      "Encountered tool call without argsText, this should never happen"
-                    );
-                    throw new Error(
-                      "Encountered tool call without argsText, this is unexpected."
-                    );
-                  }
-                  let args;
-                  try {
-                    args = sjson.parse(argsText);
-                  } catch (e) {
-                    throw new Error(
-                      `Function parameter parsing failed. ${JSON.stringify(e.message)}`
-                    );
-                  }
-                  return toolCallback({
-                    toolCallId,
-                    toolName,
-                    args
-                  });
-                },
-                (c) => {
-                  if (c === void 0) return;
-                  controller.enqueue({
-                    type: "result",
-                    path: chunk.path,
-                    artifact: c.artifact,
-                    result: c.result,
-                    isError: c.isError
-                  });
-                },
-                (e) => {
-                  controller.enqueue({
-                    type: "result",
-                    path: chunk.path,
-                    result: String(e),
-                    isError: true
-                  });
-                }
-              );
-              if (promise) {
-                toolCallPromises.set(toolCallId, promise);
-              }
-              break;
-            }
-            case "part-finish": {
-              if (chunk.meta.type !== "tool-call") break;
-              const { toolCallId } = chunk.meta;
-              const toolCallPromise = toolCallPromises.get(toolCallId);
-              if (toolCallPromise) {
-                toolCallPromise.then(() => {
-                  controller.enqueue(chunk);
-                });
-              } else {
-                controller.enqueue(chunk);
-              }
-            }
-          }
-        },
-        async flush() {
-          await Promise.all(toolCallPromises.values());
-        }
-      });
-      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform);
-    });
-  }
-};
+  getPartialJsonObjectFieldState,
+  parsePartialJsonObject
+} from "./chunk-PQLDKUPN.mjs";
 
 // src/core/accumulators/assistant-message-accumulator.ts
 var createInitialMessage = () => ({
@@ -251,12 +137,7 @@ var handleTextDelta = (message, chunk) => {
       return { ...part, text: part.text + chunk.textDelta };
     } else if (part.type === "tool-call") {
       const newArgsText = part.argsText + chunk.textDelta;
-      let newArgs;
-      try {
-        newArgs = parsePartialJson(newArgsText);
-      } catch (err) {
-        newArgs = part.args;
-      }
+      const newArgs = parsePartialJsonObject(newArgsText) ?? part.args;
       return { ...part, argsText: newArgsText, args: newArgs };
     } else {
       throw new Error(
@@ -526,7 +407,7 @@ var AssistantMessageStream = class _AssistantMessageStream {
   }
 };
 
-// src/core/ToolResponse.ts
+// src/core/tool/ToolResponse.ts
 var TOOL_RESPONSE_SYMBOL = Symbol.for("aui.tool-response");
 var ToolResponse = class {
   get [TOOL_RESPONSE_SYMBOL]() {
@@ -544,6 +425,505 @@ var ToolResponse = class {
     return typeof obj === "object" && obj !== null && TOOL_RESPONSE_SYMBOL in obj;
   }
 };
+
+// src/core/tool/ToolExecutionStream.ts
+import sjson from "secure-json-parse";
+
+// src/core/utils/withPromiseOrValue.ts
+function withPromiseOrValue(callback, thenHandler, catchHandler) {
+  try {
+    const promiseOrValue = callback();
+    if (typeof promiseOrValue === "object" && promiseOrValue !== null && "then" in promiseOrValue) {
+      return promiseOrValue.then(thenHandler, catchHandler);
+    } else {
+      thenHandler(promiseOrValue);
+    }
+  } catch (e) {
+    catchHandler(e);
+  }
+}
+
+// src/core/tool/ToolCallReader.ts
+function getField(obj, fieldPath) {
+  let current = obj;
+  for (const key of fieldPath) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+var GetHandle = class {
+  resolve;
+  reject;
+  disposed = false;
+  fieldPath;
+  constructor(resolve, reject, fieldPath) {
+    this.resolve = resolve;
+    this.reject = reject;
+    this.fieldPath = fieldPath;
+  }
+  update(args) {
+    if (this.disposed) return;
+    try {
+      if (getPartialJsonObjectFieldState(
+        args,
+        this.fieldPath
+      ) === "complete") {
+        const value = getField(args, this.fieldPath);
+        if (value !== void 0) {
+          this.resolve(value);
+          this.dispose();
+        }
+      }
+    } catch (e) {
+      this.reject(e);
+      this.dispose();
+    }
+  }
+  dispose() {
+    this.disposed = true;
+  }
+};
+var StreamValuesHandle = class {
+  controller;
+  disposed = false;
+  fieldPath;
+  constructor(controller, fieldPath) {
+    this.controller = controller;
+    this.fieldPath = fieldPath;
+  }
+  update(args) {
+    if (this.disposed) return;
+    try {
+      const value = getField(args, this.fieldPath);
+      if (value !== void 0) {
+        this.controller.enqueue(value);
+      }
+      if (getPartialJsonObjectFieldState(
+        args,
+        this.fieldPath
+      ) === "complete") {
+        this.controller.close();
+        this.dispose();
+      }
+    } catch (e) {
+      this.controller.error(e);
+      this.dispose();
+    }
+  }
+  dispose() {
+    this.disposed = true;
+  }
+};
+var StreamTextHandle = class {
+  controller;
+  disposed = false;
+  fieldPath;
+  lastValue = void 0;
+  constructor(controller, fieldPath) {
+    this.controller = controller;
+    this.fieldPath = fieldPath;
+  }
+  update(args) {
+    if (this.disposed) return;
+    try {
+      const value = getField(args, this.fieldPath);
+      if (value !== void 0 && typeof value === "string") {
+        const delta = value.substring(this.lastValue?.length || 0);
+        this.lastValue = value;
+        this.controller.enqueue(delta);
+      }
+      if (getPartialJsonObjectFieldState(
+        args,
+        this.fieldPath
+      ) === "complete") {
+        this.controller.close();
+        this.dispose();
+      }
+    } catch (e) {
+      this.controller.error(e);
+      this.dispose();
+    }
+  }
+  dispose() {
+    this.disposed = true;
+  }
+};
+var ForEachHandle = class {
+  controller;
+  disposed = false;
+  fieldPath;
+  processedIndexes = /* @__PURE__ */ new Set();
+  constructor(controller, fieldPath) {
+    this.controller = controller;
+    this.fieldPath = fieldPath;
+  }
+  update(args) {
+    if (this.disposed) return;
+    try {
+      const array = getField(args, this.fieldPath);
+      if (!Array.isArray(array)) {
+        return;
+      }
+      for (let i = 0; i < array.length; i++) {
+        if (!this.processedIndexes.has(i)) {
+          const elementPath = [...this.fieldPath, i];
+          if (getPartialJsonObjectFieldState(
+            args,
+            elementPath
+          ) === "complete") {
+            this.controller.enqueue(array[i]);
+            this.processedIndexes.add(i);
+          }
+        }
+      }
+      if (getPartialJsonObjectFieldState(
+        args,
+        this.fieldPath
+      ) === "complete") {
+        this.controller.close();
+        this.dispose();
+      }
+    } catch (e) {
+      this.controller.error(e);
+      this.dispose();
+    }
+  }
+  dispose() {
+    this.disposed = true;
+  }
+};
+var ToolCallArgsReaderImpl = class {
+  argTextDeltas;
+  handles = /* @__PURE__ */ new Set();
+  args = parsePartialJsonObject("");
+  constructor(argTextDeltas) {
+    this.argTextDeltas = argTextDeltas;
+    this.processStream();
+  }
+  async processStream() {
+    try {
+      let accumulatedText = "";
+      const reader = this.argTextDeltas.getReader();
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        accumulatedText += value;
+        const parsedArgs = parsePartialJsonObject(accumulatedText);
+        if (parsedArgs !== void 0) {
+          this.args = parsedArgs;
+          for (const handle of this.handles) {
+            handle.update(parsedArgs);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error processing argument stream:", error);
+      for (const handle of this.handles) {
+        handle.dispose();
+      }
+    }
+  }
+  get(...fieldPath) {
+    return new Promise((resolve, reject) => {
+      const handle = new GetHandle(resolve, reject, fieldPath);
+      if (this.args && getPartialJsonObjectFieldState(
+        this.args,
+        fieldPath
+      ) === "complete") {
+        const value = getField(this.args, fieldPath);
+        if (value !== void 0) {
+          resolve(value);
+          return;
+        }
+      }
+      this.handles.add(handle);
+      handle.update(this.args);
+    });
+  }
+  streamValues(...fieldPath) {
+    const simplePath = fieldPath;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const handle = new StreamValuesHandle(controller, simplePath);
+        this.handles.add(handle);
+        handle.update(this.args);
+      },
+      cancel: () => {
+        for (const handle of this.handles) {
+          if (handle instanceof StreamValuesHandle) {
+            handle.dispose();
+            this.handles.delete(handle);
+            break;
+          }
+        }
+      }
+    });
+    return stream;
+  }
+  streamText(...fieldPath) {
+    const simplePath = fieldPath;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const handle = new StreamTextHandle(controller, simplePath);
+        this.handles.add(handle);
+        handle.update(this.args);
+      },
+      cancel: () => {
+        for (const handle of this.handles) {
+          if (handle instanceof StreamTextHandle) {
+            handle.dispose();
+            this.handles.delete(handle);
+            break;
+          }
+        }
+      }
+    });
+    return stream;
+  }
+  forEach(...fieldPath) {
+    const simplePath = fieldPath;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const handle = new ForEachHandle(controller, simplePath);
+        this.handles.add(handle);
+        handle.update(this.args);
+      },
+      cancel: () => {
+        for (const handle of this.handles) {
+          if (handle instanceof ForEachHandle) {
+            handle.dispose();
+            this.handles.delete(handle);
+            break;
+          }
+        }
+      }
+    });
+    return stream;
+  }
+};
+var ToolCallResultReaderImpl = class {
+  constructor(resultPromise) {
+    this.resultPromise = resultPromise;
+  }
+  get() {
+    return this.resultPromise;
+  }
+};
+var ToolCallReaderImpl = class {
+  args;
+  result;
+  writable;
+  resolve;
+  argsText = "";
+  constructor() {
+    const stream = new TransformStream();
+    this.writable = stream.writable;
+    this.args = new ToolCallArgsReaderImpl(stream.readable);
+    const { promise, resolve } = promiseWithResolvers();
+    this.resolve = resolve;
+    this.result = new ToolCallResultReaderImpl(promise);
+  }
+  async appendArgsTextDelta(text) {
+    const writer = this.writable.getWriter();
+    try {
+      await writer.write(text);
+    } catch (err) {
+      console.warn(err);
+    } finally {
+      writer.releaseLock();
+    }
+    this.argsText += text;
+  }
+  setResult(value) {
+    this.resolve(value);
+  }
+};
+
+// src/core/tool/ToolExecutionStream.ts
+var ToolExecutionStream = class extends PipeableTransformStream {
+  constructor(options) {
+    const toolCallPromises = /* @__PURE__ */ new Map();
+    const toolCallControllers = /* @__PURE__ */ new Map();
+    super((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type !== "part-finish" || chunk.meta.type !== "tool-call") {
+            controller.enqueue(chunk);
+          }
+          const type = chunk.type;
+          switch (type) {
+            case "part-start":
+              if (chunk.part.type === "tool-call") {
+                const reader = new ToolCallReaderImpl();
+                toolCallControllers.set(chunk.part.toolCallId, reader);
+                options.streamCall({
+                  reader,
+                  toolCallId: chunk.part.toolCallId,
+                  toolName: chunk.part.toolName
+                });
+              }
+              break;
+            case "text-delta": {
+              if (chunk.meta.type === "tool-call") {
+                const toolCallId = chunk.meta.toolCallId;
+                const controller2 = toolCallControllers.get(toolCallId);
+                if (!controller2)
+                  throw new Error("No controller found for tool call");
+                controller2.appendArgsTextDelta(chunk.textDelta);
+              }
+              break;
+            }
+            case "tool-call-args-text-finish": {
+              if (chunk.meta.type !== "tool-call") break;
+              const { toolCallId, toolName } = chunk.meta;
+              const promise = withPromiseOrValue(
+                () => {
+                  const controller2 = toolCallControllers.get(toolCallId);
+                  if (!controller2) {
+                    console.log(
+                      "Encountered tool call without controller, this should never happen"
+                    );
+                    throw new Error(
+                      "Encountered tool call without controller, this is unexpected."
+                    );
+                  }
+                  let args;
+                  try {
+                    args = sjson.parse(controller2.argsText);
+                  } catch (e) {
+                    throw new Error(
+                      `Function parameter parsing failed. ${JSON.stringify(e.message)}`
+                    );
+                  }
+                  return options.execute({
+                    toolCallId,
+                    toolName,
+                    args
+                  });
+                },
+                (c) => {
+                  if (c === void 0) return;
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    artifact: c.artifact,
+                    result: c.result,
+                    isError: c.isError
+                  });
+                },
+                (e) => {
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    result: String(e),
+                    isError: true
+                  });
+                }
+              );
+              if (promise) {
+                toolCallPromises.set(toolCallId, promise);
+              }
+              break;
+            }
+            case "part-finish": {
+              if (chunk.meta.type !== "tool-call") break;
+              const { toolCallId } = chunk.meta;
+              const toolCallPromise = toolCallPromises.get(toolCallId);
+              if (toolCallPromise) {
+                toolCallPromise.then(() => {
+                  toolCallPromises.delete(toolCallId);
+                  toolCallControllers.delete(toolCallId);
+                  controller.enqueue(chunk);
+                });
+              } else {
+                controller.enqueue(chunk);
+              }
+            }
+          }
+        },
+        async flush() {
+          await Promise.all(toolCallPromises.values());
+        }
+      });
+      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform);
+    });
+  }
+};
+
+// src/core/tool/toolResultStream.ts
+var isStandardSchemaV1 = (schema) => {
+  return typeof schema === "object" && schema !== null && "~standard" in schema && schema["~standard"].version === 1;
+};
+function getToolResponse(tools, abortSignal, toolCall) {
+  const tool = tools?.[toolCall.toolName];
+  if (!tool || !tool.execute) return void 0;
+  const getResult = async (toolExecute) => {
+    let executeFn = toolExecute;
+    if (isStandardSchemaV1(tool.parameters)) {
+      let result2 = tool.parameters["~standard"].validate(toolCall.args);
+      if (result2 instanceof Promise) result2 = await result2;
+      if (result2.issues) {
+        executeFn = tool.experimental_onSchemaValidationError ?? (() => {
+          throw new Error(
+            `Function parameter validation failed. ${JSON.stringify(result2.issues)}`
+          );
+        });
+      }
+    }
+    const result = await executeFn(toolCall.args, {
+      toolCallId: toolCall.toolCallId,
+      abortSignal
+    });
+    if (result instanceof ToolResponse) return result;
+    return new ToolResponse({
+      result: result === void 0 ? "<no result>" : result
+    });
+  };
+  return getResult(tool.execute);
+}
+function getToolStreamResponse(tools, abortSignal, reader, context) {
+  tools?.[context.toolName]?.streamCall?.(reader, {
+    toolCallId: context.toolCallId,
+    abortSignal
+  });
+}
+async function unstable_runPendingTools(message, tools, abortSignal) {
+  for (const part of message.parts) {
+    if (part.type === "tool-call") {
+      const promiseOrUndefined = getToolResponse(tools, abortSignal, part);
+      if (promiseOrUndefined) {
+        const result = await promiseOrUndefined;
+        const updatedParts = message.parts.map((p) => {
+          if (p.type === "tool-call" && p.toolCallId === part.toolCallId) {
+            return {
+              ...p,
+              state: "result",
+              artifact: result.artifact,
+              result: result.result,
+              isError: result.isError
+            };
+          }
+          return p;
+        });
+        message = {
+          ...message,
+          parts: updatedParts,
+          content: updatedParts
+        };
+      }
+    }
+  }
+  return message;
+}
+function toolResultStream(tools, abortSignal) {
+  return new ToolExecutionStream({
+    execute: (toolCall) => getToolResponse(tools, abortSignal, toolCall),
+    streamCall: ({ reader, ...context }) => getToolStreamResponse(tools, abortSignal, reader, context)
+  });
+}
 export {
   AssistantMessageAccumulator,
   AssistantMessageStream,
@@ -555,6 +935,8 @@ export {
   ToolExecutionStream,
   ToolResponse,
   createAssistantStream,
-  createAssistantStreamResponse
+  createAssistantStreamResponse,
+  unstable_runPendingTools,
+  toolResultStream as unstable_toolResultStream
 };
 //# sourceMappingURL=index.mjs.map