@pyxmate/memory 0.13.0 → 0.15.0

package/dist/chunk-4YIKI2BA.mjs

@@ -1,404 +0,0 @@
-// ../client/src/memory-client.ts
-var MemoryServerError = class extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "MemoryServerError";
-    this.status = status;
-  }
-  /** True when the server returned HTTP 404 (not found). */
-  get isNotFound() {
-    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) {
-    return encodeURIComponent(segment);
-  }
-  async initialize() {
-    const response = await fetch(`${this.baseUrl}/health`, {
-      headers: this._authHeaders
-    });
-    if (!response.ok) {
-      throw new Error(`Memory server not reachable at ${this.baseUrl}: ${response.status}`);
-    }
-  }
-  async store(entry) {
-    return this.fetchApi("/api/memory/ingest", {
-      method: "POST",
-      body: JSON.stringify(entry)
-    });
-  }
-  async search(params) {
-    const searchParams = new URLSearchParams({ query: params.query });
-    if (params.limit) searchParams.set("limit", String(params.limit));
-    if (params.type) searchParams.set("type", params.type);
-    if (params.agentId) searchParams.set("agentId", params.agentId);
-    if (params.strategy) searchParams.set("strategy", params.strategy);
-    if (params.eventTimeRange) {
-      searchParams.set("eventTimeStart", params.eventTimeRange[0]);
-      searchParams.set("eventTimeEnd", params.eventTimeRange[1]);
-    }
-    if (params.asOf) searchParams.set("asOf", params.asOf);
-    if (params.abstentionThreshold != null)
-      searchParams.set("abstentionThreshold", String(params.abstentionThreshold));
-    return this.fetchApi(`/api/memory/search?${searchParams}`);
-  }
-  async get(id) {
-    try {
-      return await this.fetchApi(`/api/memory/entries/${this.encodePathSegment(id)}`);
-    } catch (error) {
-      if (error instanceof MemoryServerError && error.isNotFound) return null;
-      throw error;
-    }
-  }
-  async delete(id) {
-    try {
-      await this.fetchApi(`/api/memory/entries/${this.encodePathSegment(id)}`, {
-        method: "DELETE"
-      });
-      return true;
-    } catch (error) {
-      if (error instanceof MemoryServerError && error.isNotFound) return false;
-      throw error;
-    }
-  }
-  async clearSession(sessionId) {
-    const result = await this.fetchApi(
-      `/api/memory/sessions/${this.encodePathSegment(sessionId)}`,
-      { method: "DELETE" }
-    );
-    return result.cleared;
-  }
-  async stats() {
-    const stats = await this.fetchApi("/api/memory/stats");
-    return { ...stats, connected: true };
-  }
-  async shutdown() {
-  }
-  async list(params = {}) {
-    const searchParams = new URLSearchParams();
-    if (params.page != null) searchParams.set("page", String(params.page));
-    if (params.limit != null) searchParams.set("limit", String(params.limit));
-    if (params.type) searchParams.set("type", params.type);
-    if (params.agentId) searchParams.set("agentId", params.agentId);
-    const qs = searchParams.toString();
-    return this.fetchApi(`/api/memory/entries${qs ? `?${qs}` : ""}`);
-  }
-  // --- Additional endpoints ---
-  /**
-   * Ingest a file with optional two-phase enrichment.
-   *
-   * Without enrichment callbacks: standard single-phase ingest (backwards compatible).
-   * With enrichment callbacks: fetches extracted images, calls describeImage for each,
-   * optionally extracts entities, then submits enrichment data back to the server.
-   */
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: two-phase enrichment fans out across image-describe + entity-extract + v1/v2 negotiation; each branch maps to a documented case in memory-client-enrichment.test.ts
-  async ingestFile(file, options) {
-    const formData = new FormData();
-    formData.append("file", file);
-    if (options?.description) {
-      formData.append("description", options.description);
-    }
-    const wantsTextWindows = Boolean(
-      options?.enrichment?.extractEntities || options?.enrichment?.extractEntitiesV2
-    );
-    const headers = { ...this._authHeaders };
-    if (wantsTextWindows) {
-      headers["X-Pyx-Enrichment-Capabilities"] = "text_windows_v1";
-    }
-    const res = await fetch(`${this.baseUrl}/api/memory/ingest/file`, {
-      method: "POST",
-      body: formData,
-      headers
-    });
-    const result = await this.parseApiResponse(res);
-    if (!result.enrichment || !options?.enrichment) {
-      return result;
-    }
-    const enrichment = result.enrichment;
-    const { fileId, token, expiresAt, images } = enrichment;
-    const isV2 = "version" in enrichment;
-    const textWindows = isV2 ? enrichment.textWindows : [];
-    const descriptions = [];
-    const describeImage = options.enrichment.describeImage;
-    if (describeImage && images.length > 0) {
-      const CONCURRENCY = 5;
-      for (let i = 0; i < images.length; i += CONCURRENCY) {
-        const batch = images.slice(i, i + CONCURRENCY);
-        const batchResults = await Promise.all(
-          batch.map(async (imageMeta) => {
-            const imageRes = await fetch(
-              `${this.baseUrl}/api/memory/files/${fileId}/images/${imageMeta.imageId}?token=${encodeURIComponent(token)}`,
-              { headers: this._authHeaders }
-            );
-            if (!imageRes.ok) {
-              throw new MemoryServerError(
-                `Failed to fetch image ${imageMeta.imageId}: ${imageRes.status}`,
-                imageRes.status
-              );
-            }
-            const imageBuffer = await imageRes.arrayBuffer();
-            const description = await describeImage(imageBuffer, imageMeta);
-            return { imageId: imageMeta.imageId, description };
-          })
-        );
-        descriptions.push(...batchResults);
-      }
-    }
-    let entities;
-    let relationships;
-    const v2Callback = options.enrichment.extractEntitiesV2;
-    const legacyCallback = options.enrichment.extractEntities;
-    const imageDescriptionTexts = descriptions.map((d) => d.description);
-    if (v2Callback && (textWindows.length > 0 || imageDescriptionTexts.length > 0)) {
-      const extracted = await v2Callback({
-        textWindows,
-        imageDescriptions: imageDescriptionTexts,
-        mimeType: file.type,
-        filename: file.name
-      });
-      entities = extracted.entities;
-      relationships = extracted.relationships;
-    } else if (legacyCallback) {
-      const allInputs = [...textWindows, ...imageDescriptionTexts];
-      if (allInputs.length > 0) {
-        const extracted = await legacyCallback(allInputs);
-        entities = extracted.entities;
-        relationships = extracted.relationships;
-      }
-    }
-    const hasGraph = (entities?.length ?? 0) > 0;
-    const hasImages = descriptions.length > 0;
-    if (!hasGraph && !hasImages) {
-      return result;
-    }
-    const enrichTokenHeader = `${token}:${expiresAt}`;
-    const enrichRes = await fetch(`${this.baseUrl}/api/memory/files/${fileId}/enrich`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Enrichment-Token": enrichTokenHeader,
-        ...this._authHeaders
-      },
-      body: JSON.stringify({
-        imageDescriptions: descriptions,
-        entities,
-        relationships
-      })
-    });
-    if (!enrichRes.ok) {
-      const body = await enrichRes.json().catch(() => ({}));
-      throw new MemoryServerError(
-        body.error ?? `Enrichment failed: ${enrichRes.status}`,
-        enrichRes.status
-      );
-    }
-    const enrichData = await this.parseApiResponse(enrichRes);
-    const enrichCharacters = descriptions.reduce((sum, d) => sum + d.description.length, 0);
-    result.entryIds.push(...enrichData.entryIds);
-    result.chunks += descriptions.length;
-    result.totalCharacters += enrichCharacters;
-    return result;
-  }
-  /**
-   * Get the download URL for an uploaded file.
-   * Returns a URL that serves the original file binary with proper Content-Type.
-   */
-  getFileDownloadUrl(filename) {
-    return `${this.baseUrl}/api/memory/files/download/${encodeURIComponent(filename)}`;
-  }
-  /**
-   * Download an uploaded file by filename.
-   * Returns the raw Response (caller handles the body — arrayBuffer, blob, stream, etc.).
-   */
-  async downloadFile(filename) {
-    const url = this.getFileDownloadUrl(filename);
-    const res = await fetch(url, { headers: this._authHeaders });
-    if (!res.ok) {
-      throw new MemoryServerError(`File download failed: ${res.status}`, res.status);
-    }
-    return res;
-  }
-  /** @deprecated Use {@link list} instead. Kept for backwards compatibility. */
-  async listEntries(params) {
-    const result = await this.list(params);
-    return result.entries;
-  }
-  async graphNodes() {
-    const result = await this.fetchApi(
-      "/api/memory/graph/nodes"
-    );
-    return result.nodes;
-  }
-  async graphEdges() {
-    return this.fetchApi(
-      "/api/memory/graph/edges"
-    );
-  }
-  async graphQuery(query) {
-    return this.fetchApi("/api/memory/graph/query", {
-      method: "POST",
-      body: JSON.stringify(query)
-    });
-  }
-  // --- ExtendedMemoryInterface methods ---
-  async consolidate() {
-    return this.fetchApi("/api/memory/consolidate", {
-      method: "POST"
-    });
-  }
-  async forget(id, reason) {
-    try {
-      await this.fetchApi(`/api/memory/forget/${this.encodePathSegment(id)}`, {
-        method: "POST",
-        body: JSON.stringify({ reason })
-      });
-      return true;
-    } catch (error) {
-      if (error instanceof MemoryServerError && error.isNotFound) return false;
-      throw error;
-    }
-  }
-  async summarizeSession(sessionId) {
-    try {
-      return await this.fetchApi(
-        `/api/memory/sessions/${this.encodePathSegment(sessionId)}/summarize`,
-        { method: "POST" }
-      );
-    } catch (error) {
-      if (error instanceof MemoryServerError && error.isNotFound) return null;
-      throw error;
-    }
-  }
-  async runDecay() {
-    const result = await this.fetchApi("/api/memory/decay", {
-      method: "POST"
-    });
-    return result.archived;
-  }
-  async reindex() {
-    await this.fetchApi("/api/memory/reindex", { method: "POST" });
-  }
-  async clearGraph() {
-    const result = await this.fetchApi("/api/memory/graph/clear", {
-      method: "POST"
-    });
-    return result.deleted;
-  }
-  async deleteBySource(source) {
-    const result = await this.fetchApi(
-      `/api/memory/source/${this.encodePathSegment(source)}`,
-      { method: "DELETE" }
-    );
-    return result.deleted;
-  }
-  async queryAsOf(asOfDate, filters = {}) {
-    const params = new URLSearchParams({ asOf: asOfDate });
-    if (filters.type) params.set("type", filters.type);
-    if (filters.agentId) params.set("agentId", filters.agentId);
-    if (filters.source) params.set("source", filters.source);
-    if (filters.limit) params.set("limit", String(filters.limit));
-    const result = await this.fetchApi(
-      `/api/memory/query-as-of?${params}`
-    );
-    return result.entries;
-  }
-  async queryByEventTime(startTime, endTime, filters = {}) {
-    const params = new URLSearchParams({ startTime, endTime });
-    if (filters.type) params.set("type", filters.type);
-    if (filters.agentId) params.set("agentId", filters.agentId);
-    if (filters.source) params.set("source", filters.source);
-    if (filters.limit) params.set("limit", String(filters.limit));
-    const result = await this.fetchApi(
-      `/api/memory/query-by-event-time?${params}`
-    );
-    return result.entries;
-  }
-  async fetchApi(path, options) {
-    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;
-    try {
-      body = await res.json();
-    } catch {
-      throw new MemoryServerError(
-        `Memory server error: invalid JSON response (${res.status})`,
-        res.status
-      );
-    }
-    if (!body?.success || body.data == null) {
-      throw new MemoryServerError(body?.error ?? `Memory server error: ${res.status}`, res.status);
-    }
-    return body.data;
-  }
-};
-
-export {
-  MemoryServerError,
-  MemoryClient
-};