neotoma 0.5.0 → 0.5.1

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAsF9B,eAAO,MAAM,GAAG,6CAAY,CAAC;AA2M7B,yGAAyG;AACzG,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CAK5D;AA2gKD,wBAAsB,eAAe;;;eAgCpC"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAuF9B,eAAO,MAAM,GAAG,6CAAY,CAAC;AA2M7B,yGAAyG;AACzG,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CAK5D;AAomKD,wBAAsB,eAAe;;;eAgCpC"}

package/dist/actions.js

@@ -33,6 +33,7 @@ import { prepareEntitySnapshotWithEmbedding, upsertEntitySnapshotWithEmbedding,
 import { readOpenApiActionsFile, readOpenApiFile } from "./shared/openapi_file.js";
 import { buildSmitheryServerCard } from "./mcp_server_card.js";
 import { listRecentRecordActivity } from "./services/recent_record_activity.js";
+import { listRecentConversations } from "./services/recent_conversations.js";
 export const app = express();
 // Trust proxy headers (required for express-rate-limit when X-Forwarded-For is present)
 app.set("trust proxy", true);
@@ -1845,30 +1846,99 @@ app.get("/entities/:id/relationships", async (req, res) => {
                 const idsArr = Array.from(relatedIds);
                 const [snapshotsResult, entitiesResult] = await Promise.all([
                     db.from("entity_snapshots").select("*").in("entity_id", idsArr).eq("user_id", userId),
-                    db.from("entities").select("id, canonical_name").in("id", idsArr).eq("user_id", userId),
+                    db
+                        .from("entities")
+                        .select("id, canonical_name, entity_type")
+                        .in("id", idsArr)
+                        .eq("user_id", userId),
                 ]);
-                if (!snapshotsResult.error && snapshotsResult.data) {
-                    const canonicalNames = new Map();
-                    if (!entitiesResult.error && entitiesResult.data) {
-                        for (const ent of entitiesResult.data) {
-                            if (ent.canonical_name)
-                                canonicalNames.set(ent.id, ent.canonical_name);
-                        }
+                // Merge snapshot + entity rows so callers always get canonical_name
+                // and entity_type even when the snapshot row is missing.
+                const canonicalNames = new Map();
+                const entityTypes = new Map();
+                if (!entitiesResult.error && entitiesResult.data) {
+                    for (const ent of entitiesResult.data) {
+                        if (ent.canonical_name)
+                            canonicalNames.set(ent.id, ent.canonical_name);
+                        if (ent.entity_type)
+                            entityTypes.set(ent.id, ent.entity_type);
                     }
-                    relatedEntities = {};
+                }
+                relatedEntities = {};
+                if (!snapshotsResult.error && snapshotsResult.data) {
                     for (const e of snapshotsResult.data) {
                         if (!e.canonical_name && canonicalNames.has(e.entity_id)) {
                             e.canonical_name = canonicalNames.get(e.entity_id);
                         }
+                        if (!e.entity_type && entityTypes.has(e.entity_id)) {
+                            e.entity_type = entityTypes.get(e.entity_id);
+                        }
                         relatedEntities[e.entity_id] = e;
                     }
                 }
+                // Fill in entities that have no snapshot row yet.
+                for (const rid of idsArr) {
+                    if (relatedEntities[rid])
+                        continue;
+                    relatedEntities[rid] = {
+                        entity_id: rid,
+                        canonical_name: canonicalNames.get(rid) ?? null,
+                        entity_type: entityTypes.get(rid) ?? null,
+                    };
+                }
+                // Resolve schema-derived entity_type_label via the registry once per
+                // distinct type (best effort; non-fatal).
+                try {
+                    const { SchemaRegistryService } = await import("./services/schema_registry.js");
+                    const registry = new SchemaRegistryService();
+                    const distinctTypes = [...new Set(Array.from(entityTypes.values()).filter(Boolean))];
+                    const labelByType = new Map();
+                    for (const t of distinctTypes) {
+                        const schema = await registry.loadActiveSchema(t, userId);
+                        if (schema?.metadata?.label)
+                            labelByType.set(t, schema.metadata.label);
+                    }
+                    for (const rid of Object.keys(relatedEntities)) {
+                        const type = relatedEntities[rid]?.entity_type;
+                        if (type && labelByType.has(type)) {
+                            relatedEntities[rid].entity_type_label = labelByType.get(type);
+                        }
+                    }
+                }
+                catch (err) {
+                    // Ignore — expansions without labels are still useful.
+                    console.warn("Failed to attach entity_type_label to related entities:", err instanceof Error ? err.message : err);
+                }
             }
         }
+        // Decorate relationship rows with top-level convenience fields so clients
+        // don't have to look up `related_entities` per row. Only populated when
+        // `expand_entities=true`.
+        const decorateRelationship = (rel) => {
+            if (!relatedEntities)
+                return rel;
+            const src = relatedEntities[rel.source_entity_id];
+            const tgt = relatedEntities[rel.target_entity_id];
+            return {
+                ...rel,
+                source_entity_name: src?.canonical_name ?? null,
+                source_entity_type: src?.entity_type ?? null,
+                source_entity_type_label: src?.entity_type_label ?? null,
+                target_entity_name: tgt?.canonical_name ?? null,
+                target_entity_type: tgt?.entity_type ?? null,
+                target_entity_type_label: tgt?.entity_type_label ?? null,
+            };
+        };
+        const decoratedOutgoing = expandEntities
+            ? formattedOutgoing.map(decorateRelationship)
+            : formattedOutgoing;
+        const decoratedIncoming = expandEntities
+            ? formattedIncoming.map(decorateRelationship)
+            : formattedIncoming;
         const responseBody = {
-            outgoing: formattedOutgoing,
-            incoming: formattedIncoming,
-            relationships: [...formattedOutgoing, ...formattedIncoming],
+            outgoing: decoratedOutgoing,
+            incoming: decoratedIncoming,
+            relationships: [...decoratedOutgoing, ...decoratedIncoming],
         };
         if (relatedEntities) {
             responseBody.related_entities = relatedEntities;
@@ -2126,8 +2196,8 @@ app.post("/relationships/snapshot", async (req, res) => {
         return sendValidationError(res, parsed.error.issues);
     }
     try {
-        const userId = await getAuthenticatedUserId(req, undefined);
-        const { relationship_type, source_entity_id, target_entity_id } = parsed.data;
+        const { relationship_type, source_entity_id, target_entity_id, user_id } = parsed.data;
+        const userId = await getAuthenticatedUserId(req, user_id);
         const relationshipKey = `${relationship_type}:${source_entity_id}:${target_entity_id}`;
         const { data: snapshot, error: snapshotError } = await db
             .from("relationship_snapshots")
@@ -2236,9 +2306,7 @@ app.get("/timeline", async (req, res) => {
         }
         // Enrich events with entity canonical names and types
         const events = data || [];
-        const entityIds = [
-            ...new Set(events.map((e) => e.entity_id).filter(Boolean)),
-        ];
+        const entityIds = [...new Set(events.map((e) => e.entity_id).filter(Boolean))];
         const entityLookup = new Map();
         if (entityIds.length > 0) {
             const { data: entities } = await db
@@ -2341,6 +2409,19 @@ app.get("/record_activity", async (req, res) => {
         return handleApiError(req, res, error, "Failed to list recent record activity", "DB_QUERY_FAILED", "APIError:record_activity");
     }
 });
+// GET /recent_conversations — Inspector: conversations with nested messages (SQLite)
+app.get("/recent_conversations", async (req, res) => {
+    try {
+        const userId = await getAuthenticatedUserId(req, req.query.user_id);
+        const limit = parseInt(String(req.query.limit ?? "25"), 10) || 25;
+        const offset = parseInt(String(req.query.offset ?? "0"), 10) || 0;
+        const result = listRecentConversations(userId, limit, offset);
+        return res.json(result);
+    }
+    catch (error) {
+        return handleApiError(req, res, error, "Failed to list recent conversations", "DB_QUERY_FAILED", "APIError:recent_conversations");
+    }
+});
 // GET /api/sources - Get source list (FU-301)
 app.get("/sources", async (req, res) => {
     try {
@@ -2660,7 +2741,7 @@ async function storeStructuredForApi(params) {
     const { userId, entities, sourcePriority, idempotencyKey, originalFilename, relationships, commit: commitInput, strict: strictInput, } = params;
     const commit = commitInput !== false;
     const strict = strictInput === true;
-    const { resolveEntityWithTrace, CanonicalNameUnresolvedError, MergeRefusedError, } = await import("./services/entity_resolution.js");
+    const { resolveEntityWithTrace, CanonicalNameUnresolvedError, MergeRefusedError } = await import("./services/entity_resolution.js");
     const { detectFlatPackedRows, FlatPackedRowsError } = await import("./services/flat_packed_detection.js");
     // Reject flat-packed rows (whole tables smuggled into a single entity as
     // `<prefix>_<index>_<suffix>` keys). These cannot produce per-row snapshots
@@ -2689,10 +2770,15 @@ async function storeStructuredForApi(params) {
             entity_type: obs.entity_type,
             observation_id: obs.id,
         }));
+        // Idempotency replay: the source row already exists for
+        // (user_id, idempotency_key). No new observations or entities were
+        // written. Callers distinguish this from a zero-commit fresh write via the
+        // `replayed: true` flag (v0.5.1+). See docs/architecture/idempotence_pattern.md.
         return {
             success: true,
+            replayed: true,
             source_id: existingSource.id,
-            entities_created: existingEntities.length,
+            entities_created: 0,
             observations_created: existingEntities.length,
             entities: existingEntities,
         };
@@ -2717,6 +2803,24 @@ async function storeStructuredForApi(params) {
             source_priority: sourcePriority,
         },
     });
+    // v0.5.1: structured guidance for the v0.5.0 breaking change where callers
+    // nested fields under `attributes`. If resolution failed and the only
+    // observed top-level keys are `attributes` (plus optionally `entity_type`),
+    // surface a hint pointing callers at the flat-payload convention.
+    function buildAttributesHint(seenFields) {
+        if (!Array.isArray(seenFields))
+            return undefined;
+        const keys = seenFields.filter((k) => typeof k === "string");
+        if (keys.length === 0)
+            return undefined;
+        const nonMetaKeys = keys.filter((k) => k !== "entity_type");
+        if (nonMetaKeys.length === 1 && nonMetaKeys[0] === "attributes") {
+            return ("Payload nests fields under `attributes`. Since v0.5.0, /store expects " +
+                "fields at the top level of each entity object (e.g. `{ entity_type, " +
+                "title, canonical_name, ... }`). Move keys out of `attributes` and retry.");
+        }
+        return undefined;
+    }
     const resolved = [];
     const issues = [];
     for (let observation_index = 0; observation_index < entities.length; observation_index++) {
@@ -2784,6 +2888,7 @@ async function storeStructuredForApi(params) {
         }
         catch (err) {
             if (err instanceof CanonicalNameUnresolvedError) {
+                const hint = buildAttributesHint(err.seenFields);
                 issues.push({
                     observation_index,
                     entity_type,
@@ -2793,6 +2898,7 @@ async function storeStructuredForApi(params) {
                         seen_fields: err.seenFields,
                         attempted_value: err.attemptedValue,
                     },
+                    ...(hint ? { hint } : {}),
                 });
             }
             else if (err instanceof MergeRefusedError) {
@@ -2843,8 +2949,7 @@ async function storeStructuredForApi(params) {
                 const { recomputeSnapshot } = await import("./services/snapshot_computation.js");
                 const snap = await recomputeSnapshot(r.entity_id, userId);
                 snapshotAfter =
-                    snap
-                        ?.snapshot ?? null;
+                    snap?.snapshot ?? null;
             }
             catch (snapshotErr) {
                 logger.warn(`Snapshot recompute failed for ${r.entity_id}: ${snapshotErr}`);
@@ -2920,11 +3025,11 @@ async function storeStructuredForApi(params) {
     }
     return {
         success: true,
+        replayed: false,
         commit,
         source_id: commit ? storageResult.sourceId : null,
         entities_created: commit
-            ? createdEntities.filter((e) => e.action === "created" || e.action === "extended")
-                .length
+            ? createdEntities.filter((e) => e.action === "created" || e.action === "extended").length
             : 0,
         observations_created: commit ? createdEntities.length : 0,
         entities: createdEntities,
@@ -2932,7 +3037,7 @@ async function storeStructuredForApi(params) {
     };
 }
 async function storeUnstructuredForApi(params) {
-    const { fileContent, fileBuffer, mimeType, idempotencyKey, originalFilename, userId, } = params;
+    const { fileContent, fileBuffer, mimeType, idempotencyKey, originalFilename, userId } = params;
     const resolvedFileBuffer = fileBuffer ?? (fileContent !== undefined ? Buffer.from(fileContent, "base64") : undefined);
     if (!resolvedFileBuffer) {
         throw new Error("fileContent or fileBuffer is required for unstructured storage");
@@ -3012,7 +3117,8 @@ app.post("/store", async (req, res) => {
                 fileContent,
                 fileBuffer: resolvedFileBuffer,
                 mimeType,
-                idempotencyKey: parsed.data.file_idempotency_key ?? (!hasEntities ? parsed.data.idempotency_key : undefined),
+                idempotencyKey: parsed.data.file_idempotency_key ??
+                    (!hasEntities ? parsed.data.idempotency_key : undefined),
                 originalFilename,
             });
         }
@@ -3031,18 +3137,13 @@ app.post("/store", async (req, res) => {
         if (error instanceof Error && error.message.includes("Not authenticated")) {
             return sendError(res, 401, "AUTH_REQUIRED", error.message);
         }
-        const errCode = error && typeof error === "object"
-            ? error.code
-            : undefined;
-        if (errCode === "ERR_FORBIDDEN_ENTITY_TYPE" ||
-            errCode === "ERR_PLURAL_ENTITY_TYPE") {
+        const errCode = error && typeof error === "object" ? error.code : undefined;
+        if (errCode === "ERR_FORBIDDEN_ENTITY_TYPE" || errCode === "ERR_PLURAL_ENTITY_TYPE") {
             const message = error instanceof Error ? error.message : String(error);
             logWarn("EntityTypeGuardError:store", req, { code: errCode, message });
             return sendError(res, 400, errCode, message);
         }
-        if (error &&
-            typeof error === "object" &&
-            errCode === "ERR_STORE_RESOLUTION_FAILED") {
+        if (error && typeof error === "object" && errCode === "ERR_STORE_RESOLUTION_FAILED") {
             const err = error;
             logWarn("StoreResolutionError:store", req, {
                 issue_count: err.issues?.length ?? 0,
@@ -3055,9 +3156,7 @@ app.post("/store", async (req, res) => {
                 },
             });
         }
-        if (error &&
-            typeof error === "object" &&
-            errCode === "ERR_FLAT_PACKED_ROWS") {
+        if (error && typeof error === "object" && errCode === "ERR_FLAT_PACKED_ROWS") {
             const err = error;
             logWarn("FlatPackedRowsError:store", req, {
                 prefix: err.detection.prefix,
@@ -3280,10 +3379,7 @@ app.post("/list_observations", async (req, res) => {
         return sendValidationError(res, parsed.error.issues);
     }
     const { entity_id, limit = 100, offset = 0, updated_since, created_since } = parsed.data;
-    let query = db
-        .from("observations")
-        .select("*")
-        .eq("entity_id", entity_id);
+    let query = db.from("observations").select("*").eq("entity_id", entity_id);
     if (updated_since) {
         query = query.gte("observed_at", updated_since);
     }
@@ -3366,10 +3462,10 @@ app.post("/create_relationship", async (req, res) => {
         });
         return sendValidationError(res, parsed.error.issues);
     }
-    const { relationship_type, source_entity_id, target_entity_id, source_id, metadata } = parsed.data;
-    const userId = "00000000-0000-0000-0000-000000000000"; // v0.1.0 single-user
+    const { relationship_type, source_entity_id, target_entity_id, source_id, metadata, user_id } = parsed.data;
     const { relationshipsService } = await import("./services/relationships.js");
     try {
+        const userId = await getAuthenticatedUserId(req, user_id);
         const relationship = await relationshipsService.createRelationship({
             relationship_type,
             source_entity_id,
@@ -3889,8 +3985,7 @@ app.post("/update_schema_incremental", async (req, res) => {
         }
         catch (err) {
             const code = err?.code;
-            if (code === "ERR_FORBIDDEN_ENTITY_TYPE" ||
-                code === "ERR_PLURAL_ENTITY_TYPE") {
+            if (code === "ERR_FORBIDDEN_ENTITY_TYPE" || code === "ERR_PLURAL_ENTITY_TYPE") {
                 return sendError(res, 400, code, err.message);
             }
             throw err;
@@ -3963,8 +4058,7 @@ app.post("/register_schema", async (req, res) => {
             const code = err?.code;
             const message = err instanceof Error ? err.message : String(err);
             logWarn("ValidationError:register_schema", req, { error: message });
-            if (code === "ERR_FORBIDDEN_ENTITY_TYPE" ||
-                code === "ERR_PLURAL_ENTITY_TYPE") {
+            if (code === "ERR_FORBIDDEN_ENTITY_TYPE" || code === "ERR_PLURAL_ENTITY_TYPE") {
                 return sendError(res, 400, code, message);
             }
             return sendError(res, 400, "SCHEMA_VALIDATION_FAILED", message);