assistant-stream 0.2.44 → 0.2.46

package/dist/core/tool/ToolCallReader.js

@@ -1,322 +1,322 @@
-// src/core/tool/ToolCallReader.ts
 import { promiseWithResolvers } from "../../utils/promiseWithResolvers.js";
-import {
-  parsePartialJsonObject,
-  getPartialJsonObjectFieldState
-} from "../../utils/json/parse-partial-json-object.js";
-import {
-  asAsyncIterableStream
-} from "../../utils/index.js";
+import { parsePartialJsonObject, getPartialJsonObjectFieldState, } from "../../utils/json/parse-partial-json-object.js";
+import { asAsyncIterableStream, } from "../../utils.js";
+// TODO: remove dispose
 function getField(obj, fieldPath) {
-  let current = obj;
-  for (const key of fieldPath) {
-    if (current === void 0 || current === null) {
-      return void 0;
+    let current = obj;
+    for (const key of fieldPath) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[key];
     }
-    current = current[key];
-  }
-  return current;
+    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();
+class GetHandle {
+    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 {
+            // Check if the field is complete
+            if (getPartialJsonObjectFieldState(args, this.fieldPath) === "complete") {
+                const value = getField(args, this.fieldPath);
+                if (value !== undefined) {
+                    this.resolve(value);
+                    this.dispose();
+                }
+            }
+        }
+        catch (e) {
+            this.reject(e);
+            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;
     }
-  }
-  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();
+}
+class StreamValuesHandle {
+    controller;
+    disposed = false;
+    fieldPath;
+    constructor(controller, fieldPath) {
+        this.controller = controller;
+        this.fieldPath = fieldPath;
     }
-  }
-  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);
-          }
+    update(args) {
+        if (this.disposed)
+            return;
+        try {
+            const value = getField(args, this.fieldPath);
+            if (value !== undefined) {
+                this.controller.enqueue(value);
+            }
+            // Check if the field is complete, if so close the stream
+            if (getPartialJsonObjectFieldState(args, this.fieldPath) === "complete") {
+                this.controller.close();
+                this.dispose();
+            }
         }
-      }
-      if (getPartialJsonObjectFieldState(
-        args,
-        this.fieldPath
-      ) === "complete") {
-        this.controller.close();
-        this.dispose();
-      }
-    } catch (e) {
-      this.controller.error(e);
-      this.dispose();
+        catch (e) {
+            this.controller.error(e);
+            this.dispose();
+        }
+    }
+    dispose() {
+        this.disposed = true;
+    }
+}
+class StreamTextHandle {
+    controller;
+    disposed = false;
+    fieldPath;
+    lastValue = undefined;
+    constructor(controller, fieldPath) {
+        this.controller = controller;
+        this.fieldPath = fieldPath;
     }
-  }
-  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);
-          }
+    update(args) {
+        if (this.disposed)
+            return;
+        try {
+            const value = getField(args, this.fieldPath);
+            if (value !== undefined && typeof value === "string") {
+                const delta = value.substring(this.lastValue?.length || 0);
+                this.lastValue = value;
+                this.controller.enqueue(delta);
+            }
+            // Check if the field is complete, if so close the stream
+            if (getPartialJsonObjectFieldState(args, this.fieldPath) === "complete") {
+                this.controller.close();
+                this.dispose();
+            }
+        }
+        catch (e) {
+            this.controller.error(e);
+            this.dispose();
+        }
+    }
+    dispose() {
+        this.disposed = true;
+    }
+}
+class ForEachHandle {
+    controller;
+    disposed = false;
+    fieldPath;
+    processedIndexes = 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;
+            }
+            // Check each array element and emit completed ones that haven't been processed
+            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);
+                    }
+                }
+            }
+            // Check if the entire array is complete
+            if (getPartialJsonObjectFieldState(args, this.fieldPath) === "complete") {
+                this.controller.close();
+                this.dispose();
+            }
+        }
+        catch (e) {
+            this.controller.error(e);
+            this.dispose();
         }
