@blueharford/scrypted-spatial-awareness 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Cross-camera object tracking for Scrypted NVR with spatial awareness",
   "author": "Joshua Seidel <blueharford>",
   "license": "Apache-2.0",

package/src/core/spatial-reasoning.ts

@@ -116,7 +116,7 @@ export class SpatialReasoningEngine {
     }
 
     // Landmark contexts
-    for (const landmark of this.topology.landmarks) {
+    for (const landmark of this.topology.landmarks || []) {
       this.contextChunks.push({
         id: `landmark_${landmark.id}`,
         type: 'landmark',

package/src/core/tracking-engine.ts

@@ -14,7 +14,7 @@ import sdk, {
   Camera,
   MediaObject,
 } from '@scrypted/sdk';
-import { CameraTopology, findCamera, findConnection, findConnectionsFrom, Landmark } from '../models/topology';
+import { CameraTopology, CameraConnection, findCamera, findConnection, findConnectionsFrom, Landmark } from '../models/topology';
 import {
   TrackedObject,
   ObjectSighting,
@@ -48,12 +48,43 @@ export interface TrackingEngineConfig {
   objectAlertCooldown: number;
   /** Use LLM for enhanced descriptions */
   useLlmDescriptions: boolean;
+  /** LLM rate limit interval (ms) - minimum time between LLM calls */
+  llmDebounceInterval?: number;
+  /** Whether to fall back to basic notifications when LLM is unavailable or slow */
+  llmFallbackEnabled?: boolean;
+  /** Timeout for LLM responses (ms) */
+  llmFallbackTimeout?: number;
+  /** Enable automatic transit time learning from observations */
+  enableTransitTimeLearning?: boolean;
+  /** Enable automatic camera connection suggestions */
+  enableConnectionSuggestions?: boolean;
   /** Enable landmark learning from AI */
   enableLandmarkLearning?: boolean;
   /** Minimum confidence for landmark suggestions */
   landmarkConfidenceThreshold?: number;
 }
 
+/** Observed transit time for learning */
+interface ObservedTransit {
+  fromCameraId: string;
+  toCameraId: string;
+  transitTime: number;
+  timestamp: number;
+}
+
+/** Suggested camera connection based on observed patterns */
+export interface ConnectionSuggestion {
+  id: string;
+  fromCameraId: string;
+  fromCameraName: string;
+  toCameraId: string;
+  toCameraName: string;
+  observedTransits: ObservedTransit[];
+  suggestedTransitTime: { min: number; typical: number; max: number };
+  confidence: number;
+  timestamp: number;
+}
+
 export class TrackingEngine {
   private topology: CameraTopology;
   private state: TrackingState;
@@ -70,6 +101,20 @@ export class TrackingEngine {
   /** Callback for topology changes (e.g., landmark suggestions) */
   private onTopologyChange?: (topology: CameraTopology) => void;
 
+  // ==================== LLM Debouncing ====================
+  /** Last time LLM was called */
+  private lastLlmCallTime: number = 0;
+  /** Queue of pending LLM requests (we only keep latest) */
+  private llmDebounceTimer: NodeJS.Timeout | null = null;
+
+  // ==================== Transit Time Learning ====================
+  /** Observed transit times for learning */
+  private observedTransits: Map<string, ObservedTransit[]> = new Map();
+  /** Connection suggestions based on observed patterns */
+  private connectionSuggestions: Map<string, ConnectionSuggestion> = new Map();
+  /** Minimum observations before suggesting a connection */
+  private readonly MIN_OBSERVATIONS_FOR_SUGGESTION = 3;
+
   constructor(
     topology: CameraTopology,
     state: TrackingState,
@@ -232,7 +277,20 @@ export class TrackingEngine {
     this.objectLastAlertTime.set(globalId, Date.now());
   }
 
-  /** Get spatial reasoning result for movement (uses RAG + LLM) */
+  /** Check if LLM call is allowed (rate limiting) */
+  private isLlmCallAllowed(): boolean {
+    const debounceInterval = this.config.llmDebounceInterval || 0;
+    if (debounceInterval <= 0) return true;
+    const timeSinceLastCall = Date.now() - this.lastLlmCallTime;
+    return timeSinceLastCall >= debounceInterval;
+  }
+
+  /** Record that an LLM call was made */
+  private recordLlmCall(): void {
+    this.lastLlmCallTime = Date.now();
+  }
+
+  /** Get spatial reasoning result for movement (uses RAG + LLM) with debouncing and fallback */
   private async getSpatialDescription(
     tracked: TrackedObject,
     fromCameraId: string,
@@ -240,7 +298,16 @@ export class TrackingEngine {
     transitTime: number,
     currentCameraId: string
   ): Promise<SpatialReasoningResult | null> {
+    const fallbackEnabled = this.config.llmFallbackEnabled ?? true;
+    const fallbackTimeout = this.config.llmFallbackTimeout ?? 3000;
+
     try {
+      // Check rate limiting - if not allowed, return null to use basic description
+      if (!this.isLlmCallAllowed()) {
+        this.console.log('LLM rate-limited, using basic notification');
+        return null;
+      }
+
       // Get snapshot from camera for LLM analysis (if LLM is enabled)
       let mediaObject: MediaObject | undefined;
       if (this.config.useLlmDescriptions) {
@@ -250,16 +317,42 @@ export class TrackingEngine {
         }
       }
 
+      // Record that we're making an LLM call
+      this.recordLlmCall();
+
       // Use spatial reasoning engine for rich context-aware description
-      const result = await this.spatialReasoning.generateMovementDescription(
-        tracked,
-        fromCameraId,
-        toCameraId,
-        transitTime,
-        mediaObject
-      );
+      // Apply timeout if fallback is enabled
+      let result: SpatialReasoningResult;
+      if (fallbackEnabled && mediaObject) {
+        const timeoutPromise = new Promise<SpatialReasoningResult | null>((_, reject) => {
+          setTimeout(() => reject(new Error('LLM timeout')), fallbackTimeout);
+        });
+
+        const descriptionPromise = this.spatialReasoning.generateMovementDescription(
+          tracked,
+          fromCameraId,
+          toCameraId,
+          transitTime,
+          mediaObject
+        );
+
+        try {
+          result = await Promise.race([descriptionPromise, timeoutPromise]) as SpatialReasoningResult;
+        } catch (timeoutError) {
+          this.console.log('LLM timed out, using basic notification');
+          return null;
+        }
+      } else {
+        result = await this.spatialReasoning.generateMovementDescription(
+          tracked,
+          fromCameraId,
+          toCameraId,
+          transitTime,
+          mediaObject
+        );
+      }
 
-      // Optionally trigger landmark learning
+      // Optionally trigger landmark learning (background, non-blocking)
       if (this.config.enableLandmarkLearning && mediaObject) {
         this.tryLearnLandmark(currentCameraId, mediaObject, tracked.className);
       }
@@ -328,6 +421,9 @@ export class TrackingEngine {
           correlationConfidence: correlation.confidence,
         });
 
+        // Record for transit time learning
+        this.recordObservedTransit(lastSighting.cameraId, sighting.cameraId, transitDuration);
+
         this.console.log(
           `Object ${tracked.globalId.slice(0, 8)} transited: ` +
           `${lastSighting.cameraName} → ${sighting.cameraName} ` +
@@ -571,4 +667,274 @@ export class TrackingEngine {
   getTrackedObject(globalId: GlobalTrackingId): TrackedObject | undefined {
     return this.state.getObject(globalId);
   }
+
+  // ==================== Transit Time Learning ====================
+
+  /** Record an observed transit time for learning */
+  private recordObservedTransit(
+    fromCameraId: string,
+    toCameraId: string,
+    transitTime: number
+  ): void {
+    if (!this.config.enableTransitTimeLearning) return;
+
+    const key = `${fromCameraId}->${toCameraId}`;
+    const observation: ObservedTransit = {
+      fromCameraId,
+      toCameraId,
+      transitTime,
+      timestamp: Date.now(),
+    };
+
+    // Add to observations
+    if (!this.observedTransits.has(key)) {
+      this.observedTransits.set(key, []);
+    }
+    const observations = this.observedTransits.get(key)!;
+    observations.push(observation);
+
+    // Keep only last 100 observations per connection
+    if (observations.length > 100) {
+      observations.shift();
+    }
+
+    // Check if we should update existing connection
+    const existingConnection = findConnection(this.topology, fromCameraId, toCameraId);
+    if (existingConnection) {
+      this.maybeUpdateConnectionTransitTime(existingConnection, observations);
+    } else if (this.config.enableConnectionSuggestions) {
+      // No existing connection - suggest one
+      this.maybeCreateConnectionSuggestion(fromCameraId, toCameraId, observations);
+    }
+  }
+
+  /** Update an existing connection's transit time based on observations */
+  private maybeUpdateConnectionTransitTime(
+    connection: CameraConnection,
+    observations: ObservedTransit[]
+  ): void {
+    if (observations.length < 5) return; // Need minimum observations
+
+    const times = observations.map(o => o.transitTime).sort((a, b) => a - b);
+
+    // Calculate percentiles
+    const newMin = times[Math.floor(times.length * 0.1)];
+    const newTypical = times[Math.floor(times.length * 0.5)];
+    const newMax = times[Math.floor(times.length * 0.9)];
+
+    // Only update if significantly different (>20% change)
+    const currentTypical = connection.transitTime.typical;
+    const percentChange = Math.abs(newTypical - currentTypical) / currentTypical;
+
+    if (percentChange > 0.2 && observations.length >= 10) {
+      this.console.log(
+        `Updating transit time for ${connection.name}: ` +
+        `${Math.round(currentTypical / 1000)}s → ${Math.round(newTypical / 1000)}s (based on ${observations.length} observations)`
+      );
+
+      connection.transitTime = {
+        min: newMin,
+        typical: newTypical,
+        max: newMax,
+      };
+
+      // Notify about topology change
+      if (this.onTopologyChange) {
+        this.onTopologyChange(this.topology);
+      }
+    }
+  }
+
+  /** Create or update a connection suggestion based on observations */
+  private maybeCreateConnectionSuggestion(
+    fromCameraId: string,
+    toCameraId: string,
+    observations: ObservedTransit[]
+  ): void {
+    if (observations.length < this.MIN_OBSERVATIONS_FOR_SUGGESTION) return;
+
+    const fromCamera = findCamera(this.topology, fromCameraId);
+    const toCamera = findCamera(this.topology, toCameraId);
+    if (!fromCamera || !toCamera) return;
+
+    const key = `${fromCameraId}->${toCameraId}`;
+    const times = observations.map(o => o.transitTime).sort((a, b) => a - b);
+
+    // Calculate transit time suggestion
+    const suggestedMin = times[Math.floor(times.length * 0.1)] || times[0];
+    const suggestedTypical = times[Math.floor(times.length * 0.5)] || times[0];
+    const suggestedMax = times[Math.floor(times.length * 0.9)] || times[times.length - 1];
+
+    // Calculate confidence based on consistency and count
+    const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+    const variance = times.reduce((sum, t) => sum + Math.pow(t - avgTime, 2), 0) / times.length;
+    const stdDev = Math.sqrt(variance);
+    const coefficientOfVariation = stdDev / avgTime;
+
+    // Higher confidence with more observations and lower variance
+    const countFactor = Math.min(observations.length / 10, 1);
+    const consistencyFactor = Math.max(0, 1 - coefficientOfVariation);
+    const confidence = (countFactor * 0.6 + consistencyFactor * 0.4);
+
+    const suggestion: ConnectionSuggestion = {
+      id: `suggest_${key}`,
+      fromCameraId,
+      fromCameraName: fromCamera.name,
+      toCameraId,
+      toCameraName: toCamera.name,
+      observedTransits: observations.slice(-10), // Keep last 10
+      suggestedTransitTime: {
+        min: suggestedMin,
+        typical: suggestedTypical,
+        max: suggestedMax,
+      },
+      confidence,
+      timestamp: Date.now(),
+    };
+
+    this.connectionSuggestions.set(key, suggestion);
+
+    if (observations.length === this.MIN_OBSERVATIONS_FOR_SUGGESTION) {
+      this.console.log(
+        `New connection suggested: ${fromCamera.name} → ${toCamera.name} ` +
+        `(typical: ${Math.round(suggestedTypical / 1000)}s, confidence: ${Math.round(confidence * 100)}%)`
+      );
+    }
+  }
+
+  /** Get pending connection suggestions */
+  getConnectionSuggestions(): ConnectionSuggestion[] {
+    return Array.from(this.connectionSuggestions.values())
+      .filter(s => s.confidence >= 0.5) // Only suggest with reasonable confidence
+      .sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /** Accept a connection suggestion, adding it to topology */
+  acceptConnectionSuggestion(suggestionId: string): CameraConnection | null {
+    const key = suggestionId.replace('suggest_', '');
+    const suggestion = this.connectionSuggestions.get(key);
+    if (!suggestion) return null;
+
+    const fromCamera = findCamera(this.topology, suggestion.fromCameraId);
+    const toCamera = findCamera(this.topology, suggestion.toCameraId);
+    if (!fromCamera || !toCamera) return null;
+
+    const connection: CameraConnection = {
+      id: `conn-${Date.now()}`,
+      fromCameraId: suggestion.fromCameraId,
+      toCameraId: suggestion.toCameraId,
+      name: `${fromCamera.name} to ${toCamera.name}`,
+      exitZone: [],
+      entryZone: [],
+      transitTime: suggestion.suggestedTransitTime,
+      bidirectional: true, // Default to bidirectional
+    };
+
+    this.topology.connections.push(connection);
+    this.connectionSuggestions.delete(key);
+
+    // Notify about topology change
+    if (this.onTopologyChange) {
+      this.onTopologyChange(this.topology);
+    }
+
+    this.console.log(`Connection accepted: ${connection.name}`);
+    return connection;
+  }
+
+  /** Reject a connection suggestion */
+  rejectConnectionSuggestion(suggestionId: string): boolean {
+    const key = suggestionId.replace('suggest_', '');
+    if (!this.connectionSuggestions.has(key)) return false;
+    this.connectionSuggestions.delete(key);
+    // Also clear observations so it doesn't get re-suggested immediately
+    this.observedTransits.delete(key);
+    return true;
+  }
+
+  // ==================== Live Tracking State ====================
+
+  /** Get current state of all tracked objects for live overlay */
+  getLiveTrackingState(): {
+    objects: Array<{
+      globalId: string;
+      className: string;
+      label?: string;
+      lastCameraId: string;
+      lastCameraName: string;
+      lastSeen: number;
+      state: string;
+      cameraPosition?: { x: number; y: number };
+    }>;
+    timestamp: number;
+  } {
+    const activeObjects = this.state.getActiveObjects();
+    const objects = activeObjects.map(tracked => {
+      const lastSighting = getLastSighting(tracked);
+      const camera = lastSighting ? findCamera(this.topology, lastSighting.cameraId) : null;
+
+      return {
+        globalId: tracked.globalId,
+        className: tracked.className,
+        label: tracked.label,
+        lastCameraId: lastSighting?.cameraId || '',
+        lastCameraName: lastSighting?.cameraName || '',
+        lastSeen: tracked.lastSeen,
+        state: tracked.state,
+        cameraPosition: camera?.floorPlanPosition,
+      };
+    });
+
+    return {
+      objects,
+      timestamp: Date.now(),
+    };
+  }
+
+  /** Get journey path for visualization */
+  getJourneyPath(globalId: GlobalTrackingId): {
+    segments: Array<{
+      fromCamera: { id: string; name: string; position?: { x: number; y: number } };
+      toCamera: { id: string; name: string; position?: { x: number; y: number } };
+      transitTime: number;
+      timestamp: number;
+    }>;
+    currentLocation?: { cameraId: string; cameraName: string; position?: { x: number; y: number } };
+  } | null {
+    const tracked = this.state.getObject(globalId);
+    if (!tracked) return null;
+
+    const segments = tracked.journey.map(j => {
+      const fromCamera = findCamera(this.topology, j.fromCameraId);
+      const toCamera = findCamera(this.topology, j.toCameraId);
+
+      return {
+        fromCamera: {
+          id: j.fromCameraId,
+          name: j.fromCameraName,
+          position: fromCamera?.floorPlanPosition,
+        },
+        toCamera: {
+          id: j.toCameraId,
+          name: j.toCameraName,
+          position: toCamera?.floorPlanPosition,
+        },
+        transitTime: j.transitDuration,
+        timestamp: j.entryTime,
+      };
+    });
+
+    const lastSighting = getLastSighting(tracked);
+    let currentLocation;
+    if (lastSighting) {
+      const camera = findCamera(this.topology, lastSighting.cameraId);
+      currentLocation = {
+        cameraId: lastSighting.cameraId,
+        cameraName: lastSighting.cameraName,
+        position: camera?.floorPlanPosition,
+      };
+    }
+
+    return { segments, currentLocation };
+  }
 }

package/src/main.ts

@@ -115,6 +115,41 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       description: 'Use LLM plugin (if installed) to generate descriptive alerts like "Man walking from garage towards front door"',
       group: 'AI & Spatial Reasoning',
     },
+    llmDebounceInterval: {
+      title: 'LLM Rate Limit (seconds)',
+      type: 'number',
+      defaultValue: 10,
+      description: 'Minimum time between LLM calls to prevent API overload (0 = no limit)',
+      group: 'AI & Spatial Reasoning',
+    },
+    llmFallbackEnabled: {
+      title: 'Fallback to Basic Notifications',
+      type: 'boolean',
+      defaultValue: true,
+      description: 'When LLM is rate-limited or slow, fall back to basic notifications immediately',
+      group: 'AI & Spatial Reasoning',
+    },
+    llmFallbackTimeout: {
+      title: 'LLM Timeout (seconds)',
+      type: 'number',
+      defaultValue: 3,
+      description: 'Maximum time to wait for LLM response before falling back to basic notification',
+      group: 'AI & Spatial Reasoning',
+    },
+    enableTransitTimeLearning: {
+      title: 'Learn Transit Times',
+      type: 'boolean',
+      defaultValue: true,
+      description: 'Automatically adjust connection transit times based on observed movement patterns',
+      group: 'AI & Spatial Reasoning',
+    },
+    enableConnectionSuggestions: {
+      title: 'Suggest Camera Connections',
+      type: 'boolean',
+      defaultValue: true,
+      description: 'Automatically suggest new camera connections based on observed movement patterns',
+      group: 'AI & Spatial Reasoning',
+    },
     enableLandmarkLearning: {
       title: 'Learn Landmarks from AI',
       type: 'boolean',
@@ -291,6 +326,11 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       loiteringThreshold: (this.storageSettings.values.loiteringThreshold as number || 3) * 1000,
       objectAlertCooldown: (this.storageSettings.values.objectAlertCooldown as number || 30) * 1000,
       useLlmDescriptions: this.storageSettings.values.useLlmDescriptions as boolean ?? true,
+      llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval as number || 10) * 1000,
+      llmFallbackEnabled: this.storageSettings.values.llmFallbackEnabled as boolean ?? true,
+      llmFallbackTimeout: (this.storageSettings.values.llmFallbackTimeout as number || 3) * 1000,
+      enableTransitTimeLearning: this.storageSettings.values.enableTransitTimeLearning as boolean ?? true,
+      enableConnectionSuggestions: this.storageSettings.values.enableConnectionSuggestions as boolean ?? true,
       enableLandmarkLearning: this.storageSettings.values.enableLandmarkLearning as boolean ?? true,
       landmarkConfidenceThreshold: this.storageSettings.values.landmarkConfidenceThreshold as number ?? 0.7,
     };
@@ -576,6 +616,11 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       key === 'loiteringThreshold' ||
       key === 'objectAlertCooldown' ||
       key === 'useLlmDescriptions' ||
+      key === 'llmDebounceInterval' ||
+      key === 'llmFallbackEnabled' ||
+      key === 'llmFallbackTimeout' ||
+      key === 'enableTransitTimeLearning' ||
+      key === 'enableConnectionSuggestions' ||
       key === 'enableLandmarkLearning' ||
       key === 'landmarkConfidenceThreshold'
     ) {
@@ -668,6 +713,29 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
         return this.handleInferRelationshipsRequest(response);
       }
 
+      // Connection suggestions
+      if (path.endsWith('/api/connection-suggestions')) {
+        return this.handleConnectionSuggestionsRequest(request, response);
+      }
+
+      if (path.match(/\/api\/connection-suggestions\/[\w->]+\/(accept|reject)$/)) {
+        const parts = path.split('/');
+        const action = parts.pop()!;
+        const suggestionId = parts.pop()!;
+        return this.handleConnectionSuggestionActionRequest(suggestionId, action, response);
+      }
+
+      // Live tracking state
+      if (path.endsWith('/api/live-tracking')) {
+        return this.handleLiveTrackingRequest(response);
+      }
+
+      // Journey visualization
+      if (path.match(/\/api\/journey-path\/[\w-]+$/)) {
+        const globalId = path.split('/').pop()!;
+        return this.handleJourneyPathRequest(globalId, response);
+      }
+
       // UI Routes
       if (path.endsWith('/ui/editor') || path.endsWith('/ui/editor/')) {
         return this.serveEditorUI(response);
@@ -680,14 +748,18 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       // Default: return info page
       response.send(JSON.stringify({
         name: 'Spatial Awareness Plugin',
-        version: '0.1.0',
+        version: '0.3.0',
         endpoints: {
           api: {
             trackedObjects: '/api/tracked-objects',
             journey: '/api/journey/{globalId}',
+            journeyPath: '/api/journey-path/{globalId}',
             topology: '/api/topology',
             alerts: '/api/alerts',
             floorPlan: '/api/floor-plan',
+            liveTracking: '/api/live-tracking',
+            connectionSuggestions: '/api/connection-suggestions',
+            landmarkSuggestions: '/api/landmark-suggestions',
           },
           ui: {
             editor: '/ui/editor',
@@ -1054,6 +1126,108 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     });
   }
 
+  private handleConnectionSuggestionsRequest(request: HttpRequest, response: HttpResponse): void {
+    if (!this.trackingEngine) {
+      response.send(JSON.stringify({ suggestions: [] }), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+      return;
+    }
+
+    const suggestions = this.trackingEngine.getConnectionSuggestions();
+    response.send(JSON.stringify({
+      suggestions,
+      count: suggestions.length,
+    }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  private handleConnectionSuggestionActionRequest(
+    suggestionId: string,
+    action: string,
+    response: HttpResponse
+  ): void {
+    if (!this.trackingEngine) {
+      response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
+        code: 500,
+        headers: { 'Content-Type': 'application/json' },
+      });
+      return;
+    }
+
+    if (action === 'accept') {
+      const connection = this.trackingEngine.acceptConnectionSuggestion(suggestionId);
+      if (connection) {
+        // Save updated topology
+        const topology = this.trackingEngine.getTopology();
+        this.storage.setItem('topology', JSON.stringify(topology));
+
+        response.send(JSON.stringify({ success: true, connection }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else {
+        response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+          code: 404,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    } else if (action === 'reject') {
+      const success = this.trackingEngine.rejectConnectionSuggestion(suggestionId);
+      if (success) {
+        response.send(JSON.stringify({ success: true }), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else {
+        response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+          code: 404,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    } else {
+      response.send(JSON.stringify({ error: 'Invalid action' }), {
+        code: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+  }
+
+  private handleLiveTrackingRequest(response: HttpResponse): void {
+    if (!this.trackingEngine) {
+      response.send(JSON.stringify({ objects: [], timestamp: Date.now() }), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+      return;
+    }
+
+    const liveState = this.trackingEngine.getLiveTrackingState();
+    response.send(JSON.stringify(liveState), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  private handleJourneyPathRequest(globalId: string, response: HttpResponse): void {
+    if (!this.trackingEngine) {
+      response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
+        code: 500,
+        headers: { 'Content-Type': 'application/json' },
+      });
+      return;
+    }
+
+    const journeyPath = this.trackingEngine.getJourneyPath(globalId);
+    if (journeyPath) {
+      response.send(JSON.stringify(journeyPath), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } else {
+      response.send(JSON.stringify({ error: 'Object not found' }), {
+        code: 404,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+  }
+
   private serveEditorUI(response: HttpResponse): void {
     response.send(EDITOR_HTML, {
       headers: { 'Content-Type': 'text/html' },