@mem9/mem9 0.4.9 → 0.4.10

package/server-backend.test.ts

@@ -1,82 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { ServerBackend } from "./server-backend.js";
-
-test("register forwards only utm_* params during create-new provision", async () => {
-  const originalFetch = globalThis.fetch;
-  let requestedURL = "";
-
-  globalThis.fetch = async (input, init) => {
-    requestedURL = String(input);
-    assert.equal(init?.method, "POST");
-
-    return new Response(JSON.stringify({ id: "space-1" }), {
-      status: 201,
-      headers: {
-        "Content-Type": "application/json",
-      },
-    });
-  };
-
-  try {
-    const backend = new ServerBackend("https://api.mem9.ai", "", "agent-1", {
-      provisionQueryParams: {
-        utm_source: "bosn",
-        foo: "bar",
-        utm_campaign: "spring",
-        utm_medium: "",
-      },
-    });
-
-    const result = await backend.register();
-    assert.equal(result.id, "space-1");
-
-    const url = new URL(requestedURL);
-    assert.equal(url.origin + url.pathname, "https://api.mem9.ai/v1alpha1/mem9s");
-    assert.equal(url.searchParams.get("utm_source"), "bosn");
-    assert.equal(url.searchParams.get("utm_campaign"), "spring");
-    assert.equal(url.searchParams.has("foo"), false);
-    assert.equal(url.searchParams.has("utm_medium"), false);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("normal memory requests do not append provision query params", async () => {
-  const originalFetch = globalThis.fetch;
-  let requestedURL = "";
-
-  globalThis.fetch = async (input) => {
-    requestedURL = String(input);
-
-    return new Response(
-      JSON.stringify({
-        id: "mem-1",
-        content: "remember this",
-        created_at: "2026-04-05T00:00:00Z",
-        updated_at: "2026-04-05T00:00:00Z",
-      }),
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "application/json",
-        },
-      },
-    );
-  };
-
-  try {
-    const backend = new ServerBackend("https://api.mem9.ai", "space-key", "agent-1", {
-      provisionQueryParams: {
-        utm_source: "bosn",
-      },
-    });
-
-    await backend.store({ content: "remember this" });
-
-    assert.equal(requestedURL, "https://api.mem9.ai/v1alpha2/mem9s/memories");
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/server-backend.ts

@@ -1,194 +0,0 @@
-import type { MemoryBackend } from "./backend.js";
-import type {
-  Memory,
-  StoreResult,
-  SearchResult,
-  CreateMemoryInput,
-  UpdateMemoryInput,
-  SearchInput,
-  IngestInput,
-  IngestResult,
-} from "./types.js";
-
-type ProvisionMem9sResponse = {
-  id: string;
-};
-
-export const DEFAULT_TIMEOUT_MS = 8_000;
-export const DEFAULT_SEARCH_TIMEOUT_MS = 15_000;
-
-export interface BackendTimeouts {
-  defaultTimeoutMs?: number;
-  searchTimeoutMs?: number;
-}
-
-interface ServerBackendOptions {
-  timeouts?: BackendTimeouts;
-  provisionQueryParams?: Record<string, string>;
-}
-
-interface RequestOptions {
-  timeoutMs?: number;
-}
-
-export class ServerBackend implements MemoryBackend {
-  private baseUrl: string;
-  private apiKey: string;
-  private agentName: string;
-  private provisionQueryParams: Record<string, string>;
-  private timeouts: Required<BackendTimeouts>;
-
-  constructor(
-    apiUrl: string,
-    apiKey: string,
-    agentName: string,
-    options: ServerBackendOptions = {},
-  ) {
-    this.baseUrl = apiUrl.replace(/\/+$/, "");
-    this.apiKey = apiKey;
-    this.agentName = agentName;
-    this.provisionQueryParams = options.provisionQueryParams ?? {};
-    this.timeouts = {
-      defaultTimeoutMs: options.timeouts?.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
-      searchTimeoutMs: options.timeouts?.searchTimeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
-    };
-  }
-
-  async register(): Promise<ProvisionMem9sResponse> {
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(this.provisionQueryParams)) {
-      if (!key.startsWith("utm_") || typeof value !== "string" || value === "") {
-        continue;
-      }
-
-      query.set(key, value);
-    }
-
-    const qs = query.toString();
-    const resp = await fetch(this.baseUrl + "/v1alpha1/mem9s" + (qs ? `?${qs}` : ""), {
-      method: "POST",
-      signal: AbortSignal.timeout(this.timeouts.defaultTimeoutMs),
-    });
-
-    if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`mem9s provision failed (${resp.status}): ${body}`);
-    }
-
-    const data = (await resp.json()) as ProvisionMem9sResponse;
-    if (!data?.id) {
-      throw new Error("mem9s provision did not return API key");
-    }
-
-    this.apiKey = data.id;
-    return data;
-  }
-
-  private memoryPath(path: string): string {
-    if (!this.apiKey) {
-      throw new Error("API key is not configured");
-    }
-    return `/v1alpha2/mem9s${path}`;
-  }
-
-  async store(input: CreateMemoryInput): Promise<StoreResult> {
-    return this.request<StoreResult>("POST", this.memoryPath("/memories"), input);
-  }
-
-  async search(input: SearchInput): Promise<SearchResult> {
-    const params = new URLSearchParams();
-    if (input.q) params.set("q", input.q);
-    if (input.tags) params.set("tags", input.tags);
-    if (input.source) params.set("source", input.source);
-    if (input.limit != null) params.set("limit", String(input.limit));
-    if (input.offset != null) params.set("offset", String(input.offset));
-    if (input.memory_type) params.set("memory_type", input.memory_type);
-
-    const qs = params.toString();
-    const raw = await this.request<{
-      memories: Memory[];
-      total: number;
-      limit: number;
-      offset: number;
-    }>(
-      "GET",
-      `${this.memoryPath("/memories")}${qs ? "?" + qs : ""}`,
-      undefined,
-      { timeoutMs: this.timeouts.searchTimeoutMs },
-    );
-    return {
-      data: raw.memories ?? [],
-      total: raw.total,
-      limit: raw.limit,
-      offset: raw.offset,
-    };
-  }
-
-  async get(id: string): Promise<Memory | null> {
-    try {
-      return await this.request<Memory>("GET", this.memoryPath(`/memories/${id}`));
-    } catch {
-      return null;
-    }
-  }
-
-  async update(id: string, input: UpdateMemoryInput): Promise<Memory | null> {
-    try {
-      return await this.request<Memory>("PUT", this.memoryPath(`/memories/${id}`), input);
-    } catch {
-      return null;
-    }
-  }
-
-  async remove(id: string): Promise<boolean> {
-    try {
-      await this.request("DELETE", this.memoryPath(`/memories/${id}`));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async ingest(input: IngestInput): Promise<IngestResult> {
-    return this.request<IngestResult>("POST", this.memoryPath("/memories"), input);
-  }
-
-  private async requestRaw(
-    method: string,
-    path: string,
-    body?: unknown,
-    options?: RequestOptions,
-  ): Promise<Response> {
-    const url = this.baseUrl + path;
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      "X-Mnemo-Agent-Id": this.agentName,
-      "X-API-Key": this.apiKey,
-    };
-    return fetch(url, {
-      method,
-      headers,
-      body: body != null ? JSON.stringify(body) : undefined,
-      signal: AbortSignal.timeout(options?.timeoutMs ?? this.timeouts.defaultTimeoutMs),
-    });
-  }
-
-  private async request<T>(
-    method: string,
-    path: string,
-    body?: unknown,
-    options?: RequestOptions,
-  ): Promise<T> {
-    const resp = await this.requestRaw(method, path, body, options);
-
-    if (resp.status === 204) {
-      return undefined as T;
-    }
-
-    const data = await resp.json();
-    if (!resp.ok) {
-      throw new Error((data as { error?: string }).error || `HTTP ${resp.status}`);
-    }
-    return data as T;
-  }
-}

package/types.ts

@@ -1,96 +0,0 @@
-export interface PluginConfig {
-  // Server mode (apiUrl present → server)
-  apiUrl?: string;
-  apiKey?: string;
-  provisionToken?: string;
-  provisionQueryParams?: Record<string, string>;
-  tenantID?: string;
-  defaultTimeoutMs?: number;
-  searchTimeoutMs?: number;
-  debug?: boolean;
-  // Deprecated: use debug
-  debugRecall?: boolean;
-
-  tenantName?: string;
-
-  // Agent identity for server mode.
-  // Defaults to "agent" if not set. Overridden by ctx.agentId at runtime.
-  agentName?: string;
-
-  // Ingest: size-aware message selection for smart pipeline
-  maxIngestBytes?: number;
-}
-
-export interface Memory {
-  id: string;
-  content: string;
-  source?: string | null;
-  tags?: string[] | null;
-  metadata?: Record<string, unknown> | null;
-  version?: number;
-  updated_by?: string | null;
-  created_at: string;
-  updated_at: string;
-  score?: number;
-  confidence?: number;
-
-  // Smart memory pipeline (server mode)
-  memory_type?: string;
-  state?: string;
-  agent_id?: string;
-  session_id?: string;
-
-  relative_age?: string;
-}
-
-export interface SearchResult {
-  data: Memory[];
-  total: number;
-  limit: number;
-  offset: number;
-}
-
-export interface CreateMemoryInput {
-  content: string;
-  source?: string;
-  tags?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface UpdateMemoryInput {
-  content?: string;
-  source?: string;
-  tags?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface SearchInput {
-  q?: string;
-  tags?: string;
-  source?: string;
-  limit?: number;
-  offset?: number;
-  memory_type?: string;
-}
-
-export interface IngestMessage {
-  role: string;
-  content: string;
-}
-
-export interface IngestInput {
-  messages: IngestMessage[];
-  session_id: string;
-  agent_id: string;
-  mode?: "smart" | "raw";
-}
-
-export interface IngestResult {
-  status: "accepted" | "complete" | "partial" | "failed";
-  memories_changed?: number;
-  insight_ids?: string[];
-  warnings?: number;
-  error?: string;
-}
-
-export type StoreResult = Memory | IngestResult;