@saadnvd1/agent-os 0.3.624 → 0.3.627

package/lib/chat/worker/host.ts

@@ -533,6 +533,26 @@ export class ChatHost {
     return true;
   }
 
+  // A blocking step moved to the background frees the agent: the turn goes
+  // on, and what's queued goes in now, in order, as a message sent mid-turn
+  // does, rather than wait for the turn to end. Only the turn it was asked
+  // in: one that ended meanwhile has sent its queue by the usual rules.
+  private sendQueuedMidTurn(turn: number): void {
+    if (
+      !this.busy() ||
+      this.turnsStarted !== turn ||
+      this.closed ||
+      this.handingOver() ||
+      this.compacting ||
+      this.compactingNow
+    )
+      return;
+    for (let next; (next = claimNext(this.session.id)); ) {
+      this.emit({ type: "queue" });
+      this.sendUser(next);
+    }
+  }
+
   private sendUser(
     m: {
       id: string;
@@ -677,13 +697,20 @@ export class ChatHost {
           this.sendUser(cmd, true);
           return;
         }
+        // What the reader queued goes first: an event or agent message that
+        // reaches an idle worker (a fresh one after a restart) waits behind
+        // it rather than start a turn their next message would stop.
+        const backlog = listQueue(this.session.id).length > 0;
+        if (!this.busy() && backlog && !this.closed) {
+          enqueue(this.session.id, cmd);
+          this.emit({ type: "queue" });
+          this.sendQueued();
+          return;
+        }
         if (this.compactFirst(cmd)) return;
         // A compaction run for an earlier message takes nothing in: what's
         // sent meanwhile goes behind that message.
-        if (
-          (cmd.queue || this.compacting) &&
-          (this.busy() || listQueue(this.session.id).length)
-        ) {
+        if ((cmd.queue || this.compacting) && (this.busy() || backlog)) {
           // Behind the running turn, and behind anything queued before it.
           enqueue(this.session.id, cmd);
           this.emit({ type: "queue" });
@@ -762,7 +789,9 @@ export class ChatHost {
       case "background_task":
         try {
           if (!this.conversation.backgroundTask) throw new Error("unsupported");
+          const turn = this.turnsStarted;
           const ok = await this.conversation.backgroundTask(cmd.toolUseId);
+          if (ok) this.sendQueuedMidTurn(turn);
           this.emit({ type: "background_result", reqId: cmd.reqId, ok });
         } catch (error) {
           this.emit({

package/lib/orchestrator/tools.ts

@@ -2,7 +2,8 @@
  * The orchestrator chat's tools, as an in-process MCP server in its chat
  * worker. Each one asks the AgentOS server, which holds the live state
  * (chat activity, status, tasks) and enforces the workspace scope, brakes
- * and gates, and returns its text as is.
+ * and gates, and returns its text as is. While the server restarts a call
+ * waits for it (httpToolCaller).
  */
 
 import { createHash } from "crypto";
@@ -17,27 +18,90 @@ import { TOOL_SHAPES, TOOLS, type ToolName } from "./tool-schemas";
 
 type CallToolResult = Awaited<ReturnType<Parameters<typeof tool>[3]>>;
 
-export type ToolCaller = (tool: ToolName, args: object) => Promise<string>;
+export type ToolCaller = (
+  tool: ToolName,
+  args: object,
+  signal?: AbortSignal
+) => Promise<string>;
+
+// How long a call waits for a restarting server before it gives up. A
+// redeploy's server is back in well under this.
+export const RESTART_WAIT_MS = 120_000;
+const RETRY_FIRST_MS = 250;
+const RETRY_MAX_MS = 2000;
+
+const refused = (error: unknown) =>
+  (error as { cause?: { code?: string } } | null)?.cause?.code ===
+  "ECONNREFUSED";
+
+const sleep = (ms: number, signal?: AbortSignal) =>
+  new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 
 export const TOKEN_HEADER = "x-agentos-orchestrator";
 
+// A server that is down refused the connection and never saw the request,
+// so the call waits for it and goes again. One the restart cut off after it
+// was sent isn't repeated (start_task, send and the rest aren't safe to):
+// the agent is told to check first.
 export function httpToolCaller(
   baseUrl: string,
   workspaceId: string,
-  token: string
+  token: string,
+  waitMs = RESTART_WAIT_MS
 ): ToolCaller {
-  return async (name, args) => {
-    const res = await fetch(
-      `${baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/orchestrator/tools`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json", [TOKEN_HEADER]: token },
-        body: JSON.stringify({ tool: name, args }),
+  const url = `${baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/orchestrator/tools`;
+  return async (name, args, signal) => {
+    const deadline = Date.now() + waitMs;
+    let delay = RETRY_FIRST_MS;
+    let waiting = false;
+    for (;;) {
+      let res: Response;
+      try {
+        res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            [TOKEN_HEADER]: token,
+          },
+          body: JSON.stringify({ tool: name, args }),
+          signal,
+        });
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        if (!refused(error))
+          throw new Error(
+            `AgentOS restarted while ${name} ran, so it may or may not have taken effect. Check (sessions, read) before doing it again.`
+          );
+        if (Date.now() + delay > deadline)
+          throw new Error(
+            `AgentOS is restarting and didn't come back in time; try ${name} again shortly.`
+          );
+        if (!waiting)
+          console.error(`${name}: AgentOS is down; waiting for it to return`);
+        waiting = true;
+        await sleep(delay, signal);
+        delay = Math.min(delay * 2, RETRY_MAX_MS);
+        continue;
       }
-    );
-    const text = await res.text();
-    if (!res.ok) throw new Error(text || `AgentOS answered ${res.status}`);
-    return text;
+      const text = await res.text().catch(() => {
+        throw new Error(
+          `AgentOS restarted while ${name} ran, so it may or may not have taken effect. Check (sessions, read) before doing it again.`
+        );
+      });
+      if (!res.ok) throw new Error(text || `AgentOS answered ${res.status}`);
+      return text;
+    }
   };
 }
 
@@ -138,8 +202,12 @@ export function orchestratorTools(
     name: ORCHESTRATOR_SERVER,
     version: "1.0.0",
     tools: TOOLS.map((name) =>
-      tool(name, DESCRIPTIONS[name], TOOL_SHAPES[name], (args: object) =>
-        answer(call(name, args))
+      tool(
+        name,
+        DESCRIPTIONS[name],
+        TOOL_SHAPES[name],
+        (args: object, extra: unknown) =>
+          answer(call(name, args, (extra as { signal?: AbortSignal })?.signal))
       )
     ),
   });

package/lib/orchestrator/watcher.ts

@@ -5,7 +5,8 @@
  * every 15s while anything in the workspace is working, every 60s when not.
  */
 
-import { chatState, sendChat } from "../chat/runner";
+import { chatState, chatStateNow, sendChat } from "../chat/runner";
+import type { ChatState } from "../chat/events";
 import { getWorkspace } from "../workspaces";
 import { conditionsFor, recentlyMessaged, stackFacts } from "./conditions";
 import { deliverEvents } from "./deliver";
@@ -113,6 +114,18 @@ export function nextDiffAt(
   return Math.min(now + (working ? DIFF_BUSY_MS : DIFF_IDLE_MS), ...settles);
 }
 
+// Right after a restart nothing is attached yet, though the orchestrator's
+// worker may still be mid-turn: ask the worker, and count one that can't
+// be reached as busy for this tick.
+export async function deliveryTurn(
+  orchestratorId: string
+): Promise<ChatState | null> {
+  return (
+    chatState(orchestratorId) ??
+    (await chatStateNow(orchestratorId).catch(() => "running" as const))
+  );
+}
+
 async function tick(): Promise<void> {
   if (busy) return;
   busy = true;
@@ -136,7 +149,7 @@ async function tick(): Promise<void> {
         await deliverEvents({
           workspaceId,
           orchestratorId: orch.id,
-          turn: chatState(orch.id),
+          turn: await deliveryTurn(orch.id),
           send: sendChat,
         });
       } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.624",
+  "version": "0.3.627",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/autodeploy

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
 # Run every minute by serviceman on Saad's Mac: when origin/main moves,
 # redeploy the live instance and publish the same commit to npm. Runs in the
-# background. Chat turns live in workers and outlive the restart; reviews
-# and task setups don't, so the restart waits up to 10 minutes for them.
+# background. Chat turns (tasks' and orchestrators') live in workers and
+# outlive the restart, and an orchestrator's tool calls wait for the server to
+# return. Reviews and task setups are server jobs that run again after a
+# restart, so it waits up to 10 minutes for them rather than pay twice.
 #   sm add agentos-autodeploy "scripts/autodeploy" --cron "* * * * *"
 # Restarts are spaced AGENTOS_MIN_GAP seconds apart (an hour; 0 turns it
 # off): a head that lands inside the gap waits and is deployed, whatever it