-      }
-    } 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;
+    dispose() {
+        this.disposed = true;
+    }
+}
+// Implementation of ToolCallReader that uses stream of partial JSON
+export class ToolCallArgsReaderImpl {
+    argTextDeltas;
+    handles = 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 !== undefined) {
+                    this.args = parsedArgs;
+                    // Notify all handles of the updated args
+                    for (const handle of this.handles) {
+                        handle.update(parsedArgs);
+                    }
+                }
+            }
         }
-      }
-      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;
-          }
+        catch (error) {
+            console.error("Error processing argument stream:", error);
+            // Notify handles of the error
+            for (const handle of this.handles) {
+                handle.dispose();
+            }
         }
-      }
-    });
-    return asAsyncIterableStream(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;
-          }
+    }
+    get(...fieldPath) {
+        return new Promise((resolve, reject) => {
+            const handle = new GetHandle(resolve, reject, fieldPath);
+            // Check if the field is already complete in current args
+            if (this.args &&
+                getPartialJsonObjectFieldState(this.args, fieldPath) === "complete") {
+                const value = getField(this.args, fieldPath);
+                if (value !== undefined) {
+                    resolve(value);
+                    return;
+                }
+            }
+            this.handles.add(handle);
+            handle.update(this.args);
+        });
+    }
+    streamValues(...fieldPath) {
+        // Use a type assertion to convert the complex TypePath to a simple array
+        const simplePath = fieldPath;
+        const stream = new ReadableStream({
+            start: (controller) => {
+                const handle = new StreamValuesHandle(controller, simplePath);
+                this.handles.add(handle);
+                // Check current args immediately
+                handle.update(this.args);
+            },
+            cancel: () => {
+                // Find and dispose the corresponding handle
+                for (const handle of this.handles) {
+                    if (handle instanceof StreamValuesHandle) {
+                        handle.dispose();
+                        this.handles.delete(handle);
+                        break;
+                    }
+                }
+            },
+        });
+        return asAsyncIterableStream(stream);
+    }
+    streamText(...fieldPath) {
+        // Use a type assertion to convert the complex TypePath to a simple array
+        const simplePath = fieldPath;
+        const stream = new ReadableStream({
+            start: (controller) => {
+                const handle = new StreamTextHandle(controller, simplePath);
+                this.handles.add(handle);
+                // Check current args immediately
+                handle.update(this.args);
+            },
+            cancel: () => {
+                // Find and dispose the corresponding handle
+                for (const handle of this.handles) {
+                    if (handle instanceof StreamTextHandle) {
+                        handle.dispose();
+                        this.handles.delete(handle);
+                        break;
+                    }
+                }
+            },
+        });
+        return asAsyncIterableStream(stream);
+    }
+    forEach(...fieldPath) {
+        // Use a type assertion to convert the complex TypePath to a simple array
+        const simplePath = fieldPath;
+        const stream = new ReadableStream({
+            start: (controller) => {
+                const handle = new ForEachHandle(controller, simplePath);
+                this.handles.add(handle);
+                // Check current args immediately
+                handle.update(this.args);
+            },
+            cancel: () => {
+                // Find and dispose the corresponding handle
+                for (const handle of this.handles) {
+                    if (handle instanceof ForEachHandle) {
+                        handle.dispose();
+                        this.handles.delete(handle);
+                        break;
+                    }
+                }
+            },
+        });
+        return asAsyncIterableStream(stream);
+    }
+}
+export class ToolCallResponseReaderImpl {
+    promise;
+    constructor(promise) {
+        this.promise = promise;
+    }
+    get() {
+        return this.promise;
+    }
+}
+export class ToolCallReaderImpl {
+    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);
         }
-      }
-    });
-    return asAsyncIterableStream(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;
-          }
+        finally {
+            writer.releaseLock();
         }
-      }
-    });
-    return asAsyncIterableStream(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;
     }
-    this.argsText += text;
-  }
-  setResponse(value) {
-    this.resolve(value);
-  }
-  result = {
-    get: async () => {
-      const response = await this.response.get();
-      return response.result;
+    setResponse(value) {
+        this.resolve(value);
     }
-  };
-};
-export {
-  ToolCallArgsReaderImpl,
-  ToolCallReaderImpl,
-  ToolCallResponseReaderImpl
-};
+    result = {
+        get: async () => {
+            const response = await this.response.get();
+            return response.result;
+        },
+    };
+}
 //# sourceMappingURL=ToolCallReader.js.map