@saadnvd1/agent-os 0.3.520 → 0.3.523

package/data/agents/index.ts

@@ -1,4 +1,4 @@
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { AgentProbe } from "@/lib/agents/probe";
 
 export const agentKeys = {
@@ -20,3 +20,18 @@ export function useAgentStatusQuery() {
     refetchOnMount: "always",
   });
 }
+
+// Asks the server to probe again now, not from its minute-old answer, and
+// puts the result where the status query reads it.
+export function useRecheckAgents() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      const res = await fetch("/api/agents/status?fresh");
+      if (!res.ok) throw new Error("Couldn't check the agents");
+      return ((await res.json()) as { agents: Record<string, AgentProbe> })
+        .agents;
+    },
+    onSuccess: (agents) => client.setQueryData(agentKeys.status(), agents),
+  });
+}

package/data/chat/useChat.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
 import { markRunning } from "../statuses/stream";
 import type {
   ApprovalDecision,
@@ -21,6 +22,7 @@ import type {
 } from "@/lib/chat/events";
 import type { SearchResult } from "@/lib/chat/find";
 import { addBody, touchBody } from "@/lib/chat/bodyCache";
+import { backgroundFailure } from "@/lib/chat/background";
 
 // The index of the item with `id`, searched from the end: what changes is
 // almost always the latest.
@@ -164,6 +166,12 @@ export function useChat(
   const [taskOutputs, setTaskOutputs] = useState<Record<string, string | null>>(
     {}
   );
+  const [canBackground, setCanBackground] = useState(false);
+  // The calls asked to move to the background and not yet answered
+  // ("all" for the shortcut).
+  const [movingToBackground, setMovingToBackground] = useState<
+    ReadonlySet<string>
+  >(new Set());
   const onUndoneRef = useRef(onUndone);
   useEffect(() => {
     onUndoneRef.current = onUndone;
@@ -245,8 +253,28 @@ export function useChat(
           setModelState(m.model);
           setAccessState(m.access);
           setPlanState(m.plan);
+          setCanBackground(!!m.background);
         } else if (m.type === "context") {
           setContext(m.context);
+        } else if (m.type === "background_result") {
+          const key = m.toolUseId ?? "all";
+          setMovingToBackground((prev) => {
+            if (!prev.has(key)) return prev;
+            const next = new Set(prev);
+            next.delete(key);
+            return next;
+          });
+          const all = itemsRef.current;
+          const tool = all.find((i) => i.id === m.toolUseId);
+          const task = all.find(
+            (i) => i.kind === "task" && i.toolUseId === m.toolUseId
+          );
+          const message = backgroundFailure(
+            m,
+            tool?.kind === "tool" ? tool : undefined,
+            task?.kind === "task" ? task : undefined
+          );
+          if (message) toast(message, { duration: 2500 });
         } else if (m.type === "task_output") {
           setTaskOutputs((prev) => ({ ...prev, [m.taskId]: m.text }));
         } else if (m.type === "undo_preview") {
@@ -389,6 +417,15 @@ export function useChat(
     wsRef.current?.send(JSON.stringify({ type: "stop_task", taskId }));
   }, []);
 
+  // One call (or, with none given, every call that blocks the turn) goes to
+  // the background; the answer comes back as a toast only if it failed.
+  const backgroundTask = useCallback((toolUseId?: string) => {
+    const key = toolUseId ?? "all";
+    if (!wsRef.current) return;
+    setMovingToBackground((prev) => new Set(prev).add(key));
+    wsRef.current.send(JSON.stringify({ type: "background_task", toolUseId }));
+  }, []);
+
   const queueEdit = useCallback((id: string, text: string) => {
     wsRef.current?.send(JSON.stringify({ type: "queue_edit", id, text }));
   }, []);
@@ -496,6 +533,9 @@ export function useChat(
     undoPreview,
     clearUndo: () => setUndoPreview(null),
     stopTask,
+    canBackground,
+    backgroundTask,
+    movingToBackground,
     loadTaskOutput,
     taskOutputs,
     queue,

package/data/welcome/index.ts

@@ -0,0 +1,36 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { WelcomeGate } from "@/lib/welcome";
+
+export const welcomeKeys = {
+  all: ["welcome"] as const,
+};
+
+export function useWelcomeQuery() {
+  return useQuery({
+    queryKey: welcomeKeys.all,
+    queryFn: async () => {
+      const res = await fetch("/api/welcome");
+      if (!res.ok) throw new Error("Couldn't check first-run setup");
+      return (await res.json()) as WelcomeGate;
+    },
+    // Asked once per load: it only flips when setup is done here.
+    staleTime: Infinity,
+    retry: false,
+  });
+}
+
+export function useCompleteWelcome() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      const res = await fetch("/api/welcome", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ action: "complete" }),
+      });
+      if (!res.ok) throw new Error("Couldn't save setup");
+      return (await res.json()) as WelcomeGate;
+    },
+    onSuccess: (gate) => client.setQueryData(welcomeKeys.all, gate),
+  });
+}

package/hooks/useWelcome.ts

@@ -0,0 +1,70 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { subscribe } from "valtio";
+import { useCompleteWelcome, useWelcomeQuery } from "@/data/welcome";
+import { hrefWithWelcome, welcomeFromHref } from "@/lib/welcome-url";
+import { newDraft } from "@/stores/drafts";
+import { welcomeUi, welcomeUiActions } from "@/stores/welcomeUi";
+
+function fromAddress() {
+  const at = welcomeFromHref(window.location.href);
+  if (at.open) welcomeUiActions.open(at.step);
+  else if (welcomeUi.open) welcomeUiActions.close();
+}
+
+/**
+ * `?welcome=<step>` opens the first-run welcome at that step, on load and on
+ * back/forward; the address follows it. Moving between steps adds a history
+ * entry, so Back goes to the step before. A fresh install with setup still to
+ * do opens it by itself, once.
+ */
+export function useWelcomeUrl() {
+  const { data: gate } = useWelcomeQuery();
+  const asked = useRef(false);
+
+  useEffect(() => {
+    fromAddress();
+    let was = { open: welcomeUi.open, step: welcomeUi.step };
+    const unsubscribe = subscribe(welcomeUi, () => {
+      const href = window.location.href;
+      const next = hrefWithWelcome(href, {
+        open: welcomeUi.open,
+        step: welcomeUi.step,
+      });
+      const url = new URL(href);
+      if (next !== url.pathname + url.search + url.hash) {
+        const move = was.open && welcomeUi.open && was.step !== welcomeUi.step;
+        window.history[move ? "pushState" : "replaceState"](
+          window.history.state,
+          "",
+          next
+        );
+      }
+      was = { open: welcomeUi.open, step: welcomeUi.step };
+    });
+    window.addEventListener("popstate", fromAddress);
+    return () => {
+      unsubscribe();
+      window.removeEventListener("popstate", fromAddress);
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!gate?.show || asked.current || welcomeUi.open) return;
+    asked.current = true;
+    welcomeUiActions.open("agents");
+  }, [gate?.show]);
+}
+
+/** Setup is over, finished or skipped: remember it and close. */
+export function useEndWelcome() {
+  const { mutate } = useCompleteWelcome();
+  return (start?: boolean) => {
+    const projectId = welcomeUi.projectId;
+    mutate();
+    welcomeUiActions.close();
+    welcomeUiActions.setProject(null);
+    if (start && projectId) newDraft({ kind: "project", projectId });
+  };
+}

package/lib/agents/probe.ts

@@ -64,7 +64,34 @@ type AuthCheck = (
   env: NodeJS.ProcessEnv
 ) => Promise<AgentAuth> | AgentAuth;
 
+// Claude Code keeps who is signed in under `oauthAccount` in its config, at
+// $CLAUDE_CONFIG_DIR/.claude.json, or ~/.claude.json without that variable.
+function claudeAuth(env: NodeJS.ProcessEnv): AgentAuth {
+  const dir = env.CLAUDE_CONFIG_DIR?.trim();
+  const configDir = dir || home(".claude");
+  const config = dir ? path.join(dir, ".claude.json") : home(".claude.json");
+  if (
+    anyEnv(env, [
+      "ANTHROPIC_API_KEY",
+      "ANTHROPIC_AUTH_TOKEN",
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "CLAUDE_CODE_USE_BEDROCK",
+      "CLAUDE_CODE_USE_VERTEX",
+    ]) ||
+    hasJsonKeys(path.join(configDir, "settings.json"), "apiKeyHelper")
+  )
+    return "ready";
+  if (hasJsonKeys(config, "oauthAccount")) return "ready";
+  // A config without an account is a CLI that has never signed in; no config
+  // at all tells nothing.
+  return hasJsonKeys(config) ? "needs-login" : "unknown";
+}
+
 const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
+  claude: {
+    check: (_cli, env) => claudeAuth(env),
+    hint: "Run `claude auth login` in a terminal",
+  },
   codex: {
     // Exits 0 signed in, 1 not.
     check: async (cli, env) => {

package/lib/agents/setup-commands.ts

@@ -0,0 +1,54 @@
+/**
+ * The official commands the welcome runs in its terminal to install an agent
+ * CLI or sign it in. Typed into the user's own shell, never run by the
+ * server, so they are the same lines the install script (scripts/lib/ai-clis.sh)
+ * uses.
+ */
+
+import type { ProviderId } from "../providers/registry";
+
+export interface SetupCommands {
+  install?: string;
+  signIn?: string;
+  docs?: string;
+}
+
+export const SETUP_COMMANDS: Partial<Record<ProviderId, SetupCommands>> = {
+  claude: {
+    install: "curl -fsSL https://claude.ai/install.sh | bash",
+    signIn: "claude auth login",
+  },
+  codex: {
+    install: "npm install -g @openai/codex",
+    signIn: "codex login",
+  },
+  gemini: {
+    install: "npm install -g @google/gemini-cli",
+    signIn: "gemini",
+  },
+  kilocode: { install: "npm install -g @kilocode/cli", signIn: "kilo" },
+  cursor: { signIn: "cursor-agent login", docs: "https://cursor.com/cli" },
+  amp: { signIn: "amp login", docs: "https://ampcode.com" },
+  pi: { signIn: "pi" },
+  // No installer line we can vouch for from here; its own site has it.
+  opencode: { docs: "https://opencode.ai/docs" },
+};
+
+// The ones the welcome shows up front; the rest wait behind "Show all".
+export const FEATURED_AGENTS: ProviderId[] = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+];
+
+export type AgentState = "missing" | "needs-login" | "ready" | "installed";
+
+export function agentState(p: {
+  installed: boolean;
+  auth: "ready" | "needs-login" | "unknown";
+}): AgentState {
+  if (!p.installed) return "missing";
+  if (p.auth === "needs-login") return "needs-login";
+  return p.auth === "ready" ? "ready" : "installed";
+}

package/lib/chat/activity.ts

@@ -48,7 +48,9 @@ export function track(live: Live, e: WorkerEvent): void {
       a.tools.set(e.item.id, { label: e.item.title, since: e.item.createdAt });
     else a.tools.delete(e.item.id);
   } else if (e.type === "item" && e.item.kind === "task" && !e.item.ambient) {
-    if (e.item.status === "running") a.tasks.add(e.item.taskId);
+    // One still blocking its tool call is counted as that tool.
+    if (e.item.status === "running" && e.item.backgrounded !== false)
+      a.tasks.add(e.item.taskId);
     else a.tasks.delete(e.item.taskId);
   }
 }
@@ -65,7 +67,7 @@ export function restoreActivity(sessionId: string, state: ChatState) {
       activity.tools.set(i.id, { label: i.title, since: i.createdAt });
   }
   for (const i of runningItems(sessionId, "task"))
-    if (!i.ambient) activity.tasks.add(i.taskId);
+    if (!i.ambient && i.backgrounded !== false) activity.tasks.add(i.taskId);
   return activity;
 }
 

package/lib/chat/background.ts

