@saadnvd1/agent-os 0.3.700 → 0.3.723

package/data/models/index.ts

@@ -9,6 +9,9 @@ import type { ProviderTest } from "@/lib/models/test-provider";
 import type { ResumeResult } from "@/lib/models/resume";
 import type { ModelOverride } from "@/lib/models/resolve";
 import type { Comparison } from "@/lib/usage/compare";
+import type { ModelChoice } from "@/lib/models/catalog";
+import type { RoleMap } from "@/lib/models/config";
+import type { RoleScope, agentRolesView } from "@/lib/models/agent-roles-view";
 
 // Model routing (lib/models): role models, providers, prices.
 export const modelKeys = {
@@ -17,6 +20,29 @@ export const modelKeys = {
   compare: (days: number) => [...modelKeys.all, "compare", days] as const,
 };
 
+export const agentRoleKeys = {
+  roles: (scope: RoleScope, id?: string | null) =>
+    [...modelKeys.all, "agent-roles", scope, id ?? null] as const,
+  choices: [...modelKeys.all, "choices"] as const,
+  crew: (sessionId: string) => ["sessions", sessionId, "crew"] as const,
+};
+
+export type AgentRolesResponse = ReturnType<typeof agentRolesView>;
+
+export interface CrewResponse {
+  agentRole: string | null;
+  crewId: string | null;
+  members: {
+    id: string;
+    name: string;
+    agentRole: string | null;
+    model: string | null;
+    ref: string | null;
+    locality: "local" | "cloud";
+    availability: "up" | "down" | "unknown";
+  }[];
+}
+
 export interface ModelsResponse {
   saved: ModelSettings;
   effective: EffectiveModels;
@@ -113,3 +139,75 @@ export function useCompareQuery(days: number, enabled = true) {
 
 // Every model a role can be set to: each usable provider's, as references.
 export { modelChoices } from "@/lib/models/choices";
+
+// The agent roles (Developer, Analyst, Reviewer, Supervisor) at a scope:
+// Settings, a workspace or a project.
+export function useAgentRolesQuery(scope: RoleScope, id?: string | null) {
+  return useQuery({
+    queryKey: agentRoleKeys.roles(scope, id),
+    queryFn: async () =>
+      json<AgentRolesResponse>(
+        await fetch(
+          `/api/agent-roles?scope=${scope}${id ? `&id=${encodeURIComponent(id)}` : ""}`
+        )
+      ),
+    staleTime: 20_000,
+    refetchInterval: 30_000,
+    enabled: scope === "settings" || !!id,
+  });
+}
+
+export function useSaveAgentRoles(scope: RoleScope, id?: string | null) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { roles: RoleMap; fallbacks?: RoleMap }) =>
+      json<AgentRolesResponse>(
+        await send("/api/agent-roles", "PUT", { scope, id, ...input })
+      ),
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: modelKeys.all });
+      queryClient.setQueryData(agentRoleKeys.roles(scope, id), data);
+    },
+  });
+}
+
+// Every model a picker offers, with locality and availability.
+export function useModelChoices(enabled = true) {
+  return useQuery({
+    queryKey: agentRoleKeys.choices,
+    queryFn: async () =>
+      (
+        await json<{ choices: ModelChoice[] }>(
+          await fetch("/api/models/choices")
+        )
+      ).choices,
+    staleTime: 20_000,
+    refetchInterval: 30_000,
+    enabled,
+  });
+}
+
+export function useCrewQuery(sessionId: string | undefined, enabled = true) {
+  return useQuery({
+    queryKey: agentRoleKeys.crew(sessionId ?? ""),
+    queryFn: async () =>
+      json<CrewResponse>(await fetch(`/api/sessions/${sessionId}/crew`)),
+    staleTime: 15_000,
+    refetchInterval: 30_000,
+    enabled: !!sessionId && enabled,
+  });
+}
+
+export function useSwitchSessionModel(sessionId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (ref: string) =>
+      json<{ ok: true }>(
+        await send(`/api/sessions/${sessionId}/model`, "POST", { ref })
+      ),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["sessions"] });
+      queryClient.invalidateQueries({ queryKey: modelKeys.all });
+    },
+  });
+}

package/data/peers/keys.ts

@@ -3,4 +3,5 @@ export const peerKeys = {
   account: () => [...peerKeys.all, "account"] as const,
   pending: () => [...peerKeys.all, "pending"] as const,
   link: (id: string) => [...peerKeys.all, "link", id] as const,
+  audit: (hostId: string) => [...peerKeys.all, "audit", hostId] as const,
 };

package/data/peers/queries.ts

@@ -1,4 +1,5 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AuditRow } from "@/lib/peer/audit";
 import type { AccountMachines } from "@/lib/peer/machines";
 import type { PendingView } from "@/lib/peer/pairing";
 import type { Outgoing } from "@/lib/peer/pairing-out";
@@ -139,3 +140,33 @@ export function useAnswerLink() {
     }),
   };
 }
+
+/** Unlinks a machine linked through Connect, here and (if it answers) there. */
+export function useUnlinkPeer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (hostId: string) =>
+      json<{ name: string; told: boolean; removed: boolean }>(
+        await fetch(`/api/peers/${hostId}`, { method: "DELETE" })
+      ),
+    onSettled: () => {
+      void queryClient.invalidateQueries({ queryKey: hostKeys.all });
+      void queryClient.invalidateQueries({ queryKey: peerKeys.account() });
+    },
+  });
+}
+
+/** Every call to and from a linked machine, newest first. */
+export function usePeerAudit(hostId: string | null) {
+  return useQuery({
+    queryKey: peerKeys.audit(hostId ?? ""),
+    queryFn: async () =>
+      (
+        await json<{ rows: AuditRow[] }>(
+          await fetch(`/api/peers/${hostId}/audit`)
+        )
+      ).rows,
+    enabled: !!hostId,
+    refetchInterval: 15_000,
+  });
+}

package/data/push/topics.ts

@@ -18,6 +18,8 @@ import { archivedKeys } from "../done";
 import { awayKeys } from "../away";
 import { bookmarkKeys } from "../bookmarks/keys";
 import { learningCardsKeys } from "../learning-cards";
