assistant-stream 0.3.15 → 0.3.17

package/dist/core/serialization/ui-message-stream/chunk-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk-types.d.ts","sourceRoot":"","sources":["../../../../src/core/serialization/ui-message-stream/chunk-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,0CAAuC;AAExE,KAAK,YAAY,GACb,MAAM,GACN,QAAQ,GACR,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,OAAO,GACP,SAAS,CAAC;AAEd,KAAK,KAAK,GAAG;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE;QAAE,UAAU,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACxE,GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC1D;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC9B,GACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;CACtB,GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpC,wBAAwB,CAAC;AAE7B,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,QAAQ,MAAM,EAAE,CAAC;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,iBAAiB,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}
+{"version":3,"file":"chunk-types.d.ts","names":[],"sources":["../../../../src/core/serialization/ui-message-stream/chunk-types.ts"],"mappings":";;;KAEK,YAAA;AAAA,KASA,KAAA;EACH,WAAA;EACA,YAAY;AAAA;AAAA,KAGF,oBAAA;EACN,IAAA;EAAe,SAAA;AAAA;EACf,IAAA;EAAoB,EAAA;AAAA;EACpB,IAAA;EAAoB,SAAA;AAAA;EACpB,IAAA;AAAA;EACA,IAAA;EAAyB,EAAA;AAAA;EACzB,IAAA;EAAyB,KAAA;AAAA;EACzB,IAAA;AAAA;EAEA,IAAA;EACA,MAAA;IAAU,UAAA;IAAmB,EAAA;IAAY,GAAA;IAAa,KAAA;EAAA;AAAA;EAEtD,IAAA;EAAc,IAAA;IAAQ,QAAA;IAAkB,IAAA;EAAA;AAAA;EAExC,IAAA;EACA,EAAA;EACA,UAAA;EACA,QAAA;AAAA;EAEA,IAAA;EAAyB,QAAA;AAAA;EACzB,IAAA;AAAA;EAEA,IAAA;EACA,UAAA;EACA,MAAA,EAAQ,iBAAA;EACR,OAAA;EACA,QAAA,GAAW,iBAAA;AAAA;EAEX,IAAA;EAAoB,SAAA;AAAA;EAEpB,IAAA;EACA,YAAA,EAAc,YAAA;EACd,KAAA,EAAO,KAAA;EACP,WAAA;AAAA;EAEA,IAAA;EAAgB,YAAA,EAAc,YAAA;EAAc,KAAA,EAAO,KAAA;AAAA;EACnD,IAAA;EAAe,SAAA;AAAA,IACjB,wBAAA;AAAA,KAEQ,wBAAA;EACV,IAAA;EACA,EAAA;EACA,IAAA,EAAM,iBAAiB;EACvB,SAAA;AAAA"}

package/dist/core/serialization/ui-message-stream/chunk-types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=chunk-types.js.map

package/dist/core/tool/ToolCallReader.d.ts