@@ -0,0 +1,77 @@
+import type { ChatItem } from "./events";
+
+type Tool = Extract<ChatItem, { kind: "tool" }>;
+type Task = Extract<ChatItem, { kind: "task" }>;
+
+// A call has to have run this long before it's offered: a quick command
+// never flashes the button.
+export const BACKGROUND_AFTER_MS = 3000;
+
+// Whether a running call can be moved to the background now: the agent can
+// do it, and the call is the one blocking its turn.
+export function backgroundable(
+  supported: boolean,
+  tool: Pick<Tool, "status" | "createdAt">,
+  task: Pick<Task, "status" | "backgrounded"> | undefined,
+  now: number
+): boolean {
+  return (
+    supported &&
+    tool.status === "running" &&
+    task?.status === "running" &&
+    task.backgrounded === false &&
+    now - tool.createdAt >= BACKGROUND_AFTER_MS
+  );
+}
+
+// Ctrl+B, nothing else held, and only while there is something to move;
+// otherwise the key is left to the page.
+export function backgroundKey(
+  e: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    repeat?: boolean;
+    isComposing?: boolean;
+  },
+  available: boolean
+): boolean {
+  return (
+    available &&
+    e.key.toLowerCase() === "b" &&
+    e.ctrlKey &&
+    !(e.metaKey || e.altKey || e.shiftKey || e.repeat || e.isComposing)
+  );
+}
+
+// Errors that mean the agent never got the request.
+const UNREACHED = new Set(["unsupported", "unavailable", "timeout"]);
+
+// What to tell the reader when moving a call didn't happen; null when it did.
+export function backgroundFailure(
+  result: { ok: boolean; error?: string },
+  tool: Pick<Tool, "status"> | undefined,
+  task: Pick<Task, "backgrounded"> | undefined
+): string | null {
+  if (result.ok) return null;
+  if (result.error) {
+    return UNREACHED.has(result.error) || /went away/.test(result.error)
+      ? "Couldn't reach the agent. Try again"
+      : "Background tasks are turned off for this session";
+  }
+  if (tool && tool.status !== "running") return "That step already finished";
+  if (task?.backgrounded) return "Already running in the background";
+  return "Nothing to move to the background yet";
+}
+
+// The last line of a task's output that says anything.
+export function outputTail(text: string | null | undefined): string | null {
+  const lines = text?.split("\n") ?? [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line) return line;
+  }
+  return null;
+}

package/lib/chat/driver.ts