+import { claimKeys } from "../claims/keys";
+import { analystKeys } from "../analyst/keys";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -41,6 +43,7 @@ function keysFor(topic: string): QueryKey[] {
     case "projects":
       return [projectKeys.all, sessionKeys.all];
     case "groups":
+    case "session_groups":
       return [sessionKeys.all];
     case "workspaces":
       return [workspaceKeys.all, orchestratorKeys.all];
@@ -76,6 +79,12 @@ function keysFor(topic: string): QueryKey[] {
       return [devServerKeys.all];
     case "learning_cards":
       return [learningCardsKeys.all, orchestratorKeys.all];
+    case "work_claims":
+      return [claimKeys.all, sessionKeys.all];
+    case "analyst_links":
+      return [analystKeys.all, sessionKeys.all];
+    case "analyst_recommendations":
+      return [analystKeys.all];
     case "chat_bookmarks":
       return [bookmarkKeys.all];
     default:

package/data/session-groups/index.ts

@@ -0,0 +1,156 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
+import { sessionKeys } from "@/data/sessions/keys";
+import type { SessionsResponse } from "@/data/sessions/queries";
+
+async function send<T>(
+  url: string,
+  method: string,
+  body?: unknown
+): Promise<T> {
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error ?? "Could not change the group");
+  return data as T;
+}
+
+// Groups ride along in the sessions response, so every edit patches that
+// one cache entry and lets the change push settle the rest.
+function useGroupCache() {
+  const queryClient = useQueryClient();
+  const key = sessionKeys.list();
+  return {
+    key,
+    refresh: () => queryClient.invalidateQueries({ queryKey: key }),
+    async patch(edit: (old: SessionsResponse) => SessionsResponse) {
+      await queryClient.cancelQueries({ queryKey: key });
+      const previous = queryClient.getQueryData<SessionsResponse>(key);
+      queryClient.setQueryData<SessionsResponse>(
+        key,
+        (old) => old && edit(old)
+      );
+      return { previous };
+    },
+    restore(previous?: SessionsResponse) {
+      if (previous) queryClient.setQueryData(key, previous);
+    },
+  };
+}
+
+export function useCreateGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { name: string; workspaceId: string | null }) =>
+      send<{ sessionGroup: SessionGroup }>("/api/session-groups", "POST", v),
+    onSuccess: ({ sessionGroup }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: [...old.sessionGroups, sessionGroup],
+      })),
+    onError: (e: Error) => toast.error(e.message),
+    onSettled: cache.refresh,
+  });
+}
+
+export function useUpdateGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: ({
+      id,
+      ...patch
+    }: {
+      id: string;
+      name?: string;
+      collapsed?: boolean;
+    }) => send(`/api/session-groups/${id}`, "PATCH", patch),
+    onMutate: ({ id, ...patch }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.map((g) =>
+          g.id === id ? { ...g, ...patch } : g
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+export function useReorderGroups() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { workspaceId: string | null; ids: string[] }) =>
+      send("/api/session-groups/order", "POST", v),
+    onMutate: ({ ids }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.map((g) =>
+          ids.includes(g.id) ? { ...g, sort_order: ids.indexOf(g.id) } : g
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+// Deleting is soft: the toast's Undo restores the group and its members.
+export function useDeleteGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (g: { id: string; name: string }) =>
+      send(`/api/session-groups/${g.id}`, "DELETE"),
+    onMutate: (g) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.filter((x) => x.id !== g.id),
+      })),
+    onSuccess: (_d, g) =>
+      toast(`Deleted group ${g.name}`, {
+        description: "Its sessions went back to the shelves.",
+        duration: 10_000,
+        action: {
+          label: "Undo",
+          onClick: () =>
+            send(`/api/session-groups/${g.id}/restore`, "POST")
+              .catch((e: Error) => toast.error(e.message))
+              .finally(cache.refresh),
+        },
+      }),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+// One or many sessions into a group, or out of it with groupId null.
+export function useAssignGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { ids: string[]; groupId: string | null }) =>
+      send("/api/sessions/group", "POST", v),
+    onMutate: ({ ids, groupId }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessions: old.sessions.map((s) =>
+          ids.includes(s.id) ? { ...s, session_group_id: groupId } : s
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}

package/data/sessions/index.ts

@@ -6,7 +6,6 @@ export {
   useRenameSession,
   useForkSession,
   useSummarizeSession,
-  useMoveSessionToGroup,
   useMoveSessionToProject,
   useSessionSetup,
 } from "./queries";

package/data/sessions/pin.ts

@@ -1,11 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
 import { sessionKeys } from "./keys";
-
-interface SessionsResponse {
-  sessions: Session[];
-  groups: Group[];
-}
+import type { SessionsResponse } from "./queries";
 
 export function usePinSession() {
   const queryClient = useQueryClient();

package/data/sessions/queries.ts

@@ -1,13 +1,15 @@
+import { toast } from "sonner";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
 import type { AgentType } from "@/lib/providers";
 import type { ChatAccess, ChatFile, ChatImage } from "@/lib/chat/events";
 import { sessionKeys } from "./keys";
 import { usePollWhenOffline, usePushConnected } from "../push/connection";
 
-interface SessionsResponse {
+export interface SessionsResponse {
   sessions: Session[];
-  groups: Group[];
+  sessionGroups: SessionGroup[];
 }
 
 async function fetchSessions(): Promise<SessionsResponse> {
@@ -128,31 +130,6 @@ export function useSummarizeSession() {
   });
 }
 
-export function useMoveSessionToGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      sessionId,
-      groupPath,
-    }: {
-      sessionId: string;
-      groupPath: string;
-    }) => {
-      const res = await fetch(`/api/sessions/${sessionId}`, {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ groupPath }),
-      });
-      if (!res.ok) throw new Error("Failed to move session");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}
-
 export function useMoveSessionToProject() {
   const queryClient = useQueryClient();
 
@@ -172,7 +149,11 @@ export function useMoveSessionToProject() {
       if (!res.ok) throw new Error("Failed to move session");
       return res.json();
     },
-    onSuccess: () => {
+    onSuccess: (data: { clearedGroup?: string | null }) => {
+      if (data.clearedGroup)
+        toast(`Removed from ${data.clearedGroup}`, {
+          description: "Groups stay inside one workspace.",
+        });
       queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
     },
   });
