feat(agentos): OTLP gateway identity enrich + live-chat UX for SDK agents

agentos-server:
- OTLP trace gateway now enriches spans with computeragent.{group,owner,actor}.id
  resolved from the validated cak_ key (otel-auth → res.locals.otelIdentity;
  routes/otlp decodes → stamps each span → re-encodes via an embedded OTLP proto;
  fail-safe verbatim fallback; gzip-aware). Adds protobufjs + introspectCakBearer.
  So local SDK runs are group-scoped in the obs read like remote (CAS) runs.
- agents/resolve falls back to Mongo _id; group-scoped readable ids; ownership.

agentos (SPA):
- Inline local-SDK agents are live-chattable; library (git/local) agents show a
  clear read-only "ran locally — can't be chatted here" state instead of a
  misleading composer/empty prompt.
- Cold sessions can't be resumed (their local sandbox is gone): show a notice +
  prominent "Start a new session" button (also surfaced on a failed turn).
- sse.ts surfaces turn errors instead of a silent "(no reply)".
- Registry page hook refactor (useAgentRegistry).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: abhi-bhat-lyzr

agentos/src/App.tsx

@@ -8,7 +8,6 @@ import { RegistryPage } from "./components/RegistryPage.tsx";
 import { AgentDashboard } from "./components/AgentDashboard.tsx";
 import { SettingsPage } from "./components/SettingsPage.tsx";
 import { Separator } from "./components/ui/separator.tsx";
