Merge remote-tracking branch 'origin/deploy' into feat/obs-service-scope-ttft

Author: abhi-bhat-lyzr

agentos/src/api.ts

@@ -216,6 +216,23 @@ export interface PIIDetectionConfig {
   custom_pii?: CustomPII[];
 }
 
+/** One SRS connectivity probe (reachability + authenticated API call). */
+export interface SrsProbe {
+  configured: boolean;
+  reachable: boolean;
+  authenticated: boolean;
+  latencyMs: number | null;
+  error?: string;
+}
+
+/** GET /srs/health — the full guardrail chain, measured server-side:
+ *  `agentos` = agentos-server → SRS; `cas` = agentos → CAS + CAS → SRS.
+ *  The response arriving at all proves the SPA → agentos hop. */
+export interface SrsHealth {
+  agentos: SrsProbe;
+  cas: { reachable: boolean; srs: SrsProbe | null; error?: string };
+}
+
 export interface PolicyDoc {
   _id: string;
   name: string;
@@ -514,6 +531,9 @@ export const api = {
   deleteSchedule: (id: string) => reqJSON<{ ok: boolean }>("DELETE", `/schedules/${encodeURIComponent(id)}`),
   runScheduleNow: (id: string) => postJSON<{ ok: boolean }>(`/schedules/${encodeURIComponent(id)}/run-now`, {}),
   // Policies — SRS-proxied. Server injects x-api-key.
+  // SRS connectivity, measured server-side: raw /health reachability + an
+  // authenticated /v1/rai/policies probe (the exact path this UI uses).
+  srsHealth: () => getJSON<SrsHealth>("/srs/health"),
   policies: () => getJSON<{ policies: PolicyDoc[] }>("/policies").then((d) => d.policies),
   policy: (id: string) => getJSON<PolicyDoc>(`/policies/${encodeURIComponent(id)}`),
   createPolicy: (body: Partial<PolicyDoc>) => postJSON<PolicyDoc>("/policies", body),

agentos/src/components/PoliciesPage.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { api, type PolicyDoc, type CedarPolicyEntry, type OPAPolicyDoc, type PIIAction } from "../api.ts";
+import { api, type PolicyDoc, type CedarPolicyEntry, type OPAPolicyDoc, type PIIAction, type SrsHealth } from "../api.ts";
 import { useAuth } from "../context/AuthContext.tsx";
 
 /**
@@ -49,6 +49,7 @@ export function PoliciesPage() {
           <div>
             <div className="text-base font-semibold">Policies</div>
             <div className="text-[11px] text-gray-500">SRS-managed · Cedar + OPA</div>
+            <SrsStatus />
           </div>
           {canWrite && (
             <button
@@ -79,7 +80,9 @@ export function PoliciesPage() {
               >
                 <div className="flex items-center gap-2">
                   <span className="text-sm font-medium truncate">{p.name}</span>
-                  <span className="ml-auto text-[10px] text-gray-600 font-mono">{p._id.slice(-6)}</span>
+                  <span className="ml-auto" onClick={(e) => e.stopPropagation()}>
+                    <CopyableId id={p._id} short />
+                  </span>
                 </div>
                 <div className="text-[11px] text-gray-500 mt-0.5 truncate">{p.description || <em>no description</em>}</div>
                 <div className="text-[10px] text-accent-soft mt-1 flex gap-2">
@@ -260,9 +263,7 @@ function PolicyEditor({
     <div className="p-6 max-w-3xl">
       <div className="flex items-center justify-between mb-5">
         <h2 className="text-lg font-semibold">{initial ? "Edit policy" : "Create policy"}</h2>
-        {initial && (
-          <div className="text-[11px] text-gray-500 font-mono">{initial._id}</div>
-        )}
+        {initial && <CopyableId id={initial._id} />}
       </div>
       {err && <div className="mb-3 text-sm text-red-400">{err}</div>}
 
@@ -645,6 +646,92 @@ function RegoPoliciesModal({
   );
 }
 
+/**
+ * SRS connectivity pill. Polls `/srs/health` on mount, on every refresh, and
+ * every 30s — both signals are measured from agentos-server (the browser has
+ * no route to SRS): raw reachability + the authenticated proxy path the
+ * Policies UI itself uses. Click to re-check immediately.
+ */
+function SrsStatus() {
+  const [health, setHealth] = useState<SrsHealth | null>(null);
+  const [agentosUp, setAgentosUp] = useState<boolean | null>(null); // the fetch itself = SPA → agentos
+  const [checking, setChecking] = useState(false);
+
+  const check = () => {
+    setChecking(true);
+    api.srsHealth()
+      .then((h) => { setHealth(h); setAgentosUp(true); })
+      .catch(() => { setHealth(null); setAgentosUp(false); })
+      .finally(() => setChecking(false));
+  };
+  useEffect(() => {
+    check();
+    const t = setInterval(check, 30_000);
+    return () => clearInterval(t);
+  }, []);
+
+  const probeState = (p: { configured: boolean; reachable: boolean; authenticated: boolean; latencyMs: number | null; error?: string } | null | undefined, fallback: string) => {
+    if (!p) return { dot: "bg-gray-500", text: fallback };
+    if (!p.configured) return { dot: "bg-gray-500", text: "not configured" };
+    if (p.authenticated) return { dot: "bg-emerald-500", text: `connected · ${p.latencyMs}ms` };
+    if (p.reachable) return { dot: "bg-amber-500", text: "reachable, auth failing" };
+    return { dot: "bg-red-500", text: "unreachable" };
+  };
+
+  const rows: Array<{ label: string; dot: string; text: string; title?: string }> = [
+    agentosUp === false
+      ? { label: "AgentOS", dot: "bg-red-500", text: "unreachable" }
+      : { label: "AgentOS", dot: agentosUp ? "bg-emerald-500" : "bg-gray-500", text: agentosUp ? "connected" : "checking…" },
+    { label: "AgentOS → SRS", ...probeState(health?.agentos, "checking…"), title: health?.agentos?.error },
+    health && !health.cas.reachable
+      ? { label: "CAS → SRS", dot: "bg-red-500", text: "CAS unreachable", title: health.cas.error }
+      : { label: "CAS → SRS", ...probeState(health?.cas.srs, health ? "no /srs/health (old CAS?)" : "checking…"), title: health?.cas.error ?? health?.cas.srs?.error },
+  ];
+
+  return (
+    <button
+      type="button"
+      onClick={check}
+      title="Click to re-check connectivity"
+      className={`mt-1.5 block text-left space-y-0.5 ${checking ? "opacity-60" : ""}`}
+    >
+      {rows.map((r) => (
+        <span key={r.label} title={r.title} className="flex items-center gap-1.5 text-[10px] text-gray-500 hover:text-gray-300">
+          <span className={`h-1.5 w-1.5 rounded-full ${r.dot}`} />
+          <span className="w-24 text-left">{r.label}</span>
+          <span>{r.text}</span>
+        </span>
+      ))}
+    </button>
+  );
+}
+
+/**
+ * Click-to-copy policy id. Shown wherever a policy surfaces so users can paste
+ * the id straight into the SDK (`ComputerAgent(policy_id="…")`). `short` shows
+ * the id's tail in tight rows; the copied value is always the full id.
+ */
+export function CopyableId({ id, short = false }: { id: string; short?: boolean }) {
+  const [copied, setCopied] = useState(false);
+  const copy = async () => {
+    try {
+      await navigator.clipboard.writeText(id);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1200);
+    } catch { /* clipboard unavailable (http) — ignore */ }
+  };
+  return (
+    <button
+      type="button"
+      onClick={copy}
+      title={`Copy policy id: ${id}`}
+      className="text-[10px] text-gray-500 hover:text-accent font-mono inline-flex items-center gap-1"
+    >
+      {copied ? "copied ✓" : short ? `…${id.slice(-6)} ⧉` : `${id} ⧉`}
+    </button>
+  );
+}
+
 function Section({ title, children, right }: { title: string; children: React.ReactNode; right?: React.ReactNode }) {
   return (
     <div className="mb-5 rounded-lg border border-ink-600 bg-ink-800 p-4">

agentos/src/components/PolicyTab.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from "react";
 import { api, type PolicyDoc, type AgentPolicyBinding } from "../api.ts";
+import { CopyableId } from "./PoliciesPage.tsx";
 
 /**
  * Per-agent policy attachment. Dropdown to bind one of the policies fetched
@@ -72,7 +73,13 @@ export function PolicyTab({
           <div className="text-sm text-gray-500">Loading…</div>
         ) : boundPolicy ? (
           <div>
-            <div className="text-sm font-medium">{boundPolicy.name}</div>
+            <div className="flex items-center gap-2">
+              <span className="text-sm font-medium">{boundPolicy.name}</span>
+              <CopyableId id={boundPolicy._id} />
+            </div>
+            <div className="text-[10px] text-gray-600 mt-0.5">
+              Use in the SDK: <code className="font-mono">ComputerAgent(policy_id="{boundPolicy._id}")</code>
+            </div>
             <div className="text-xs text-gray-500 mt-0.5">{boundPolicy.description || <em>no description</em>}</div>
             <div className="text-[11px] text-accent-soft mt-1">{guardrailSummary(boundPolicy)}</div>
             <button

examples/computeragent-server.ts

@@ -950,6 +950,43 @@ export class ComputerAgentServer {
       }),
     );
 
+    // SRS connectivity as seen from THIS server — the exact link the gateway's
+    // PII redaction and the SrsPolicyDecider depend on. `reachable` = raw
+    // GET /health; `authenticated` = an x-api-key'd /v1/rai/policies probe.
+    // Surfaced in the AgentOS UI's SRS status pill (proxied via agentos-server).
+    this.app.get("/srs/health", async (c) => {
+      const srsBase = (process.env.SRS_BASE_URL ?? "").replace(/\/+$/, "");
+      const srsKey = process.env.SRS_API_KEY ?? "";
+      if (!srsBase) {
+        return c.json({ configured: false, reachable: false, authenticated: false, latencyMs: null });
+      }
+      const t0 = Date.now();
+      let reachable = false;
+      let authenticated = false;
+      let error: string | null = null;
+      try {
+        const h = await fetch(`${srsBase}/health`, { signal: AbortSignal.timeout(5000) });
+        reachable = h.ok;
+        if (reachable) {
+          const a = await fetch(`${srsBase}/v1/rai/policies`, {
+            headers: { "x-api-key": srsKey },
+            signal: AbortSignal.timeout(5000),
+          });
+          authenticated = a.ok;
+          if (!a.ok) error = `auth check: SRS ${a.status}`;
+        }
+      } catch (err) {
+        error = (err as Error).message;
+      }
+      return c.json({
+        configured: true,
+        reachable,
+        authenticated,
+        latencyMs: Date.now() - t0,
+        ...(error ? { error } : {}),
+      });
+    });
+
     this.app.post("/run", async (c) => {
       const max = this.opts.maxConcurrentRuns ?? 4;
       if (this.runs.size >= max) {

packages/agentos-server/src/routes/policies.ts

@@ -81,6 +81,67 @@ async function srs(
   }
 }
 
+// ── SRS connectivity health ────────────────────────────────────────────────
+// The full guardrail chain, measured server-side (the browser has no route to
+// SRS or the CAS):
+//   agentos — THIS server → SRS: raw GET /health reachability + an x-api-key'd
+//             /v1/rai/policies probe (the exact proxy path the Policies UI uses).
+//   cas     — THIS server → CAS (is the harness up?) and CAS → SRS (the link
+//             the gateway PII redaction + SrsPolicyDecider depend on), relayed
+//             from the CAS's own /srs/health.
+// The SPA polls this to render the SRS status pill. Responding at all proves
+// the SPA → agentos hop.
+interface SrsProbe {
+  configured: boolean;
+  reachable: boolean;
+  authenticated: boolean;
+  latencyMs: number | null;
+  error?: string;
+}
+
+async function probeSrs(): Promise<SrsProbe> {
+  if (!SRS_BASE) return { configured: false, reachable: false, authenticated: false, latencyMs: null };
+  const t0 = Date.now();
+  let reachable = false;
+  let authenticated = false;
+  let error: string | null = null;
+  try {
+    const h = await fetch(`${SRS_BASE}/health`, { signal: AbortSignal.timeout(5000) });
+    reachable = h.ok;
+    if (reachable) {
+      const a = await fetch(`${SRS_BASE}/v1/rai/policies`, {
+        headers: { "x-api-key": SRS_KEY },
+        signal: AbortSignal.timeout(5000),
+      });
+      authenticated = a.ok;
+      if (!a.ok) error = `auth check: SRS ${a.status}`;
+    }
+  } catch (err) {
+    error = (err as Error).message;
+  }
+  return { configured: true, reachable, authenticated, latencyMs: Date.now() - t0, ...(error ? { error } : {}) };
+}
+
+async function probeCasSrs(): Promise<{ reachable: boolean; srs: SrsProbe | null; error?: string }> {
+  const { caBase } = await import("../upstream.js");
+  const { caAuthHeader } = await import("../auth.js");
+  try {
+    const r = await fetch(`${caBase()}/srs/health`, {
+      headers: caAuthHeader(),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!r.ok) return { reachable: true, srs: null, error: `CAS /srs/health → ${r.status}` };
+    return { reachable: true, srs: (await r.json()) as SrsProbe };
+  } catch (err) {
+    return { reachable: false, srs: null, error: (err as Error).message };
+  }
+}
+
+policiesRouter.get("/srs/health", authorize("policies:read"), async (_req, res) => {
+  const [agentos, cas] = await Promise.all([probeSrs(), probeCasSrs()]);
+  res.json({ agentos, cas });
+});
+
 // ── RAI policies → SRS /v1/rai/policies ───────────────────────────────────
 policiesRouter.get("/policies", authorize("policies:read"), (_req, res) =>
   srs(res, "GET", "/v1/rai/policies", { fallback: { policies: [] } }),

packages/llm-proxy-openai/src/proxy.ts

@@ -300,8 +300,14 @@ async function srsRedactText(
 
 /**
  * Redact every prompt text span in an Anthropic request in place (system +
- * message text blocks). Accumulates one placeholder→original map across all
- * spans. Short-circuits with `blocked` if any span trips a `block` action.
+ * message text blocks), accumulating one placeholder→original map.
+ *
+ * Only the LATEST user message may BLOCK. The system prompt and prior history
+ * are redacted (masked) but never block — the client resends the full
+ * conversation each turn, so a one-time `block`-action value (e.g. a phone
+ * number the user typed earlier) would otherwise re-block every subsequent
+ * turn forever. SRS still returns the masked text alongside a block verdict,
+ * so history values are scrubbed regardless.
  */
 async function redactAnthropicRequest(
   body: AnthropicRequest,
@@ -311,40 +317,49 @@ async function redactAnthropicRequest(
 ): Promise<{ blocked: boolean; blockReason?: string; map: Record<string, string> }> {
   const map: Record<string, string> = {};
 
-  const run = async (text: string): Promise<string | null> => {
+  // Redact a span + merge its map; always returns the (masked) text even on block.
+  const redact = async (text: string) => {
     const r = await srsRedactText(text, policyId, cfg, log);
-    if (r.blocked) return null; // signal block to caller
     Object.assign(map, r.map);
-    return r.text;
+    return r;
   };
 
-  // system prompt
+  // Index of the most recent user message — the only span allowed to block.
+  let lastUserIdx = -1;
+  for (let i = body.messages.length - 1; i >= 0; i--) {
+    if (body.messages[i]?.role === "user") { lastUserIdx = i; break; }
+  }
+
+  // system prompt — redact only, never block
   if (typeof body.system === "string") {
-    const out = await run(body.system);
-    if (out === null) return { blocked: true, blockReason: "PII policy blocked system prompt", map };
-    body.system = out;
+    body.system = (await redact(body.system)).text;
   } else if (Array.isArray(body.system)) {
     for (const blk of body.system) {
       if (blk && typeof blk === "object" && typeof blk.text === "string") {
-        const out = await run(blk.text);
-        if (out === null) return { blocked: true, map };
-        blk.text = out;
+        blk.text = (await redact(blk.text)).text;
       }
     }
   }
 
-  // messages
-  for (const msg of body.messages) {
+  // messages — redact all; honour `block` only for the latest user message
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    if (!msg) continue;
+    const canBlock = i === lastUserIdx;
     if (typeof msg.content === "string") {
-      const out = await run(msg.content);
-      if (out === null) return { blocked: true, map };
-      msg.content = out;
+      const r = await redact(msg.content);
+      msg.content = r.text;
+      if (canBlock && r.blocked) {
+        return { blocked: true, ...(r.blockReason ? { blockReason: r.blockReason } : {}), map };
+      }
     } else if (Array.isArray(msg.content)) {
       for (const blk of msg.content) {
         if (blk.type === "text" && typeof blk.text === "string") {
-          const out = await run(blk.text);
-          if (out === null) return { blocked: true, map };
-          blk.text = out;
+          const r = await redact(blk.text);
+          blk.text = r.text;
+          if (canBlock && r.blocked) {
+            return { blocked: true, ...(r.blockReason ? { blockReason: r.blockReason } : {}), map };
+          }
         }
       }
     }