@orq-ai/node 4.11.0-rc.3 → 4.11.0-rc.31

package/src/lib/event-streams.ts

@@ -26,22 +26,45 @@ export class EventStream<T extends SseMessage<unknown>>
     opts?: { dataRequired?: boolean },
   ) {
     const upstream = responseBody.getReader();
-    let buffer: Uint8Array = new Uint8Array();
+    let buffer: Uint8Array = new Uint8Array(4096);
+    let bufferLen = 0;
+    let searchStart = 0;
     const state = { eventId: undefined as string | undefined };
     const dataRequired = opts?.dataRequired ?? true;
     super({
       async pull(downstream) {
         try {
           while (true) {
-            const match = findBoundary(buffer);
+            const match = findBoundary(buffer, bufferLen, searchStart);
             if (!match) {
+              // Bytes before the trailing MAX_BOUNDARY_LEN-1 were already
+              // scanned with full lookahead and cannot start a boundary even
+              // once more data arrives, so the next scan can skip them.
+              searchStart = Math.max(0, bufferLen - MAX_BOUNDARY_LEN + 1);
               const chunk = await upstream.read();
               if (chunk.done) return downstream.close();
-              buffer = concatBuffer(buffer, chunk.value);
+              if (bufferLen + chunk.value.length > buffer.length) {
+                const grown = new Uint8Array(
+                  Math.max(buffer.length * 2, bufferLen + chunk.value.length),
+                );
+                grown.set(buffer.subarray(0, bufferLen));
+                buffer = grown;
+              }
+              buffer.set(chunk.value, bufferLen);
+              bufferLen += chunk.value.length;
               continue;
             }
             const message = buffer.slice(0, match.index);
-            buffer = buffer.slice(match.index + match.length);
+            buffer.copyWithin(0, match.index + match.length, bufferLen);
+            bufferLen -= match.index + match.length;
+            if (buffer.length > 4096 && bufferLen <= buffer.length >> 2) {
+              // Release oversized capacity retained after an unusually large
+              // event so long-lived streams do not hold peak memory.
+              const shrunk = new Uint8Array(Math.max(4096, bufferLen * 2));
+              shrunk.set(buffer.subarray(0, bufferLen));
+              buffer = shrunk;
+            }
+            searchStart = 0;
             const item = parseMessage(message, parse, state, dataRequired);
             if (item && !item.done) return downstream.enqueue(item.value);
             if (item?.done) {
@@ -89,13 +112,6 @@ export class EventStream<T extends SseMessage<unknown>>
   }
 }
 
-function concatBuffer(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const c = new Uint8Array(a.length + b.length);
-  c.set(a, 0);
-  c.set(b, a.length);
-  return c;
-}
-
 const CR = 13;
 const LF = 10;
 const BOUNDARIES = [
@@ -108,12 +124,14 @@ const BOUNDARIES = [
   [LF, CR], // \n\r
   [LF, LF], // \n\n
 ];
+const MAX_BOUNDARY_LEN = BOUNDARIES.reduce((m, b) => Math.max(m, b.length), 0);
 
 function findBoundary(
   buf: Uint8Array,
+  len: number,
+  from: number,
 ): { index: number; length: number } | null {
-  const len = buf.length;
-  for (let i = 0; i < len; i++) {
+  for (let i = from; i < len; i++) {
     if (buf[i] !== CR && buf[i] !== LF) continue;
     for (const boundary of BOUNDARIES) {
       if (i + boundary.length > len) continue;

package/src/lib/matchers.ts

@@ -6,7 +6,7 @@ import { APIError } from "../models/errors/apierror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export type Encoding =
   | "jsonl"

package/src/lib/primitives.ts

@@ -148,3 +148,19 @@ export function allRequired<V extends Record<string, unknown>>(
 
   return v as ReturnType<typeof allRequired<V>>;
 }
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}

package/src/lib/retries.ts

@@ -194,6 +194,14 @@ async function retryBackoff(
 }
 
 function retryIntervalFromResponse(res: Response): number {
+  const retryAfterMsVal = res.headers.get("retry-after-ms");
+  if (retryAfterMsVal) {
+    const parsedMs = Number(retryAfterMsVal);
+    if (Number.isFinite(parsedMs) && parsedMs >= 0) {
+      return parsedMs;
+    }
+  }
+
   const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
     return 0;

package/src/lib/sdks.ts

@@ -24,6 +24,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -132,27 +133,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);
@@ -198,9 +227,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +275,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );