@schlenkr/ragents 0.1.17 → 0.1.19

package/README.md

@@ -41,7 +41,11 @@ npm install -g @schlenkr/ragents
   ```
 
 - `workspace-client <server-url> [folder ...]` - register this machine and its folders as a
-  workspace for a server, so a run on that server works in these folders.
+  workspace for a server, so a run on that server works in these folders. Includes the same
+  ripgrep and Windows Bash as the VS Code extension. `RAGENTS_USER` and `RAGENTS_PASSWORD` in
+  the environment enable session renewal; `RAGENTS_TOKEN` supplies an existing or personal token.
+  Terminal or parent closure stops it and its children. Use `--detached` explicitly for nohup
+  or a service manager; SIGINT/SIGTERM still stop it.
 
   ```sh
   ragents workspace-client https://ragents.example.com ~/projects/demo

package/apps/web/dist/help/guide-distributed.html

@@ -130,7 +130,7 @@
       <a class="nav-github" href="https://github.com/SchlenkR/RAgents" aria-label="GitHub"><svg class="gh-icon" viewBox="0 0 24 24" aria-hidden="true"><path fill="currentColor" d="M12 2a10 10 0 0 0-3.2 19.5c.5.1.7-.2.7-.5v-1.7c-2.8.6-3.4-1.3-3.4-1.3-.5-1.2-1.1-1.5-1.1-1.5-.9-.6.1-.6.1-.6 1 .1 1.5 1 1.5 1 .9 1.6 2.4 1.1 3 .9.1-.7.4-1.1.6-1.4-2.2-.3-4.6-1.1-4.6-5 0-1.1.4-2 1-2.7-.1-.3-.4-1.3.1-2.7 0 0 .8-.3 2.8 1a9.6 9.6 0 0 1 5 0c1.9-1.3 2.8-1 2.8-1 .5 1.4.2 2.4.1 2.7.6.7 1 1.6 1 2.7 0 3.9-2.4 4.7-4.6 5 .4.3.7.9.7 1.9V21c0 .3.2.6.7.5A10 10 0 0 0 12 2Z"/></svg><span class="gh-label">GitHub</span></a>
     </nav>
     <button class="nav-menu" type="button" aria-expanded="false" aria-controls="main-navigation"><span data-menu-label>Menu</span><svg viewBox="0 0 24 24" aria-hidden="true"><path d="m6 9 6 6 6-6"/></svg></button>
-  </header><main class="shell" id="main"><div class="guide-layout"><aside class="guide-sidebar"><nav class="guide-chapters" aria-label="Guide navigation"><a href="guide.html">Overview</a><div class="guide-nav-group"><p>Understand</p><a href="guide-ideas.html">Core ideas</a><a href="guide-runtime.html">Actors and messages</a></div><div class="guide-nav-group"><p>Use</p><a href="guide-getting-started.html">Get started</a><a href="guide-clients.html">Web and VS Code</a><a href="guide-distributed.html" aria-current="page">Distributed work</a></div><div class="guide-nav-group"><p>Build</p><a href="guide-functions.html">Work with TypeScript</a><a href="guide-programs.html">Build mini-apps</a><a href="guide-plugins.html">Plugins and skills</a></div><div class="guide-nav-group"><p>Access</p><a href="guide-access.html">Assign permissions</a></div></nav></aside><details class="guide-mobile-nav"><summary>Guide: Distributed work</summary><nav class="guide-chapters" aria-label="Guide navigation"><a href="guide.html">Overview</a><div class="guide-nav-group"><p>Understand</p><a href="guide-ideas.html">Core ideas</a><a href="guide-runtime.html">Actors and messages</a></div><div class="guide-nav-group"><p>Use</p><a href="guide-getting-started.html">Get started</a><a href="guide-clients.html">Web and VS Code</a><a href="guide-distributed.html" aria-current="page">Distributed work</a></div><div class="guide-nav-group"><p>Build</p><a href="guide-functions.html">Work with TypeScript</a><a href="guide-programs.html">Build mini-apps</a><a href="guide-plugins.html">Plugins and skills</a></div><div class="guide-nav-group"><p>Access</p><a href="guide-access.html">Assign permissions</a></div></nav></details><article class="guide-body"><header class="guide-title"><p class="eyebrow"><a href="guide.html">Guide</a></p><h1>Distributed work</h1><p>Run the host locally or remotely, keep tools beside the project, and move runs between servers.</p></header><details class="guide-page-nav"><summary>On this page</summary><nav aria-label="On this page"><a href="#work-without-a-checkout">Work without a checkout</a><a href="#connect-to-a-server">Connect to a server</a><a href="#transfer-a-run">Transfer a run</a><a href="#work-on-windows">Work on Windows</a></nav></details><h2 id="work-without-a-checkout">Work without a checkout</h2>
+  </header><main class="shell" id="main"><div class="guide-layout"><aside class="guide-sidebar"><nav class="guide-chapters" aria-label="Guide navigation"><a href="guide.html">Overview</a><div class="guide-nav-group"><p>Understand</p><a href="guide-ideas.html">Core ideas</a><a href="guide-runtime.html">Actors and messages</a></div><div class="guide-nav-group"><p>Use</p><a href="guide-getting-started.html">Get started</a><a href="guide-clients.html">Web and VS Code</a><a href="guide-distributed.html" aria-current="page">Distributed work</a></div><div class="guide-nav-group"><p>Build</p><a href="guide-functions.html">Work with TypeScript</a><a href="guide-programs.html">Build mini-apps</a><a href="guide-plugins.html">Plugins and skills</a></div><div class="guide-nav-group"><p>Access</p><a href="guide-access.html">Assign permissions</a></div></nav></aside><details class="guide-mobile-nav"><summary>Guide: Distributed work</summary><nav class="guide-chapters" aria-label="Guide navigation"><a href="guide.html">Overview</a><div class="guide-nav-group"><p>Understand</p><a href="guide-ideas.html">Core ideas</a><a href="guide-runtime.html">Actors and messages</a></div><div class="guide-nav-group"><p>Use</p><a href="guide-getting-started.html">Get started</a><a href="guide-clients.html">Web and VS Code</a><a href="guide-distributed.html" aria-current="page">Distributed work</a></div><div class="guide-nav-group"><p>Build</p><a href="guide-functions.html">Work with TypeScript</a><a href="guide-programs.html">Build mini-apps</a><a href="guide-plugins.html">Plugins and skills</a></div><div class="guide-nav-group"><p>Access</p><a href="guide-access.html">Assign permissions</a></div></nav></details><article class="guide-body"><header class="guide-title"><p class="eyebrow"><a href="guide.html">Guide</a></p><h1>Distributed work</h1><p>Run the host locally or remotely, keep tools beside the project, and move runs between servers.</p></header><details class="guide-page-nav"><summary>On this page</summary><nav aria-label="On this page"><a href="#work-without-a-checkout">Work without a checkout</a><a href="#connect-to-a-server">Connect to a server</a><a href="#run-a-cli-workstation">Run a CLI workstation</a><a href="#transfer-a-run">Transfer a run</a><a href="#work-on-windows">Work on Windows</a></nav></details><h2 id="work-without-a-checkout">Work without a checkout</h2>
 <p>Using RAgents does not require a repository. <code>pnpm build:package</code> creates the npm package
 <code>@schlenkr/ragents</code> from this checkout in <code>dist/ragents</code>; with <code>--pack</code>, it also creates
 <code>dist/schlenkr-ragents-&lt;version&gt;.tgz</code>. The package contains the server, engine, executor, all
@@ -246,6 +246,22 @@ records only forwarded calls with user, alias, target, status, and token count.<
 starts with the new web interface as long as the host API stays the same. Otherwise the start
 refuses the fetched bundles, and <code>connect</code> names the version to install.</li>
 </ul>
+<h2 id="run-a-cli-workstation">Run a CLI workstation</h2>
+<p><code>ragents workspace-client &lt;server-url&gt; [folders ...]</code> registers this machine with the same tools
+and executor as the VS Code extension. No folder means the current directory; <code>--id</code> and <code>--label</code>
+set its stable identity and display name. The npm installation includes ripgrep on every supported
+platform and the curated Bash on Windows. Plugin tools are provisioned before registration.</p>
+<p>Set <code>RAGENTS_TOKEN</code> for a personal or existing session token. For automatic sign-in and renewal,
+configure <code>RAGENTS_USER</code> and <code>RAGENTS_PASSWORD</code> in the process environment. Neither is a command-line
+option. Invalid or absent credentials when sign-in is required produce a visible failure and a
+nonzero exit. A temporary connection loss reconnects and registers the workstation again.</p>
+<p>Closing the terminal or SSH session, closing stdin, or ending the owning process unregisters the
+workstation and stops its children. SIGINT, SIGTERM, and SIGHUP also stop it. For an intentional
+background service, pass <code>--detached</code> and let a service manager own it, or run:</p>
+<pre><code class="language-sh">nohup ragents workspace-client https://ragents.example.com /home/user/project --detached &gt;workspace.log 2&gt;&amp;1 &lt;/dev/null &amp;
+</code></pre>
+<p>The flag ignores terminal closure, parent loss, and SIGHUP; it does not daemonize. SIGINT and
+SIGTERM still unregister and shut down. Use the service manager&#39;s stop command to end a service.</p>
 <h2 id="transfer-a-run">Transfer a run</h2>
 <p>A run can move from one server to another and continue there, for example from a notebook to an
 always-on machine or from a central server to a developer for local inspection.</p>
@@ -299,13 +315,11 @@ otherwise it tells the model to exclude dependency and build folders from <code>
 contains no git, so your login works as usual: Git Credential Manager, <code>~/.gitconfig</code> and
 <code>~/.ssh</code>. On your own machine the bash inherits your whole environment, except the variables of
 VS Code itself and <code>BASH_ENV</code>/<code>ENV</code>.</li>
-<li><strong>Without the extension</strong> (<code>ragents start</code> or <code>ragents workspace-client</code> from the npm package)
-set <code>RAGENTS_BASH</code> to the <code>bash.exe</code> of such a bundle, for example
-<code>&lt;extension folder&gt;\dist\bash\win32-x64\usr\bin\bash.exe</code>. Without it every <code>bash</code> call fails
-and names what is missing. <code>RAGENTS_RG</code> names an <code>rg</code> in the same way, for example
-<code>&lt;extension folder&gt;\dist\rg\win32-x64\rg.exe</code>, on every platform; without it, an <code>rg</code> on
-<code>PATH</code> is used if there is one. A <code>RAGENTS_RG</code> that points to a missing file stops the server
-start or the workstation&#39;s registration.</li>
+<li><strong>CLI workstation</strong> (<code>ragents workspace-client</code>) carries the same Bash and ripgrep as the
+extension. npm installs only the optional tools package for this machine; keep optional
+dependencies enabled. A checkout uses the extension build from <code>pnpm bundle:rg</code> and
+<code>pnpm bundle:bash</code>. A standalone server (<code>ragents start</code>) still takes <code>RAGENTS_BASH</code> and
+<code>RAGENTS_RG</code> from its environment; these variables do not override workstation bundles.</li>
 <li><strong>Node.js</strong> is enough with <code>@schlenkr/ragents</code>. A checkout additionally needs <strong>pnpm</strong>, and
 <code>pnpm install</code>, <code>pnpm build:agent</code>, and <code>scripts/start.sh</code> need a bash of your own, such as
 Git Bash.</li>

package/apps/web/dist/help/guide-distributed.md

@@ -143,6 +143,29 @@ expose only the alias.
   starts with the new web interface as long as the host API stays the same. Otherwise the start
   refuses the fetched bundles, and `connect` names the version to install.
 
+## Run a CLI workstation
+
+`ragents workspace-client <server-url> [folders ...]` registers this machine with the same tools
+and executor as the VS Code extension. No folder means the current directory; `--id` and `--label`
+set its stable identity and display name. The npm installation includes ripgrep on every supported
+platform and the curated Bash on Windows. Plugin tools are provisioned before registration.
+
+Set `RAGENTS_TOKEN` for a personal or existing session token. For automatic sign-in and renewal,
+configure `RAGENTS_USER` and `RAGENTS_PASSWORD` in the process environment. Neither is a command-line
+option. Invalid or absent credentials when sign-in is required produce a visible failure and a
+nonzero exit. A temporary connection loss reconnects and registers the workstation again.
+
+Closing the terminal or SSH session, closing stdin, or ending the owning process unregisters the
+workstation and stops its children. SIGINT, SIGTERM, and SIGHUP also stop it. For an intentional
+background service, pass `--detached` and let a service manager own it, or run:
+
+```sh
+nohup ragents workspace-client https://ragents.example.com /home/user/project --detached >workspace.log 2>&1 </dev/null &
+```
+
+The flag ignores terminal closure, parent loss, and SIGHUP; it does not daemonize. SIGINT and
+SIGTERM still unregister and shut down. Use the service manager's stop command to end a service.
+
 ## Transfer a run
 
 A run can move from one server to another and continue there, for example from a notebook to an
@@ -203,13 +226,11 @@ The local host and workspace also run on Windows. Requirements are:
   contains no git, so your login works as usual: Git Credential Manager, `~/.gitconfig` and
   `~/.ssh`. On your own machine the bash inherits your whole environment, except the variables of
   VS Code itself and `BASH_ENV`/`ENV`.
-- **Without the extension** (`ragents start` or `ragents workspace-client` from the npm package)
-  set `RAGENTS_BASH` to the `bash.exe` of such a bundle, for example
-  `<extension folder>\dist\bash\win32-x64\usr\bin\bash.exe`. Without it every `bash` call fails
-  and names what is missing. `RAGENTS_RG` names an `rg` in the same way, for example
-  `<extension folder>\dist\rg\win32-x64\rg.exe`, on every platform; without it, an `rg` on
-  `PATH` is used if there is one. A `RAGENTS_RG` that points to a missing file stops the server
-  start or the workstation's registration.
+- **CLI workstation** (`ragents workspace-client`) carries the same Bash and ripgrep as the
+  extension. npm installs only the optional tools package for this machine; keep optional
+  dependencies enabled. A checkout uses the extension build from `pnpm bundle:rg` and
+  `pnpm bundle:bash`. A standalone server (`ragents start`) still takes `RAGENTS_BASH` and
+  `RAGENTS_RG` from its environment; these variables do not override workstation bundles.
 - **Node.js** is enough with `@schlenkr/ragents`. A checkout additionally needs **pnpm**, and
   `pnpm install`, `pnpm build:agent`, and `scripts/start.sh` need a bash of your own, such as
   Git Bash.

package/apps/web/src/server-client.ts

@@ -0,0 +1,165 @@
+import type { AccessSnapshot } from "../../../packages/ragents/src/access";
+import { accessSnapshotFrom } from "./access-session";
+import { RpcClient } from "./rpc/client";
+
+export class ServerError extends Error {
+  constructor(message: string, readonly status: number, readonly code?: string) {
+    super(message);
+    this.name = "ServerError";
+  }
+}
+
+export class UnreachableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UnreachableError";
+  }
+}
+
+const sessionTokenFrom = (setCookie: readonly string[]): string => {
+  for (const cookie of setCookie) {
+    const pair = cookie.split(";")[0] ?? "";
+    const token = pair.slice(pair.indexOf("=") + 1).trim();
+    if (/^[A-Za-z0-9_-]{43}$/.test(token)) return token;
+  }
+  throw new ServerError("The server did not deliver a session token.", 500);
+};
+
+const errorFrom = async (response: Response): Promise<ServerError> => {
+  let message = `The server responded with ${response.status}.`;
+  let code: string | undefined;
+  try {
+    const body = await response.json() as { error?: unknown; message?: unknown; code?: unknown };
+    if (typeof body.error === "string" && body.error) message = body.error;
+    else if (typeof body.message === "string" && body.message) message = body.message;
+    if (typeof body.code === "string") code = body.code;
+  } catch {}
+  return new ServerError(message, response.status, code);
+};
+
+/** A workstation's access: sign-in and delivery over HTTP, everything else as JSON-RPC; the session token goes as bearer. */
+export interface SignInOptions {
+  readonly credentials: () => Promise<{ id: string; password: string } | undefined>;
+  readonly onToken?: (token: string) => Promise<void>;
+  readonly log?: (line: string) => void;
+}
+
+export class ServerClient {
+  #authenticating: Promise<boolean> | undefined;
+  #signInFailure: string | undefined;
+  readonly origin: string;
+  readonly rpc: RpcClient;
+
+  constructor(readonly baseUrl: string, private token: string | undefined, private readonly request: typeof fetch = fetch, private readonly signIn?: SignInOptions) {
+    this.origin = new URL(baseUrl).origin;
+    this.rpc = new RpcClient({
+      baseUrl: this.origin,
+      fetch: (input, init) => this.#authorized(input, init),
+    });
+  }
+
+  signInFailure(): string | undefined {
+    return this.#signInFailure;
+  }
+
+  async #authorized(input: Parameters<typeof fetch>[0], init?: RequestInit): Promise<Response> {
+    const token = this.token;
+    const send = () => this.request(input, { ...init, headers: this.headers(init?.headers as Record<string, string> | undefined ?? {}) });
+    const response = await send();
+    if (response.status !== 401 || !this.signIn || init?.signal?.aborted) return response;
+    const rejection = await response.clone().json().catch(() => undefined) as { code?: unknown } | undefined;
+    if (rejection?.code !== "login-required") {
+      this.#signInFailure = "Access token required: this server does not accept automatic user/password sign-in. Supply a valid access token.";
+      return response;
+    }
+    if (token === this.token) {
+      this.#authenticating ??= this.#authenticate().finally(() => { this.#authenticating = undefined; });
+      if (!await this.#authenticating) return response;
+    }
+    if (init?.signal?.aborted) return response;
+    await response.body?.cancel();
+    const retried = await send();
+    if (retried.status === 401) this.#signInFailure = "Sign-in required: the server rejected the renewed session.";
+    return retried;
+  }
+
+  async #authenticate(): Promise<boolean> {
+    try {
+      const credentials = await this.signIn!.credentials();
+      if (!credentials) {
+        this.#signInFailure = "Sign-in required: no credentials are configured for session renewal.";
+        return false;
+      }
+      this.signIn!.log?.(`== Signing in to ${this.origin} with configured credentials`);
+      const { token } = await this.login(credentials.id, credentials.password);
+      await this.signIn!.onToken?.(token);
+      this.useToken(token);
+      this.#signInFailure = undefined;
+      return true;
+    } catch {
+      this.#signInFailure = "Sign-in required: automatic sign-in failed. Check the configured credentials and server availability.";
+      return false;
+    }
+  }
+
+  get hasToken(): boolean {
+    return this.token !== undefined;
+  }
+
+  get accessToken(): string | undefined {
+    return this.token;
+  }
+
+  /** The client reads the token on every request, so the messaging layer stays in place. */
+  useToken(token: string | undefined): void {
+    this.token = token;
+  }
+
+  url(path: string): string {
+    return new URL(path, `${this.origin}/`).toString();
+  }
+
+  headers(extra: Record<string, string> = {}): Record<string, string> {
+    return this.token === undefined ? extra : { ...extra, authorization: `Bearer ${this.token}` };
+  }
+
+  async fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    try {
+      return await this.#authorized(this.url(path), init);
+    } catch (cause) {
+      throw new UnreachableError(`${this.origin} is unreachable: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+  }
+
+  async json<T>(path: string, init: RequestInit = {}, validate: (value: unknown) => T = (value) => value as T): Promise<T> {
+    const response = await this.fetch(path, init);
+    if (!response.ok) throw await errorFrom(response);
+    return validate(await response.json());
+  }
+
+  async access(): Promise<AccessSnapshot> {
+    const snapshot = await this.json("/api/access", { cache: "no-store" }, accessSnapshotFrom);
+    if (!snapshot.enabled || snapshot.user || !this.signIn) return snapshot;
+    this.#authenticating ??= this.#authenticate().finally(() => { this.#authenticating = undefined; });
+    return await this.#authenticating ? this.json("/api/access", { cache: "no-store" }, accessSnapshotFrom) : snapshot;
+  }
+
+  async login(id: string, password: string): Promise<{ snapshot: AccessSnapshot; token: string }> {
+    const response = await this.request(this.url("/api/access/login"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id, password }),
+      signal: AbortSignal.timeout(10_000),
+      redirect: "error",
+    });
+    if (!response.ok) throw await errorFrom(response);
+    const snapshot = accessSnapshotFrom(await response.json());
+    if (!snapshot.user) throw new ServerError("The server did not confirm the sign-in.", 500);
+    return { snapshot, token: sessionTokenFrom(response.headers.getSetCookie()) };
+  }
+
+  async logout(): Promise<void> {
+    const response = await this.fetch("/api/access/logout", { method: "POST" });
+    if (!response.ok && response.status !== 401) throw await errorFrom(response);
+  }
+}

package/bundles/ragents.workspace/ragents-bundle.json

@@ -137,7 +137,7 @@
     }
   },
   "revision": "db9370b7b3449c44be49986b074806351b857c430963aa878e209d2d5c9ba4f8",
-  "sourceRevision": "012d6527173d20efeeaa5102b884d7cd9bbf781cf4fa6446164529ec252fcc2e",
+  "sourceRevision": "25a05a48b591f8f4b575b06d495f7f191037d7419b79a98ad321328c455f4e0d",
   "server": "server/index.js",
   "web": {
     "entry": "web/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schlenkr/ragents",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "RAgents host: server, engine, plugins and tools without a source checkout",
   "keywords": [
     "agents",
@@ -70,7 +70,15 @@
     "vscode-jsonrpc": "9.0.2",
     "yaml": "2.9.0"
   },
+  "optionalDependencies": {
+    "@schlenkr/ragents-tools-win32-x64": "0.1.19",
+    "@schlenkr/ragents-tools-win32-arm64": "0.1.19",
+    "@schlenkr/ragents-tools-darwin-x64": "0.1.19",
+    "@schlenkr/ragents-tools-darwin-arm64": "0.1.19",
+    "@schlenkr/ragents-tools-linux-x64": "0.1.19",
+    "@schlenkr/ragents-tools-linux-arm64": "0.1.19"
+  },
   "ragents": {
-    "hostVersion": "29cbfb6c019aa6a9ceb540363ca37ef2f9d03cb1"
+    "hostVersion": "9fd1390d0bf180bd36be46f0409d318a223e6ef2"
   }
 }

package/packages/agent/src/core/agent-settings.ts

@@ -2,7 +2,7 @@
 export interface AgentSettings {
 	/** Retries after a retryable model error, with exponential backoff. */
 	retry: { enabled: boolean; maxRetries: number; baseDelayMs: number };
-	/** Timeout and retries of a single provider request; unset values leave the SDK defaults. */
+	/** Idle timeout (time without any received chunk) and retries of a single provider request; unset values leave the SDK defaults. */
 	providerRequest: { timeoutMs: number; maxRetries?: number; maxRetryDelayMs: number };
 }
 
@@ -13,5 +13,5 @@ export interface AgentSettingsInput {
 
 export const agentSettings = (input: AgentSettingsInput = {}): AgentSettings => ({
 	retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000, ...input.retry },
-	providerRequest: { timeoutMs: 300_000, maxRetryDelayMs: 60_000, ...input.providerRequest },
+	providerRequest: { timeoutMs: 600_000, maxRetryDelayMs: 60_000, ...input.providerRequest },
 });

package/packages/ai/src/api/ai-sdk.ts

@@ -33,6 +33,16 @@ async function runStream(model: Model<"openai-completions">, context: Context, o
 	};
 	const controller = new AbortController();
 	const signal = options?.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+	let idleTimer: ReturnType<typeof setTimeout> | undefined;
+	let idleExpired = false;
+	const restartIdleTimer = () => {
+		clearTimeout(idleTimer);
+		if (options?.timeoutMs === undefined) return;
+		idleTimer = setTimeout(() => {
+			idleExpired = true;
+			controller.abort();
+		}, options.timeoutMs);
+	};
 	try {
 		const retention = options?.cacheRetention ?? (getProviderEnvValue("AGENT_CACHE_RETENTION", options?.env) === "long" ? "long" : "short");
 		const cacheControl = retention !== "none" && (model.compat?.cacheControlFormat === "anthropic" || model.id.startsWith("anthropic/"))
@@ -67,7 +77,6 @@ async function runStream(model: Model<"openai-completions">, context: Context, o
 			maxRetries: options?.maxRetries ?? 0,
 			streamRetries: 0,
 			abortSignal: signal,
-			timeout: options?.timeoutMs,
 			stopWhen: stepCountIs(1),
 			includeRawChunks: true,
 			onError: () => {},
@@ -83,7 +92,9 @@ async function runStream(model: Model<"openai-completions">, context: Context, o
 		let rawThinkingIndex: number | undefined;
 		let hasFinishReason = false;
 		let finished = false;
+		restartIdleTimer();
 		for await (const part of result.fullStream) {
+			restartIdleTimer();
 			switch (part.type) {
 				case "raw": {
 					const chunk = part.rawValue as { id?: string; model?: string; choices?: Array<{ finish_reason?: string | null; delta?: {
@@ -216,9 +227,11 @@ async function runStream(model: Model<"openai-completions">, context: Context, o
 	} catch (error) {
 		controller.abort();
 		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-		output.errorMessage = formatProviderError(normalizeProviderError(error), model.provider === "relay" ? `Relay ${model.baseUrl}` : undefined);
+		const failure = idleExpired ? new Error(`Timeout: no data from the provider for ${options?.timeoutMs} ms`) : error;
+		output.errorMessage = formatProviderError(normalizeProviderError(failure), model.provider === "relay" ? `Relay ${model.baseUrl}` : undefined);
 		events.push({ type: "error", reason: output.stopReason, error: output });
 	} finally {
+		clearTimeout(idleTimer);
 		events.end();
 	}
 }

package/packages/ai/src/types.ts

@@ -89,7 +89,8 @@ export interface StreamOptions {
 	 */
 	headers?: ProviderHeaders;
 	/**
-	 * HTTP request timeout in milliseconds for providers/SDKs that support it.
+	 * Timeout in milliseconds for providers/SDKs that support it. The openai-completions
+	 * stream counts it as idle time: any received chunk restarts it, so an active stream never expires.
 	 * For example, OpenAI and Anthropic SDK clients default to 10 minutes.
 	 */
 	timeoutMs?: number;

package/packages/workspace-executor/src/bundled-tools.ts

@@ -0,0 +1,49 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+export const WORKSPACE_TOOL_TARGETS = ["win32-x64", "win32-arm64", "darwin-x64", "darwin-arm64", "linux-x64", "linux-arm64"] as const;
+export type WorkspaceToolTarget = typeof WORKSPACE_TOOL_TARGETS[number];
+
+export const workspaceToolsPackageName = (target: string): string => `@schlenkr/ragents-tools-${target}`;
+
+export interface BundledToolsOptions {
+  readonly root: string;
+  readonly distribution: "extension" | "package";
+  readonly platform?: NodeJS.Platform;
+  readonly arch?: string;
+  readonly paths?: typeof path;
+  readonly exists?: (file: string) => boolean;
+  readonly resolvePackage?: (specifier: string) => string;
+}
+
+export interface BundledTools {
+  readonly bash: string | undefined;
+  readonly rg: string | undefined;
+}
+
+export const resolveBundledTools = (options: BundledToolsOptions): BundledTools => {
+  const platform = options.platform ?? process.platform;
+  const target = `${platform}-${options.arch ?? process.arch}`;
+  const paths = options.paths ?? path;
+  const exists = options.exists ?? existsSync;
+  const packageRoot = (): string => {
+    if (!WORKSPACE_TOOL_TARGETS.includes(target as WorkspaceToolTarget)) throw new Error(`Unsupported workstation platform: ${target}`);
+    const name = workspaceToolsPackageName(target);
+    try {
+      const resolve = options.resolvePackage ?? createRequire(paths.join(options.root, "package.json")).resolve;
+      return paths.dirname(resolve(`${name}/package.json`));
+    } catch {
+      throw new Error(`The bundled workstation tools ${name} are missing. Reinstall @schlenkr/ragents with optional dependencies enabled.`);
+    }
+  };
+  const root = options.distribution === "package" ? packageRoot() : options.root;
+  const bash = platform === "win32" ? paths.join(root, "dist", "bash", target, "usr", "bin", "bash.exe") : undefined;
+  const rg = paths.join(root, "dist", "rg", target, platform === "win32" ? "rg.exe" : "rg");
+  if (options.distribution === "package") {
+    for (const file of [rg, bash]) {
+      if (file !== undefined && !exists(file)) throw new Error(`Bundled workstation tool is missing: ${file}. Reinstall @schlenkr/ragents with optional dependencies enabled.`);
+    }
+  }
+  return { bash, rg: exists(rg) ? rg : undefined };
+};

package/packages/workspace-executor/src/owner-lifetime.d.mts

@@ -0,0 +1,18 @@
+import type { EventEmitter } from "node:events";
+import type { Readable } from "node:stream";
+
+export interface OwnerLifetimeOptions {
+  readonly detached?: boolean;
+  readonly parents?: readonly number[];
+  readonly onStop: (reason: string) => void;
+  readonly stdin?: Pick<Readable, "on" | "off" | "resume" | "pause" | "destroyed" | "readableEnded"> | null;
+  readonly signals?: EventEmitter;
+  readonly alive?: (pid: number) => boolean;
+  readonly intervalMs?: number;
+}
+
+export function processAlive(pid: number): boolean;
+export function watchOwnerLifetime(options: OwnerLifetimeOptions): () => void;
+export function processChildren(pid?: number): number[];
+export function terminateProcessTree(pid: number): void;
+export function exitWorkspaceProcess(code: number): never;

package/packages/workspace-executor/src/owner-lifetime.mjs

@@ -0,0 +1,102 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, readdirSync } from "node:fs";
+
+export const processAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+
+export const watchOwnerLifetime = ({ detached = false, parents = [process.ppid], onStop, stdin = process.stdin, signals = process, alive = processAlive, intervalMs = 1000 }) => {
+  const releases = [];
+  const signalReleases = [];
+  let stopped = false;
+  const dispose = () => {
+    for (const release of releases.splice(0)) release();
+  };
+  const stop = (reason) => {
+    if (stopped) return;
+    stopped = true;
+    dispose();
+    onStop(reason);
+  };
+  const listen = (emitter, event, handler, keepDuringStop = false) => {
+    emitter.on(event, handler);
+    (keepDuringStop ? signalReleases : releases).push(() => emitter.off(event, handler));
+  };
+  listen(signals, "SIGINT", () => stop("SIGINT"), true);
+  listen(signals, "SIGTERM", () => stop("SIGTERM"), true);
+  listen(signals, "SIGHUP", () => { if (!detached) stop("SIGHUP"); }, true);
+  if (!detached) {
+    if (parents.some((pid) => !Number.isSafeInteger(pid) || pid <= 0)) throw new Error("The workspace owner PID must be a positive integer.");
+    const check = () => {
+      if (parents.some((pid) => !alive(pid))) stop("parent exited");
+    };
+    const timer = setInterval(check, intervalMs);
+    timer.unref();
+    releases.push(() => clearInterval(timer));
+    listen(signals, "disconnect", () => stop("owner disconnected"));
+    if (stdin) {
+      listen(stdin, "end", () => stop("stdin closed"));
+      listen(stdin, "close", () => stop("stdin closed"));
+      listen(stdin, "error", () => stop("stdin failed"));
+      stdin.resume();
+      releases.push(() => stdin.pause());
+      if (stdin.destroyed || stdin.readableEnded) queueMicrotask(() => stop("stdin closed"));
+    }
+    queueMicrotask(check);
+  }
+  return () => {
+    stopped = true;
+    dispose();
+    for (const release of signalReleases.splice(0)) release();
+  };
+};
+
+export const processChildren = (pid = process.pid) => {
+  if (process.platform === "win32") {
+    const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command",
+      `Get-CimInstance Win32_Process -Filter 'ParentProcessId = ${pid}' | ForEach-Object { $_.ProcessId }`], { encoding: "utf8", windowsHide: true, timeout: 5000 });
+    if (result.status !== 0) throw new Error("Cannot inspect workspace child processes for shutdown.");
+    return result.stdout.trim().split(/\s+/).map(Number).filter((child) => child > 0);
+  }
+  const rows = process.platform === "linux" ? readdirSync("/proc").filter((entry) => /^\d+$/.test(entry)).flatMap((entry) => {
+    try {
+      const stat = readFileSync(`/proc/${entry}/stat`, "utf8");
+      return [[Number(entry), Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1])]];
+    } catch (error) {
+      if (["ENOENT", "ESRCH", "EACCES"].includes(error.code)) return [];
+      throw error;
+    }
+  }) : (() => {
+    const table = spawnSync("ps", ["-axo", "pid=,ppid="], { encoding: "utf8" });
+    if (table.status !== 0) throw new Error("Cannot inspect workspace child processes for shutdown.");
+    return table.stdout.trim().split("\n").map((line) => line.trim().split(/\s+/).map(Number));
+  })();
+  const descendants = (parent) => rows.filter((row) => row[1] === parent).flatMap((row) => [...descendants(row[0]), row[0]]);
+  return descendants(pid);
+};
+
+export const terminateProcessTree = (pid) => {
+  if (process.platform === "win32") {
+    const killed = spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore", windowsHide: true, timeout: 5000 });
+    if (killed.status !== 0 && processAlive(pid)) throw new Error(`Could not stop workspace child process ${pid}.`);
+    return;
+  }
+  for (const child of [...processChildren(pid), pid]) {
+    try { process.kill(child, "SIGKILL"); } catch (error) { if (error.code !== "ESRCH") throw error; }
+  }
+};
+
+export const exitWorkspaceProcess = (code) => {
+  for (const pid of processChildren()) {
+    if (process.platform === "win32") terminateProcessTree(pid);
+    else {
+      try { process.kill(pid, "SIGKILL"); } catch (error) { if (error.code !== "ESRCH") throw error; }
+    }
+  }
+  process.exit(code);
+};

package/plugins/ragents.workspace/client/transport.ts

@@ -1,13 +1,11 @@
-import { RpcClient } from "../../../apps/web/src/rpc/client";
-import type { WorkspaceClientTransport } from "./workspace-client";
+import { ServerClient } from "../../../apps/web/src/server-client";
 
-/** A workstation access without a user interface: the message layer with a bearer token. */
-export const workspaceClientTransport = (baseUrl: string, token: string | undefined): WorkspaceClientTransport => ({
-  rpc: new RpcClient({
-    baseUrl: new URL(baseUrl).origin,
-    fetch: (input, init) => {
-      const headers = init?.headers as Record<string, string> | undefined ?? {};
-      return fetch(input, { ...init, headers: token === undefined ? headers : { ...headers, authorization: `Bearer ${token}` } });
+export const workspaceClientTransport = (baseUrl: string, token: string | undefined, environment: NodeJS.ProcessEnv = process.env): ServerClient =>
+  new ServerClient(baseUrl, token, fetch, {
+    log: (line) => console.error(line),
+    credentials: async () => {
+      const id = environment.RAGENTS_USER;
+      const password = environment.RAGENTS_PASSWORD;
+      return id && password ? { id, password } : undefined;
     },
-  }),
-});
+  });

package/plugins/ragents.workspace/client/workspace-client.ts

@@ -65,6 +65,7 @@ export interface WorkspaceClientOptions {
 /** What the workstation needs for the server: the message layer. */
 export interface WorkspaceClientTransport {
   readonly rpc: RpcClient;
+  readonly signInFailure?: () => string | undefined;
 }
 
 type ExecuteInput = OperationInput<typeof workspaceClientContracts.execute>;
@@ -255,6 +256,11 @@ export class WorkspaceClient {
     releases.push(
       rpc.handle(workspaceClientContracts.execute, (input, context) => this.#execute(attachment, input, context)),
       rpc.onConnected(() => void this.#announce()),
+      rpc.onStatus((status) => {
+        if (status.kind === "unauthorized" && attachment === this.#attachment) {
+          this.#set({ kind: "failed", message: this.transport.signInFailure?.() ?? "The server requires a sign-in.", mismatch: false });
+        }
+      }),
     );
     this.#attachment = attachment;
     return attachment;
@@ -288,13 +294,14 @@ export class WorkspaceClient {
   #connected(): Promise<void> {
     const rpc = this.transport.rpc;
     if (rpc.status.kind === "connected") return Promise.resolve();
+    if (rpc.status.kind === "unauthorized") return Promise.reject(new Error(this.transport.signInFailure?.() ?? "The server requires a sign-in."));
     return new Promise((settle, fail) => {
       const release = rpc.onStatus((status) => {
         if (status.kind === "connecting") return;
         release();
         if (status.kind === "connected") settle();
         else if (status.kind === "retrying") fail(new Error(status.message));
-        else if (status.kind === "unauthorized") fail(new Error("The server requires a sign-in."));
+        else if (status.kind === "unauthorized") fail(new Error(this.transport.signInFailure?.() ?? "The server requires a sign-in."));
         else fail(new Error("The server's event stream is closed."));
       });
     });