assistant-stream 0.1.3 → 0.1.5

package/dist/index.js

@@ -40,7 +40,9 @@ __export(index_exports, {
   ToolExecutionStream: () => ToolExecutionStream,
   ToolResponse: () => ToolResponse,
   createAssistantStream: () => createAssistantStream,
-  createAssistantStreamResponse: () => createAssistantStreamResponse
+  createAssistantStreamResponse: () => createAssistantStreamResponse,
+  unstable_runPendingTools: () => unstable_runPendingTools,
+  unstable_toolResultStream: () => toolResultStream
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -62,16 +64,19 @@ var AssistantStream = {
   }
 };
 
-// src/core/utils/stream/merge.ts
-var promiseWithResolvers = () => {
+// src/utils/promiseWithResolvers.ts
+var promiseWithResolvers = function() {
   let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
     resolve = res;
     reject = rej;
   });
+  if (!resolve || !reject) throw new Error("Failed to create promise");
   return { promise, resolve, reject };
 };
+
+// src/core/utils/stream/merge.ts
 var createMergeStream = () => {
   const list = [];
   let sealed = false;
@@ -952,18 +957,8 @@ function createAssistantStream(callback) {
   }
   return controller.__internal_getReadable();
 }
-var promiseWithResolvers2 = function() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  if (!resolve || !reject) throw new Error("Failed to create promise");
-  return { promise, resolve, reject };
-};
 function createAssistantStreamController() {
-  const { resolve, promise } = promiseWithResolvers2();
+  const { resolve, promise } = promiseWithResolvers();
   let controller;
   const stream = createAssistantStream((c) => {
     controller = c;
@@ -981,126 +976,10 @@ function createAssistantStreamResponse(callback) {
   );
 }
 
-// src/core/effects/ToolExecutionStream.ts
+// src/utils/json/parse-partial-json-object.ts
 var import_secure_json_parse = __toESM(require("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 = import_secure_json_parse.default.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);
-    });
-  }
-};
-
-// src/core/utils/json/parse-partial-json-object.ts
-var import_secure_json_parse2 = __toESM(require("secure-json-parse"));
-
-// src/core/utils/json/fix-json.ts
+// src/utils/json/fix-json.ts
 function fixJson(input) {
   const stack = ["ROOT"];
   let lastValidIndex = -1;
@@ -1459,17 +1338,20 @@ function fixJson(input) {
   return [result, path];
 }
 
-// src/core/utils/json/parse-partial-json-object.ts
+// src/utils/json/parse-partial-json-object.ts
 var PARTIAL_JSON_OBJECT_META_SYMBOL = Symbol(
   "aui.parse-partial-json-object.meta"
 );
+var getPartialJsonObjectMeta = (obj) => {
+  return obj?.[PARTIAL_JSON_OBJECT_META_SYMBOL];
+};
 var parsePartialJsonObject = (json) => {
   if (json.length === 0)
     return {
       [PARTIAL_JSON_OBJECT_META_SYMBOL]: { state: "partial", partialPath: [] }
     };
   try {
-    const res = import_secure_json_parse2.default.parse(json);
+    const res = import_secure_json_parse.default.parse(json);
     if (typeof res !== "object" || res === null)
       throw new Error("argsText is expected to be an object");
     res[PARTIAL_JSON_OBJECT_META_SYMBOL] = {
@@ -1480,7 +1362,7 @@ var parsePartialJsonObject = (json) => {
   } catch {
     try {
       const [fixedJson, partialPath] = fixJson(json);
-      const res = import_secure_json_parse2.default.parse(fixedJson);
+      const res = import_secure_json_parse.default.parse(fixedJson);
       if (typeof res !== "object" || res === null)
         throw new Error("argsText is expected to be an object");
       res[PARTIAL_JSON_OBJECT_META_SYMBOL] = {
@@ -1493,6 +1375,26 @@ var parsePartialJsonObject = (json) => {
     }
   }
 };
+var getFieldState = (parent, parentMeta, fieldPath) => {
+  if (typeof parent !== "object" || parent === null) return parentMeta.state;
+  if (parentMeta.state === "complete") return "complete";
+  if (fieldPath.length === 0) return parentMeta.state;
+  const [field, ...restPath] = fieldPath;
+  if (!Object.prototype.hasOwnProperty.call(parent, field)) return "partial";
+  const [partialField, ...restPartialPath] = parentMeta.partialPath;
+  if (field !== partialField) return "complete";
+  const child = parent[field];
+  const childMeta = {
+    state: "partial",
+    partialPath: restPartialPath
+  };
+  return getFieldState(child, childMeta, restPath);
+};
+var getPartialJsonObjectFieldState = (obj, fieldPath) => {
+  const meta = getPartialJsonObjectMeta(obj);
+  if (!meta) throw new Error("unable to determine object state");
+  return getFieldState(obj, meta, fieldPath.map(String));
+};
 
 // src/core/accumulators/assistant-message-accumulator.ts
 var createInitialMessage = () => ({
@@ -1886,7 +1788,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]() {
@@ -1904,6 +1806,521 @@ var ToolResponse = class {
     return typeof obj === "object" && obj !== null && TOOL_RESPONSE_SYMBOL in obj;
   }
 };
+
+// src/core/tool/ToolExecutionStream.ts
+var import_secure_json_parse2 = __toESM(require("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 ToolCallResponseReaderImpl = class {
+  constructor(promise) {
+    this.promise = promise;
+  }
+  get() {
+    return this.promise;
+  }
+};
+var ToolCallReaderImpl = class {
+  args;
+  response;
+  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.response = new ToolCallResponseReaderImpl(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;
+  }
+  setResponse(value) {
+    this.resolve(value);
+  }
+  result = {
+    get: async () => {
+      const response = await this.response.get();
+      return response.result;
+    }
+  };
+};
+
+// 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 streamController = toolCallControllers.get(toolCallId);
+              if (!streamController)
+                throw new Error("No controller found for tool call");
+              const promise = withPromiseOrValue(
+                () => {
+                  if (!streamController.argsText) {
+                    console.log(
+                      "Encountered tool call without args, this should never happen"
+                    );
+                    throw new Error(
+                      "Encountered tool call without args, this is unexpected."
+                    );
+                  }
+                  let args;
+                  try {
+                    args = import_secure_json_parse2.default.parse(streamController.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;
+                  const result = new ToolResponse({
+                    artifact: c.artifact,
+                    result: c.result,
+                    isError: c.isError
+                  });
+                  streamController.setResponse(result);
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    ...result
+                  });
+                },
+                (e) => {
+                  const result = new ToolResponse({
+                    result: String(e),
+                    isError: true
+                  });
+                  streamController.setResponse(result);
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    ...result
+                  });
+                }
+              );
+              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)
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssistantMessageAccumulator,
@@ -1916,6 +2333,8 @@ var ToolResponse = class {
   ToolExecutionStream,
   ToolResponse,
   createAssistantStream,
-  createAssistantStreamResponse
+  createAssistantStreamResponse,
+  unstable_runPendingTools,
+  unstable_toolResultStream
 });
 //# sourceMappingURL=index.js.map