@piagent/platform 1.36.0 → 1.37.0

package/packages/piagent-core/managed/studio-link.mjs

@@ -15,6 +15,7 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { CLIENT_AGENT } from './client-agent.mjs';
+import { failureCode, failureText } from '../runtime/managed-failure.mjs';
 
 // Codes whose cause is Studio or the way to it: Studio, its gateway or its
 // connector did not answer (stopped, restarting, an update), or Agent Watch
@@ -34,6 +35,13 @@ const LOG_BYTES = 2 * 1024 * 1024, QUEUE = 50, BATCH = 20, SEND_TRIES = 5;
 const MIN_PAUSE_MS = 2_000, MAX_PAUSE_MS = 30_000, MAX_STREAK_PAUSE_MS = 5 * 60_000, BEAT_TIMEOUT_MS = 5_000;
 // After Studio was away, Agent Watch gets this long to reach it again.
 export const BROKER_GRACE_MS = 10 * 60_000;
+// Agent Watch could not reach Studio while Studio answers here: its way to
+// Studio failed for a moment (a gateway's 5xx, a dropped connection, a slow
+// answer). Found on 2026-10-22: one such failure renewing the grant stopped a
+// 25-minute task at once. It is asked again, pausing longer each time, until
+// it has failed for this long without a request going through; then it fails
+// as before (Agent Watch itself is broken, not the way to Studio).
+export const BROKER_RETRY_MS = 3 * 60_000;
 
 const header = (headers, name) => {
   if (!headers) return null;
@@ -74,7 +82,7 @@ export class StudioLink {
     if (seen.boot) this.last = { boot: seen.boot, version: seen.version ?? this.last.version };
   }
   // A request went through: the next wait starts with a short pause again.
-  ok() { this.streak = 0; }
+  ok() { this.streak = 0; this.brokerSince = null; }
   waits(code) { return STUDIO_WAIT_CODES.has(code); }
   // Studio or the way to it, whatever Studio's heartbeat says now.
   always(code) { return this.waits(code) && !conditional(code); }
@@ -107,7 +115,7 @@ export class StudioLink {
     if (signal?.aborted) throw signal.reason ?? Error('aborted');
     if (!this.waits(code)) return null;
     const first = conditional(code) ? await this.beat(signal) : null;
-    if (first?.state === 'ready' && !this.justBack()) return null;
+    if (first?.state === 'ready' && !this.justBack() && !this.brokerRetry(code)) return null;
     const controller = new AbortController(), stop = () => controller.abort(signal?.reason);
     signal?.addEventListener('abort', stop, { once: true });
     this.waiting.add(controller);
@@ -115,7 +123,8 @@ export class StudioLink {
     const seen = new Set(first ? [first.state] : []);
     this.log({ kind: 'studio_wait', state: 'start', id: event.id, phase, role, code, version: event.before.version, conversation });
     this.notify({ type: 'managed_studio_wait', id: event.id, role, phase, code, state: 'start', waitedMs: 0 });
-    this.status(`Studio is not answering (${code}). Waiting; the work goes on by itself when Studio is back. Esc stops.`);
+    this.status(first?.state === 'ready' ? `Agent Watch could not reach Studio (${code}). Asking again; the work goes on by itself. Esc stops.`
+      : `Studio is not answering (${code}). Waiting; the work goes on by itself when Studio is back. Esc stops.`);
     // Failing again right after a wait (Studio answers, the request does
     // not): each such wait starts with a longer pause, up to five minutes.
     let pause = Math.min(MAX_STREAK_PAUSE_MS, this.minPauseMs * 2 ** Math.min(this.streak, 8));
@@ -147,7 +156,15 @@ export class StudioLink {
   async needed(code, signal) {
     if (signal?.aborted) throw signal.reason ?? Error('aborted');
     if (!this.waits(code)) return false;
-    return !(conditional(code) && (await this.beat(signal)).state === 'ready' && !this.justBack());
+    return !(conditional(code) && (await this.beat(signal)).state === 'ready' && !this.justBack() && !this.brokerRetry(code, false));
+  }
+  // An Agent Watch failure on a Studio that answers: asked again within
+  // BROKER_RETRY_MS of the first one since a request last went through.
+  brokerRetry(code, start = true) {
+    if (!BROKER.test(code)) return false;
+    const since = this.brokerSince ?? this.now();
+    if (start) this.brokerSince = since;
+    return this.now() - since < (this.brokerRetryMs ?? BROKER_RETRY_MS);
   }
   justBack() { return !!this.recoveredAt && this.now() - this.recoveredAt < (this.brokerGraceMs ?? BROKER_GRACE_MS); }
 
@@ -239,3 +256,16 @@ export function resumeMessage(wait, code) {
     content: `Harness: your last step was cut off because ${why} [${code}]; Studio answers again after about ${minutes} min. Nothing you asked for is lost: the files and the checklist are as you left them. Check where you were (the checklist, git status, the last command you ran) and continue the member's task from there; do not redo work that is already done.`,
     details: { phase: 'resume', cause: wait.cause, waitedMs: wait.waited_ms, code } };
 }
+
+// A broker call (closing the round's run) when Agent Watch's way to Studio
+// fails for a moment: asked again while the link waits, so a passing gateway
+// error does not fail a turn whose work is done.
+export async function viaLink(link, ask, { conversation = null, runId = null } = {}) {
+  for (;;) {
+    try { return await ask(); }
+    catch (error) {
+      const code = failureCode(failureText(error));
+      if (!(await link?.waitUntilBack({ phase: 'broker', code, conversation, runId }).catch(() => null))) throw error;
+    }
+  }
+}

package/packages/piagent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piagent/core",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "type": "module",
   "private": true,
   "license": "MIT",

package/packages/piagent-core/runtime/managed-failure.mjs

@@ -166,6 +166,11 @@ export function failureCode(raw) {
   // The provider library's words for an answer stream that ended empty: Studio
   // admitted the request and nothing came back. It is not asked again.
   if (/stream ended without a (terminal event|stop reason)|response has no body/i.test(text)) return 'upstream_incomplete';
+  // Studio's own words when its upstream cut an answer already streaming: its
+  // error event carries the code, which the provider libraries drop (seen
+  // 2026-10-21: "Request interrupted" stopped a long task with no ask again).
+  if (/^Request interrupted\b/i.test(text)) return 'upstream_interrupted';
+  if (/^The answer ran past its output limit\b/i.test(text)) return 'output_limit_exceeded';
   if (NETWORK.test(text)) return 'studio-unreachable';
   return 'managed-request-failed';
 }

package/scripts/company-terminal.mjs

@@ -388,7 +388,8 @@ export function companyTerminalExtension({ managed, packageRoot, sdkRoot, bindin
       const session = managed()?.session;
       if (!session?.subscribe || heard === session) return;
       heard = session;
-      const showBranch = async () => { const branch = await branchOf(managed()?.cwd ?? ctx.cwd); ctx.ui?.setStatus?.('agent-watch-branch', branch ? `⎇ ${branch}` : undefined); };
+      // The conversation can close while git answers (a client ends right after a turn): its ctx is then stale.
+      const showBranch = async () => { try { const branch = await branchOf(managed()?.cwd ?? ctx.cwd); ctx.ui?.setStatus?.('agent-watch-branch', branch ? `⎇ ${branch}` : undefined); } catch { /* closed meanwhile */ } };
       ctx.ui?.setWorkingMessage?.(WORKING);
       void showBranch();
       session.subscribe((event) => {

package/scripts/piagent-studio.mjs

@@ -15,16 +15,17 @@ const digest = file => createHash('sha256').update(fs.readFileSync(file)).digest
 process.removeAllListeners('warning');
 process.on('warning', warning => { if (warning.name !== 'ExperimentalWarning') process.stderr.write(`${warning.name}: ${warning.message}\n`); });
 const args = process.argv.slice(2), flags = new Map();
-if (args.includes('--help')) { console.log('piagent studio [--web [--no-open] | --serve | --check | --doctor | --prompt <text> [--json]] [--config <Agent Watch configuration>] [--project <folder>]\nDefaults: the configuration imported into ~/.pi/agent and the current project. Personal sessions remain under pi / piagent dashboard.\n--json with --prompt writes the event stream of `pi --mode json` (JSONL on stdout; failures on stderr, exit 1).'); process.exit(0); }
+if (args.includes('--help')) { console.log('piagent studio [--web [--no-open] | --serve | --check | --doctor | --prompt <text> [--json] | --rpc] [--config <Agent Watch configuration>] [--project <folder>]\nDefaults: the configuration imported into ~/.pi/agent and the current project. Personal sessions remain under pi / piagent dashboard.\n--json with --prompt writes the event stream of `pi --mode json` (JSONL on stdout; failures on stderr, exit 1).\n--rpc speaks the protocol of `pi --mode rpc` on stdin/stdout for one company conversation (several messages, questions as extension UI requests).'); process.exit(0); }
 for (let i = 0; i < args.length; i++) {
-  if (['--check', '--doctor', '--web', '--serve', '--no-open', '--json'].includes(args[i])) { flags.set(args[i], true); continue; }
+  if (['--check', '--doctor', '--web', '--serve', '--no-open', '--json', '--rpc'].includes(args[i])) { flags.set(args[i], true); continue; }
   if (!['--config', '--project', '--prompt'].includes(args[i]) || flags.has(args[i]) || !args[i + 1]) throw Error('managed-launch-arguments');
   flags.set(args[i], args[++i]);
 }
 if (flags.has('--json') && !flags.has('--prompt')) throw Error('managed-launch-arguments');
+if (flags.has('--rpc') && ['--check', '--doctor', '--web', '--serve', '--prompt', '--json'].some((f) => flags.has(f))) throw Error('managed-launch-arguments');
 const home = os.homedir();
 // Joining Agent Watch takes a few seconds; keys typed before the Terminal draws are lost, so say so.
-if (!['--check', '--prompt', '--serve', '--doctor', '--web'].some((f) => flags.has(f)) && process.stderr.isTTY) process.stderr.write('Piagent công ty: đang kết nối Agent Watch, chờ ô nhập hiện ra rồi gõ…\n');
+if (!['--check', '--prompt', '--serve', '--doctor', '--web', '--rpc'].some((f) => flags.has(f)) && process.stderr.isTTY) process.stderr.write('Piagent công ty: đang kết nối Agent Watch, chờ ô nhập hiện ra rồi gõ…\n');
 // Do this before importing the SDK: it must not discover personal keys, Node
 // preload hooks, proxy overrides or provider endpoints from an ambient shell.
 const clean = { PATH: '/usr/bin:/bin', HOME: home, LANG: 'en_US.UTF-8', TERM: process.env.TERM || 'xterm-256color', ...interopEnvironment() };
@@ -182,6 +183,15 @@ try {
       const { failureLines } = await import('./company-terminal.mjs');
       process.stderr.write(`${failureLines(last.errorMessage) ?? String(last.errorMessage??'Agent Watch: the request failed [managed-request-failed]')}\n`);process.exitCode = 1;
     }
+  } else if (flags.has('--rpc')) {
+    // One company conversation driven by a client (a script, a test that
+    // plays the member) over Pi's RPC protocol. Pi exits the process when the
+    // client closes stdin, so the conversation, its broker and its lease are
+    // released inside Pi's own dispose instead of the finally below.
+    process.env.PI_OFFLINE = '1'; process.env.PI_SKIP_VERSION_CHECK = '1';
+    const dispose = host.dispose.bind(host);
+    host.dispose = async () => { try { await dispose(); } finally { await current?.dispose(); current = null; hold?.release(); } };
+    await api.runRpcMode(host);
   } else {
     // The company terminal runs the pinned Pi release: no "Run pi update" notice
     // (updating Pi breaks the Agent Watch import), no package-update, catalog or