Add action metrics to agent chat and simplify feedback filters

src/agent-session.ts

@@ -15,9 +15,13 @@ function ageContext(profile: Record<string, unknown>) {
   return { ...profile, ageYears: age };
 }
 
-async function analysisResults(sessionId: string, userId: string): Promise<SessionResult> {
+export async function analysisResults(sessionId: string, userId: string, isAdmin = false): Promise<SessionResult> {
   const response = await fetch(new URL(`/api/sessions/${sessionId}`, env.ANALYSIS_API_URL), {
-    headers: { "x-sporalize-proxy-secret": env.ANALYSIS_PROXY_SECRET, "x-sporalize-user-id": userId },
+    headers: {
+      "x-sporalize-proxy-secret": env.ANALYSIS_PROXY_SECRET,
+      "x-sporalize-user-id": userId,
+      ...(isAdmin ? { "x-sporalize-admin": "true" } : {}),
+    },
     signal: AbortSignal.timeout(120000),
   });
   if (!response.ok) throw new Error(`Unable to load results for session ${sessionId} (${response.status})`);
@@ -51,10 +55,9 @@ export async function generateSessionFeedback(db: SupabaseClient, sessionId: str
     const { data: examples, error: examplesError } = await db.from("annotations")
       .select("action_id,score,annotations_notes(note),actions!inner(action_id,session_id,type,sessions!inner(player_id,players!inner(gender,bdate,height,weight,position)))")
       .eq("actions.type", action.type)
-      .eq("actions.sessions.players.gender", player.gender)
       .in("actions.session_id", ownedSessionIds)
       .neq("action_id", action.action_id)
-      .limit(10);
+      .limit(5);
     if (examplesError) throw new Error(`Unable to load human annotations: ${examplesError.message}`);
     const referenceRows = (examples ?? []).filter((row: any) =>
       row.score !== null || (row.annotations_notes ?? []).some((note: { note: string }) => typeof note.note === "string" && note.note.trim().length > 0));

src/server.ts

@@ -9,7 +9,7 @@ import { pipeline } from "node:stream/promises";
 import { z } from "zod";
 import { authPublicOrigin, env } from "./config.js";
 import { analysisRouter } from "./analysis.js";
-import { generateSessionFeedback } from "./agent-session.js";
+import { analysisResults, generateSessionFeedback } from "./agent-session.js";
 import { authenticatedUser, clearPasswordRecoveryCookie, clearSessionCookies, hasPasswordRecoveryCookie, safeRedirect, setPasswordRecoveryCookie, setSessionCookies } from "./auth.js";
 import { hashPassword, oauthClient, supabaseAdmin, supabaseAuth, syncProfile, userHasPassword, userPayload } from "./supabase.js";
 import { registerProfileImageRoutes } from "./profile-images.js";
@@ -828,7 +828,12 @@ app.post("/api/agent/chat", async (req, res, next) => {
         const { data: feedback, error: feedbackError } = await supabaseAdmin.from("actions_feedbacks")
           .select("feedback").eq("action_id", input.actionId).order("feedback");
         if (feedbackError) throw new Error(`Unable to load chat feedback: ${feedbackError.message}`);
-        context.action = { ...action, feedback: (feedback ?? []).map((row) => row.feedback) };
+        const results = await analysisResults(input.sessionId, current.user.id, isAdmin);
+        const measured = results.actions.find((item) => item.id === input.actionId);
+        if (!measured) return res.status(404).json({ error: "Analysis results for this action are unavailable." });
+        context.action = { ...action,
+          results: { metrics: measured.inActionMetrics ?? [], analytics: measured.rawAnalytics ?? {} },
+          feedback: (feedback ?? []).map((row) => row.feedback) };
       }
     }
     if (input.playerId && !input.sessionId) {

tests/agent-chat.test.ts

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createServer, type IncomingHttpHeaders } from "node:http";
+import type { AddressInfo } from "node:net";
+import { test } from "node:test";
+
+test("action chat sends current measurements on every message and preserves access checks", { timeout: 30_000 }, async () => {
+  const owner = "11111111-1111-4111-8111-111111111111";
+  const other = "22222222-2222-4222-8222-222222222222";
+  const sessionId = "33333333-3333-4333-8333-333333333333";
+  const actionId = "44444444-4444-4444-8444-444444444444";
+  const otherActionId = "55555555-5555-4555-8555-555555555555";
+  const analytics = { foot_region: "Toe", active_foot_speed: 1232.04, standing_foot_contact_seconds: 0,
+    minimum_knee_angle: null, future_metric: false };
+  const measured = { id: actionId, label: "Pass", rawAnalytics: analytics,
+    inActionMetrics: Object.entries(analytics).map(([name, value]) => ({ name, value, unit: name === "active_foot_speed" ? "cm/s" : "" })) };
+  const otherMeasured = { id: otherActionId, label: "Shoot", rawAnalytics: { ball_speed: 1303.31 },
+    inActionMetrics: [{ name: "Ball Speed", value: 1303.31, unit: "cm/s" }] };
+  let role = "user";
+  let sessionOwner = owner;
+  let resultsAvailable = true;
+  let analysisStatus = 200;
+  let analysisReads = 0;
+  let analysisHeaders: IncomingHttpHeaders = {};
+  type ChatPayload = { actions: unknown[]; message: string; history: unknown[];
+    context: { action?: { action_id: string; results: { metrics: unknown[]; analytics: unknown }; feedback: string[]; annotations: unknown }; actions?: unknown[] } };
+  const chats: ChatPayload[] = [];
+  const upstream = createServer(async (req, res) => {
+    const url = new URL(req.url!, "http://stub");
+    res.setHeader("Content-Type", "application/json");
+    if (url.pathname === "/auth/v1/user") return res.end(JSON.stringify({ id: owner, email: "test@example.com" }));
+    if (url.pathname === `/api/sessions/${sessionId}`) {
+      analysisReads++;
+      analysisHeaders = req.headers;
+      res.statusCode = analysisStatus;
+      return res.end(JSON.stringify({ id: sessionId, actions: resultsAvailable ? [otherMeasured, measured] : [] }));
+    }
+    if (url.pathname === "/api/chat") {
+      let body = "";
+      for await (const chunk of req) body += chunk;
+      chats.push(JSON.parse(body));
+      return res.end(JSON.stringify({ reply: "Measured coaching reply." }));
+    }
+    const table = url.pathname.split("/").at(-1);
+    let rows: Record<string, unknown>[] = table === "users" ? [{ user_id: owner, account_role: role }]
+      : table === "users_subscriptions" ? [{ user_id: owner, subscription_id: "plan", startdate: "2000-01-01", enddate: "2099-01-01", plan: { subscription_id: "plan" } }]
+      : table === "sessions" ? [{ session_id: sessionId, user_id: sessionOwner, name: "Practice", players: { fname: "Player" } }]
+      : table === "actions" ? [actionId, otherActionId].map((id) => ({ action_id: id, session_id: sessionId, type: "Pass", start_frame: 750, end_frame: 780,
+        annotations: [{ score: 7, annotations_notes: [{ note: "Coach note." }] }] }))
+      : table === "actions_feedbacks" ? [{ action_id: actionId, feedback: "Saved action evaluation." }]
+      : table === "sessions_feedbacks" ? [{ session_id: sessionId, feedback: "Saved session evaluation." }] : [];
+    for (const [key, filter] of url.searchParams) {
+      if (filter.startsWith("eq.")) rows = rows.filter((row) => String(row[key]) === filter.slice(3));
+    }
+    res.end(JSON.stringify(rows));
+  });
+  upstream.listen(0, "127.0.0.1");
+  await once(upstream, "listening");
+  const upstreamOrigin = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;
+  const portProbe = createServer();
+  portProbe.listen(0, "127.0.0.1");
+  await once(portProbe, "listening");
+  const port = (portProbe.address() as AddressInfo).port;
+  await new Promise<void>((resolve) => portProbe.close(() => resolve()));
+  const origin = `http://127.0.0.1:${port}`;
+  const child = spawn(process.execPath, ["--import", "tsx", "src/server.ts"], {
+    env: { ...process.env, NODE_ENV: "test", PORT: String(port), FRONTEND_URL: origin, BACKEND_URL: origin,
+      SUPABASE_URL: upstreamOrigin, SUPABASE_ANON_KEY: "test-anon", SUPABASE_SERVICE_ROLE_KEY: "test-service",
+      ANALYSIS_API_URL: upstreamOrigin, ANALYSIS_PROXY_SECRET: "x".repeat(32),
+      AGENT_API_URL: upstreamOrigin, AGENT_API_KEY: "a".repeat(32), HF_TOKEN: "" },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  try {
+    let stderr = "";
+    child.stderr.on("data", (data) => { stderr += String(data); });
+    await new Promise<void>((resolve, reject) => {
+      child.stdout.on("data", (data) => { if (String(data).includes("API listening")) resolve(); });
+      child.once("exit", (code) => reject(new Error(`API exited: ${code}\n${stderr}`)));
+      child.once("error", reject);
+    });
+    const request = (input: Record<string, unknown>, authenticated = true) => fetch(`${origin}/api/agent/chat`, {
+      method: "POST", signal: AbortSignal.timeout(10000),
+      headers: { "Content-Type": "application/json", Origin: origin, ...(authenticated ? { Cookie: "sp_access=access" } : {}) },
+      body: JSON.stringify({ message: "Explain these measurements.", ...input }),
+    });
+    const selected = { sessionId, actionId };
+    assert.equal((await request(selected, false)).status, 401);
+    assert.equal(analysisReads, 0);
+    assert.equal((await request(selected)).status, 200);
+    assert.equal(analysisReads, 1);
+    assert.deepEqual(chats[0].context.action?.results, { metrics: measured.inActionMetrics, analytics });
+    assert.deepEqual(chats[0].context.action?.feedback, ["Saved action evaluation."]);
+    assert.deepEqual(chats[0].context.action?.annotations, [{ score: 7, annotations_notes: [{ note: "Coach note." }] }]);
+    assert.equal(analysisHeaders["x-sporalize-user-id"], owner);
+    assert.equal(analysisHeaders["x-sporalize-proxy-secret"], "x".repeat(32));
+    assert.equal(analysisHeaders["x-sporalize-admin"], undefined);
+
+    analytics.active_foot_speed = 1500.123456;
+    measured.inActionMetrics.find((metric) => metric.name === "active_foot_speed")!.value = analytics.active_foot_speed;
+    const history = [{ role: "user", content: "Explain these measurements." }, { role: "assistant", content: "Previous reply." }];
+    assert.equal((await request({ ...selected, message: "What changed?", history })).status, 200);
+    assert.equal(analysisReads, 2);
+    assert.deepEqual(chats[1].context.action?.results, { metrics: measured.inActionMetrics, analytics });
+    assert.deepEqual(chats[1].history, history);
+    assert.equal((await request({ sessionId, actionId: otherActionId })).status, 200);
+    assert.deepEqual(chats[2].context.action?.results, { metrics: otherMeasured.inActionMetrics, analytics: otherMeasured.rawAnalytics });
+
+    const chatCount = chats.length;
+    const readCount = analysisReads;
+    sessionOwner = other;
+    assert.equal((await request(selected)).status, 404);
+    assert.equal(analysisReads, readCount, "unauthorized requests must not load measurements");
+    assert.equal(chats.length, chatCount);
+    role = "admin";
+    assert.equal((await request(selected)).status, 200);
+    assert.equal(analysisHeaders["x-sporalize-admin"], "true");
+    assert.equal(analysisHeaders["x-sporalize-user-id"], owner);
+    assert.deepEqual(chats.at(-1)?.context.action?.results, { metrics: measured.inActionMetrics, analytics });
+    role = "user";
+    sessionOwner = owner;
+
+    const successfulChats = chats.length;
+    resultsAvailable = false;
+    assert.equal((await request(selected)).status, 404);
+    analysisStatus = 503;
+    assert.equal((await request(selected)).status, 500);
+    assert.equal(chats.length, successfulChats, "missing results must not produce an ungrounded reply");
+    const failedReads = analysisReads;
+    assert.equal((await request({ actionId })).status, 400);
+    assert.equal((await request({ ...selected, actionId: "66666666-6666-4666-8666-666666666666" })).status, 404);
+    assert.equal(analysisReads, failedReads);
+    assert.equal((await request({ sessionId })).status, 200);
+    assert.equal((await request({})).status, 200);
+    assert.equal(analysisReads, failedReads, "general and session chats do not need action measurements");
+    assert.equal(chats.at(-1)?.context.action, undefined);
+  } finally {
+    if (child.exitCode === null && child.signalCode === null) {
+      const exited = once(child, "exit");
+      child.kill();
+      await exited;
+    }
+    upstream.closeAllConnections();
+    await new Promise<void>((resolve) => upstream.close(() => resolve()));
+  }
+});