assistant-stream 0.0.18 → 0.0.20

package/dist/index.js

@@ -36,31 +36,199 @@ __export(index_exports, {
   DataStreamEncoder: () => DataStreamEncoder,
   PlainTextDecoder: () => PlainTextDecoder,
   PlainTextEncoder: () => PlainTextEncoder,
-  createAssistantRun: () => createAssistantRun
+  createAssistantStream: () => createAssistantStream,
+  createAssistantStreamResponse: () => createAssistantStreamResponse
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/core/AssistantStream.ts
-var AssistantStream = class _AssistantStream {
-  constructor(readable) {
-    this.readable = readable;
-    this.readable = readable;
+var AssistantStream = {
+  toResponse(stream, transformer) {
+    return new Response(AssistantStream.toByteStream(stream, transformer));
+  },
+  fromResponse(response, transformer) {
+    return AssistantStream.fromByteStream(response.body, transformer);
+  },
+  toByteStream(stream, transformer) {
+    return stream.pipeThrough(transformer);
+  },
+  fromByteStream(readable, transformer) {
+    return readable.pipeThrough(transformer);
   }
-  toResponse(transformer) {
-    return new Response(this.toByteStream(transformer));
+};
+
+// src/core/utils/PipeableTransformStream.ts
+var PipeableTransformStream = class extends TransformStream {
+  constructor(transform) {
+    super();
+    const readable = transform(super.readable);
+    Object.defineProperty(this, "readable", {
+      value: readable,
+      writable: false
+    });
   }
-  static fromResponse(response, transformer) {
-    return _AssistantStream.fromByteStream(response.body, transformer);
+};
+
+// src/core/serialization/DataStream.ts
+var DataStreamEncoder = class {
+  _transformStream;
+  get writable() {
+    return this._transformStream.writable;
   }
-  toByteStream(transformer) {
-    return this.readable.pipeThrough(transformer);
+  get readable() {
+    return this._transformStream.readable;
   }
-  static fromByteStream(readable, transformer) {
-    return new _AssistantStream(readable.pipeThrough(transformer));
+  constructor() {
+    this._transformStream = new PipeableTransformStream((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const type = chunk.type;
+          switch (type) {
+            case "text-delta":
+              controller.enqueue("0:" + JSON.stringify(chunk.textDelta) + "\n");
+              break;
+            case "tool-call-begin":
+              controller.enqueue(
+                "b:" + JSON.stringify({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName
+                }) + "\n"
+              );
+              break;
+            case "tool-call-delta":
+              controller.enqueue(
+                "c:" + JSON.stringify({
+                  toolCallId: chunk.toolCallId,
+                  argsTextDelta: chunk.argsTextDelta
+                }) + "\n"
+              );
+              break;
+            case "tool-result":
+              controller.enqueue(
+                "a:" + JSON.stringify({
+                  toolCallId: chunk.toolCallId,
+                  result: chunk.result
+                }) + "\n"
+              );
+              break;
+            case "error":
+              controller.enqueue(`3:${JSON.stringify(chunk.error)}
+`);
+              break;
+            default:
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+          }
+        }
+      });
+      return readable.pipeThrough(transform).pipeThrough(new TextEncoderStream());
+    });
   }
-  tee() {
-    const [readable1, readable2] = this.readable.tee();
-    return [new _AssistantStream(readable1), new _AssistantStream(readable2)];
+};
+var decodeStreamPart = (part) => {
+  const index = part.indexOf(":");
+  if (index === -1) throw new Error("Invalid stream part");
+  return {
+    type: part.slice(0, index),
+    value: JSON.parse(part.slice(index + 1))
+  };
+};
+var DataStreamDecoder = class {
+  _transformStream;
+  get writable() {
+    return this._transformStream.writable;
+  }
+  get readable() {
+    return this._transformStream.readable;
+  }
+  constructor() {
+    this._transformStream = new PipeableTransformStream((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const { type, value } = decodeStreamPart(chunk);
+          switch (type) {
+            case "0":
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: value
+              });
+              break;
+            case "b": {
+              const { toolCallId, toolName } = value;
+              controller.enqueue({
+                type: "tool-call-begin",
+                toolCallId,
+                toolName
+              });
+              break;
+            }
+            case "c": {
+              const { toolCallId, argsTextDelta } = value;
+              controller.enqueue({
+                type: "tool-call-delta",
+                toolCallId,
+                argsTextDelta
+              });
+              break;
+            }
+            case "a": {
+              const { toolCallId, result } = value;
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId,
+                result
+              });
+              break;
+            }
+            case "9": {
+              const { toolCallId, args } = value;
+              controller.enqueue({
+                type: "tool-call-begin",
+                toolCallId,
+                toolName: toolCallId
+              });
+              controller.enqueue({
+                type: "tool-call-delta",
+                toolCallId,
+                argsTextDelta: JSON.stringify(args)
+              });
+              break;
+            }
+            case "2":
+            case "3":
+            case "8":
+            case "d":
+            case "e": {
+              break;
+            }
+            default:
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+          }
+        }
+      });
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new ChunkByLineStream()).pipeThrough(transform);
+    });
+  }
+};
+var ChunkByLineStream = class extends TransformStream {
+  buffer = "";
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+          controller.enqueue(lines[i]);
+        }
+        this.buffer = lines[lines.length - 1];
+      },
+      flush: (controller) => {
+        if (this.buffer) {
+          controller.enqueue(this.buffer);
+        }
+      }
+    });
   }
 };
 
