@openagents-org/agent-launcher 0.2.185 → 0.2.187

package/src/adapters/copilot.js

@@ -76,7 +76,7 @@ const SECRET_ENV_VARS = [
 const ACT_ALLOW_TOOLS = ['shell', 'write'];
 
 // How long to wait for a turn before giving up (no output / hung CLI).
-const TURN_TIMEOUT_MS = 10 * 60 * 1000;
+const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 
 class CopilotAdapter extends BaseAdapter {
   /**
@@ -565,10 +565,15 @@ class CopilotAdapter extends BaseAdapter {
       let pending = Promise.resolve();
       let settled = false;
 
-      const timeout = setTimeout(() => {
-        this._stopProcess(proc).catch(() => {});
-        finish({ timedOut: true, finalText: accumulatedText() });
-      }, TURN_TIMEOUT_MS);
+      let timeout = null;
+      const resetTimeout = () => {
+        if (timeout) clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          this._stopProcess(proc).catch(() => {});
+          finish({ timedOut: true, finalText: accumulatedText() });
+        }, TURN_IDLE_TIMEOUT_MS);
+      };
+      resetTimeout();
 
       const finish = (summary) => {
         if (settled) return;
@@ -657,6 +662,9 @@ class CopilotAdapter extends BaseAdapter {
         }
       };
 
+      if (proc.stdout) proc.stdout.on('data', resetTimeout);
+      if (proc.stderr) proc.stderr.on('data', resetTimeout);
+
       proc.stdout.on('data', (chunk) => {
         for (const ev of parser.push(chunk)) {
           pending = pending.then(() => handle(ev)).catch(() => {});

package/src/adapters/hermes.js

@@ -25,6 +25,7 @@ const { spawn, bridgeSpawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+const { REASON } = require('./health-status');
 const { whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -123,6 +124,34 @@ class HermesAdapter extends BaseAdapter {
     return null;
   }
 
+  /**
+   * Preflight gate (run by the daemon before join). Hermes can do nothing
+   * without its CLI, so when none can be resolved we surface a precise
+   * 'runtime_missing' reason and skip the workspace join — instead of joining,
+   * reporting "online" and then failing every message. That contradiction is
+   * exactly what users hit: the workspace showed a green hermes and "all set"
+   * while the smoke test on the same screen said "Not installed", because
+   * `create_agent --install` treats a failed third-party install script as a
+   * warning and connects the agent anyway.
+   *
+   * Re-resolves rather than trusting the constructor's lookup: an install that
+   * landed after the daemon started must not need a restart to be seen. NOTE:
+   * 'runtime_missing' (binary gone/never landed at run time), NOT
+   * 'not_installed' — install detection lives in the installer.
+   */
+  preflight() {
+    if (!this._hermesBin) this._hermesBin = this._findHermesBinary();
+    if (!this._hermesBin) {
+      return {
+        ok: false,
+        reason: REASON.RUNTIME_MISSING,
+        message: `Hermes CLI not found — install with: ${HERMES_INSTALL_HINT}`,
+      };
+    }
+    this._log(`Hermes CLI resolved: ${this._hermesBin}`);
+    return { ok: true };
+  }
+
   _resolveProfile(explicit, agentName) {
     if (explicit && explicit !== '' && explicit !== 'auto') return explicit;
     // Match agent name to an existing ~/.hermes/profiles/<name> if present
@@ -371,6 +400,17 @@ class HermesAdapter extends BaseAdapter {
     const sender = msg.senderName || msg.senderType || 'user';
     this._log(`Processing workspace message from ${sender} in ${msgChannel}`);
 
+    // Re-resolve per message: the constructor's lookup is a snapshot, and an
+    // agent that was created before its CLI finished installing would
+    // otherwise stay broken until the daemon restarts.
+    if (!this._hermesBin) this._hermesBin = this._findHermesBinary();
+    if (!this._hermesBin) {
+      const message = `Hermes CLI not found — install with: ${HERMES_INSTALL_HINT}`;
+      this._reportStatus(REASON.RUNTIME_MISSING, message);
+      await this.sendError(msgChannel, message);
+      return;
+    }
+
     await this._autoTitleChannel(msgChannel, content);
     await this.sendStatus(msgChannel, 'thinking...');
 

package/src/adapters/llm-direct.js

@@ -158,7 +158,8 @@ class LlmDirectAdapter extends BaseAdapter {
       'Authorization': `Bearer ${this._apiKey}`,
     };
     const payload = JSON.stringify({
-      model: this._model || 'gpt-4o',
+      // The model picked in the workspace, which modelLabel() reports, wins.
+      model: this.modelLabel() || 'gpt-4o',
       messages,
       stream: true,
     });

package/src/adapters/opencode.js

@@ -27,8 +27,10 @@ const { whichBinary, whereBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
-// Max wall-clock for a single `opencode run`. When it fires, Node kills the
-// child with SIGTERM, the 'close' handler sees signal='SIGTERM' / code=null.
+// Max time an `opencode run` may stay completely silent. This is deliberately
+// an IDLE timeout, not a wall-clock cap: long coding tasks routinely exceed
+// five minutes while continuing to emit text/tool events. A fixed spawn
+// timeout killed those healthy runs midway through their answer.
 const TIMEOUT_MS = 300000; // 5 minutes
 
 // Pinned OpenCode CLI version. Do NOT use @latest anywhere (registry.json /
@@ -158,6 +160,34 @@ class OpenCodeAdapter extends BaseAdapter {
   }
 
   /** Environment the CLI is spawned with. */
+
+  /** Test seam for the inactivity watchdog. */
+  _runTimeoutMs() {
+    return TIMEOUT_MS;
+  }
+
+  /**
+   * Arm a watchdog that expires only after a continuous period without CLI
+   * output. Every stdout/stderr chunk proves the process is still making
+   * progress and pushes the deadline out again.
+   */
+  _createIdleWatchdog(onTimeout) {
+    const timeoutMs = this._runTimeoutMs();
+    let timer = null;
+    let stopped = false;
+    const touch = () => {
+      if (stopped) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onTimeout, timeoutMs);
+    };
+    const cancel = () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    };
+    touch();
+    return { touch, cancel, timeoutMs };
+  }
   _spawnEnv() {
     return { ...(this.agentEnv || process.env) };
   }
@@ -701,8 +731,8 @@ class OpenCodeAdapter extends BaseAdapter {
    * CRITICAL: opencode-ai does NOT read the OPENCODE_MODEL env var. When no
    * model is given on the command line AND none is set in opencode.json, the
    * non-interactive `run` command hangs forever waiting for interactive
-   * provider/model selection — it emits zero output until the spawn timeout
-   * kills it with SIGTERM (surfaced as the misleading "exited with code null").
+   * provider/model selection — it emits zero output until the inactivity
+   * watchdog kills it with SIGTERM.
    * Passing `--model` explicitly is what makes headless runs actually work.
    */
   _resolveModel() {
@@ -843,7 +873,6 @@ class OpenCodeAdapter extends BaseAdapter {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
         cwd: runCwd,
-        timeout: TIMEOUT_MS,
         detached: !IS_WINDOWS,
         // Never let a console window appear. Besides being ugly, an attached
         // console makes opencode start its interactive TUI and hang instead of
@@ -859,9 +888,16 @@ class OpenCodeAdapter extends BaseAdapter {
       let pendingEvents = Promise.resolve();
       const responseState = { finalText: '', allText: '', seenText: false };
       let settled = false;
+      let timedOut = false;
+      const watchdog = this._createIdleWatchdog(() => {
+        timedOut = true;
+        this._log(`opencode idle for ${this._runTimeoutMs() / 1000}s; terminating`);
+        this._stopProcess(proc).catch(() => {});
+      });
       const finish = (fn, arg) => {
         if (settled) return;
         settled = true;
+        watchdog.cancel();
         if (this._channelProcesses[msgChannel] === proc) {
           delete this._channelProcesses[msgChannel];
         }
@@ -870,6 +906,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
       if (proc.stdout) {
         proc.stdout.on('data', (d) => {
+          watchdog.touch();
           const chunk = d.toString('utf-8');
           stdout += chunk;
           streamBuffer += chunk;
@@ -882,7 +919,10 @@ class OpenCodeAdapter extends BaseAdapter {
           }
         });
       }
-      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => {
+        watchdog.touch();
+        stderr += d;
+      });
 
       // Send the prompt via stdin, then close it so opencode knows the message
       // is complete and never blocks waiting for more input. Guard the write:
@@ -897,9 +937,8 @@ class OpenCodeAdapter extends BaseAdapter {
 
       proc.on('error', (err) => finish(reject, err));
       // 'close' (not 'exit') fires after stdout/stderr have fully drained, so we
-      // never parse a truncated response. The handler receives (code, signal):
-      // when the spawn timeout kills the child, code is null and signal is the
-      // signal name — report that as a timeout rather than "exited with code null".
+      // never parse a truncated response. The explicit `timedOut` flag keeps a
+      // watchdog termination distinct from an external signal or crash.
       proc.on('close', async (code, signal) => {
         try { await pendingEvents; } catch {}
 
@@ -917,14 +956,18 @@ class OpenCodeAdapter extends BaseAdapter {
         // because stderr happened to be empty.
         const stdoutErr = OpenCodeAdapter._extractErrorFromStdout(stdout);
 
-        if (signal) {
-          this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
+        if (timedOut) {
+          this._log(`opencode timed out after ${watchdog.timeoutMs / 1000}s idle (output: ${!!stdout})`);
           const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
-          // A signal almost always means our own timeout fired; only override to
-          // a more specific provider error if stdout/stderr clearly show one.
           const category = (cls.category === 'unknown_error' || cls.category === 'process_crashed')
             ? 'timeout' : cls.category;
-          return finish(reject, this._failure(category, cls.diagnostic || `signal=${signal}`, cls.detail));
+          return finish(reject, this._failure(category, cls.diagnostic || `idle=${watchdog.timeoutMs}ms`, cls.detail));
+        }
+
+        if (signal) {
+          this._log(`opencode killed by signal ${signal} (output: ${!!stdout})`);
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          return finish(reject, this._failure(cls.category, cls.diagnostic || `signal=${signal}`, cls.detail));
         }
 
         if (code !== 0) {

package/src/adapters/openworker.js

@@ -98,7 +98,6 @@ const SERVER_READY_TIMEOUT_MS = 90000;
 const HEALTH_POLL_INTERVAL_MS = 400;
 
 // Max wall-clock for one turn, after which we interrupt and report it.
-const TURN_TIMEOUT_MS = 900000; // 15 minutes
 
 // Idle watchdog over the event stream, in the same shape the CLI adapters use.
 const WATCHDOG_INTERVAL_MS = 15000;
@@ -674,7 +673,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelSockets[channel] === socket) delete this._channelSockets[channel];
         try { socket.close(); } catch {}
         const userStopped = this._stoppingChannels.has(channel);
@@ -821,12 +819,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Turn exceeded ${TURN_TIMEOUT_MS}ms — interrupting`);
-        send({ type: 'interrupt' });
-        if (!error) error = 'The turn ran past its time limit and was stopped.';
-        finish({});
-      }, TURN_TIMEOUT_MS);
     });
   }
 

package/src/adapters/utils.js

@@ -88,19 +88,22 @@ function formatAttachmentsForPrompt(
       const url = att.url || `${base}/v1/files/${fileId}`;
       const curl = isWindows ? 'curl.exe' : 'curl';
       const tmpDir = isWindows ? '$env:TEMP' : '/tmp';
+      // A web upload's filename is its workspace path (uploaded_files/<stamp>_<name>)
+      // and curl -o does not create folders, so that download failed with exit 23.
+      const localName = filename.split(/[\\/]/).pop() || fileId || 'attachment';
       if (contentType.startsWith('image/')) {
         lines.push(
           `- Image: ${filename} (file_id: ${fileId}) — ` +
           `download with curl, then use your Read tool on the local file to view it:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
-          `  Step 2: Use the Read tool on ${tmpDir}/${filename} to see the image`
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${localName}\n` +
+          `  Step 2: Use the Read tool on ${tmpDir}/${localName} to see the image`
         );
       } else {
         lines.push(
           `- File: ${filename} (file_id: ${fileId}, type: ${contentType}) — ` +
           `download with curl, then use your Read tool on the local file:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
-          `  Step 2: Use the Read tool on ${tmpDir}/${filename} to read the file`
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${localName}\n` +
+          `  Step 2: Use the Read tool on ${tmpDir}/${localName} to read the file`
         );
       }
     } else {

package/src/daemon.js

@@ -9,6 +9,7 @@ const { execSync, execFileSync } = require('child_process');
 const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
+const { listEndpointModels } = require('./model-list');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
 /**
@@ -44,6 +45,23 @@ function filesystemRoots(platform = os.platform(), exists = fs.existsSync) {
   return roots;
 }
 
+/**
+ * Hostname of a configured base URL, or null when there is none. The roster
+ * carries only this: a relay URL can hold a credential in its userinfo or
+ * path. A value written without a scheme (`localhost:4000`) still names a host.
+ */
+function endpointHost(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  for (const candidate of [raw, `http://${raw}`]) {
+    try {
+      const host = new URL(candidate).hostname.toLowerCase();
+      if (host) return host;
+    } catch {}
+  }
+  return null;
+}
+
 /**
  * Agent process lifecycle manager.
  *
@@ -326,7 +344,8 @@ class Daemon {
         // Model/key: per-agent env override, else the type-level saved env.
         // Both power the workspace agent cards; the key goes out MASKED only,
         // so the edit form can show a key is configured without the secret
-        // ever leaving the device.
+        // ever leaving the device. The endpoint goes out as a hostname, so
+        // the workspace can tell a relay from the vendor its model list is for.
         let typeEnv = {};
         try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
         const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
@@ -338,6 +357,7 @@ class Daemon {
           model: model || null,
           workingDir: a.path || null,
           apiKeyMasked: apiKey ? maskApiKey(apiKey) : null,
+          baseUrlHost: endpointHost(this._configuredBaseUrl(a, typeEnv)),
           probe: this._probes[a.name] || null,
         });
       }
@@ -347,6 +367,52 @@ class Daemon {
     return roster;
   }
 
+  /**
+   * The base URL this agent's CLI is pointed at, found the way _buildAgentEnv
+   * builds its env: LLM_BASE_URL or a provider variable (OPENAI_BASE_URL,
+   * ANTHROPIC_BASE_URL, …) saved for it or mapped by resolve_env, and failing
+   * those, the daemon's own environment for the provider variable this type's
+   * LLM_BASE_URL maps to, which the spawned CLI inherits.
+   */
+  _configuredBaseUrl(a, typeEnv) {
+    const saved = { ...typeEnv, ...(a.env || {}) };
+    let env = saved;
+    try { env = { ...saved, ...this.envManager.resolve(a.type, saved, this.registry) }; } catch {}
+    const set = (v) => String(v || '').trim();
+    if (set(env.LLM_BASE_URL)) return env.LLM_BASE_URL;
+    const key = Object.keys(env).find((k) => /_BASE_URL$/.test(k) && set(env[k]));
+    if (key) return env[key];
+    let rules = [];
+    try { rules = (this.registry && this.registry.getResolveRules(a.type)) || []; } catch {}
+    const inherited = rules.find((r) => r && r.from === 'LLM_BASE_URL' && r.to && set(process.env[r.to]));
+    return inherited ? process.env[inherited.to] : null;
+  }
+
+  /**
+   * Where this agent's CLI sends requests and with which key, for listing that
+   * endpoint's models. The key is looked up the way the CLI would find it: the
+   * protocol's own variables for an Anthropic-protocol agent, else LLM_API_KEY
+   * or the variable resolve_env maps it to, inherited from the daemon or not.
+   */
+  _agentEndpoint(a) {
+    let typeEnv = {};
+    try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
+    const env = this._buildAgentEnv(a);
+    let entry = null;
+    try { entry = this.registry.getEntry(a.type); } catch {}
+    const protocol = (entry && entry.protocol) || 'openai';
+    const rules = (entry && entry.resolve_env && entry.resolve_env.rules) || [];
+    const keyVars = protocol === 'anthropic'
+      ? ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_API_KEY', 'LLM_API_KEY']
+      : ['LLM_API_KEY', ...rules.filter((r) => r && r.from === 'LLM_API_KEY').map((r) => r.to), 'OPENAI_API_KEY'];
+    const keyVar = keyVars.find((k) => k && String(env[k] || '').trim());
+    return {
+      baseUrl: this._configuredBaseUrl(a, typeEnv),
+      apiKey: keyVar ? String(env[keyVar]).trim() : '',
+      protocol,
+    };
+  }
+
   /**
    * Filesystem hint for the working-directory picker: home, its immediate
    * (non-hidden) subfolders, and the device's filesystem roots. Roots let a
@@ -606,6 +672,20 @@ async _runNodeCommand(n, cmd) {
         this._nodeHeartbeat();
         ok = true;
         message = `Detected ${this._runtimes.length} runtime(s)`;
+      } else if (action === 'list_models') {
+        // The model picker asks what the agent's own endpoint serves. The
+        // request needs the key, which is why it runs here.
+        if (!name) throw new Error('Missing agent name');
+        const agent = this.config.getAgent(name);
+        if (!agent || !this._agentOnNodeWorkspace(agent, n)) {
+          throw new Error(`Agent '${name}' is not managed by this workspace`);
+        }
+        const endpoint = this._agentEndpoint(agent);
+        if (!endpoint.baseUrl) throw new Error(`Agent '${name}' uses its CLI's default endpoint`);
+        const listed = await listEndpointModels(endpoint);
+        ok = listed.models.length > 0;
+        message = ok ? `Listed ${listed.models.length} model(s)` : listed.error;
+        data = { models: listed.models };
       } else if (action === 'list_dir') {
         data = this._listDir(args.path);
         ok = true;