@@ -82,6 +82,10 @@ export interface ChatConversation {
   setPlan(plan: boolean): Promise<void>;
   respond(id: string, answer: ApprovalDecision): void;
   stopTask(taskId: string): Promise<void>;
+  // Moves a blocking call (a Bash command or a subagent) to the background,
+  // the one with that tool_use id or every one when none is given. False
+  // when there was nothing to move.
+  backgroundTask?(toolUseId?: string): Promise<boolean>;
   // Puts files back as they were before a message (dryRun: only say what).
   undo(checkpoint: string, dryRun: boolean): Promise<UndoResult>;
   close(): void;
@@ -99,6 +103,8 @@ export interface ChatDriver {
   // as Claude does. Without it, a turn's end is that point: a message sent
   // mid-turn joins the turn or is run before it ends.
   atRest?: boolean;
+  // Can move a blocking call to the background (backgroundTask).
+  backgroundTasks?: boolean;
   start(options: ChatStartOptions): ChatConversation;
   // What the agent offers in a folder (its commands, skills and models),
   // without starting a conversation. Ends whatever it started once `signal`

package/lib/chat/drivers/claude-mapper.ts

@@ -72,6 +72,9 @@ export type ClaudeMessage = {
   usage?: { tool_uses?: number };
   skip_transcript?: boolean;
   ambient?: boolean;
+  is_backgrounded?: boolean;
+  // task_updated.
+  patch?: { is_backgrounded?: boolean };
   // prompt_suggestion: the agent's guess at the next message.
   suggestion?: string;
   // session_state_changed.
@@ -98,6 +101,10 @@ export function toCommand(c: SdkCommand): ChatCommand {
 
 const now = () => Date.now();
 
+// "Command was manually backgrounded by user with ID: abc. Output is being
+// written to: ..." (also "running in background with ID: abc").
+const BACKGROUND_NOTICE = /^[^\n]*background(?:ed)?[^\n]*? with ID: (\w+)/;
+
 const INTERRUPT_NOTICE =
   /doesn't want to proceed with this tool use|Request interrupted by user/i;
 
@@ -220,6 +227,8 @@ export class ClaudeMapper {
               },
             ]
           : [];
+      case "task_updated":
+        return this.taskMoved(m);
       case "task_started":
       case "task_progress":
       case "task_notification":
@@ -264,6 +273,7 @@ export class ClaudeMapper {
       taskType: m.task_type ?? prev?.taskType,
       subagentType: m.subagent_type ?? prev?.subagentType,
       status: done ? (m.status ?? "completed") : "running",
+      backgrounded: m.is_backgrounded ?? prev?.backgrounded,
       endedAt: done ? now() : undefined,
       summary: m.summary ?? prev?.summary,
       outputFile: m.output_file ?? prev?.outputFile,
@@ -276,6 +286,16 @@ export class ClaudeMapper {
     return [{ type: "item", item }];
   }
 
+  // A foreground task moved to the background (or back).
+  private taskMoved(m: ClaudeMessage): DriverEvent[] {
+    const prev = m.task_id ? this.tasks.get(m.task_id) : undefined;
+    const to = m.patch?.is_backgrounded;
+    if (!prev || to === undefined || prev.backgrounded === to) return [];
+    const item: TaskItem = { ...prev, backgrounded: to };
+    this.tasks.set(prev.taskId, item);
+    return [{ type: "item", item }];
+  }
+
   // Items are created on their first text, so blocks that never send any
   // (hidden thinking, empty starts) never show up as empty bubbles.
   private stream(m: ClaudeMessage): DriverEvent[] {
@@ -401,20 +421,38 @@ export class ClaudeMapper {
       // An interrupt answers the running tool with a notice meant for the
       // model, not the reader.
       const stopped = b.is_error && INTERRUPT_NOTICE.test(text);
+      const moved = stopped ? undefined : this.movedTask(b.tool_use_id, text);
       const done = stopped
         ? { ...tool, status: "stopped" as const, output: undefined }
-        : {
-            ...tool,
-            status: b.is_error ? ("error" as const) : ("done" as const),
-            output: clipOutput(text),
-            endedAt: now(),
-          };
+        : moved
+          ? {
+              ...tool,
+              status: "done" as const,
+              // The notice is for the model; the task has the output.
+              output: undefined,
+              endedAt: now(),
+              backgroundTaskId: moved,
+            }
+          : {
+              ...tool,
+              status: b.is_error ? ("error" as const) : ("done" as const),
+              output: clipOutput(text),
+              endedAt: now(),
+            };
       this.tools.delete(b.tool_use_id);
       out.push({ type: "item", item: done });
     }
     return out;
   }
 
+  // The task a tool call became when it went to the background, from the
+  // task it started or, failing that, the notice it was answered with.
+  private movedTask(toolUseId: string, text: string): string | undefined {
+    for (const t of this.tasks.values())
+      if (t.toolUseId === toolUseId && t.backgrounded === true) return t.taskId;
+    return BACKGROUND_NOTICE.exec(text)?.[1];
+  }
+
   private result(m: ClaudeMessage): DriverEvent[] {
     const out: DriverEvent[] = [];
     // Tools still open when the turn ends were cut off.

package/lib/chat/drivers/claude.ts

@@ -129,6 +129,7 @@ export function writtenPlanFile(m: ClaudeMessage): string | undefined {
 
 export const claudeDriver: ChatDriver = {
   id: "claude",
+  backgroundTasks: true,
 
   // Claude Code reports its commands, skills and models while starting up,
   // before any message, so a short-lived start tells the composer what's
@@ -349,6 +350,9 @@ export const claudeDriver: ChatDriver = {
       async stopTask(taskId) {
         await q.stopTask(taskId);
       },
+      backgroundTask(toolUseId) {
+        return q.backgroundTasks(toolUseId);
+      },
       async undo(checkpoint, dryRun) {
         const r = await q.rewindFiles(checkpoint, { dryRun });
         return {

package/lib/chat/events.ts

@@ -165,6 +165,8 @@ export type ChatItem =
       deferred?: boolean;
       hasOutput?: boolean;
       hasDiff?: boolean;
+      // The task this call became when it was moved to the background.
+      backgroundTaskId?: string;
     })
   | (Base & {
       kind: "todos";
@@ -233,6 +235,9 @@ export type ChatItem =
       taskType?: string;
       subagentType?: string;
       status: "running" | "completed" | "failed" | "stopped";
+      // False while it still blocks the tool call that started it; unset
+      // means it runs in the background.
+      backgrounded?: boolean;
       endedAt?: number;
       summary?: string;
       outputFile?: string;
@@ -353,10 +358,18 @@ export type ChatServerMessage =
       access: ChatAccess;
       // Plan mode: on, or null when the session can't use it.
       plan: boolean | null;
+      // Whether a blocking call can be moved to the background.
+      background?: boolean;
     }
   | { type: "context"; context: ChatContext | null }
   | { type: "undo_preview"; from: string; preview: UndoPreview }
   | { type: "task_output"; taskId: string; text: string | null }
+  | {
+      type: "background_result";
+      toolUseId?: string;
+      ok: boolean;
+      error?: string;
+    }
   | { type: "undone"; from: string; text: string };
 
 // What a browser sends.
@@ -379,6 +392,7 @@ export type ChatClientMessage =
   | ({ type: "respond"; id: string } & ApprovalDecision)
   | { type: "undo"; from: string; dryRun?: boolean }
   | { type: "stop_task"; taskId: string }
+  | { type: "background_task"; toolUseId?: string }
   | { type: "task_output"; taskId: string }
   // Older items, from before a page's cursor.
   | { type: "history"; before: number }

package/lib/chat/registry.ts

@@ -35,6 +35,8 @@ export interface Live {
   canQueue?: boolean;
   // Whether it takes "fresh" (a fresh start the reader asked for).
   canFresh?: boolean;
+  // Whether it takes "background_task" (an older worker drops it).
+  canBackground?: boolean;
   // From an older build and idle: retired once its guess at the next
   // message is in, or this fires.
   retiring?: NodeJS.Timeout;

package/lib/chat/runner.ts

@@ -15,6 +15,7 @@ import type {
   ApprovalDecision,
   ChatContext,
   ChatImage,
+  ChatServerMessage,
   ChatState,
   Compacting,
   SentBy,
@@ -304,6 +305,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
       canPlan: !!hello.caps?.includes("plan"),
       canQueue: !!hello.caps?.includes("queue"),
       canFresh: !!hello.caps?.includes("fresh"),
+      canBackground: !!hello.caps?.includes("background"),
     };
     // From an older build and busy, or running background work: it goes at
     // its next turn boundary, by itself if it can. Messages meanwhile wait
@@ -836,6 +838,24 @@ export function stopChatTask(sessionId: string, taskId: string): void {
   registry.live.get(sessionId)?.worker.command({ type: "stop_task", taskId });
 }
 
+// Moves a blocking call to the background and says how that went.
+export async function backgroundChatTask(
+  sessionId: string,
+  toolUseId: string | undefined,
+  reply: (m: ChatServerMessage) => void
+): Promise<void> {
+  const live = registry.live.get(sessionId);
+  const r = live?.canBackground
+    ? await live.worker.background(toolUseId)
+    : { error: "unavailable" };
+  reply({
+    type: "background_result",
+    toolUseId,
+    ok: !!r.ok,
+    ...(r.error && { error: r.error }),
+  });
+}
+
 export function chatTaskOutput(
   sessionId: string,
   taskId: string

package/lib/chat/settings.ts

@@ -75,6 +75,7 @@ export function emitCapabilities(session: Session, listener?: Listener): void {
     model: chatModel(session),
     access: session.chat_access,
     plan: canPlan(session) ? !!session.chat_plan : null,
+    background: chatDriverFor(session.agent_type)?.backgroundTasks === true,
   };
   if (listener) listener(m);
   else emit(session.id, m);

package/lib/chat/socket.ts

@@ -12,6 +12,7 @@ import {
   carryOutPlan,
   chatFileSuggestions,
   chatHistory,
+  backgroundChatTask,
   chatTaskOutput,
   chatToolBody,
   deleteQueuedChat,
@@ -183,6 +184,14 @@ function onChatMessage(
     run(carryOutPlan(sessionId, String(msg.id)));
   else if (msg.type === "respond") respondChat(sessionId, msg.id, msg);
   else if (msg.type === "stop_task") stopChatTask(sessionId, msg.taskId);
+  else if (msg.type === "background_task")
+    run(
+      backgroundChatTask(
+        sessionId,
+        typeof msg.toolUseId === "string" ? msg.toolUseId : undefined,
+        reply
+      )
+    );
   else if (msg.type === "task_output")
     reply({
       type: "task_output",