-import { useAgents } from "./context/AgentsContext.tsx";
 import { cn } from "./lib/cn.ts";
 
 export default function App() {
@@ -83,16 +82,13 @@ function HomeRoute() {
 }
 
 function RegistryRoute() {
-  const { agents, loaded, err, reload } = useAgents();
   const navigate = useNavigate();
+  // RegistryPage owns its own paginated/infinite-scroll data via useAgentRegistry;
+  // it only needs to know the open agent (for selection) and how to navigate.
   return (
     <RegistryPage
-      agents={agents}
-      loaded={loaded}
-      err={err}
       selected={null}
       onOpenAgent={(agentId) => navigate(`/agents/${encodeURIComponent(agentId)}`)}
-      onReload={reload}
     />
   );
 }

agentos/src/api.ts

@@ -446,6 +446,20 @@ export interface EvalRun {
 
 export const api = {
   agents: () => getJSON<{ agents: Agent[] }>("/agents").then((d) => d.agents),
+  // Paginated registry read (offset-based) with server-side search + an
+  // active/archived filter. Used by the registry page's infinite scroll;
+  // `agents` (above) stays the full-list read for the shared AgentsContext.
+  agentsPage: (p: { limit: number; offset: number; q?: string; archived?: "false" | "true" | "all" }) => {
+    const qs = new URLSearchParams({
+      limit: String(p.limit),
+      offset: String(p.offset),
+      archived: p.archived ?? "false",
+    });
+    if (p.q && p.q.trim()) qs.set("q", p.q.trim());
+    return getJSON<{ agents: Agent[]; total: number; limit: number; offset: number; hasMore: boolean }>(
+      `/agents?${qs.toString()}`,
+    );
+  },
   registerAgent: (input: RegisterAgentInput) =>
     postJSON<{ ok: boolean; id: string; name: string }>("/agents/register", input),
   unregisterAgent: (agentId: string) =>

agentos/src/components/ChatTab.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from "react";
-import { Paperclip, Play, Send, RefreshCw, AlertCircle } from "lucide-react";
+import { Paperclip, Play, Send, RefreshCw, AlertCircle, Plus } from "lucide-react";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { api } from "../api.ts";
@@ -28,25 +28,42 @@ export function ChatTab({
   agentId,
   agentName,
   sandboxCapable,
+  liveChatCapable = true,
+  resumeWarm = true,
   resumeSessionId,
   onConsumedResume,
   initialMessage,
   onConsumedInitial,
   onSessionStarted,
+  onNewSession,
   disabled = false,
 }: {
   /** Registry ObjectId — used to address the agent in API calls. */
   agentId: string;
   /** Human name — used for display + the `bot` field on logged turns. */
   agentName: string;
   sandboxCapable: boolean;
+  /** False for library-mode agents with no server-runnable source: we never
+   *  boot a chat-sandbox (it would 400 LIBRARY_AGENT_NO_LIVE_CHAT). Historical
+   *  transcripts stay viewable read-only; the composer is locked with a notice. */
+  liveChatCapable?: boolean;
+  /** Whether the session being RESUMED still has a live (warm) sandbox. A cold
+   *  session can't be resumed — the local sandbox that held its Claude
+   *  conversation is gone (resume → "No conversation found"). We show its
+   *  transcript read-only and direct the user to a New session. Ignored for a
+   *  fresh chat (resumeSessionId == null). */
+  resumeWarm?: boolean;
   resumeSessionId: string | null;
   onConsumedResume: () => void;
   initialMessage?: string | null;
   onConsumedInitial?: () => void;
   /** Fired once a sandbox boots and a sessionId is established (new or resumed),
    *  so the parent can refresh / highlight the session list. */
   onSessionStarted?: (sessionId: string) => void;
+  /** Start a fresh session (parent's "New chat"). When provided, an ended /
+   *  non-resumable view shows a prominent "Start a new session" button. Only
+   *  passed when the agent can actually chat (live-chat-capable + agents:run). */
+  onNewSession?: () => void;
   /** When true the composer is locked (e.g. the agent is archived). Sending is
    *  refused server-side regardless; this just makes the UI state explicit. */
   disabled?: boolean;
@@ -58,8 +75,15 @@ export function ChatTab({
   const [input, setInput] = useState("");
   const [busy, setBusy] = useState(false);
   const [err, setErr] = useState<string | null>(null);
+  // True when the resumed session is cold (no warm sandbox) and therefore
+  // can't be continued — history is read-only and the user must start a New session.
+  const [resumeEnded, setResumeEnded] = useState(false);
   const scrollRef = useRef<HTMLDivElement>(null);
 
+  // Composer is locked for an archived agent, a library agent (no runnable
+  // source), or a cold session that can't be resumed.
+  const composerLocked = disabled || !liveChatCapable || resumeEnded;
+
   useEffect(() => {
     scrollRef.current?.scrollTo({ top: scrollRef.current.scrollHeight });
   }, [msgs]);
@@ -69,24 +93,39 @@ export function ChatTab({
     setSessionId(null);
     setMsgs([]);
     setErr(null);
+    setResumeEnded(false);
   }, [agentId]);
 
   useEffect(() => {
     if (!resumeSessionId) return;
     const sid = resumeSessionId;
     onConsumedResume();
     (async () => {
+      let prior: Msg[] = [];
       try {
         const d = await api.session(sid);
-        const prior: Msg[] = d.entries.map((e) => ({
-          role: e.type.includes("user") ? "user" : "assistant",
+        prior = d.entries.map((e) => ({
+          role: (e.type.includes("user") ? "user" : "assistant") as Msg["role"],
           text: e.text,
         }));
-        setMsgs(prior.length ? prior : [{ role: "status", text: "Resumed — no stored transcript. Continue below.", loading: false }]);
       } catch {
-        setMsgs([{ role: "status", text: "Resumed session — memory is loaded. Continue below.", loading: false }]);
+        /* no stored transcript — fall through to the notices below */
+      }
+      // Resume is only possible when the agent is live-chat-capable AND this
+      // session still has a warm sandbox. A cold session can't be resumed: the
+      // local sandbox that held its Claude conversation is gone, so a resume
+      // would fail with "No conversation found". Show history read-only and
+      // direct the user to a New session (which boots a fresh sandbox).
+      if (liveChatCapable && resumeWarm) {
+        setMsgs(prior.length ? prior : [{ role: "status", text: "Resumed — no stored transcript. Continue below.", loading: false }]);
+        await boot(sid);
+      } else {
+        setResumeEnded(true);
+        const note = !liveChatCapable
+          ? "Read-only — this agent has no runnable source, so live chat is unavailable."
+          : "This conversation has ended — it ran in a local session that's no longer live, so it can't be resumed. Click “+ New” to start a fresh chat.";
+        setMsgs([...prior, { role: "status", text: note, loading: false }]);
       }
-      await boot(sid);
     })();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [resumeSessionId]);
@@ -95,7 +134,9 @@ export function ChatTab({
     if (!initialMessage) return;
     const m = initialMessage;
     onConsumedInitial?.();
-    void send(m);
+    // A library agent can't start a live chat; consume the handed-over message
+    // but don't boot a sandbox (it would 400).
+    if (liveChatCapable) void send(m);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [initialMessage]);
 
@@ -123,7 +164,7 @@ export function ChatTab({
   }
 
   async function send(textArg?: string) {
-    if (disabled) return;
+    if (composerLocked) return;
     const text = (textArg ?? input).trim();
     if (!text || busy) return;
 
@@ -216,7 +257,13 @@ export function ChatTab({
             </Button>
           </>
         ) : (
-          <span className="text-muted-foreground">{booting ? "Booting sandbox…" : "Send a message to start a session"}</span>
+          <span className="text-muted-foreground">
+            {!liveChatCapable
+              ? "Read-only — this agent ran locally and can’t be chatted here"
+              : booting
+                ? "Booting sandbox…"
+                : "Send a message to start a session"}
+          </span>
         )}
       </div>
 
@@ -225,12 +272,24 @@ export function ChatTab({
         {err && (
           <div className="flex items-start gap-2 text-sm text-destructive p-3 rounded-md bg-destructive/10 border border-destructive/20">
             <AlertCircle className="h-4 w-4 shrink-0 mt-0.5" />
-            <span>{err}</span>
+            <div className="flex-1 min-w-0 space-y-2">
+              <span>{err}</span>
+              {onNewSession && (
+                <div>
+                  <Button size="sm" onClick={onNewSession} className="gap-1.5">
+                    <Plus className="h-3.5 w-3.5" />
+                    Start a new session
+                  </Button>
+                </div>
+              )}
+            </div>
           </div>
         )}
         {msgs.length === 0 && !err && (
-          <div className="h-full grid place-items-center text-muted-foreground text-sm">
-            Talk to {agentName}. It runs with its configured identity and tools.
+          <div className="h-full grid place-items-center text-muted-foreground text-sm text-center px-6">
+            {liveChatCapable
+              ? `Talk to ${agentName}. It runs with its configured identity and tools.`
+              : `${agentName} ran in a local session and can’t be chatted here. Any past sessions remain viewable (read-only).`}
           </div>
         )}
         {msgs.map((m, i) => {
@@ -249,26 +308,55 @@ export function ChatTab({
 
       {/* Input */}
       <div className="px-6 py-4 border-t border-border">
+        {!liveChatCapable ? (
+          // Library agent (ran locally / no runnable source): no composer at all,
+          // just a clear notice so it's obvious why there's nothing to type into.
+          <div className="flex items-center gap-2 text-sm text-muted-foreground">
+            <AlertCircle className="h-4 w-4 shrink-0" />
+            <span>This agent ran in a local session and can’t be chatted here. Past sessions are read-only.</span>
+          </div>
+        ) : resumeEnded && onNewSession ? (
+          // Cold session — can't be resumed. Offer the New session action right
+          // here so the user doesn't have to hunt for the sidebar "+ New".
+          <div className="flex items-center justify-between gap-3 flex-wrap">
+            <span className="text-sm text-muted-foreground">
+              This conversation ran in a local session and can’t be resumed.
+            </span>
+            <Button onClick={onNewSession} className="rounded-xl gap-1.5">
+              <Plus className="h-4 w-4" />
+              <span>Start a new session</span>
+            </Button>
+          </div>
+        ) : (
         <div className="flex gap-2">
           <Textarea
             value={input}
             onChange={(e) => setInput(e.target.value)}
             onKeyDown={(e) => {
               if (e.key === "Enter" && !e.shiftKey) {
                 e.preventDefault();
-                if (!disabled) send();
+                if (!composerLocked) send();
               }
             }}
-            disabled={disabled}
-            placeholder={disabled ? "This agent is archived — unarchive it to chat." : `Message ${agentName}…  (Enter to send, Shift+Enter for newline)`}
+            disabled={composerLocked}
+            placeholder={
+              disabled
+                ? "This agent is archived — unarchive it to chat."
+                : !liveChatCapable
+                  ? "Library agent — no runnable source, so live chat is unavailable. Past sessions are read-only."
+                  : resumeEnded
+                    ? "This chat has ended — click “+ New” to start a fresh session."
+                    : `Message ${agentName}…  (Enter to send, Shift+Enter for newline)`
+            }
             rows={2}
             className="flex-1 resize-none rounded-xl bg-card px-3.5 py-2.5"
           />
-          <Button onClick={() => send()} disabled={disabled || busy || !input.trim()} className="rounded-xl px-4">
+          <Button onClick={() => send()} disabled={composerLocked || busy || !input.trim()} className="rounded-xl px-4">
             {busy ? <RefreshCw className="h-4 w-4 animate-spin" /> : <Send className="h-4 w-4" />}
             <span>Send</span>
           </Button>
         </div>
+        )}
       </div>
     </div>
   );