@pyxmate/memory 0.11.0 → 0.12.1

package/dist/{chunk-5IERAVVW.mjs → chunk-4YIKI2BA.mjs}

@@ -11,24 +11,31 @@ var MemoryServerError = class extends Error {
     return this.status === 404;
   }
 };
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var MemoryClient = class {
   baseUrl;
   _authHeaders;
+  _requestTimeoutMs;
   constructor(memoryUrl, apiKeyOrOptions) {
     this.baseUrl = memoryUrl.replace(/\/$/, "");
     let apiKey;
     let defaultHeaders = {};
+    let requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
     if (typeof apiKeyOrOptions === "string") {
       apiKey = apiKeyOrOptions;
     } else if (apiKeyOrOptions) {
       apiKey = apiKeyOrOptions.apiKey;
       defaultHeaders = apiKeyOrOptions.defaultHeaders ?? {};
+      if (apiKeyOrOptions.requestTimeoutMs !== void 0) {
+        requestTimeoutMs = apiKeyOrOptions.requestTimeoutMs;
+      }
     }
     const trimmed = apiKey?.trim();
     this._authHeaders = {
       ...trimmed ? { Authorization: `Bearer ${trimmed}` } : {},
       ...defaultHeaders
     };
+    this._requestTimeoutMs = requestTimeoutMs;
   }
   /** Encode a path segment to prevent URL injection */
   encodePathSegment(segment) {
@@ -335,16 +342,44 @@ var MemoryClient = class {
     return result.entries;
   }
   async fetchApi(path, options) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...this._authHeaders
-      }
-    });
+    const signal = options?.signal ?? AbortSignal.timeout(this._requestTimeoutMs);
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers,
+          ...this._authHeaders
+        },
+        signal
+      });
+    } catch (err) {
+      throw this.translateFetchError(err, path);
+    }
     return this.parseApiResponse(res);
   }
+  /**
+   * Map fetch-layer rejections into a typed `MemoryServerError` so callers
+   * can react uniformly. AbortSignal.timeout fires a `TimeoutError`; the
+   * caller's signal generally fires an `AbortError`. Anything else (DNS,
+   * TCP reset, TLS) becomes a wrapped error with status 0.
+   */
+  translateFetchError(err, path) {
+    if (err instanceof Error) {
+      if (err.name === "TimeoutError") {
+        return new MemoryServerError(
+          `Memory server request timed out after ${this._requestTimeoutMs}ms (${path})`,
+          504
+        );
+      }
+      if (err.name === "AbortError") {
+        return new MemoryServerError(`Memory server request aborted (${path})`, 499);
+      }
+      return new MemoryServerError(`Memory server request failed: ${err.message} (${path})`, 0);
+    }
+    return new MemoryServerError(`Memory server request failed: ${String(err)} (${path})`, 0);
+  }
   /** Parse and validate a JSON API response, throwing MemoryServerError on any failure. */
   async parseApiResponse(res) {
     let body;

package/dist/{chunk-DGVOXKYV.mjs → chunk-DZZHJ66P.mjs}

@@ -1,6 +1,6 @@
 import {
   MemoryClient
-} from "./chunk-5IERAVVW.mjs";
+} from "./chunk-4YIKI2BA.mjs";
 
 // ../dashboard/src/aggregations/consolidation-analytics.ts
 function analyzeConsolidationLog(entries) {

package/dist/dashboard.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-DGVOXKYV.mjs";
-import "./chunk-5IERAVVW.mjs";
+} from "./chunk-DZZHJ66P.mjs";
+import "./chunk-4YIKI2BA.mjs";
 export {
   DashboardClient,
   Poller,

package/dist/index.d.ts

@@ -128,10 +128,26 @@ interface MemoryClientOptions {
     apiKey?: string;
     /** Additional headers to send with every request (e.g., X-Caller-Access-Level). */
     defaultHeaders?: Record<string, string>;
+    /**
+     * Default per-request timeout in milliseconds. Without this, a wedged
+     * memory server (e.g. event-loop blocked by inference) makes every
+     * caller hang forever — that was the Korens demo wedge in 2026-04 where
+     * a 161-second pyx-memory stall propagated through the runtime to the
+     * browser. Defaults to 30 s, which is high enough that normal
+     * `/search` and `/stats` requests never hit it but low enough that a
+     * stuck server fails loudly.
+     *
+     * Only applied when the caller does NOT pass their own `signal` via
+     * RequestInit. Long-running operations (large `consolidate`, `reindex`,
+     * file ingest with enrichment) should pass their own AbortSignal —
+     * that signal fully replaces the default ceiling.
+     */
+    requestTimeoutMs?: number;
 }
 declare class MemoryClient implements ExtendedMemoryInterface {
     protected baseUrl: string;
     private readonly _authHeaders;
+    private readonly _requestTimeoutMs;
     constructor(memoryUrl: string, apiKeyOrOptions?: string | MemoryClientOptions);
     /** Encode a path segment to prevent URL injection */
     private encodePathSegment;
@@ -191,6 +207,13 @@ declare class MemoryClient implements ExtendedMemoryInterface {
     queryAsOf(asOfDate: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
     queryByEventTime(startTime: string, endTime: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
     protected fetchApi<T>(path: string, options?: RequestInit): Promise<T>;
+    /**
+     * Map fetch-layer rejections into a typed `MemoryServerError` so callers
+     * can react uniformly. AbortSignal.timeout fires a `TimeoutError`; the
+     * caller's signal generally fires an `AbortError`. Anything else (DNS,
+     * TCP reset, TLS) becomes a wrapped error with status 0.
+     */
+    private translateFetchError;
     /** Parse and validate a JSON API response, throwing MemoryServerError on any failure. */
     private parseApiResponse;
 }

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   MemoryClient,
   MemoryServerError
-} from "./chunk-5IERAVVW.mjs";
+} from "./chunk-4YIKI2BA.mjs";
 
 // ../shared/src/constants/defaults.ts
 var DEFAULTS = {

package/dist/react.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-DGVOXKYV.mjs";
-import "./chunk-5IERAVVW.mjs";
+} from "./chunk-DZZHJ66P.mjs";
+import "./chunk-4YIKI2BA.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts
 import { useCallback as useCallback2, useMemo } from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",