@@ -195,6 +176,25 @@ export interface LaunchSessionInput {
   prompt: string;
   images?: ChatImage[];
   files?: ChatFile[];
+  // Start in an agent role (lib/models/agent-roles): its binding picks the
+  // model, and `model` (when not blank) overrides it for this session.
+  agentRole?: string;
+  // The crew it joins: the session that began it.
+  crewId?: string;
+  // When the role's model is down, run on the role's fallback.
+  onUnavailable?: "fallback";
+}
+
+// The role's model server isn't answering (HTTP 409): nothing was started.
+export class ModelUnavailableError extends Error {
+  constructor(
+    message: string,
+    readonly role: string,
+    readonly ref: string,
+    readonly fallback: string | null
+  ) {
+    super(message);
+  }
 }
 
 interface LaunchSessionResponse {
@@ -218,6 +218,13 @@ export function useLaunchSession() {
         body: JSON.stringify(input),
       });
       const data = await res.json();
+      if (res.status === 409 && data.code === "model_unavailable")
+        throw new ModelUnavailableError(
+          data.error,
+          data.role,
+          data.ref,
+          data.fallback ?? null
+        );
       if (!res.ok || data.error)
         throw new Error(data.error ?? "Couldn't start");
       return data;

package/data/sessions/shelf.ts

@@ -1,12 +1,8 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
 import { toSqliteTime } from "@/lib/session-meta";
 import { sessionKeys } from "./keys";
-
-interface SessionsResponse {
-  sessions: Session[];
-  groups: Group[];
-}
+import type { SessionsResponse } from "./queries";
 
 async function post(url: string, body: object) {
   const res = await fetch(url, {

package/data/tasks/index.ts

@@ -47,6 +47,8 @@ export function useCreateTask() {
       priority?: Priority;
       baseBranch?: string;
       hostId?: string;
+      // Queue behind other work: a task, or "claim:<id>".
+      after?: string;
       view?: "chat" | "terminal";
     }) =>
       // Over the workspace's running task limit it's queued instead.

package/hooks/useSessions.ts

@@ -6,20 +6,17 @@ import {
   useRenameSession,
   useForkSession,
   useSummarizeSession,
-  useMoveSessionToGroup,
   useMoveSessionToProject,
 } from "@/data/sessions";
 
 export function useSessions() {
   const { data, refetch } = useSessionsQuery();
   const sessions = data?.sessions ?? [];
-  const groups = data?.groups ?? [];
 
   const deleteMutation = useDeleteSession();
   const renameMutation = useRenameSession();
   const forkMutation = useForkSession();
   const summarizeMutation = useSummarizeSession();
-  const moveToGroupMutation = useMoveSessionToGroup();
   const moveToProjectMutation = useMoveSessionToProject();
 
   const fetchSessions = useCallback(async () => {
@@ -61,13 +58,6 @@ export function useSessions() {
     [summarizeMutation]
   );
 
-  const moveSessionToGroup = useCallback(
-    async (sessionId: string, groupPath: string) => {
-      await moveToGroupMutation.mutateAsync({ sessionId, groupPath });
-    },
-    [moveToGroupMutation]
-  );
-
   const moveSessionToProject = useCallback(
     async (sessionId: string, projectId: string) => {
       await moveToProjectMutation.mutateAsync({ sessionId, projectId });
@@ -77,7 +67,6 @@ export function useSessions() {
 
   return {
     sessions,
-    groups,
     loaded: data !== undefined,
     summarizingSessionId: summarizeMutation.isPending
       ? (summarizeMutation.variables as string)
@@ -88,7 +77,6 @@ export function useSessions() {
     renameSession,
     forkSession,
     summarizeSession,
-    moveSessionToGroup,
     moveSessionToProject,
   };
 }