streamfold 0.1.4 → 0.1.5

package/src/internal/wasm-runtime.js

@@ -1,4 +1,5 @@
 import { wasmBinaryBase64 } from "./wasm-binary.js";
+import { streamError } from "./errors.js";
 
 const DEPTH_MASK = 0x00ff_ffff;
 const COMPLETE_FLAG = 1 << 24;
@@ -36,7 +37,7 @@ const getExports = () => {
   return exports;
 };
 
-const parserError = ({ wasm, handle, maxBytes, maxDepth }, code) => {
+const describeParserError = ({ wasm, handle, maxBytes, maxDepth }, code) => {
   const offset = wasm.streamfold_parser_error_offset(handle) >>> 0;
   const byte = wasm.streamfold_parser_error_byte(handle);
   if (code === 1) {
@@ -61,6 +62,28 @@ const parserError = ({ wasm, handle, maxBytes, maxDepth }, code) => {
   return new SyntaxError(`Rust parser failed with error code ${code}`);
 };
 
+const parserErrorCodes = [
+  "PARSER_ERROR",
+  "UNEXPECTED_TOKEN",
+  "MISMATCHED_CLOSING",
+  "TRAILING_DATA",
+  "EMPTY_INPUT",
+  "INCOMPLETE_JSON",
+  "INVALID_JSON",
+  "MAX_BYTES_EXCEEDED",
+  "MAX_DEPTH_EXCEEDED",
+];
+
+const parserError = (parser, code) =>
+  streamError(
+    describeParserError(parser, code),
+    parserErrorCodes[code] ?? "PARSER_ERROR",
+    {
+      byteOffset:
+        parser.wasm.streamfold_parser_error_offset(parser.handle) >>> 0,
+    },
+  );
+
 const readState = (parser, encoded) => {
   const { wasm, handle } = parser;
   const error = encoded >>> ERROR_SHIFT;
@@ -190,6 +213,12 @@ const pushChunk = (parser, chunk) => {
 };
 
 export const pushWasmParser = (parser, chunk) => {
+  if (typeof chunk !== "string") {
+    throw streamError(
+      new TypeError("A structured stream chunk must be a string"),
+      "INVALID_CHUNK",
+    );
+  }
   let input = parser.pendingHighSurrogate + chunk;
   parser.pendingHighSurrogate = "";
 
@@ -217,10 +246,7 @@ export const finishWasmParser = (parser) => {
 };
 
 export const readWasmParser = (parser) =>
-  readState(
-    parser,
-    parser.wasm.streamfold_parser_state(parser.handle),
-  );
+  readState(parser, parser.wasm.streamfold_parser_state(parser.handle));
 
 export const freeWasmParser = ({ wasm, handle }) => {
   wasm.streamfold_parser_free(handle);

package/src/langchain.d.ts

@@ -1,6 +1,7 @@
 import type {
-  EventStructuredStream,
-  StructuredStreamIntegration,
+  BatchEventStructuredStream,
+  BatchStructuredStreamIntegration,
+  StructuredStreamIntegrationOptions,
   StructuredStreamPool,
 } from "./index.js";
 
@@ -16,11 +17,12 @@ export interface LangChainToolCallMessage {
   readonly tool_call_chunks?: readonly LangChainToolCallChunk[];
 }
 
-export const langchain: StructuredStreamIntegration<
+export const langchain: BatchStructuredStreamIntegration<
   LangChainToolCallMessage,
   string
 >;
 
 export function createStructuredStream(
   pool?: StructuredStreamPool<string>,
-): EventStructuredStream<LangChainToolCallMessage, string>;
+  options?: StructuredStreamIntegrationOptions,
+): BatchEventStructuredStream<LangChainToolCallMessage, string>;

package/src/langchain.js

@@ -1,22 +1,24 @@
 import { createStructuredStreamPool } from "./index.js";
 import { createIntegration } from "./internal/integration.js";
 
-export const langchain = (pool = createStructuredStreamPool()) => {
+export const langchain = (pool = createStructuredStreamPool(), options) => {
   const idsByIndex = new Map();
 
   return createIntegration(
     pool,
-    (message) => {
+    (message, calls) => {
       let update;
       for (const chunk of message.tool_call_chunks ?? []) {
         let id = idsByIndex.get(chunk.index);
         if (id === undefined && chunk.id) {
           id = chunk.id;
           idsByIndex.set(chunk.index, id);
-          update = pool.start(id);
+          update = calls.start(id);
         }
         if (id !== undefined && chunk.args) {
-          update = pool.push(id, chunk.args);
+          update = calls.push(id, chunk.args);
+        } else if (id === undefined && chunk.args) {
+          calls.unmatched("Arguments delta has no matching tool call index");
         }
       }
       return update;
@@ -25,6 +27,8 @@ export const langchain = (pool = createStructuredStreamPool()) => {
       for (const id of idsByIndex.values()) complete(id);
       idsByIndex.clear();
     },
+    "langchain",
+    options,
   );
 };
 

package/src/openai.d.ts

@@ -1,6 +1,7 @@
 import type {
-  EventStructuredStream,
-  StructuredStreamIntegration,
+  BatchEventStructuredStream,
+  BatchStructuredStreamIntegration,
+  StructuredStreamIntegrationOptions,
   StructuredStreamPool,
 } from "./index.js";
 
@@ -27,11 +28,12 @@ export type OpenAiResponsesToolEvent =
       readonly [key: string]: unknown;
     };
 
-export const openAI: StructuredStreamIntegration<
+export const openAI: BatchStructuredStreamIntegration<
   OpenAiResponsesToolEvent,
   string
 >;
 
 export function createStructuredStream(
   pool?: StructuredStreamPool<string>,
-): EventStructuredStream<OpenAiResponsesToolEvent, string>;
+  options?: StructuredStreamIntegrationOptions,
+): BatchEventStructuredStream<OpenAiResponsesToolEvent, string>;

package/src/openai.js

@@ -1,20 +1,27 @@
 import { createStructuredStreamPool } from "./index.js";
 import { append, createIntegration } from "./internal/integration.js";
 
-export const openAI = (pool = createStructuredStreamPool()) =>
-  createIntegration(pool, (event, complete) => {
-    if (event.type === "response.output_item.added") {
-      if (event.item.type !== "function_call") return undefined;
-      return pool.start(event.item.id);
-    }
-    if (event.type === "response.function_call_arguments.delta") {
-      return append(pool, event.item_id, event.delta);
-    }
-    if (event.type === "response.function_call_arguments.done") {
-      if (!pool.has(event.item_id)) pool.start(event.item_id, event.arguments);
-      return complete(event.item_id);
-    }
-    return undefined;
-  });
+export const openAI = (pool = createStructuredStreamPool(), options) =>
+  createIntegration(
+    pool,
+    (event, calls) => {
+      if (event.type === "response.output_item.added") {
+        if (event.item.type !== "function_call") return undefined;
+        return calls.start(event.item.id);
+      }
+      if (event.type === "response.function_call_arguments.delta") {
+        return append(calls, event.item_id, event.delta);
+      }
+      if (event.type === "response.function_call_arguments.done") {
+        if (!calls.has(event.item_id))
+          calls.start(event.item_id, event.arguments);
+        return calls.complete(event.item_id);
+      }
+      return undefined;
+    },
+    undefined,
+    "openai",
+    options,
+  );
 
 export { openAI as createStructuredStream };

package/src/read-structured.js

@@ -0,0 +1,48 @@
+import { createStructuredStreamPool } from "./index.js";
+import { streamError } from "./internal/errors.js";
+
+export async function* readStructured(
+  events,
+  { adapter, integration, limits, onDiagnostic },
+) {
+  if (
+    (adapter === undefined) === (integration === undefined) ||
+    (adapter !== undefined && typeof adapter !== "function") ||
+    (integration !== undefined && typeof integration !== "function")
+  ) {
+    throw streamError(
+      new TypeError("Choose exactly one adapter or integration factory"),
+      "INVALID_OPTIONS",
+    );
+  }
+  let pool;
+  let stream;
+  try {
+    if (integration !== undefined) {
+      pool = createStructuredStreamPool(limits);
+      stream = integration(pool, { onDiagnostic });
+    } else {
+      stream = adapter(
+        onDiagnostic === undefined ? limits : { ...limits, onDiagnostic },
+      );
+    }
+    for await (const event of events) {
+      for (const update of stream.pushAll(event)) yield update;
+    }
+    if (pool === undefined) {
+      for (const completed of stream.finish()) yield completed;
+    } else {
+      // SDK finish() appends pending calls to its legacy completion history.
+      const pending = pool.size;
+      const completed = stream.finish();
+      if (pending > 0) {
+        for (const result of completed.slice(-pending)) {
+          yield { type: "complete", ...result };
+        }
+      }
+    }
+  } finally {
+    if (pool === undefined) stream?.dispose();
+    else for (const id of pool.activeIds) pool.abort(id);
+  }
+}

package/src/vercel-ai.d.ts

@@ -1,6 +1,7 @@
 import type {
-  EventStructuredStream,
-  StructuredStreamIntegration,
+  BatchEventStructuredStream,
+  BatchStructuredStreamIntegration,
+  StructuredStreamIntegrationOptions,
   StructuredStreamPool,
 } from "./index.js";
 
@@ -42,11 +43,12 @@ export type VercelAiToolInputEvent =
       readonly [key: string]: unknown;
     };
 
-export const vercelAI: StructuredStreamIntegration<
+export const vercelAI: BatchStructuredStreamIntegration<
   VercelAiToolInputEvent,
   string
 >;
 
 export function createStructuredStream(
   pool?: StructuredStreamPool<string>,
-): EventStructuredStream<VercelAiToolInputEvent, string>;
+  options?: StructuredStreamIntegrationOptions,
+): BatchEventStructuredStream<VercelAiToolInputEvent, string>;

package/src/vercel-ai.js

@@ -1,22 +1,40 @@
 import { createStructuredStreamPool } from "./index.js";
 import { createIntegration } from "./internal/integration.js";
 
-export const vercelAI = (pool = createStructuredStreamPool()) =>
-  createIntegration(pool, (event, complete) => {
-    const id = event.id ?? event.toolCallId;
-    if (id === undefined) return undefined;
+export const vercelAI = (pool = createStructuredStreamPool(), options) =>
+  createIntegration(
+    pool,
+    (event, calls) => {
+      const id = event.id ?? event.toolCallId;
+      if (id === undefined) {
+        if (
+          [
+            "tool-input-start",
+            "tool-input-delta",
+            "tool-input-end",
+            "tool-input-available",
+          ].includes(event.type)
+        ) {
+          calls.unmatched("Tool input event is missing its call id");
+        }
+        return undefined;
+      }
 
-    if (event.type === "tool-input-start") return pool.start(id);
-    if (event.type === "tool-input-delta") {
-      return pool.push(id, event.delta ?? event.inputTextDelta);
-    }
-    if (
-      event.type === "tool-input-end" ||
-      event.type === "tool-input-available"
-    ) {
-      return complete(id);
-    }
-    return undefined;
-  });
+      if (event.type === "tool-input-start") return calls.start(id);
+      if (event.type === "tool-input-delta") {
+        return calls.push(id, event.delta ?? event.inputTextDelta);
+      }
+      if (
+        event.type === "tool-input-end" ||
+        event.type === "tool-input-available"
+      ) {
+        return calls.complete(id);
+      }
+      return undefined;
+    },
+    undefined,
+    "vercel-ai",
+    options,
+  );
 
 export { vercelAI as createStructuredStream };