rhombus-node-mcp 0.1.54 → 0.1.55

package/dist/api/person-tracking-tool-api.js

@@ -1,134 +1,139 @@
 import { buildMediaHints } from "./badge-correlation.js";
-import { getFaceEvents, getRegisteredFaces, searchSimilarFaces } from "./faces-tool-api.js";
+import { searchElementsEvents } from "./elements-tool-api.js";
+import { getCameraList } from "./get-entity-tool-api.js";
+import { searchNetboxEvents } from "./netbox-tool-api.js";
+import { searchOnGuardEvents } from "./onguard-tool-api.js";
+import { listReidentificationEmbeddings, searchReidentificationMatchesByEmbedding } from "./reid-tool-api.js";
 import { formatTimestamp } from "../util.js";
-/**
- * Fuzzy-match a free-text name against the registered-faces directory. Mirrors faces-tool's scoring
- * (4 = exact full name, 3 = first name, 2 = last name, 1 = substring ≥3 chars) but returns every person
- * tied at the best score so the caller can flag ambiguity instead of silently tracking the wrong person.
- */
-function matchRegisteredPeople(query, people) {
-    const input = query.toLowerCase().trim();
-    if (!input)
-        return [];
-    let bestScore = 0;
-    const scored = [];
-    for (const person of people) {
-        if (!person.name || !person.uuid)
-            continue;
-        const fullName = person.name.toLowerCase().trim();
-        const parts = fullName.split(/\s+/);
-        let score = 0;
-        if (fullName === input)
-            score = 4;
-        else if (parts[0] === input)
-            score = 3;
-        else if (parts.length > 1 && parts[parts.length - 1] === input)
-            score = 2;
-        else if (input.length >= 3 && fullName.includes(input))
-            score = 1;
-        if (score > 0) {
-            scored.push({ name: person.name, uuid: person.uuid, score });
-            if (score > bestScore)
-                bestScore = score;
-        }
-    }
-    // Dedupe by uuid among the best-scoring tier.
-    const seen = new Set();
-    const top = [];
-    for (const s of scored) {
-        if (s.score !== bestScore || seen.has(s.uuid))
-            continue;
-        seen.add(s.uuid);
-        top.push({ name: s.name, personUuid: s.uuid });
-    }
-    return top;
+const DEFAULT_BADGE_MATCH_WINDOW_S = 30;
+const DEFAULT_TRACK_FORWARD_MS = 6 * 60 * 60 * 1000; // track 6h forward from the badge tap if no endTime
+/** RUUID without any `.vN` facet suffix, so a badge event's camera matches the camera-state list. */
+function stripFacet(uuid) {
+    return (uuid ?? "").split(".")[0];
 }
 /**
- * Reconstructs one person's movements across cameras as a chronological track of face sightings, each
- * with the still/clip hints needed to show the moment. Pure orchestration over the face-recognition
- * APIs:
- *   - faceEventUuid  -> searchSimilarFaces (appearance match; works for unrecognized people)
- *   - personUuid     -> getFaceEvents filtered to that person
- *   - personQuery    -> resolve name against registered faces, then getFaceEvents
+ * Reconstructs where a named person went, grounded in access control + person re-identification:
+ *   1. find the person's badge tap(s) (OnGuard / Elements / NetBox) → a camera + time we KNOW is them,
+ *   2. pull the re-id embedding recorded on that camera nearest the badge time (the person at the door),
+ *   3. re-id-search that embedding across cameras over the window → their cross-camera movement track.
+ *
+ * Identity comes from the badge (not face recognition); the track is appearance/re-id based.
  */
 export async function getPersonTrack(args, timeZone, requestModifiers, sessionId) {
-    let resolvedPerson;
-    let raw = [];
-    if (args.faceEventUuid) {
-        // Appearance-based track from a seed sighting — handles people who aren't registered/named.
-        const similar = await searchSimilarFaces(args.faceEventUuid, timeZone, requestModifiers, sessionId);
-        raw = similar.map((s) => ({
-            deviceUuid: s.deviceUuid,
-            timestampMs: s.eventTimestampMs,
-            datetime: s.eventTimestamp,
-            similarity: s.similarity,
-            faceName: undefined,
-        }));
+    // 1. Anchor on access-control events. Check all three badge integrations; an org may use any.
+    const badgeArgs = {
+        cardholderQuery: args.personQuery,
+        locationUuids: args.locationUuids,
+        afterMs: args.afterMs,
+        beforeMs: args.beforeMs,
+        limit: args.limit ?? 200,
+    };
+    const empty = { events: [] };
+    const [og, el, nb] = await Promise.all([
+        searchOnGuardEvents(badgeArgs, timeZone, requestModifiers, sessionId).catch(() => empty),
+        searchElementsEvents(badgeArgs, timeZone, requestModifiers, sessionId).catch(() => empty),
+        searchNetboxEvents(badgeArgs, timeZone, requestModifiers, sessionId).catch(() => empty),
+    ]);
+    const badgeEvents = [
+        ...og.events.map((e) => ({ ...e, integration: "OnGuard" })),
+        ...el.events.map((e) => ({ ...e, integration: "Elements" })),
+        ...nb.events.map((e) => ({ ...e, integration: "NetBox" })),
+    ]
+        .filter((e) => e.deviceUuid && e.timestampMs != null)
+        .sort((a, b) => (a.timestampMs ?? 0) - (b.timestampMs ?? 0));
+    if (badgeEvents.length === 0) {
+        return {
+            sightings: [],
+            path: [],
+            count: 0,
+            note: `No access-control (badge) events found for "${args.personQuery}" in the window — can't anchor a re-id track. Try a wider time range, or confirm the name as it appears on the badge.`,
+        };
+    }
+    // Earliest badge tap in the window — track forward from there.
+    const anchor = badgeEvents[0];
+    const resolvedPerson = anchor.cardholderName ? { name: anchor.cardholderName } : undefined;
+    const anchorOut = {
+        deviceUuid: anchor.deviceUuid,
+        timestampMs: anchor.timestampMs,
+        datetime: anchor.datetime,
+        integration: anchor.integration,
+        area: anchor.areaEntering ?? anchor.areaExiting,
+    };
+    // 2. Resolve the badge camera's location (re-id list is scoped by location).
+    let anchorLocationUuid;
+    try {
+        const { cameras } = await getCameraList(requestModifiers, sessionId);
+        const dev = stripFacet(anchor.deviceUuid);
+        anchorLocationUuid = cameras.find((c) => stripFacet(c.uuid) === dev)?.locationUuid;
+    }
+    catch {
+        // best-effort; the re-id list can still run device-scoped without a location
+    }
+    // 3. Ground the re-id embedding: the person detected on that camera nearest the badge tap.
+    const winMs = (args.badgeMatchWindowSeconds ?? DEFAULT_BADGE_MATCH_WINDOW_S) * 1000;
+    const anchorMs = anchor.timestampMs;
+    const embeddings = await listReidentificationEmbeddings({
+        deviceUuids: [anchor.deviceUuid],
+        locationUuid: anchorLocationUuid,
+        startTimestampMs: anchorMs - winMs,
+        endTimestampMs: anchorMs + winMs,
+        limit: 100,
+    }, requestModifiers, sessionId);
+    if (embeddings.length === 0) {
+        return {
+            resolvedPerson,
+            anchor: anchorOut,
+            sightings: [],
+            path: [],
+            count: 0,
+            note: `Found ${anchor.cardholderName ?? "the person"}'s badge tap at ${anchor.datetime}, but no person re-identification embedding was recorded on that camera within ±${args.badgeMatchWindowSeconds ?? DEFAULT_BADGE_MATCH_WINDOW_S}s — can't build a re-id track. (Re-id needs human-detection coverage on the door camera.)`,
+        };
     }
-    else {
-        // Resolve to a person UUID (directly or by name) before pulling their face events.
-        let personUuid = args.personUuid;
-        if (!personUuid && args.personQuery) {
-            const peopleResponse = await getRegisteredFaces({}, requestModifiers, sessionId);
-            const matches = matchRegisteredPeople(args.personQuery, peopleResponse.people ?? []);
-            if (matches.length > 1) {
-                return { ambiguousPeople: matches, sightings: [], path: [], count: 0 };
-            }
-            if (matches.length === 0) {
-                return { sightings: [], path: [], count: 0 };
-            }
-            resolvedPerson = matches[0];
-            personUuid = matches[0].personUuid;
-        }
-        else if (personUuid) {
-            resolvedPerson = { personUuid };
-        }
-        if (!personUuid) {
-            return { sightings: [], path: [], count: 0 };
-        }
-        const faceEventArgs = {
-            pageRequest: { maxPageSize: args.limit ?? 200, lastEvaluatedKey: null },
-            searchFilter: {
-                faceNameContains: null,
-                faceNames: [],
-                hasEmbedding: null,
-                hasName: null,
-                labels: [],
-                locationUuids: args.locationUuids ?? [],
-                personUuids: [personUuid],
-                timestampFilter: args.afterMs != null || args.beforeMs != null
-                    ? {
-                        rangeStart: args.afterMs != null ? new Date(args.afterMs).toISOString() : null,
-                        rangeEnd: args.beforeMs != null ? new Date(args.beforeMs).toISOString() : null,
-                    }
-                    : null,
-            },
+    // The detection closest in time to the badge tap is the best proxy for the badge holder.
+    const seed = embeddings.reduce((best, e) => Math.abs((e.timestamp ?? 0) - anchorMs) < Math.abs((best.timestamp ?? 0) - anchorMs) ? e : best);
+    if (!seed.embedding || seed.embedding.length === 0) {
+        return {
+            resolvedPerson,
+            anchor: anchorOut,
+            sightings: [],
+            path: [],
+            count: 0,
+            note: "The re-id detection at the door had no embedding vector; can't search for matches.",
         };
-        const { faceEvents } = await getFaceEvents(faceEventArgs, timeZone, requestModifiers, sessionId);
-        raw = faceEvents.map((e) => ({
-            deviceUuid: e.deviceUuid,
-            timestampMs: e.eventTimestampMs,
-            datetime: e.eventTimestamp,
-            locationUuid: e.locationUuid,
-            faceName: e.faceName,
-            thumbnailS3Key: e.thumbnailS3Key,
-        }));
-        if (!resolvedPerson?.name) {
-            const named = raw.find((r) => r.faceName);
-            if (named?.faceName)
-                resolvedPerson = { name: named.faceName, personUuid };
-        }
     }
-    // Always enforce the time window client-side (searchSimilarFaces has no time filter, and the face-event
-    // time filter defaults to the last 7 days if unset) and order chronologically.
-    const ordered = raw
-        .filter((r) => r.timestampMs != null)
-        .filter((r) => (args.afterMs == null || r.timestampMs >= args.afterMs))
-        .filter((r) => (args.beforeMs == null || r.timestampMs <= args.beforeMs))
-        .sort((a, b) => (a.timestampMs ?? 0) - (b.timestampMs ?? 0))
-        .slice(0, args.limit ?? 200);
-    const sightings = buildSightings(ordered, timeZone, args.clipPaddingSeconds);
-    // Camera sequence the person moved through, collapsing consecutive repeats.
+    // 4. Re-id search that appearance across cameras over the window.
+    const searchStart = args.afterMs ?? anchorMs;
+    const searchEnd = args.beforeMs ?? anchorMs + DEFAULT_TRACK_FORWARD_MS;
+    const matches = await searchReidentificationMatchesByEmbedding({
+        searchEmbedding: seed.embedding,
+        locationUuid: args.locationUuids?.[0],
+        startTimestampMs: searchStart,
+        endTimestampMs: searchEnd,
+        limit: args.limit ?? 200,
+    }, requestModifiers, sessionId);
+    // 5. Build the chronological track with media hints.
+    const ordered = matches
+        .filter((m) => m.timestamp != null)
+        .sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    const sightings = ordered.map((m, i) => {
+        const next = ordered[i + 1];
+        const gapToNextSeconds = next?.timestamp != null && m.timestamp != null
+            ? Math.round((next.timestamp - m.timestamp) / 1000)
+            : undefined;
+        const { clipHint, stillHint } = buildMediaHints({ deviceUuid: m.deviceUuid, timestampMs: m.timestamp }, args.clipPaddingSeconds);
+        return {
+            timestampMs: m.timestamp,
+            datetime: m.timestamp != null ? formatTimestamp(m.timestamp, timeZone) : undefined,
+            deviceUuid: m.deviceUuid,
+            locationUuid: m.locationUuid,
+            distance: m.distance,
+            stableTrackId: m.stableTrackId,
+            thumbnailUri: m.thumbnailUri,
+            clipHint,
+            stillHint,
+            gapToNextSeconds,
+        };
+    });
     const path = [];
     for (const s of sightings) {
         if (s.deviceUuid && s.deviceUuid !== path[path.length - 1])
@@ -136,30 +141,10 @@ export async function getPersonTrack(args, timeZone, requestModifiers, sessionId
     }
     return {
         resolvedPerson,
+        anchor: anchorOut,
         sightings,
         path,
         lastKnownSighting: sightings[sightings.length - 1],
         count: sightings.length,
     };
 }
-function buildSightings(ordered, timeZone, clipPaddingSeconds) {
-    return ordered.map((s, i) => {
-        const next = ordered[i + 1];
-        const gapToNextSeconds = next?.timestampMs != null && s.timestampMs != null
-            ? Math.round((next.timestampMs - s.timestampMs) / 1000)
-            : undefined;
-        const { clipHint, stillHint } = buildMediaHints({ deviceUuid: s.deviceUuid, timestampMs: s.timestampMs }, clipPaddingSeconds);
-        return {
-            timestampMs: s.timestampMs,
-            datetime: s.datetime ?? (s.timestampMs != null ? formatTimestamp(s.timestampMs, timeZone) : undefined),
-            deviceUuid: s.deviceUuid,
-            locationUuid: s.locationUuid,
-            faceName: s.faceName,
-            similarity: s.similarity,
-            thumbnailS3Key: s.thumbnailS3Key,
-            clipHint,
-            stillHint,
-            gapToNextSeconds,
-        };
-    });
-}

package/dist/api/reid-tool-api.js

@@ -0,0 +1,62 @@
+import { postApi } from "../network/network.js";
+function mapEmbedding(e) {
+    return {
+        deviceUuid: e.deviceUuid ?? undefined,
+        locationUuid: e.locationUuid ?? undefined,
+        timestamp: e.timestamp ?? undefined,
+        embedding: (e.embedding ?? []).filter((n) => n != null),
+        embeddingId: e.embeddingId ?? undefined,
+        stableTrackId: e.stableTrackId ?? undefined,
+        thumbnailUri: e.thumbnailUri ?? undefined,
+    };
+}
+/**
+ * Lists the person re-identification embeddings recorded on the given camera(s) in a time window —
+ * i.e. the people the camera's human-detection AI saw. Used to grab the embedding of the person standing
+ * at a door at a known moment (e.g. a badge tap), so it can be tracked across other cameras.
+ */
+export async function listReidentificationEmbeddings(args, requestModifiers, sessionId) {
+    const body = {
+        deviceUuids: args.deviceUuids,
+        locationUuid: args.locationUuid,
+        startTimestampMs: args.startTimestampMs,
+        endTimestampMs: args.endTimestampMs,
+        limit: args.limit ?? 100,
+    };
+    const res = await postApi({
+        route: "/search/listReidentificationEmbeddings",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(res.errorMsg ?? "listReidentificationEmbeddings failed");
+    return (res.embeddings ?? []).map(mapEmbedding);
+}
+/**
+ * Searches person re-identification matches for a given appearance embedding across cameras and time —
+ * "find this same person elsewhere". Returns sightings ordered by similarity (distance asc; lower is a
+ * closer match).
+ */
+export async function searchReidentificationMatchesByEmbedding(args, requestModifiers, sessionId) {
+    const body = {
+        searchEmbedding: args.searchEmbedding,
+        deviceUuids: args.deviceUuids,
+        locationUuid: args.locationUuid,
+        startTimestampMs: args.startTimestampMs,
+        endTimestampMs: args.endTimestampMs,
+        limit: args.limit ?? 100,
+    };
+    const res = await postApi({
+        route: "/search/searchReidentificationMatchesByEmbedding",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(res.errorMsg ?? "searchReidentificationMatchesByEmbedding failed");
+    return (res.matches ?? []).map((m) => ({
+        ...mapEmbedding(m.embedding ?? {}),
+        distance: m.distance ?? undefined,
+    }));
+}

package/dist/tools-console/person-tracking-tool.js

@@ -3,28 +3,25 @@ import { OUTPUT_SCHEMA, TOOL_ARGS } from "../types/person-tracking-tool-types.js
 import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
 const TOOL_NAME = "person-tracking-tool";
 const TOOL_DESCRIPTION = `
-Tracks one person's movements across cameras using face recognition. Use this for "track this person",
-"where did X go", "follow this person across the building", or "where was X last seen" — the camera-based
-counterpart to the badge-timeline tools (which follow door taps).
+Reconstructs where a named person went across cameras, e.g. "show me where Brandon Salzberg went" or
+"track Eve through the building yesterday". Identity is grounded in ACCESS CONTROL and the track uses
+person RE-IDENTIFICATION (appearance), NOT face recognition:
 
-Identify the person ONE of three ways (in priority order):
-- faceEventUuid: track by APPEARANCE from a specific sighting — works even for an unrecognized/unnamed
-  person (e.g. follow the person in this face event). Get a faceEventUuid from the faces-tool.
-- personUuid: the exact registered-person UUID (from faces-tool get-registered-faces).
-- personQuery: a full-text name (e.g. "Eve" or "Eve Adams"); it is resolved against the registered-faces
-  directory. If "ambiguousPeople" is returned the name matched more than one person — ask the user which
-  one before trusting the track.
+1. Finds the person's badge tap(s) (OnGuard / Elements / NetBox) in the window — a camera + time we KNOW
+   is them. (Pass the name as it appears on the badge.)
+2. Pulls the person re-id embedding recorded on that door camera nearest the badge tap (the person at the
+   door).
+3. Re-id-searches that appearance across all cameras over the window to reconstruct their movement.
 
-Returns the person's sightings in CHRONOLOGICAL order (oldest first), each with:
-- datetime / timestampMs, deviceUuid (the camera), and locationUuid
-- similarity (only on appearance/faceEventUuid tracks) and a face thumbnail key
-- clipHint (camera + start/end window) and stillHint (camera + timestamp)
-- gapToNextSeconds: time until the next sighting (a large gap = unobserved movement between cameras)
-plus a "path" array (the camera sequence, consecutive repeats collapsed) and "lastKnownSighting" (the
-person's last-known location).
+Returns:
+- resolvedPerson and "anchor" (the badge tap that grounded the track: door camera, time, integration).
+- sightings: chronological re-id hits, each with deviceUuid (camera), timestampMs/datetime, distance
+  (LOWER = closer appearance match), a thumbnail, clipHint/stillHint, and gapToNextSeconds.
+- path (camera sequence) and lastKnownSighting (last-known location).
+- note: set when no badge tap was found, or no re-id embedding existed on the door camera.
 
 Resolve relative times like "yesterday" to ISO 8601 first (use the timestamp tool), then pass
-startTime/endTime. Face tracking depends on face-recognition coverage, so treat the track as investigative.
+startTime/endTime. Re-id depends on human-detection coverage, so treat the track as investigative, not proof.
 
 IMPORTANT — to show the movement visually: for each sighting (or the key transitions), call the camera-tool
 (requestType "image", cameraUuid = sighting.deviceUuid, timestamp = sighting.timestampMs) for a still, and/or
@@ -35,12 +32,11 @@ const TOOL_HANDLER = async (args, _extra) => {
     const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
     try {
         const result = await getPersonTrack({
-            personQuery: args.personQuery ?? undefined,
-            personUuid: args.personUuid ?? undefined,
-            faceEventUuid: args.faceEventUuid ?? undefined,
-            locationUuids: args.locationUuids ?? undefined,
+            personQuery: args.personQuery,
             afterMs: args.startTime ? new Date(args.startTime).getTime() : undefined,
             beforeMs: args.endTime ? new Date(args.endTime).getTime() : undefined,
+            locationUuids: args.locationUuids ?? undefined,
+            badgeMatchWindowSeconds: args.badgeMatchWindowSeconds ?? undefined,
             clipPaddingSeconds: args.clipPaddingSeconds ?? undefined,
             limit: args.limit ?? undefined,
         }, args.timeZone ?? "UTC", requestModifiers, sessionId);

package/dist/types/person-tracking-tool-types.js

@@ -4,32 +4,25 @@ import { ISOTimestampFormatDescription } from "../utils/timestampInput.js";
 export const TOOL_ARGS = {
     personQuery: z
         .string()
-        .nullable()
-        .describe('The recognized person to track, full-text name match against registered faces, e.g. "Eve" or "Eve Adams". ' +
-        "Provide this OR personUuid OR faceEventUuid."),
-    personUuid: z
-        .string()
-        .nullable()
-        .describe("The exact person UUID to track (from faces-tool get-registered-faces). Takes precedence over personQuery."),
-    faceEventUuid: z
-        .string()
-        .nullable()
-        .describe("Track by appearance from a specific face sighting (a faceEvent UUID), even when the person isn't a registered/named face. " +
-        "Use this for 'track THIS person' from a sighting. Takes precedence over personQuery/personUuid."),
-    locationUuids: z
-        .array(createUuidSchema())
-        .nullable()
-        .describe("Optional: restrict to these Rhombus location UUIDs. Use the location-tool to resolve names."),
+        .describe('The person to track, full-text name match against their access-control (badge) records, e.g. "Brandon" or "Brandon Salzberg".'),
     startTime: z
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
         .nullable()
-        .describe("Start of the window (inclusive). " + ISOTimestampFormatDescription),
+        .describe("Start of the window to search badge taps and track over (inclusive). " + ISOTimestampFormatDescription),
     endTime: z
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
         .nullable()
         .describe("End of the window (inclusive). " + ISOTimestampFormatDescription),
+    locationUuids: z
+        .array(createUuidSchema())
+        .nullable()
+        .describe("Optional: restrict badge search and the re-id track to these Rhombus location UUIDs."),
+    badgeMatchWindowSeconds: z
+        .number()
+        .nullable()
+        .describe("± seconds around the badge tap to look on the door camera for the person's re-id embedding (default 30)."),
     clipPaddingSeconds: z
         .number()
         .nullable()
@@ -42,36 +35,22 @@ export const TOOL_ARGS = {
 };
 const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
 const ClipHintSchema = z
-    .object({
-    deviceUuid: z.string(),
-    startTimeMs: z.number(),
-    endTimeMs: z.number(),
-})
+    .object({ deviceUuid: z.string(), startTimeMs: z.number(), endTimeMs: z.number() })
     .describe("Pass to clips-tool createClip to get video of this sighting.");
 const StillHintSchema = z
-    .object({
-    deviceUuid: z.string(),
-    timestampMs: z.number(),
-})
+    .object({ deviceUuid: z.string(), timestampMs: z.number() })
     .describe("Pass to camera-tool (requestType image) to get a still of this sighting.");
-const PersonRefSchema = z.object({
-    name: z.string().optional(),
-    personUuid: z.string().optional(),
-});
 export const SightingSchema = z.object({
     timestampMs: z.number().optional(),
     datetime: z.string().optional().describe("Human-readable sighting time in the requested timezone."),
-    deviceUuid: z
-        .string()
-        .optional()
-        .describe("The camera that saw the person. Pass to camera-tool (image) or clips-tool (createClip)."),
-    locationUuid: z.string().optional().describe("The location where the sighting occurred."),
-    faceName: z.string().optional().describe("The recognized name on this sighting, if any."),
-    similarity: z
+    deviceUuid: z.string().optional().describe("The camera that re-identified the person."),
+    locationUuid: z.string().optional(),
+    distance: z
         .number()
         .optional()
-        .describe("Appearance-match similarity (0-1) when tracking from a faceEventUuid seed."),
-    thumbnailS3Key: z.string().optional().describe("Thumbnail key for the detected face on this sighting."),
+        .describe("Re-id match distance to the door embedding — LOWER means a closer appearance match."),
+    stableTrackId: z.number().optional().describe("Per-camera track-consolidation id for this detection."),
+    thumbnailUri: z.string().optional().describe("Thumbnail of the detected person."),
     clipHint: ClipHintSchema.optional(),
     stillHint: StillHintSchema.optional(),
     gapToNextSeconds: z
@@ -79,21 +58,31 @@ export const SightingSchema = z.object({
         .optional()
         .describe("Seconds until the next sighting — large gaps mean the person was unobserved between cameras."),
 });
+const AnchorSchema = z
+    .object({
+    deviceUuid: z.string().optional().describe("The door camera where the badge tap happened."),
+    timestampMs: z.number().optional(),
+    datetime: z.string().optional(),
+    integration: z.string().optional().describe("Which badge system the tap came from (OnGuard / Elements / NetBox)."),
+    area: z.string().optional(),
+})
+    .describe("The access-control badge tap used to ground the re-id track (the known identity moment).");
 export const OUTPUT_SCHEMA = z.object({
-    resolvedPerson: PersonRefSchema.optional().describe("The person actually tracked (name + UUID), when resolved."),
-    ambiguousPeople: z
-        .array(PersonRefSchema)
+    resolvedPerson: z
+        .object({ name: z.string().optional() })
         .optional()
-        .describe("Set when personQuery matched more than one registered person — disambiguate with the user before trusting the track."),
+        .describe("The person resolved from the badge record."),
+    anchor: AnchorSchema.optional(),
     sightings: z
         .array(SightingSchema)
         .optional()
-        .describe("The person's camera sightings in chronological order (oldest first)."),
+        .describe("Re-id sightings of the person across cameras, in chronological order (oldest first)."),
     path: z
         .array(z.string())
         .optional()
-        .describe("Camera UUIDs the person passed through, in order (consecutive repeats collapsed)."),
-    lastKnownSighting: SightingSchema.optional().describe("The most recent sighting — the person's last-known location."),
-    count: z.number().optional().describe("Number of sightings returned."),
+        .describe("Camera UUIDs the person was re-identified at, in order (consecutive repeats collapsed)."),
+    lastKnownSighting: SightingSchema.optional().describe("The most recent re-id sighting — last-known location."),
+    count: z.number().optional().describe("Number of re-id sightings returned."),
+    note: z.string().optional().describe("Set when the track couldn't be built (no badge tap, or no re-id at the door)."),
     error: z.string().optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",