assistant-stream 0.1.8 → 0.2.1

package/dist/utils/promiseWithResolvers.js

@@ -1,29 +1,4 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/promiseWithResolvers.ts
-var promiseWithResolvers_exports = {};
-__export(promiseWithResolvers_exports, {
-  promiseWithResolvers: () => promiseWithResolvers
-});
-module.exports = __toCommonJS(promiseWithResolvers_exports);
-var promiseWithResolvers = function() {
+const promiseWithResolvers = function() {
   let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
@@ -33,8 +8,7 @@ var promiseWithResolvers = function() {
   if (!resolve || !reject) throw new Error("Failed to create promise");
   return { promise, resolve, reject };
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   promiseWithResolvers
-});
+};
 //# sourceMappingURL=promiseWithResolvers.js.map

package/dist/utils/promiseWithResolvers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/promiseWithResolvers.ts"],"sourcesContent":["export const promiseWithResolvers = function <T>() {\n  let resolve: ((value: T | PromiseLike<T>) => void) | undefined;\n  let reject: ((reason?: unknown) => void) | undefined;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  if (!resolve || !reject) throw new Error(\"Failed to create promise\");\n  return { promise, resolve, reject };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAM,uBAAuB,WAAe;AACjD,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,MAAI,CAAC,WAAW,CAAC,OAAQ,OAAM,IAAI,MAAM,0BAA0B;AACnE,SAAO,EAAE,SAAS,SAAS,OAAO;AACpC;","names":[]}
+{"version":3,"sources":["../../src/utils/promiseWithResolvers.ts"],"sourcesContent":["export const promiseWithResolvers = function <T>() {\n  let resolve: ((value: T | PromiseLike<T>) => void) | undefined;\n  let reject: ((reason?: unknown) => void) | undefined;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  if (!resolve || !reject) throw new Error(\"Failed to create promise\");\n  return { promise, resolve, reject };\n};\n"],"mappings":"AAAO,MAAM,uBAAuB,WAAe;AACjD,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,MAAI,CAAC,WAAW,CAAC,OAAQ,OAAM,IAAI,MAAM,0BAA0B;AACnE,SAAO,EAAE,SAAS,SAAS,OAAO;AACpC;","names":[]}

package/dist/utils.js

@@ -1,36 +1,13 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  asAsyncIterableStream: () => import_AsyncIterableStream.asAsyncIterableStream,
-  getPartialJsonObjectFieldState: () => import_parse_partial_json_object.getPartialJsonObjectFieldState,
-  parsePartialJsonObject: () => import_parse_partial_json_object.parsePartialJsonObject
-});
-module.exports = __toCommonJS(utils_exports);
-var import_parse_partial_json_object = require("./utils/json/parse-partial-json-object.js");
-var import_AsyncIterableStream = require("./utils/AsyncIterableStream.js");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import {
+  parsePartialJsonObject,
+  getPartialJsonObjectFieldState
+} from "./utils/json/parse-partial-json-object";
+import {
+  asAsyncIterableStream
+} from "./utils/AsyncIterableStream";
+export {
   asAsyncIterableStream,
   getPartialJsonObjectFieldState,
   parsePartialJsonObject
-});
+};
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["export {\n  parsePartialJsonObject,\n  getPartialJsonObjectFieldState,\n} from \"./utils/json/parse-partial-json-object\";\nexport {\n  type AsyncIterableStream,\n  asAsyncIterableStream,\n} from \"./utils/AsyncIterableStream\";\nexport type {\n  ReadonlyJSONValue,\n  ReadonlyJSONArray,\n  ReadonlyJSONObject,\n} from \"./utils/json/json-value\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uCAGO;AACP,iCAGO;","names":[]}
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["export {\n  parsePartialJsonObject,\n  getPartialJsonObjectFieldState,\n} from \"./utils/json/parse-partial-json-object\";\nexport {\n  type AsyncIterableStream,\n  asAsyncIterableStream,\n} from \"./utils/AsyncIterableStream\";\nexport type {\n  ReadonlyJSONValue,\n  ReadonlyJSONArray,\n  ReadonlyJSONObject,\n} from \"./utils/json/json-value\";\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EAEE;AAAA,OACK;","names":[]}

package/package.json

@@ -1,30 +1,28 @@
 {
   "name": "assistant-stream",
-  "version": "0.1.8",
+  "version": "0.2.1",
   "license": "MIT",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "default": "./dist/index.js"
     },
     "./ai-sdk": {
       "types": "./dist/ai-sdk.d.ts",
-      "import": "./dist/ai-sdk.mjs",
-      "require": "./dist/ai-sdk.js"
+      "default": "./dist/ai-sdk.js"
     },
     "./utils": {
       "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.mjs",
-      "require": "./dist/utils.js"
+      "default": "./dist/utils.js"
     }
   },
   "source": "./src/index.ts",
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "src",
     "ai-sdk",
     "utils",
     "README.md"
@@ -47,7 +45,7 @@
   "homepage": "https://www.assistant-ui.com/",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/assistant-ui/assistant-ui.git"
+    "url": "https://github.com/assistant-ui/assistant-ui/tree/main/packages/assistant-stream"
   },
   "bugs": {
     "url": "https://github.com/assistant-ui/assistant-ui/issues"

package/{dist/ai-sdk/index.mjs → src/ai-sdk/index.ts}

@@ -1,19 +1,36 @@
-// src/ai-sdk/index.ts
-import { AssistantTransformStream } from "../core/utils/stream/AssistantTransformStream.mjs";
-var fromStreamText = (stream) => {
-  const toolControllers = /* @__PURE__ */ new Map();
-  let currentToolCallArgsText;
+import type { TextStreamPart, ObjectStreamPart, Tool } from "ai";
+import { AssistantStream } from "../core/AssistantStream";
+import { AssistantTransformStream } from "../core/utils/stream/AssistantTransformStream";
+import { ToolCallStreamController } from "../core/modules/tool-call";
+import { ReadonlyJSONValue } from "../utils/json/json-value";
+
+export const fromStreamText = (
+  stream: ReadableStream<TextStreamPart<Record<string, Tool>>>,
+): AssistantStream => {
+  const toolControllers = new Map<string, ToolCallStreamController>();
+  let currentToolCallArgsText: ToolCallStreamController | undefined;
+
   const endCurrentToolCallArgsText = () => {
     if (!currentToolCallArgsText) return;
     currentToolCallArgsText.argsText.close();
-    currentToolCallArgsText = void 0;
+    currentToolCallArgsText = undefined;
   };
-  const transformer = new AssistantTransformStream({
+
+  const transformer = new AssistantTransformStream<
+    TextStreamPart<Record<string, Tool>>
+  >({
     transform(chunk, controller) {
       const { type } = chunk;
-      if (type !== "tool-call-delta" && type !== "tool-call" && type !== "error" && type !== "tool-result") {
+
+      if (
+        type !== "tool-call-delta" &&
+        type !== "tool-call" &&
+        type !== "error" &&
+        (type as string) !== "tool-result"
+      ) {
         endCurrentToolCallArgsText();
       }
+
       switch (type) {
         case "text-delta": {
           const { textDelta } = chunk;
@@ -29,7 +46,7 @@ var fromStreamText = (stream) => {
           const { toolCallId, toolName } = chunk;
           currentToolCallArgsText = controller.addToolCallPart({
             toolCallId,
-            toolName
+            toolName,
           });
           toolControllers.set(toolCallId, currentToolCallArgsText);
           break;
@@ -41,12 +58,15 @@ var fromStreamText = (stream) => {
           toolController.argsText.append(argsTextDelta);
           break;
         }
-        case "tool-result": {
-          const { toolCallId, result } = chunk;
+        case "tool-result" as string: {
+          const { toolCallId, result } = chunk as unknown as {
+            toolCallId: string;
+            result: ReadonlyJSONValue;
+          };
           const toolController = toolControllers.get(toolCallId);
           if (!toolController) throw new Error("Tool call not found");
           toolController.setResponse({
-            result
+            result,
           });
           toolController.close();
           toolControllers.delete(toolCallId);
@@ -56,18 +76,19 @@ var fromStreamText = (stream) => {
           const { toolCallId, toolName, args } = chunk;
           const toolController = controller.addToolCallPart({
             toolCallId,
-            toolName
+            toolName,
           });
           toolController.argsText.append(JSON.stringify(args));
           toolController.argsText.close();
           toolControllers.set(toolCallId, toolController);
           break;
         }
+
         case "step-start":
           controller.enqueue({
             type: "step-start",
             path: [],
-            messageId: chunk.messageId
+            messageId: chunk.messageId,
           });
           break;
         case "step-finish":
@@ -76,43 +97,49 @@ var fromStreamText = (stream) => {
             path: [],
             finishReason: chunk.finishReason,
             usage: chunk.usage,
-            isContinued: chunk.isContinued
+            isContinued: chunk.isContinued,
           });
           break;
         case "error":
           controller.enqueue({
             type: "error",
             path: [],
-            error: String(chunk.error)
+            error: String(chunk.error),
           });
           break;
+
         case "finish": {
           controller.enqueue({
             type: "message-finish",
             path: [],
             finishReason: chunk.finishReason,
-            usage: chunk.usage
+            usage: chunk.usage,
           });
           break;
         }
+
         case "source":
           controller.appendSource({
             type: "source",
-            ...chunk.source
+            ...chunk.source,
           });
           break;
+
         case "file":
           controller.appendFile({
             type: "file",
             mimeType: chunk.mimeType,
-            data: chunk.base64
+            data: chunk.base64,
           });
           break;
+
         case "reasoning-signature":
         case "redacted-reasoning":
+          // ignore these for now
           break;
+
         default: {
-          const unhandledType = type;
+          const unhandledType: never = type;
           throw new Error(`Unhandled chunk type: ${unhandledType}`);
         }
       }
@@ -122,13 +149,18 @@ var fromStreamText = (stream) => {
         toolController.close();
       }
       toolControllers.clear();
-    }
+    },
   });
+
   return stream.pipeThrough(transformer);
 };
-var fromStreamObject = (stream, toolName) => {
-  let toolCall;
-  const transformer = new AssistantTransformStream({
+
+export const fromStreamObject = (
+  stream: ReadableStream<ObjectStreamPart<unknown>>,
+  toolName: string,
+): AssistantStream => {
+  let toolCall!: ToolCallStreamController;
+  const transformer = new AssistantTransformStream<ObjectStreamPart<unknown>>({
     start(controller) {
       toolCall = controller.addToolCallPart(toolName);
     },
@@ -143,31 +175,30 @@ var fromStreamObject = (stream, toolName) => {
         case "finish": {
           toolCall.argsText.close();
           toolCall.setResponse({
-            result: "{}"
+            result: "{}",
           });
           break;
         }
+
         case "object":
           break;
+
         case "error": {
           controller.enqueue({
             type: "error",
             path: [],
-            error: String(chunk.error)
+            error: String(chunk.error),
           });
           break;
         }
+
         default: {
-          const unhandledType = type;
+          const unhandledType: never = type;
           throw new Error(`Unhandled chunk type: ${unhandledType}`);
         }
       }
-    }
+    },
   });
+
   return stream.pipeThrough(transformer);
 };
-export {
-  fromStreamObject,
-  fromStreamText
-};
-//# sourceMappingURL=index.mjs.map

package/{dist/ai-sdk/language-model.mjs → src/ai-sdk/language-model.ts}

@@ -1,23 +1,31 @@
-// src/ai-sdk/language-model.ts
-import { AssistantTransformStream } from "../core/utils/stream/AssistantTransformStream.mjs";
-function bufferToBase64(buffer) {
+import type { LanguageModelV1StreamPart } from "ai";
+import { AssistantTransformStream } from "../core/utils/stream/AssistantTransformStream";
+import { ToolCallStreamController } from "../core/modules/tool-call";
+
+function bufferToBase64(buffer: Uint8Array) {
   return btoa(String.fromCharCode(...buffer));
 }
-var LanguageModelV1StreamDecoder = class extends AssistantTransformStream {
+
+export class LanguageModelV1StreamDecoder extends AssistantTransformStream<LanguageModelV1StreamPart> {
   constructor() {
-    let currentToolCall;
+    let currentToolCall:
+      | { toolCallId: string; controller: ToolCallStreamController }
+      | undefined;
+
     const endCurrentToolCall = () => {
       if (!currentToolCall) return;
       currentToolCall.controller.argsText.close();
       currentToolCall.controller.close();
-      currentToolCall = void 0;
+      currentToolCall = undefined;
     };
+
     super({
       transform(chunk, controller) {
         const { type } = chunk;
         if (type === "text-delta" || type === "reasoning") {
           endCurrentToolCall();
         }
+
         switch (type) {
           case "text-delta": {
             controller.appendText(chunk.textDelta);
@@ -27,21 +35,27 @@ var LanguageModelV1StreamDecoder = class extends AssistantTransformStream {
             controller.appendReasoning(chunk.textDelta);
             break;
           }
+
           case "source": {
             controller.appendSource({
               type: "source",
-              ...chunk.source
+              ...chunk.source,
             });
             break;
           }
+
           case "file": {
             controller.appendFile({
               type: "file",
               mimeType: chunk.mimeType,
-              data: typeof chunk.data === "string" ? chunk.data : bufferToBase64(chunk.data)
+              data:
+                typeof chunk.data === "string"
+                  ? chunk.data
+                  : bufferToBase64(chunk.data),
             });
             break;
           }
+
           case "tool-call-delta": {
             const { toolCallId, toolName, argsTextDelta } = chunk;
             if (currentToolCall?.toolCallId === toolCallId) {
@@ -52,25 +66,29 @@ var LanguageModelV1StreamDecoder = class extends AssistantTransformStream {
                 toolCallId,
                 controller: controller.addToolCallPart({
                   toolCallId,
-                  toolName
-                })
+                  toolName,
+                }),
               };
               currentToolCall.controller.argsText.append(argsTextDelta);
             }
+
             break;
           }
+
           case "tool-call": {
             const { toolCallId, toolName, args } = chunk;
+
             if (currentToolCall?.toolCallId === toolCallId) {
               currentToolCall.controller.argsText.close();
             } else {
               const toolController = controller.addToolCallPart({
                 toolCallId,
                 toolName,
-                argsText: args
+                argsText: args,
               });
               toolController.close();
             }
+
             break;
           }
           case "finish": {
@@ -78,29 +96,27 @@ var LanguageModelV1StreamDecoder = class extends AssistantTransformStream {
               type: "message-finish",
               finishReason: chunk.finishReason,
               usage: chunk.usage,
-              path: []
+              path: [],
             });
             controller.close();
             break;
           }
+
           case "error":
           case "response-metadata":
           case "reasoning-signature":
           case "redacted-reasoning":
             break;
+
           default: {
-            const unhandledType = type;
+            const unhandledType: never = type;
             throw new Error(`Unhandled chunk type: ${unhandledType}`);
           }
         }
       },
       flush() {
         endCurrentToolCall();
-      }
+      },
     });
   }
-};
-export {
-  LanguageModelV1StreamDecoder
-};
-//# sourceMappingURL=language-model.mjs.map
+}

package/src/ai-sdk.ts

@@ -0,0 +1,2 @@
+export * from "./ai-sdk/index";
+export { LanguageModelV1StreamDecoder } from "./ai-sdk/language-model";

package/src/core/AssistantStream.ts

@@ -0,0 +1,39 @@
+import { AssistantStreamChunk } from "./AssistantStreamChunk";
+
+export type AssistantStream = ReadableStream<AssistantStreamChunk>;
+
+export type AssistantStreamEncoder = ReadableWritablePair<
+  Uint8Array,
+  AssistantStreamChunk
+> & {
+  headers?: Headers;
+};
+
+export const AssistantStream = {
+  toResponse(stream: AssistantStream, transformer: AssistantStreamEncoder) {
+    return new Response(AssistantStream.toByteStream(stream, transformer), {
+      headers: transformer.headers ?? {},
+    });
+  },
+
+  fromResponse(
+    response: Response,
+    transformer: ReadableWritablePair<AssistantStreamChunk, Uint8Array>,
+  ) {
+    return AssistantStream.fromByteStream(response.body!, transformer);
+  },
+
+  toByteStream(
+    stream: AssistantStream,
+    transformer: ReadableWritablePair<Uint8Array, AssistantStreamChunk>,
+  ) {
+    return stream.pipeThrough(transformer);
+  },
+
+  fromByteStream(
+    readable: ReadableStream<Uint8Array>,
+    transformer: ReadableWritablePair<AssistantStreamChunk, Uint8Array>,
+  ) {
+    return readable.pipeThrough(transformer);
+  },
+};

package/src/core/AssistantStreamChunk.ts

@@ -0,0 +1,93 @@
+import { ReadonlyJSONValue } from "../utils/json/json-value";
+
+export type PartInit =
+  | {
+      readonly type: "text" | "reasoning";
+    }
+  | {
+      readonly type: "tool-call";
+      readonly toolCallId: string;
+      readonly toolName: string;
+    }
+  | {
+      readonly type: "source";
+      readonly sourceType: "url";
+      readonly id: string;
+      readonly url: string;
+      readonly title?: string;
+    }
+  | {
+      readonly type: "file";
+      readonly data: string;
+      readonly mimeType: string;
+    };
+
+export type AssistantStreamChunk = { readonly path: readonly number[] } & (
+  | {
+      readonly type: "part-start";
+      readonly part: PartInit;
+    }
+  | {
+      readonly type: "part-finish";
+    }
+  | {
+      readonly type: "tool-call-args-text-finish";
+    }
+  | {
+      readonly type: "text-delta";
+      readonly textDelta: string;
+    }
+  | {
+      readonly type: "annotations";
+      readonly annotations: ReadonlyJSONValue[];
+    }
+  | {
+      readonly type: "data";
+      readonly data: ReadonlyJSONValue[];
+    }
+  | {
+      readonly type: "step-start";
+      readonly messageId: string;
+    }
+  | {
+      readonly type: "step-finish";
+      readonly finishReason:
+        | "stop"
+        | "length"
+        | "content-filter"
+        | "tool-calls"
+        | "error"
+        | "other"
+        | "unknown";
+      readonly usage: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+      };
+      readonly isContinued: boolean;
+    }
+  | {
+      readonly type: "message-finish";
+      readonly finishReason:
+        | "stop"
+        | "length"
+        | "content-filter"
+        | "tool-calls"
+        | "error"
+        | "other"
+        | "unknown";
+      readonly usage: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+      };
+    }
+  | {
+      readonly type: "result";
+      readonly artifact?: ReadonlyJSONValue | undefined;
+      readonly result: ReadonlyJSONValue;
+      readonly isError: boolean;
+    }
+  | {
+      readonly type: "error";
+      readonly error: string;
+    }
+);