@pyxmate/memory 1.17.0 → 1.17.2

package/dist/cli/pyx-mem.mjs

@@ -835,7 +835,7 @@ function createProxyServer(client, version, uploadLocalFile) {
   return server;
 }
 async function runMcpProxyServer(opts) {
-  const version = opts.version ?? (true ? "1.17.0" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.17.2" : "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();

package/dist/data-plane-contract.mjs

@@ -536,7 +536,38 @@ function normalizeMcpStoreMetadata(value) {
   }
   return { ...caller, ...serverOwned };
 }
-function normalizeStore(input, context, mcp) {
+function mergeCanonicalGraphInput(entities, relationships, triples) {
+  const uniqueEntities = /* @__PURE__ */ new Map();
+  const addEntity = (entity) => {
+    const key = `${normalizeNameKey(entity.name)}\0${normalizeGraphLabel(entity.type, "CONCEPT")}`;
+    if (!uniqueEntities.has(key)) uniqueEntities.set(key, entity);
+  };
+  const uniqueRelationships = /* @__PURE__ */ new Map();
+  const addRelationship = (relationship) => {
+    const key = [
+      normalizeNameKey(relationship.source),
+      normalizeNameKey(relationship.target),
+      normalizeGraphLabel(relationship.type, "RELATED_TO")
+    ].join("\0");
+    if (!uniqueRelationships.has(key)) uniqueRelationships.set(key, relationship);
+  };
+  for (const entity of entities) addEntity(entity);
+  for (const relationship of relationships) addRelationship(relationship);
+  for (const triple of triples) {
+    addEntity(triple.subject);
+    addEntity(triple.object);
+    addRelationship({
+      source: triple.subject.name,
+      target: triple.object.name,
+      type: normalizeGraphLabel(triple.relation, "RELATED_TO")
+    });
+  }
+  return {
+    entities: [...uniqueEntities.values()],
+    relationships: [...uniqueRelationships.values()]
+  };
+}
+function canonicalizeStorePayload(input, resolvedAt, mcp, compileAdmission) {
   const value = requireObject(input, "input");
   const common = [
     "id",
@@ -559,19 +590,14 @@ function normalizeStore(input, context, mcp) {
     mcp ? [...common, "topic", "project", "metadata", "triples", "entitiesOnly"] : [...common, "metadata"],
     "input"
   );
-  if (value.namespaceId !== void 0 && value.namespaceId !== context.scope.namespaceId) {
-    throw new Error("input.namespaceId does not match trusted context.scope.namespaceId");
-  }
-  if (value.extractEntities === true) {
-    throw new Error("input.extractEntities=true requires external I/O and is not execution-ready");
-  }
+  compileAdmission?.(value);
   const normalized = {
     content: requireString(value.content, "input.content"),
     type: optionalEnum(value.type, MEMORY_TYPES, "input.type") ?? "long-term",
     targets: normalizeStoreTargets(value.targets),
     metadata: mcp ? normalizeMcpStoreMetadata(value) : canonicalValue(value.metadata ?? {}, "input.metadata"),
-    createdAt: context.resolvedAt,
-    ingestTime: context.resolvedAt,
+    createdAt: resolvedAt,
+    ingestTime: resolvedAt,
     extractEntities: false
   };
   withOptional(normalized, "id", optionalCallerEntryId(value.id, "input.id"));
@@ -591,6 +617,7 @@ function normalizeStore(input, context, mcp) {
   }
   const entities = normalizeGraphEntities(value.entities) ?? [];
   const relationships = normalizeGraphRelationships(value.relationships) ?? [];
+  const triples = [];
   if (mcp && value.triples !== void 0) {
     if (!Array.isArray(value.triples) || value.triples.length > 256) {
       throw new Error("input.triples must be an array of at most 256 items");
@@ -602,57 +629,45 @@ function normalizeStore(input, context, mcp) {
       const subject = tripleEntities?.[0];
       const object = tripleEntities?.[1];
       if (!subject || !object) throw new Error(`input.triples[${index}] has invalid endpoints`);
-      entities.push(subject, object);
-      relationships.push({
-        source: subject.name,
-        target: object.name,
-        type: normalizeGraphLabel(
-          requireString(triple.relation, `input.triples[${index}].relation`),
-          "RELATED_TO"
-        )
+      triples.push({
+        subject,
+        relation: requireString(triple.relation, `input.triples[${index}].relation`),
+        object
       });
     }
   }
-  const uniqueEntities = /* @__PURE__ */ new Map();
-  for (const entity of entities) {
-    const key = `${normalizeNameKey(entity.name)}\0${entity.type}`;
-    if (!uniqueEntities.has(key)) uniqueEntities.set(key, entity);
-  }
-  const uniqueRelationships = /* @__PURE__ */ new Map();
-  for (const relationship of relationships) {
-    const key = [
-      normalizeNameKey(relationship.source),
-      normalizeNameKey(relationship.target),
-      normalizeGraphLabel(relationship.type, "RELATED_TO")
-    ].join("\0");
-    if (!uniqueRelationships.has(key)) uniqueRelationships.set(key, relationship);
-  }
+  const merged = mergeCanonicalGraphInput(entities, relationships, triples);
   const graphTargeted = normalized.targets.includes(
     "graph"
   );
-  const entityNames = new Set(
-    [...uniqueEntities.values()].map(
-      (entity) => normalizeNameKey(entity.name)
-    )
-  );
-  const hasResolvableRelationship = [...uniqueRelationships.values()].some((relationship) => {
-    const value2 = relationship;
-    const source = normalizeNameKey(value2.source);
-    const target = normalizeNameKey(value2.target);
+  const entityNames = new Set(merged.entities.map((entity) => normalizeNameKey(entity.name)));
+  const hasResolvableRelationship = merged.relationships.some((relationship) => {
+    const source = normalizeNameKey(relationship.source);
+    const target = normalizeNameKey(relationship.target);
     return source !== target && entityNames.has(source) && entityNames.has(target);
   });
   const entitiesOnly = mcp && value.entitiesOnly !== void 0 ? requireBoolean(value.entitiesOnly, "input.entitiesOnly") : false;
-  if (mcp && graphTargeted && uniqueEntities.size >= 2 && !hasResolvableRelationship && !entitiesOnly) {
+  if (mcp && graphTargeted && merged.entities.length >= 2 && !hasResolvableRelationship && !entitiesOnly) {
     throw new Error(
       "GRAPH_RELATIONSHIPS_REQUIRED: graph stores with two or more entities require a relationship that connects declared entity names, or entitiesOnly=true"
     );
   }
-  if (uniqueEntities.size > 0) normalized.entities = [...uniqueEntities.values()];
-  if (uniqueRelationships.size > 0) {
-    normalized.relationships = [...uniqueRelationships.values()];
-  }
+  if (merged.entities.length > 0) normalized.entities = merged.entities;
+  if (merged.relationships.length > 0) normalized.relationships = merged.relationships;
   return normalized;
 }
+function normalizeStore(input, context, mcp) {
+  return canonicalizeStorePayload(input, context.resolvedAt, mcp, (value) => {
+    if (value.namespaceId !== void 0 && value.namespaceId !== context.scope.namespaceId) {
+      throw new Error("input.namespaceId does not match trusted context.scope.namespaceId");
+    }
+    if (value.extractEntities === true) {
+      throw new Error(
+        "input.extractEntities=true requires external I/O and is not execution-ready"
+      );
+    }
+  });
+}
 function normalizeBatchStore(input, context) {
   const value = requireObject(input, "input");
   requireExactKeys(value, ["entries"], "input");

package/package.json

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