@pyxmate/memory 1.0.0 → 1.1.0

package/dist/{chunk-PXQLVQAA.mjs → chunk-U3U4MHWS.mjs}

@@ -1,7 +1,68 @@
 import {
+  RAGStrategy,
   mergeExtractedEntities
 } from "./chunk-X6AYWXW7.mjs";
 
+// ../client/src/disabled-memory.ts
+var DEFAULT_PAGE_LIMIT = 20;
+var DisabledMemory = class {
+  async initialize() {
+    console.warn("[pyx-memory] No memory backend configured \u2014 running without memory.");
+  }
+  async store(entry) {
+    return {
+      id: "disabled",
+      content: entry.content,
+      type: entry.type,
+      metadata: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async search() {
+    return { entries: [], totalCount: 0, strategy: RAGStrategy.NAIVE };
+  }
+  async list(params = {}) {
+    return {
+      entries: [],
+      totalCount: 0,
+      page: params.page ?? 1,
+      limit: params.limit ?? DEFAULT_PAGE_LIMIT
+    };
+  }
+  async get() {
+    return null;
+  }
+  async delete() {
+    return false;
+  }
+  async clearSession() {
+    return 0;
+  }
+  async stats() {
+    return {
+      totalEntries: 0,
+      storageUsedBytes: 0,
+      vectorCount: 0,
+      recentAccessCount: 0,
+      connected: false
+    };
+  }
+  async queryAsOf() {
+    return [];
+  }
+  async lineage() {
+    return { versions: [], source: "chain" };
+  }
+  async reinforce() {
+    return { updated: [] };
+  }
+  async queryByEventTime() {
+    return [];
+  }
+  async shutdown() {
+  }
+};
+
 // ../client/src/memory-client.ts
 var MemoryServerError = class extends Error {
   status;
@@ -789,6 +850,7 @@ var MemoryClient = class {
 };
 
 export {
+  DisabledMemory,
   MemoryServerError,
   MemoryClient
 };

package/dist/{chunk-ZCGJGI2O.mjs → chunk-ZILXBWWH.mjs}

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

package/dist/cli/pyx-mem.mjs

@@ -563,9 +563,91 @@ function createReadCredentials(providerFactory) {
   };
 }
 
+// src/mcp/proxy-server.ts
+import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var REMOTE_MCP_PATH = "/mcp";
+function createProxyServer(client, version) {
+  const caps = client.getServerCapabilities();
+  const server = new Server(client.getServerVersion() ?? { name: "pyx-memory", version }, {
+    capabilities: {
+      // Advertise the PRESENCE of tools/prompts, but NOT their `listChanged`
+      // sub-capability: this proxy does not relay the remote's list_changed
+      // notifications, so claiming listChanged would be a capability the host
+      // could rely on but we never honor (Codex: keep the proxy transparent).
+      ...caps?.tools ? { tools: {} } : {},
+      ...caps?.prompts ? { prompts: {} } : {}
+    },
+    instructions: client.getInstructions()
+  });
+  if (caps?.tools) {
+    server.setRequestHandler(
+      ListToolsRequestSchema,
+      (req) => client.listTools(req.params)
+    );
+    server.setRequestHandler(
+      CallToolRequestSchema,
+      (req) => client.callTool(req.params)
+    );
+  }
+  if (caps?.prompts) {
+    server.setRequestHandler(
+      ListPromptsRequestSchema,
+      (req) => client.listPrompts(req.params)
+    );
+    server.setRequestHandler(
+      GetPromptRequestSchema,
+      (req) => client.getPrompt(req.params)
+    );
+  }
+  return server;
+}
+async function runMcpProxyServer(opts) {
+  const version = opts.version ?? (true ? "1.1.0" : "0.0.0-dev");
+  const read = await opts.readCredentials();
+  if (!read.ok) {
+    const text = read.result.content.map((c) => c.type === "text" ? c.text : "").join(" ").trim();
+    throw new Error(text || "pyx-memory credentials are unavailable. Run: pyx-mem login");
+  }
+  const { endpoint, apiKey } = read.credentials;
+  const url = new URL(`${endpoint.replace(/\/+$/, "")}${REMOTE_MCP_PATH}`);
+  const client = new McpClient({ name: "pyx-mem-proxy", version }, { capabilities: {} });
+  const clientTransport = new StreamableHTTPClientTransport(url, {
+    requestInit: { headers: { Authorization: `Bearer ${apiKey}` } }
+  });
+  try {
+    await client.connect(clientTransport);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Could not reach the pyx-memory remote MCP at ${url.href}: ${msg}. Verify the endpoint and key with \`pyx-mem doctor\`, or run the bundled server with \`pyx-mem mcp\`.`
+    );
+  }
+  try {
+    const server = createProxyServer(client, version);
+    const transport = new StdioServerTransport();
+    const closed = new Promise((resolve3) => {
+      transport.onclose = () => resolve3();
+    });
+    await server.connect(transport);
+    await closed;
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StdioServerTransport as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/prompts/index.ts
 import { z } from "zod";
@@ -1377,7 +1459,7 @@ var ALL_TOOL_NAMES = ALL_TOOLS.map((t) => t.name);
 // src/mcp/server.ts
 async function runMcpServer(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const version = opts.version ?? (true ? "1.0.0" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.1.0" : "0.0.0-dev");
   const server = new McpServer(
     { name: "pyx-memory", version },
     { instructions: PYX_MEMORY_INSTRUCTIONS, capabilities: { tools: {}, prompts: {} } }
@@ -1396,7 +1478,7 @@ async function runMcpServer(opts) {
   for (const prompt of ALL_PROMPTS) {
     prompt.register(server);
   }
-  const transport = new StdioServerTransport();
+  const transport = new StdioServerTransport2();
   const closed = new Promise((resolve3) => {
     transport.onclose = () => resolve3();
   });
@@ -1405,14 +1487,15 @@ async function runMcpServer(opts) {
 }
 
 // src/cli/commands/mcp.ts
-async function mcpCommand() {
+async function mcpCommand(opts = {}) {
   const readCredentials = createReadCredentials(() => getDefaultKeychain());
   const onStdinEnd = new Promise((resolve3) => {
     process.stdin.once("end", resolve3);
     process.stdin.once("close", resolve3);
   });
   try {
-    await Promise.race([runMcpServer({ readCredentials }), onStdinEnd]);
+    const run = opts.remote ? runMcpProxyServer({ readCredentials }) : runMcpServer({ readCredentials });
+    await Promise.race([run, onStdinEnd]);
     return EXIT.OK;
   } catch (err) {
     process.stderr.write(`Internal error: ${err instanceof Error ? err.message : String(err)}
@@ -2101,7 +2184,9 @@ Commands:
   logout                                       Delete stored pyx-memory credentials.
   doctor [--json]                              Diagnose keychain, credentials, backend, MCP startup.
   scaffold [--name <dir>]                      Generate Docker, env, SDK, and memory design-guide starter files.
-  mcp                                          Start stdio MCP server.
+  mcp [--remote]                               Start stdio MCP server. --remote proxies to the hosted
+                                               server so tools + instructions stay server-owned
+                                               (zero-touch updates; key stays in the keychain).
   mcp install <target> [--scope user|local|project]
                                                Install pyx-memory MCP config for your AI agent.
                                                Targets: claude-code, codex, cursor, cline, continue, windsurf, gemini-cli, pi, oh-my-pi, openclaw, hermes.
@@ -2183,7 +2268,7 @@ function runMcpInstall(target, scope) {
   return handler({ scope });
 }
 function runMcpCommand(parsed) {
-  if (parsed.subcommand === void 0) return mcpCommand();
+  if (parsed.subcommand === void 0) return mcpCommand({ remote: parsed.flags.remote === true });
   if (parsed.subcommand === "install") {
     const target = parsed.positional[0];
     const scope = typeof parsed.flags.scope === "string" ? parsed.flags.scope : void 0;

package/dist/dashboard.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-ZCGJGI2O.mjs";
-import "./chunk-PXQLVQAA.mjs";
+} from "./chunk-ZILXBWWH.mjs";
+import "./chunk-U3U4MHWS.mjs";
 import "./chunk-X6AYWXW7.mjs";
 export {
   DashboardClient,

package/dist/index.d.ts

@@ -149,6 +149,37 @@ interface ExtendedMemoryInterface extends MemoryInterface {
     getEntitySynthesis(name: string): Promise<MemoryEntry$1 | null>;
 }
 
+/**
+ * No-op {@link MemoryInterface} for hosts that run without a memory backend
+ * (e.g. `MEMORY_URL` is unset). Every method returns a safe default, so the
+ * rest of the system functions without branching on `memory == null`.
+ *
+ * Canonical single source: this lives in the SAME package as `MemoryInterface`,
+ * so any method added to the interface fails THIS class's compile in the same
+ * build. The null-object can never silently drift behind the contract — the
+ * failure mode that left hand-rolled copies in downstream repos missing
+ * `lineage`/`reinforce` after the interface grew them.
+ *
+ * `initialize()` emits a single `console.warn`; pass nothing else — it is a
+ * pure null-object. Hosts wanting structured logging should log at the wiring
+ * site where they choose `DisabledMemory` over a real client.
+ */
+declare class DisabledMemory implements MemoryInterface {
+    initialize(): Promise<void>;
+    store(entry: StoreInput$1): Promise<MemoryEntry$1>;
+    search(): Promise<MemorySearchResult$1>;
+    list(params?: MemoryListParams): Promise<MemoryListResult>;
+    get(): Promise<MemoryEntry$1 | null>;
+    delete(): Promise<boolean>;
+    clearSession(): Promise<number>;
+    stats(): Promise<MemoryStats$1>;
+    queryAsOf(): Promise<MemoryEntry$1[]>;
+    lineage(): Promise<LineageResult$1>;
+    reinforce(): Promise<ReinforceResult$1>;
+    queryByEventTime(): Promise<MemoryEntry$1[]>;
+    shutdown(): Promise<void>;
+}
+
 /**
  * Callbacks for two-phase file enrichment. All callbacks are optional:
  *   - Image-rich PDF + describeImage only → describes images, no entity extraction
@@ -1431,4 +1462,4 @@ interface CreatePyxMemoryOptions {
 }
 declare function createPyxMemory(opts?: CreatePyxMemoryOptions): MemoryClient;
 
-export { type AgentId, type ApiResponse, type ConsolidationRunResult, type CorrectionInput, type CorrectionRecord, type CreatePyxMemoryOptions, DEFAULTS, DEPRECATED_RAG_STRATEGIES, type DroppedGraphRelationship, EmbeddingProviderName, type EnrichmentCallbacks, type EntityExtractionResult, type ExtendedMemoryInterface, type FetchCorrectionsInput, type GraphEnrichment, type GraphEnrichmentStatus, type GraphFailureMode, type GraphNode, type GraphRelationship, type GraphRepairResult, type GraphTraversalResult, type IngestEntity, type IngestErrorEvent, type IngestEvent, type IngestFileOptions, type IngestHeartbeatEvent, type IngestProgressEvent, type IngestRelationship, type IngestResultEvent, type IngestStage, type IngestionResult, type LineageParams, type LineageResult, type LineageVersion, MemoryClient, type MemoryClientOptions, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemoryLogFilters, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, type MoveEntriesFilter, MoveFailureReason, type MoveResult, type MoveTarget, NamespaceIsolation, type PrincipalContext, RAGStrategy, type ReinforceParams, type ReinforceResult, type ReinforceSignal, SINGLE_TENANT_ID, SensitivityLevel, type SourceEvidence, type StoreInput, StoreTarget, type TemporalQueryFilters, type TenantScopeOptions, type Timestamp, type Topology, type TopologyExtractionProvider, type TopologyServiceVariant, VectorProvider, type WikiLintReport, createPyxMemory, mergeExtractedEntities, normalizeGraphLabel, normalizeNameKey };
+export { type AgentId, type ApiResponse, type ConsolidationRunResult, type CorrectionInput, type CorrectionRecord, type CreatePyxMemoryOptions, DEFAULTS, DEPRECATED_RAG_STRATEGIES, DisabledMemory, type DroppedGraphRelationship, EmbeddingProviderName, type EnrichmentCallbacks, type EntityExtractionResult, type ExtendedMemoryInterface, type FetchCorrectionsInput, type GraphEnrichment, type GraphEnrichmentStatus, type GraphFailureMode, type GraphNode, type GraphRelationship, type GraphRepairResult, type GraphTraversalResult, type IngestEntity, type IngestErrorEvent, type IngestEvent, type IngestFileOptions, type IngestHeartbeatEvent, type IngestProgressEvent, type IngestRelationship, type IngestResultEvent, type IngestStage, type IngestionResult, type LineageParams, type LineageResult, type LineageVersion, MemoryClient, type MemoryClientOptions, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemoryLogFilters, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, type MoveEntriesFilter, MoveFailureReason, type MoveResult, type MoveTarget, NamespaceIsolation, type PrincipalContext, RAGStrategy, type ReinforceParams, type ReinforceResult, type ReinforceSignal, SINGLE_TENANT_ID, SensitivityLevel, type SourceEvidence, type StoreInput, StoreTarget, type TemporalQueryFilters, type TenantScopeOptions, type Timestamp, type Topology, type TopologyExtractionProvider, type TopologyServiceVariant, VectorProvider, type WikiLintReport, createPyxMemory, mergeExtractedEntities, normalizeGraphLabel, normalizeNameKey };

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import {
+  DisabledMemory,
   MemoryClient,
   MemoryServerError
-} from "./chunk-PXQLVQAA.mjs";
+} from "./chunk-U3U4MHWS.mjs";
 import {
   DEFAULTS,
   DEPRECATED_RAG_STRATEGIES,
@@ -35,6 +36,7 @@ function createPyxMemory(opts = {}) {
 export {
   DEFAULTS,
   DEPRECATED_RAG_STRATEGIES,
+  DisabledMemory,
   EmbeddingProviderName,
   MemoryClient,
   MemoryServerError,

package/dist/react.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-ZCGJGI2O.mjs";
-import "./chunk-PXQLVQAA.mjs";
+} from "./chunk-ZILXBWWH.mjs";
+import "./chunk-U3U4MHWS.mjs";
 import "./chunk-X6AYWXW7.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts

package/package.json

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