@@ -89,19 +257,17 @@ var TextStreamControllerImpl = class {
   }
 };
 var createTextStream = (readable) => {
-  return new AssistantStream(
-    new ReadableStream({
-      start(c) {
-        return readable.start?.(new TextStreamControllerImpl(c));
-      },
-      pull(c) {
-        return readable.pull?.(new TextStreamControllerImpl(c));
-      },
-      cancel(c) {
-        return readable.cancel?.(c);
-      }
-    })
-  );
+  return new ReadableStream({
+    start(c) {
+      return readable.start?.(new TextStreamControllerImpl(c));
+    },
+    pull(c) {
+      return readable.pull?.(new TextStreamControllerImpl(c));
+    },
+    cancel(c) {
+      return readable.cancel?.(c);
+    }
+  });
 };
 
 // src/core/modules/tool-call.ts
@@ -119,7 +285,7 @@ var ToolCallStreamControllerImpl = class {
         this._argsTextController = c;
       }
     });
-    stream.readable.pipeTo(
+    stream.pipeTo(
       new WritableStream({
         write: (chunk) => {
           if (chunk.type !== "text-delta")
@@ -159,19 +325,17 @@ var createToolCallStream = (readable) => {
     toolCallId: readable.toolCallId,
     toolName: readable.toolName
   };
-  return new AssistantStream(
-    new ReadableStream({
-      start(c) {
-        return readable.start?.(new ToolCallStreamControllerImpl(c, options));
-      },
-      pull(c) {
-        return readable.pull?.(new ToolCallStreamControllerImpl(c, options));
-      },
-      cancel(c) {
-        return readable.cancel?.(c);
-      }
-    })
-  );
+  return new ReadableStream({
+    start(c) {
+      return readable.start?.(new ToolCallStreamControllerImpl(c, options));
+    },
+    pull(c) {
+      return readable.pull?.(new ToolCallStreamControllerImpl(c, options));
+    },
+    cancel(c) {
+      return readable.cancel?.(c);
+    }
+  });
 };
 
 // src/core/modules/runs.ts
@@ -244,7 +408,7 @@ var createMergeStream = () => {
         throw new Error(
           "Cannot add streams after the run callback has settled."
         );
-      const item = { reader: stream.readable.getReader() };
+      const item = { reader: stream.getReader() };
       list.push(item);
       if (list.length === 1) {
         handlePull(item);
@@ -262,7 +426,7 @@ var RunControllerImpl = class {
     this._merge.seal();
     this._textPartController?.close();
   }
-  appendStep(stream) {
+  merge(stream) {
     this._merge.addStream(stream);
   }
   appendText(textDelta) {
@@ -278,225 +442,68 @@ var RunControllerImpl = class {
         controller = c;
       }
     });
-    this.appendStep(textStream);
+    this.merge(textStream);
     return controller;
   }
   addToolCallPart(options) {
-    const opt = typeof options === "string" ? { toolName: options, toolCallId: generateId() } : options;
+    const opt = typeof options === "string" ? { toolName: options } : options;
     let controller;
     const toolCallStream = createToolCallStream({
-      toolCallId: opt.toolCallId,
+      toolCallId: opt.toolCallId ?? generateId(),
       toolName: opt.toolName,
       start(c) {
         controller = c;
       }
     });
-    this.appendStep(toolCallStream);
+    this.merge(toolCallStream);
+    if (opt.args !== void 0) {
+      controller.argsText.append(JSON.stringify(opt.args));
+      controller.argsText.close();
+    }
+    if (opt !== void 0) {
+      controller.setResult(opt.result);
+    }
     return controller;
   }
   addError(error) {
     this._merge.addStream(
-      new AssistantStream(
-        new ReadableStream({
-          start(c) {
-            c.enqueue({
-              type: "error",
-              error
-            });
-          }
-        })
-      )
+      new ReadableStream({
+        start(c) {
+          c.enqueue({
+            type: "error",
+            error
+          });
+        }
+      })
     );
   }
 };
-function createAssistantRun(callback) {
+function createAssistantStream(callback) {
   const controller = new RunControllerImpl();
   const promiseOrVoid = callback(controller);
   if (promiseOrVoid instanceof Promise) {
-    promiseOrVoid.catch((e) => {
-      controller.addError(e instanceof Error ? e.message : String(e));
-      throw e;
-    }).finally(() => controller.close());
+    const runTask = async () => {
+      try {
+        await promiseOrVoid;
+      } catch (e) {
+        controller.addError(e instanceof Error ? e.message : String(e));
+        throw e;
+      } finally {
+        controller.close();
+      }
+    };
+    runTask();
   } else {
     controller.close();
   }
-  return new AssistantStream(controller.getReadable());
+  return controller.getReadable();
+}
+function createAssistantStreamResponse(callback) {
+  return AssistantStream.toResponse(
+    createAssistantStream(callback),
+    new DataStreamEncoder()
+  );
 }
-
-// src/core/utils/PipeableTransformStream.ts
-var PipeableTransformStream = class extends TransformStream {
-  constructor(transform) {
-    super();
-    const readable = transform(super.readable);
-    Object.defineProperty(this, "readable", {
-      value: readable,
-      writable: false
-    });
-  }
-};
-
-// src/core/serialization/DataStream.ts
-var DataStreamEncoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          const type = chunk.type;
-          switch (type) {
-            case "text-delta":
-              controller.enqueue("0:" + JSON.stringify(chunk.textDelta) + "\n");
-              break;
-            case "tool-call-begin":
-              controller.enqueue(
-                "b:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName
-                }) + "\n"
-              );
-              break;
-            case "tool-call-delta":
-              controller.enqueue(
-                "c:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  argsTextDelta: chunk.argsTextDelta
-                }) + "\n"
-              );
-              break;
-            case "tool-result":
-              controller.enqueue(
-                "a:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  result: chunk.result
-                }) + "\n"
-              );
-              break;
-            case "error":
-              controller.enqueue(`3:${JSON.stringify(chunk.error)}
-`);
-              break;
-            default:
-              const exhaustiveCheck = type;
-              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
-          }
-        }
-      });
-      return readable.pipeThrough(transform).pipeThrough(new TextEncoderStream());
-    });
-  }
-};
-var decodeStreamPart = (part) => {
-  const index = part.indexOf(":");
-  if (index === -1) throw new Error("Invalid stream part");
-  return {
-    type: part.slice(0, index),
-    value: JSON.parse(part.slice(index + 1))
-  };
-};
-var DataStreamDecoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          const { type, value } = decodeStreamPart(chunk);
-          switch (type) {
-            case "0":
-              controller.enqueue({
-                type: "text-delta",
-                textDelta: value
-              });
-              break;
-            case "b": {
-              const { toolCallId, toolName } = value;
-              controller.enqueue({
-                type: "tool-call-begin",
-                toolCallId,
-                toolName
-              });
-              break;
-            }
-            case "c": {
-              const { toolCallId, argsTextDelta } = value;
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallId,
-                argsTextDelta
-              });
-              break;
-            }
-            case "a": {
-              const { toolCallId, result } = value;
-              controller.enqueue({
-                type: "tool-result",
-                toolCallId,
-                result
-              });
-              break;
-            }
-            case "9": {
-              const { toolCallId, args } = value;
-              controller.enqueue({
-                type: "tool-call-begin",
-                toolCallId,
-                toolName: toolCallId
-              });
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallId,
-                argsTextDelta: JSON.stringify(args)
-              });
-              break;
-            }
-            case "2":
-            case "3":
-            case "8":
-            case "d":
-            case "e": {
-              break;
-            }
-            default:
-              const exhaustiveCheck = type;
-              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
-          }
-        }
-      });
-      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new ChunkByLineStream()).pipeThrough(transform);
-    });
-  }
-};
-var ChunkByLineStream = class extends TransformStream {
-  buffer = "";
-  constructor() {
-    super({
-      transform: (chunk, controller) => {
-        this.buffer += chunk;
-        const lines = this.buffer.split("\n");
-        for (let i = 0; i < lines.length - 1; i++) {
-          controller.enqueue(lines[i]);
-        }
-        this.buffer = lines[lines.length - 1];
-      },
-      flush: (controller) => {
-        if (this.buffer) {
-          controller.enqueue(this.buffer);
-        }
-      }
-    });
-  }
-};
 
 // src/core/serialization/PlainText.ts
 var PlainTextEncoder = class {
@@ -1049,7 +1056,7 @@ var AssistantMessageStream = class _AssistantMessageStream {
   }
   static fromAssistantStream(stream) {
     return new _AssistantMessageStream(
-      stream.readable.pipeThrough(assistantMessageAccumulator())
+      stream.pipeThrough(assistantMessageAccumulator())
     );
   }
   async unstable_result() {
@@ -1095,6 +1102,7 @@ var AssistantMessageStream = class _AssistantMessageStream {
   DataStreamEncoder,
   PlainTextDecoder,
   PlainTextEncoder,
-  createAssistantRun
+  createAssistantStream,
+  createAssistantStreamResponse
 });
 //# sourceMappingURL=index.js.map