@@ -1,34 +1,38 @@
-import type { ToolCallArgsReader, ToolCallReader, ToolCallResponseReader } from "./tool-types.js";
-import type { DeepPartial, TypeAtPath, TypePath } from "./type-path-utils.js";
-import type { ToolResponse } from "./ToolResponse.js";
-import type { AsyncIterableStream, ReadonlyJSONObject, ReadonlyJSONValue } from "../../utils.js";
-export declare class ToolCallArgsReaderImpl<T extends ReadonlyJSONObject> implements ToolCallArgsReader<T> {
-    private argTextDeltas;
-    private handles;
-    private args;
-    constructor(argTextDeltas: ReadableStream<string>);
-    private processStream;
-    get<PathT extends TypePath<T>>(...fieldPath: PathT): Promise<TypeAtPath<T, PathT>>;
-    streamValues<PathT extends TypePath<T>>(...fieldPath: PathT): AsyncIterableStream<DeepPartial<TypeAtPath<T, PathT>>>;
-    streamText<PathT extends TypePath<T>>(...fieldPath: PathT): TypeAtPath<T, PathT> extends string & infer U ? AsyncIterableStream<U> : never;
-    forEach<PathT extends TypePath<T>>(...fieldPath: PathT): TypeAtPath<T, PathT> extends Array<infer U> ? AsyncIterableStream<U> : never;
+import { ReadonlyJSONObject, ReadonlyJSONValue } from "../../utils/json/json-value.js";
+import { AsyncIterableStream } from "../../utils/AsyncIterableStream.js";
+import { DeepPartial, TypeAtPath, TypePath } from "./type-path-utils.js";
+import { ToolCallArgsReader, ToolCallReader, ToolCallResponseReader } from "./tool-types.js";
+import { ToolResponse } from "./ToolResponse.js";
+//#region src/core/tool/ToolCallReader.d.ts
+declare class ToolCallArgsReaderImpl<T extends ReadonlyJSONObject> implements ToolCallArgsReader<T> {
+  private argTextDeltas;
+  private handles;
+  private args;
+  constructor(argTextDeltas: ReadableStream<string>);
+  private processStream;
+  get<PathT extends TypePath<T>>(...fieldPath: PathT): Promise<TypeAtPath<T, PathT>>;
+  streamValues<PathT extends TypePath<T>>(...fieldPath: PathT): AsyncIterableStream<DeepPartial<TypeAtPath<T, PathT>>>;
+  streamText<PathT extends TypePath<T>>(...fieldPath: PathT): TypeAtPath<T, PathT> extends string & infer U ? AsyncIterableStream<U> : never;
+  forEach<PathT extends TypePath<T>>(...fieldPath: PathT): TypeAtPath<T, PathT> extends Array<infer U> ? AsyncIterableStream<U> : never;
 }
-export declare class ToolCallResponseReaderImpl<TResult extends ReadonlyJSONValue> implements ToolCallResponseReader<TResult> {
-    private readonly promise;
-    constructor(promise: Promise<ToolResponse<TResult>>);
-    get(): Promise<ToolResponse<TResult>>;
+declare class ToolCallResponseReaderImpl<TResult extends ReadonlyJSONValue> implements ToolCallResponseReader<TResult> {
+  private readonly promise;
+  constructor(promise: Promise<ToolResponse<TResult>>);
+  get(): Promise<ToolResponse<TResult>>;
 }
-export declare class ToolCallReaderImpl<TArgs extends ReadonlyJSONObject, TResult extends ReadonlyJSONValue> implements ToolCallReader<TArgs, TResult> {
-    readonly args: ToolCallArgsReaderImpl<TArgs>;
-    readonly response: ToolCallResponseReaderImpl<TResult>;
-    private readonly writable;
-    private readonly resolve;
-    argsText: string;
-    constructor();
-    appendArgsTextDelta(text: string): Promise<void>;
-    setResponse(value: ToolResponse<TResult>): void;
-    result: {
-        get: () => Promise<TResult>;
-    };
+declare class ToolCallReaderImpl<TArgs extends ReadonlyJSONObject, TResult extends ReadonlyJSONValue> implements ToolCallReader<TArgs, TResult> {
+  readonly args: ToolCallArgsReaderImpl<TArgs>;
+  readonly response: ToolCallResponseReaderImpl<TResult>;
+  private readonly writable;
+  private readonly resolve;
+  argsText: string;
+  constructor();
+  appendArgsTextDelta(text: string): Promise<void>;
+  setResponse(value: ToolResponse<TResult>): void;
+  result: {
+    get: () => Promise<TResult>;
+  };
 }
+//#endregion
+export { ToolCallArgsReaderImpl, ToolCallReaderImpl, ToolCallResponseReaderImpl };
 //# sourceMappingURL=ToolCallReader.d.ts.map

package/dist/core/tool/ToolCallReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolCallReader.d.ts","sourceRoot":"","sources":["../../../src/core/tool/ToolCallReader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACvB,wBAAqB;AACtB,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,6BAA0B;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,0BAAuB;AAEnD,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EAClB,uBAAoB;AAyNrB,qBAAa,sBAAsB,CAAC,CAAC,SAAS,kBAAkB,CAC9D,YAAW,kBAAkB,CAAC,CAAC,CAAC;IAEhC,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,IAAI,CAAuC;gBAEvC,aAAa,EAAE,cAAc,CAAC,MAAM,CAAC;YAKnC,aAAa;IA6B3B,GAAG,CAAC,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,EAC3B,GAAG,SAAS,EAAE,KAAK,GAClB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IA4BhC,YAAY,CAAC,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,EACpC,GAAG,SAAS,EAAE,KAAK,GAClB,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IA2BzD,UAAU,CAAC,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,EAClC,GAAG,SAAS,EAAE,KAAK,GAClB,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,GAC5C,mBAAmB,CAAC,CAAC,CAAC,GACtB,KAAK;IA2BT,OAAO,CAAC,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,EAC/B,GAAG,SAAS,EAAE,KAAK,GAClB,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAC1C,mBAAmB,CAAC,CAAC,CAAC,GACtB,KAAK;CA0BV;AAED,qBAAa,0BAA0B,CAAC,OAAO,SAAS,iBAAiB,CACvE,YAAW,sBAAsB,CAAC,OAAO,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAE7D,GAAG;CAGX;AAED,qBAAa,kBAAkB,CAC7B,KAAK,SAAS,kBAAkB,EAChC,OAAO,SAAS,iBAAiB,CACjC,YAAW,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC;IAEzC,SAAgB,IAAI,EAAE,sBAAsB,CAAC,KAAK,CAAC,CAAC;IACpD,SAAgB,QAAQ,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IAE1D,QAAQ,EAAE,MAAM,CAAM;;IAYvB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAatD,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,IAAI;IAI/C,MAAM;;MAKJ;CACH"}
+{"version":3,"file":"ToolCallReader.d.ts","names":[],"sources":["../../../src/core/tool/ToolCallReader.ts"],"mappings":";;;;;;cA0Oa,sBAAA,WAAiC,kBAAA,aACjC,kBAAA,CAAmB,CAAA;EAAA,QAEtB,aAAA;EAAA,QACA,OAAA;EAAA,QACA,IAAA;cAEI,aAAA,EAAe,cAAA;EAAA,QAKb,aAAA;EA6Bd,GAAA,eAAkB,QAAA,CAAS,CAAA,EAAA,CAAA,GACtB,SAAA,EAAW,KAAA,GACb,OAAA,CAAQ,UAAA,CAAW,CAAA,EAAG,KAAA;EA4BzB,YAAA,eAA2B,QAAA,CAAS,CAAA,EAAA,CAAA,GAC/B,SAAA,EAAW,KAAA,GACb,mBAAA,CAAoB,WAAA,CAAY,UAAA,CAAW,CAAA,EAAG,KAAA;EA2BjD,UAAA,eAAyB,QAAA,CAAS,CAAA,EAAA,CAAA,GAC7B,SAAA,EAAW,KAAA,GACb,UAAA,CAAW,CAAA,EAAG,KAAA,6BACb,mBAAA,CAAoB,CAAA;EA4BxB,OAAA,eAAsB,QAAA,CAAS,CAAA,EAAA,CAAA,GAC1B,SAAA,EAAW,KAAA,GACb,UAAA,CAAW,CAAA,EAAG,KAAA,UAAe,KAAA,YAC5B,mBAAA,CAAoB,CAAA;AAAA;AAAA,cA6Bb,0BAAA,iBAA2C,iBAAA,aAC3C,sBAAA,CAAuB,OAAA;EAAA,iBAEL,OAAA;cAAA,OAAA,EAAS,OAAA,CAAQ,YAAA,CAAa,OAAA;EAEpD,GAAA,CAAA,GAAG,OAAA,CAAA,YAAA,CAAA,OAAA;AAAA;AAAA,cAKC,kBAAA,eACG,kBAAA,kBACE,iBAAA,aACL,cAAA,CAAe,KAAA,EAAO,OAAA;EAAA,SAEjB,IAAA,EAAM,sBAAA,CAAuB,KAAA;EAAA,SAC7B,QAAA,EAAU,0BAAA,CAA2B,OAAA;EAAA,iBACpC,QAAA;EAAA,iBACA,OAAA;EAEV,QAAA;;EAYD,mBAAA,CAAoB,IAAA,WAAe,OAAA;EAazC,WAAA,CAAY,KAAA,EAAO,YAAA,CAAa,OAAA;EAIhC,MAAA"}

package/dist/core/tool/ToolCallReader.js

@@ -1,322 +1,269 @@
 import { promiseWithResolvers } from "../../utils/promiseWithResolvers.js";
-import { parsePartialJsonObject, getPartialJsonObjectFieldState, } from "../../utils/json/parse-partial-json-object.js";
+import { getPartialJsonObjectFieldState, parsePartialJsonObject } from "../../utils/json/parse-partial-json-object.js";
 import { asAsyncIterableStream } from "../../utils/AsyncIterableStream.js";
-// TODO: remove dispose
+//#region src/core/tool/ToolCallReader.ts
 function getField(obj, fieldPath) {
-    let current = obj;
-    for (const key of fieldPath) {
-        if (current === undefined || current === null) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-}
-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();
-        }
-    }
-    dispose() {
-        this.disposed = true;
-    }
-}
-class StreamValuesHandle {
-    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 !== 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();
-            }
-        }
-        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;
-    }
-    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();
-        }
-    }
-    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);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error("Error processing argument stream:", error);
-            // Notify handles of the error
-            for (const handle of this.handles) {
-                handle.dispose();
-            }
-        }
-    }
-    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);
-        }
-        finally {
-            writer.releaseLock();
-        }
-        this.argsText += text;
-    }
-    setResponse(value) {
-        this.resolve(value);
-    }
-    result = {
-        get: async () => {
-            const response = await this.response.get();
-            return response.result;
-        },
-    };
+	let current = obj;
+	for (const key of fieldPath) {
+		if (current === void 0 || current === null) return;
+		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)) {
+				if (getPartialJsonObjectFieldState(args, [...this.fieldPath, i]) === "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;
+		return asAsyncIterableStream(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;
+				}
+			}
+		}));
+	}
+	streamText(...fieldPath) {
+		const simplePath = fieldPath;
+		return asAsyncIterableStream(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;
+				}
+			}
+		}));
+	}
+	forEach(...fieldPath) {
+		const simplePath = fieldPath;
+		return asAsyncIterableStream(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;
+				}
+			}
+		}));
+	}
+};
+var ToolCallResponseReaderImpl = class {
+	promise;
+	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 () => {
+		return (await this.response.get()).result;
+	} };
+};
+//#endregion
+export { ToolCallArgsReaderImpl, ToolCallReaderImpl, ToolCallResponseReaderImpl };
+
 //# sourceMappingURL=ToolCallReader.js.map