assistant-stream 0.1.4 → 0.1.6

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { a as AssistantStreamChunk, c as AssistantMessage, d as AssistantStreamEncoder, A as AssistantStream, T as ToolResponse } from './assistant-stream-ISFjQ0mQ.mjs';
-export { e as createAssistantStream, f as createAssistantStreamResponse } from './assistant-stream-ISFjQ0mQ.mjs';
+export { b as AssistantStreamController, e as createAssistantStream, f as createAssistantStreamResponse } from './assistant-stream-ISFjQ0mQ.mjs';
 import { JSONSchema7 } from 'json-schema';
 import { DeepPartial } from 'ai';
 import { A as AsyncIterableStream } from './AsyncIterableStream-C3C8ZoXv.mjs';
@@ -98,12 +98,18 @@ interface ToolCallArgsReader<TArgs> {
      */
     forEach<PathT extends TypePath<TArgs>>(...fieldPath: PathT): TypeAtPath<TArgs, PathT> extends Array<infer U> ? AsyncIterableStream<U> : never;
 }
-interface ToolCallResultReader<TResult> {
-    get: () => Promise<TResult>;
+interface ToolCallResponseReader<TResult> {
+    get: () => Promise<ToolResponse<TResult>>;
 }
 interface ToolCallReader<TArgs, TResult> {
     args: ToolCallArgsReader<TArgs>;
-    result: ToolCallResultReader<TResult>;
+    response: ToolCallResponseReader<TResult>;
+    /**
+     * @deprecated Deprecated. Use `response.get().result` instead.
+     */
+    result: {
+        get: () => Promise<TResult>;
+    };
 }
 type ToolExecutionContext = {
     toolCallId: string;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { a as AssistantStreamChunk, c as AssistantMessage, d as AssistantStreamEncoder, A as AssistantStream, T as ToolResponse } from './assistant-stream-kAoIMgvk.js';
-export { e as createAssistantStream, f as createAssistantStreamResponse } from './assistant-stream-kAoIMgvk.js';
+export { b as AssistantStreamController, e as createAssistantStream, f as createAssistantStreamResponse } from './assistant-stream-kAoIMgvk.js';
 import { JSONSchema7 } from 'json-schema';
 import { DeepPartial } from 'ai';
 import { A as AsyncIterableStream } from './AsyncIterableStream-C3C8ZoXv.js';
@@ -98,12 +98,18 @@ interface ToolCallArgsReader<TArgs> {
      */
     forEach<PathT extends TypePath<TArgs>>(...fieldPath: PathT): TypeAtPath<TArgs, PathT> extends Array<infer U> ? AsyncIterableStream<U> : never;
 }
-interface ToolCallResultReader<TResult> {
-    get: () => Promise<TResult>;
+interface ToolCallResponseReader<TResult> {
+    get: () => Promise<ToolResponse<TResult>>;
 }
 interface ToolCallReader<TArgs, TResult> {
     args: ToolCallArgsReader<TArgs>;
-    result: ToolCallResultReader<TResult>;
+    response: ToolCallResponseReader<TResult>;
+    /**
+     * @deprecated Deprecated. Use `response.get().result` instead.
+     */
+    result: {
+        get: () => Promise<TResult>;
+    };
 }
 type ToolExecutionContext = {
     toolCallId: string;

package/dist/index.js

@@ -2085,17 +2085,17 @@ var ToolCallArgsReaderImpl = class {
     return stream;
   }
 };
-var ToolCallResultReaderImpl = class {
-  constructor(resultPromise) {
-    this.resultPromise = resultPromise;
+var ToolCallResponseReaderImpl = class {
+  constructor(promise) {
+    this.promise = promise;
   }
   get() {
-    return this.resultPromise;
+    return this.promise;
   }
 };
 var ToolCallReaderImpl = class {
   args;
-  result;
+  response;
   writable;
   resolve;
   argsText = "";
@@ -2105,7 +2105,7 @@ var ToolCallReaderImpl = class {
     this.args = new ToolCallArgsReaderImpl(stream.readable);
     const { promise, resolve } = promiseWithResolvers();
     this.resolve = resolve;
-    this.result = new ToolCallResultReaderImpl(promise);
+    this.response = new ToolCallResponseReaderImpl(promise);
   }
   async appendArgsTextDelta(text) {
     const writer = this.writable.getWriter();
@@ -2118,9 +2118,15 @@ var ToolCallReaderImpl = class {
     }
     this.argsText += text;
   }
-  setResult(value) {
+  setResponse(value) {
     this.resolve(value);
   }
+  result = {
+    get: async () => {
+      const response = await this.response.get();
+      return response.result;
+    }
+  };
 };
 
 // src/core/tool/ToolExecutionStream.ts
@@ -2160,20 +2166,22 @@ var ToolExecutionStream = class extends PipeableTransformStream {
             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(
                 () => {
-                  const controller2 = toolCallControllers.get(toolCallId);
-                  if (!controller2) {
+                  if (!streamController.argsText) {
                     console.log(
-                      "Encountered tool call without controller, this should never happen"
+                      "Encountered tool call without args, this should never happen"
                     );
                     throw new Error(
-                      "Encountered tool call without controller, this is unexpected."
+                      "Encountered tool call without args, this is unexpected."
                     );
                   }
                   let args;
                   try {
-                    args = import_secure_json_parse2.default.parse(controller2.argsText);
+                    args = import_secure_json_parse2.default.parse(streamController.argsText);
                   } catch (e) {
                     throw new Error(
                       `Function parameter parsing failed. ${JSON.stringify(e.message)}`
@@ -2187,21 +2195,29 @@ var ToolExecutionStream = class extends PipeableTransformStream {
                 },
                 (c) => {
                   if (c === void 0) return;
-                  controller.enqueue({
-                    type: "result",
-                    path: chunk.path,
+                  const result = new ToolResponse({
                     artifact: c.artifact,
                     result: c.result,
                     isError: c.isError
                   });
-                },
-                (e) => {
+                  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) {