@animalabs/membrane 0.5.40 → 0.5.42

package/src/providers/utils.ts

@@ -0,0 +1,109 @@
+/**
+ * Safely parse a JSON string, returning an empty object on failure.
+ * Used for tool call arguments which may be malformed from streaming.
+ */
+export function safeParseJson(str: string | undefined): Record<string, unknown> {
+  try {
+    return JSON.parse(str || '{}');
+  } catch (e) {
+    console.warn('[membrane] Failed to parse tool arguments JSON:', e);
+    return {};
+  }
+}
+
+/**
+ * Create a combined AbortSignal that fires on either the caller's signal
+ * or a timeout (whichever comes first).
+ *
+ * The returned `cleanup` function MUST be called in a `finally` block to
+ * clear the timeout and remove the event listener, preventing leaks.
+ *
+ * Timeout aborts with `DOMException('Request timed out', 'AbortError')`
+ * so it classifies identically to user-initiated aborts.
+ */
+export function createCombinedSignal(
+  signal?: AbortSignal,
+  timeoutMs?: number
+): { signal?: AbortSignal; cleanup?: () => void } {
+  if (!signal && !timeoutMs) return {};
+  if (signal && !timeoutMs) return { signal };
+
+  const controller = new AbortController();
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  if (timeoutMs) {
+    timeoutId = setTimeout(
+      () => controller.abort(new DOMException('Request timed out', 'AbortError')),
+      timeoutMs
+    );
+  }
+
+  const onAbort = () => controller.abort(signal!.reason);
+  if (signal) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+    } else {
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  }
+
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (signal) signal.removeEventListener('abort', onAbort);
+    },
+  };
+}
+
+/**
+ * SSE (Server-Sent Events) line parser that correctly handles events
+ * split across multiple TCP chunks.
+ *
+ * The naive approach of `chunk.split('\n').filter(l => l.startsWith('data: '))`
+ * silently drops events when an SSE line spans two chunks:
+ *   Chunk 1: `data: {"choices":[{"delta":{"content":"don'`  (no newline — incomplete)
+ *   Chunk 2: `t do that"}}]}\n`                              (doesn't start with `data: `)
+ * Result: the entire event is lost, causing "skipped words" in output.
+ *
+ * This parser buffers partial lines and only yields complete `data: ...` lines.
+ */
+export class SSELineParser {
+  private buffer: string = '';
+
+  /**
+   * Feed a raw chunk from the stream reader and get back complete SSE data lines.
+   * Each returned string is the content after `data: ` (e.g. the JSON payload or `[DONE]`).
+   */
+  feed(chunk: string): string[] {
+    this.buffer += chunk;
+    const results: string[] = [];
+
+    // Split on newlines, keeping the last (potentially incomplete) segment in the buffer
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('data: ')) {
+        results.push(trimmed.slice(6));
+      }
+      // Skip empty lines, comments (`:...`), and other SSE fields (event:, id:, retry:)
+    }
+
+    return results;
+  }
+
+  /**
+   * Flush any remaining buffered content (call when stream ends).
+   */
+  flush(): string[] {
+    if (!this.buffer.trim()) return [];
+    const trimmed = this.buffer.trim();
+    this.buffer = '';
+    if (trimmed.startsWith('data: ')) {
+      return [trimmed.slice(6)];
+    }
+    return [];
+  }
+}

package/src/types/request.ts

@@ -161,6 +161,15 @@ export interface NormalizedRequest {
    */
   assistantParticipant?: string;
 
+  /**
+   * Control streaming behavior when calling membrane.stream().
+   * - true or undefined: use streaming (default)
+   * - false: force non-streaming — membrane.stream() will internally use
+   *   complete() and synthesize streaming callbacks from the full response.
+   *   Useful for working around provider streaming bugs.
+   */
+  streaming?: boolean;
+
   /** Provider-specific parameters (pass-through) */
   providerParams?: Record<string, unknown>;
 }