assistant-stream 0.0.26 → 0.0.28

package/dist/index.js

@@ -823,6 +823,10 @@ var AssistantStreamControllerImpl = class {
     this._closeSubscriber = callback;
   }
   _addPart(part, stream) {
+    if (this._append) {
+      this._append.controller.close();
+      this._append = void 0;
+    }
     this.enqueue({
       type: "part-start",
       part,
@@ -839,9 +843,6 @@ var AssistantStreamControllerImpl = class {
   }
   appendText(textDelta) {
     if (this._append?.kind !== "text") {
-      if (this._append) {
-        this._append.controller.close();
-      }
       this._append = {
         kind: "text",
         controller: this.addTextPart()
@@ -851,9 +852,6 @@ var AssistantStreamControllerImpl = class {
   }
   appendReasoning(textDelta) {
     if (this._append?.kind !== "reasoning") {
-      if (this._append) {
-        this._append.controller.close();
-      }
       this._append = {
         kind: "reasoning",
         controller: this.addReasoningPart()
@@ -1000,6 +998,22 @@ function createAssistantStreamResponse(callback) {
 
 // src/core/effects/ToolExecutionStream.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();
@@ -1029,58 +1043,49 @@ var ToolExecutionStream = class extends PipeableTransformStream {
               const argsText = toolCallArgsText[toolCallId];
               if (!argsText)
                 throw new Error("Unexpected tool call without args");
-              const executeTool = () => {
-                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
-                });
-              };
-              let promiseOrUndefined;
-              try {
-                promiseOrUndefined = executeTool();
-              } catch (e) {
-                controller.enqueue({
-                  type: "result",
-                  path: chunk.path,
-                  result: String(e),
-                  isError: true
-                });
-                break;
-              }
-              if (promiseOrUndefined instanceof Promise) {
-                const toolCallPromise = promiseOrUndefined.then((c) => {
+              const promise = withPromiseOrValue(
+                () => {
+                  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;
+                  if (c.artifact !== void 0) {
+                    controller.enqueue({
+                      type: "artifact",
+                      path: chunk.path,
+                      artifact: c.artifact
+                    });
+                  }
                   controller.enqueue({
                     type: "result",
                     path: chunk.path,
-                    result: c,
-                    isError: false
+                    result: c.result,
+                    isError: c.isError
                   });
-                }).catch((e) => {
+                },
+                (e) => {
                   controller.enqueue({
                     type: "result",
                     path: chunk.path,
                     result: String(e),
                     isError: true
                   });
-                });
-                toolCallPromises.set(toolCallId, toolCallPromise);
-              } else if (promiseOrUndefined !== void 0) {
-                controller.enqueue({
-                  type: "result",
-                  path: chunk.path,
-                  result: promiseOrUndefined,
-                  isError: false
-                });
+                }
+              );
+              if (promise) {
+                toolCallPromises.set(toolCallId, promise);
               }
               break;
             }
@@ -1694,8 +1699,10 @@ var handleErrorChunk = (message, chunk) => {
   };
 };
 var AssistantMessageAccumulator = class extends TransformStream {
-  constructor() {
-    let message = createInitialMessage();
+  constructor({
+    initialMessage
+  } = {}) {
+    let message = initialMessage ?? createInitialMessage();
     super({
       transform(chunk, controller) {
         const type = chunk.type;