@hydra-acp/cli 0.1.25 → 0.1.26

package/dist/index.js

@@ -380,8 +380,10 @@ async function ensureBinary(args) {
   }
   await downloadAndExtract({
     agentId: args.agentId,
+    version: args.version,
     archiveUrl: args.target.archive,
-    installDir
+    installDir,
+    onProgress: args.onProgress
   });
   if (!await fileExists(cmdPath)) {
     throw new Error(
@@ -401,9 +403,16 @@ async function downloadAndExtract(args) {
     const archivePath = await downloadTo({
       url: args.archiveUrl,
       dir: tempDir,
-      agentId: args.agentId
+      agentId: args.agentId,
+      version: args.version,
+      onProgress: args.onProgress
     });
     logSink(`hydra-acp: extracting ${args.agentId}`);
+    safeEmit(args.onProgress, {
+      phase: "extract",
+      agentId: args.agentId,
+      version: args.version
+    });
     await extract(archivePath, tempDir);
     await fsp.unlink(archivePath).catch(() => void 0);
     try {
@@ -414,16 +423,35 @@ async function downloadAndExtract(args) {
         await fsp.rm(tempDir, { recursive: true, force: true }).catch(
           () => void 0
         );
+        safeEmit(args.onProgress, {
+          phase: "installed",
+          agentId: args.agentId,
+          version: args.version
+        });
         return;
       }
       throw err;
     }
     logSink(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+    safeEmit(args.onProgress, {
+      phase: "installed",
+      agentId: args.agentId,
+      version: args.version
+    });
   } catch (err) {
     await fsp.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
     throw err;
   }
 }
+function safeEmit(cb, event) {
+  if (!cb) {
+    return;
+  }
+  try {
+    cb(event);
+  } catch {
+  }
+}
 async function downloadTo(args) {
   const filename = inferArchiveName(args.url);
   const dest = path2.join(args.dir, filename);
@@ -436,17 +464,34 @@ async function downloadTo(args) {
   const total = Number(response.headers.get("content-length") ?? "0");
   const out = fs3.createWriteStream(dest);
   const nodeStream = Readable.fromWeb(response.body);
+  safeEmit(args.onProgress, {
+    phase: "download_start",
+    agentId: args.agentId,
+    version: args.version,
+    totalBytes: total
+  });
   let received = 0;
-  let lastEmit = Date.now();
-  const EMIT_INTERVAL_MS = 2e3;
+  let lastLogEmit = Date.now();
+  let lastCbEmit = 0;
+  const LOG_INTERVAL_MS = 2e3;
+  const CB_INTERVAL_MS = 150;
   nodeStream.on("data", (chunk) => {
     received += chunk.length;
     const now = Date.now();
-    if (now - lastEmit < EMIT_INTERVAL_MS) {
-      return;
+    if (now - lastCbEmit >= CB_INTERVAL_MS) {
+      lastCbEmit = now;
+      safeEmit(args.onProgress, {
+        phase: "download_progress",
+        agentId: args.agentId,
+        version: args.version,
+        receivedBytes: received,
+        totalBytes: total
+      });
+    }
+    if (now - lastLogEmit >= LOG_INTERVAL_MS) {
+      lastLogEmit = now;
+      logSink(formatProgress(args.agentId, received, total));
     }
-    lastEmit = now;
-    logSink(formatProgress(args.agentId, received, total));
   });
   await new Promise((resolve3, reject) => {
     nodeStream.on("error", reject);
@@ -461,6 +506,13 @@ async function downloadTo(args) {
     /* done */
     true
   ));
+  safeEmit(args.onProgress, {
+    phase: "download_done",
+    agentId: args.agentId,
+    version: args.version,
+    receivedBytes: received,
+    totalBytes: total
+  });
   return dest;
 }
 function formatProgress(agentId, received, total, done = false) {
@@ -559,9 +611,11 @@ async function ensureNpmPackage(args) {
   }
   await installInto({
     agentId: args.agentId,
+    version: args.version,
     packageSpec: args.packageSpec,
     installDir,
-    registry: args.registry
+    registry: args.registry,
+    onProgress: args.onProgress
   });
   if (!await fileExists2(binPath)) {
     throw new Error(
@@ -577,6 +631,12 @@ async function installInto(args) {
     logSink2(
       `hydra-acp: installing ${args.packageSpec} for ${args.agentId} into ${tempDir}`
     );
+    safeEmit2(args.onProgress, {
+      phase: "install_start",
+      agentId: args.agentId,
+      version: args.version,
+      packageSpec: args.packageSpec
+    });
     await runNpmInstall({
       packageSpec: args.packageSpec,
       cwd: tempDir,
@@ -590,11 +650,21 @@ async function installInto(args) {
         await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
           () => void 0
         );
+        safeEmit2(args.onProgress, {
+          phase: "installed",
+          agentId: args.agentId,
+          version: args.version
+        });
         return;
       }
       throw err;
     }
     logSink2(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+    safeEmit2(args.onProgress, {
+      phase: "installed",
+      agentId: args.agentId,
+      version: args.version
+    });
   } catch (err) {
     await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
       () => void 0
@@ -602,44 +672,87 @@ async function installInto(args) {
     throw err;
   }
 }
+function safeEmit2(cb, event) {
+  if (!cb) {
+    return;
+  }
+  try {
+    cb(event);
+  } catch {
+  }
+}
+var ETXTBSY_RETRIES = 5;
+var ETXTBSY_BACKOFF_MS = 25;
 function runNpmInstall(args) {
-  return new Promise((resolve3, reject) => {
-    const registryArgs = args.registry ? ["--registry", args.registry] : [];
-    const child = spawn2(
-      "npm",
-      ["install", "--no-audit", "--no-fund", "--silent", ...registryArgs, args.packageSpec],
-      {
-        cwd: args.cwd,
-        stdio: ["ignore", "pipe", "pipe"]
-      }
-    );
-    let stderrTail = "";
-    child.stdout?.on("data", (chunk) => {
-      void chunk;
-    });
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-      stderrTail = (stderrTail + chunk).slice(-4096);
-    });
-    child.on("error", (err) => {
-      const msg = err.code === "ENOENT" ? `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)` : err.message;
-      reject(new Error(msg));
-    });
-    child.on("exit", (code, signal) => {
-      if (code === 0) {
-        resolve3();
+  return runNpmInstallOnce(args, 0);
+}
+async function runNpmInstallOnce(args, attempt) {
+  try {
+    await new Promise((resolve3, reject) => {
+      const registryArgs = args.registry ? ["--registry", args.registry] : [];
+      let child;
+      try {
+        child = spawn2(
+          "npm",
+          [
+            "install",
+            "--no-audit",
+            "--no-fund",
+            "--silent",
+            ...registryArgs,
+            args.packageSpec
+          ],
+          { cwd: args.cwd, stdio: ["ignore", "pipe", "pipe"] }
+        );
+      } catch (err) {
+        reject(err);
         return;
       }
-      const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
-      const tail = stderrTail.trim();
-      reject(
-        new Error(
-          tail ? `npm install ${args.packageSpec} failed (${reason})
+      let stderrTail = "";
+      child.stdout?.on("data", (chunk) => {
+        void chunk;
+      });
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk) => {
+        stderrTail = (stderrTail + chunk).slice(-4096);
+      });
+      child.on("error", (err) => {
+        const e = err;
+        if (e.code === "ENOENT") {
+          reject(
+            new Error(
+              `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)`
+            )
+          );
+          return;
+        }
+        reject(err);
+      });
+      child.on("exit", (code, signal) => {
+        if (code === 0) {
+          resolve3();
+          return;
+        }
+        const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
+        const tail = stderrTail.trim();
+        reject(
+          new Error(
+            tail ? `npm install ${args.packageSpec} failed (${reason})
 stderr: ${tail}` : `npm install ${args.packageSpec} failed (${reason})`
-        )
-      );
+          )
+        );
+      });
     });
-  });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ETXTBSY" && attempt < ETXTBSY_RETRIES) {
+      await new Promise(
+        (r) => setTimeout(r, ETXTBSY_BACKOFF_MS * (attempt + 1))
+      );
+      return runNpmInstallOnce(args, attempt + 1);
+    }
+    throw err;
+  }
 }
 async function fileExists2(p) {
   try {
@@ -837,12 +950,14 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
       };
     }
     const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
+    const npmCb = options.onInstallProgress;
     const binPath = await ensureNpmPackage({
       agentId: agent.id,
       version,
       packageSpec: npx.package,
       bin,
-      registry: options.npmRegistry
+      registry: options.npmRegistry,
+      onProgress: npmCb ? (e) => npmCb({ source: "npm", ...e }) : void 0
     });
     return {
       command: binPath,
@@ -858,10 +973,12 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
         `Agent ${agent.id} has no binary distribution for ${currentPlatformKey() ?? "this platform"}.`
       );
     }
+    const binCb = options.onInstallProgress;
     const cmdPath = await ensureBinary({
       agentId: agent.id,
       version,
-      target
+      target,
+      onProgress: binCb ? (e) => binCb({ source: "binary", ...e }) : void 0
     });
     const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
@@ -1094,6 +1211,29 @@ function extractHydraMeta(meta) {
       out.availableModes = modes;
     }
   }
+  if (Array.isArray(obj.availableModels)) {
+    const models = [];
+    for (const raw of obj.availableModels) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const m = raw;
+      if (typeof m.modelId !== "string") {
+        continue;
+      }
+      const model = { modelId: m.modelId };
+      if (typeof m.name === "string") {
+        model.name = m.name;
+      }
+      if (typeof m.description === "string") {
+        model.description = m.description;
+      }
+      models.push(model);
+    }
+    if (models.length > 0) {
+      out.availableModels = models;
+    }
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
@@ -1217,6 +1357,23 @@ var PromptAmendedParams = z3.object({
   originator: PromptOriginatorSchema,
   amendedAt: z3.number()
 });
+var AgentInstallProgressParams = z3.object({
+  agentId: z3.string(),
+  version: z3.string(),
+  source: z3.enum(["binary", "npm"]),
+  phase: z3.enum([
+    "download_start",
+    "download_progress",
+    "download_done",
+    "extract",
+    "install_start",
+    "installed"
+  ]),
+  receivedBytes: z3.number().optional(),
+  totalBytes: z3.number().optional(),
+  packageSpec: z3.string().optional()
+});
+var AGENT_INSTALL_PROGRESS_METHOD = "hydra-acp/agent_install_progress";
 var ProxyInitializeParams = z3.object({
   protocolVersion: z3.number().optional(),
   proxyInfo: z3.object({
@@ -1787,11 +1944,19 @@ var Session = class {
   // Last available_modes_update we observed from the agent. Same
   // pattern as commands: cache, persist, broadcast on change.
   agentAdvertisedModes = [];
+  // Last availableModels payload we observed (from current_model_update,
+  // a session/new / session/load response, or — for opencode — a
+  // config_option_update where configOptions[i].id === "model").
+  // Cached so a mid-session attach can synthesize a model picker
+  // snapshot, and so session/set_model can validate the requested id
+  // against what the agent claims to support.
+  agentAdvertisedModels = [];
   // Persist hooks for snapshot-shaped state. SessionManager hooks these
   // to mirror changes into meta.json so cold-resurrect attaches can
   // surface the latest snapshot via the attach response _meta.
   agentCommandsHandlers = [];
   agentModesHandlers = [];
+  agentModelsHandlers = [];
   modelHandlers = [];
   modeHandlers = [];
   usageHandlers = [];
@@ -1827,6 +1992,9 @@ var Session = class {
     if (init.agentModes && init.agentModes.length > 0) {
       this.agentAdvertisedModes = [...init.agentModes];
     }
+    if (init.agentModels && init.agentModels.length > 0) {
+      this.agentAdvertisedModels = [...init.agentModels];
+    }
     this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
     this.spawnReplacementAgent = init.spawnReplacementAgent;
     this.logger = init.logger;
@@ -1864,6 +2032,23 @@ var Session = class {
       }
     });
   }
+  // Re-broadcast our cached availableModels via current_model_update.
+  // Spec shape: { currentModel, availableModels } — we only include the
+  // currentModel field when we know it, so this broadcast can also fire
+  // model-list updates standalone before any current model is set.
+  broadcastAvailableModels() {
+    const update = {
+      sessionUpdate: "current_model_update",
+      availableModels: [...this.agentAdvertisedModels]
+    };
+    if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+      update.currentModel = this.currentModel;
+    }
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update
+    });
+  }
   // Register session/update, session/request_permission, and onExit
   // handlers on an agent connection. Re-run on every /hydra agent so
   // the new agent is plumbed identically. The exit handler's identity
@@ -1894,6 +2079,10 @@ var Session = class {
         this.recordAndBroadcast("session/update", params);
         return;
       }
+      if (this.maybeApplyAgentConfigOption(params)) {
+        this.recordAndBroadcast("session/update", params);
+        return;
+      }
       if (this.maybeApplyAgentUsage(params)) {
         this.recordAndBroadcast("session/update", params);
         return;
@@ -2042,16 +2231,19 @@ var Session = class {
         recordedAt
       });
     }
-    if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+    if (this.currentModel !== void 0 && this.currentModel.length > 0 || this.agentAdvertisedModels.length > 0) {
+      const update = {
+        sessionUpdate: "current_model_update"
+      };
+      if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+        update.currentModel = this.currentModel;
+      }
+      if (this.agentAdvertisedModels.length > 0) {
+        update.availableModels = [...this.agentAdvertisedModels];
+      }
       out.push({
         method: "session/update",
-        params: {
-          sessionId,
-          update: {
-            sessionUpdate: "current_model_update",
-            currentModel: this.currentModel
-          }
-        },
+        params: { sessionId, update },
         recordedAt
       });
     }
@@ -2686,6 +2878,18 @@ var Session = class {
   onTitleChange(handler) {
     this.titleHandlers.push(handler);
   }
+  // External entry point for retitling a live session from outside the
+  // ACP slash-command path (e.g. PATCH /v1/sessions/:id from the picker).
+  // Goes through the same enqueuePrompt path as /hydra title so it
+  // serializes after any in-flight turn and shares broadcast/persistence.
+  retitle(title) {
+    return this.runTitleCommand(title);
+  }
+  // External entry point for the LLM-regen title path (T in the picker,
+  // equivalent to bare /hydra title with no arg).
+  retitleFromAgent() {
+    return this.runTitleCommand("");
+  }
   // Update the canonical title and broadcast a session_info_update to
   // every attached client. Clients that already speak the spec's
   // session_info_update need no hydra-specific wiring to pick this up.
@@ -2733,12 +2937,19 @@ var Session = class {
   // Apply an agent-emitted current_model_update. Returns true if the
   // notification was a model update (caller still needs to broadcast
   // it). Returns false otherwise so the caller can try the next kind.
+  // current_model_update can carry availableModels in the same payload
+  // (per ACP spec); we cache that list too so session/set_model can
+  // validate against it.
   maybeApplyAgentModel(params) {
     const obj = params ?? {};
     const update = obj.update ?? {};
     if (update.sessionUpdate !== "current_model_update") {
       return false;
     }
+    const models = parseModelsList(update.availableModels);
+    if (models.length > 0) {
+      this.setAgentAdvertisedModels(models);
+    }
     const raw = typeof update.currentModel === "string" ? update.currentModel : typeof update.model === "string" ? update.model : void 0;
     if (raw === void 0) {
       return true;
@@ -2756,6 +2967,55 @@ var Session = class {
     }
     return true;
   }
+  // Apply an opencode-style config_option_update. opencode emits this
+  // (not the spec-shaped current_model_update / available_models_update)
+  // to carry both the current model and the list of available models.
+  // The payload is `configOptions: [{ id: "model", currentValue, options:
+  // [{ value, name }] }, ...]`. We harvest only the entry whose id is
+  // "model" — other ids ("mode", "effort", etc.) are opencode-internal
+  // and not consumed by hydra. Returns true when we recognized and
+  // handled the notification so the wireAgent loop can stop trying
+  // further extractors (the broadcast still fires; clients that grok
+  // config_option_update render it directly).
+  maybeApplyAgentConfigOption(params) {
+    const obj = params ?? {};
+    const update = obj.update ?? {};
+    if (update.sessionUpdate !== "config_option_update") {
+      return false;
+    }
+    const list = update.configOptions;
+    if (!Array.isArray(list)) {
+      return true;
+    }
+    for (const raw of list) {
+      if (!raw || typeof raw !== "object") {
+        continue;
+      }
+      const opt = raw;
+      if (opt.id !== "model") {
+        continue;
+      }
+      const models = parseModelsList(opt.options);
+      if (models.length > 0) {
+        this.setAgentAdvertisedModels(models);
+      }
+      const cv = opt.currentValue;
+      if (typeof cv === "string") {
+        const trimmed = cv.trim();
+        if (trimmed && trimmed !== this.currentModel) {
+          this.currentModel = trimmed;
+          for (const handler of this.modelHandlers) {
+            try {
+              handler(trimmed);
+            } catch {
+            }
+          }
+        }
+      }
+      break;
+    }
+    return true;
+  }
   maybeApplyAgentMode(params) {
     const obj = params ?? {};
     const update = obj.update ?? {};
@@ -2854,6 +3114,20 @@ var Session = class {
     }
     this.broadcastAvailableModes();
   }
+  setAgentAdvertisedModels(models) {
+    if (sameAdvertisedModels(this.agentAdvertisedModels, models)) {
+      this.broadcastAvailableModels();
+      return;
+    }
+    this.agentAdvertisedModels = models;
+    for (const handler of this.agentModelsHandlers) {
+      try {
+        handler(models);
+      } catch {
+      }
+    }
+    this.broadcastAvailableModels();
+  }
   // Subscribe to snapshot-state updates. SessionManager wires these to
   // persist the new value into meta.json so cold resurrect can restore
   // them via the attach response _meta.
@@ -2863,6 +3137,9 @@ var Session = class {
   onAgentModesChange(handler) {
     this.agentModesHandlers.push(handler);
   }
+  onAgentModelsChange(handler) {
+    this.agentModelsHandlers.push(handler);
+  }
   onModelChange(handler) {
     this.modelHandlers.push(handler);
   }
@@ -2888,6 +3165,15 @@ var Session = class {
   availableModes() {
     return [...this.agentAdvertisedModes];
   }
+  // The agent's advertised models list. Used by acp-ws.ts's dedicated
+  // session/set_model handler to validate the requested modelId before
+  // forwarding to the agent (catches cross-agent set_model storms from
+  // clients that assume a different agent is on the other end). When
+  // the agent never advertised any models, returns [] and the
+  // set_model handler falls back to pass-through.
+  availableModels() {
+    return [...this.agentAdvertisedModels];
+  }
   // Pick up an agent-emitted session_info_update and store its title
   // as our canonical record. The notification is also forwarded to
   // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -3035,6 +3321,12 @@ var Session = class {
       this.agentMeta = fresh.agentMeta;
       this.agentAdvertisedCommands = [];
       this.broadcastMergedCommands();
+      if (this.agentAdvertisedModels.length > 0) {
+        this.setAgentAdvertisedModels([]);
+      }
+      if (this.agentAdvertisedModes.length > 0) {
+        this.setAgentAdvertisedModes([]);
+      }
       await oldAgent.kill().catch(() => void 0);
       if (transcript) {
         await this.runInternalPrompt(transcript).catch(() => void 0);
@@ -3601,6 +3893,42 @@ function sameAdvertisedModes(a, b) {
   }
   return true;
 }
+function sameAdvertisedModels(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.modelId !== b[i]?.modelId || a[i]?.name !== b[i]?.name || a[i]?.description !== b[i]?.description) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseModelsList(list) {
+  if (!Array.isArray(list)) {
+    return [];
+  }
+  const out = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      continue;
+    }
+    const r = raw;
+    const modelId = typeof r.modelId === "string" && r.modelId.trim() || typeof r.value === "string" && r.value.trim() || typeof r.id === "string" && r.id.trim() || void 0;
+    if (!modelId) {
+      continue;
+    }
+    const model = { modelId };
+    if (typeof r.name === "string" && r.name.length > 0) {
+      model.name = r.name;
+    }
+    if (typeof r.description === "string" && r.description.length > 0) {
+      model.description = r.description;
+    }
+    out.push(model);
+  }
+  return out;
+}
 function extractAdvertisedModes(params) {
   const obj = params ?? {};
   const update = obj.update ?? {};
@@ -3805,6 +4133,11 @@ var PersistedAgentMode = z4.object({
   name: z4.string().optional(),
   description: z4.string().optional()
 });
+var PersistedAgentModel = z4.object({
+  modelId: z4.string(),
+  name: z4.string().optional(),
+  description: z4.string().optional()
+});
 var PersistedUsage = z4.object({
   used: z4.number().optional(),
   size: z4.number().optional(),
@@ -3851,6 +4184,7 @@ var SessionRecord = z4.object({
   currentUsage: PersistedUsage.optional(),
   agentCommands: z4.array(PersistedAgentCommand).optional(),
   agentModes: z4.array(PersistedAgentMode).optional(),
+  agentModels: z4.array(PersistedAgentModel).optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -3970,6 +4304,7 @@ function recordFromMemorySession(args) {
     currentUsage: args.currentUsage,
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
+    agentModels: args.agentModels,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -4204,7 +4539,8 @@ var SessionManager = class {
       cwd: params.cwd,
       agentArgs: params.agentArgs,
       mcpServers: params.mcpServers,
-      model: params.model
+      model: params.model,
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       cwd: params.cwd,
@@ -4221,7 +4557,8 @@ var SessionManager = class {
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel,
       currentMode: fresh.initialMode,
-      agentModes: fresh.initialModes
+      agentModes: fresh.initialModes,
+      agentModels: fresh.initialModels
     });
     await this.attachManagerHooks(session);
     return session;
@@ -4266,7 +4603,10 @@ var SessionManager = class {
     if (params.upstreamSessionId === "") {
       return this.doResurrectFromImport(params);
     }
-    const plan = await planSpawn(agentDef, params.agentArgs ?? [], { npmRegistry: this.npmRegistry });
+    const plan = await planSpawn(agentDef, params.agentArgs ?? [], {
+      npmRegistry: this.npmRegistry,
+      onInstallProgress: params.onInstallProgress
+    });
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -4324,6 +4664,7 @@ var SessionManager = class {
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {})),
+      agentModels: params.agentModels ?? nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})),
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
@@ -4347,7 +4688,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd,
       agentArgs: params.agentArgs,
-      mcpServers: []
+      mcpServers: [],
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -4370,6 +4712,7 @@ var SessionManager = class {
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: params.agentModes ?? fresh.initialModes,
+      agentModels: params.agentModels ?? fresh.initialModels,
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
     });
@@ -4399,7 +4742,10 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
-    const plan = await planSpawn(agentDef, params.agentArgs ?? [], { npmRegistry: this.npmRegistry });
+    const plan = await planSpawn(agentDef, params.agentArgs ?? [], {
+      npmRegistry: this.npmRegistry,
+      onInstallProgress: params.onInstallProgress
+    });
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -4425,15 +4771,25 @@ var SessionManager = class {
         );
       }
       let initialModel = extractInitialModel(newResult);
+      const initialModels = extractInitialModels(newResult);
       const desired = params.model ?? this.defaultModels[params.agentId];
       if (desired && desired !== initialModel) {
-        try {
-          await agent.connection.request("session/set_model", {
-            sessionId: sessionIdRaw,
-            modelId: desired
-          });
-          initialModel = desired;
-        } catch {
+        const validates = initialModels.length === 0 || initialModels.some((m) => m.modelId === desired);
+        if (validates) {
+          try {
+            await agent.connection.request("session/set_model", {
+              sessionId: sessionIdRaw,
+              modelId: desired
+            });
+            initialModel = desired;
+          } catch {
+          }
+        } else {
+          const known = initialModels.map((m) => m.modelId).join(", ");
+          process.stderr.write(
+            `hydra-acp: defaultModels[${params.agentId}]=${JSON.stringify(desired)} is not in the agent's availableModels (${known}); skipping session/set_model
+`
+          );
         }
       }
       const initialModes = extractInitialModes(newResult);
@@ -4443,6 +4799,7 @@ var SessionManager = class {
         upstreamSessionId: sessionIdRaw,
         agentMeta: newResult._meta,
         initialModel,
+        initialModels: initialModels.length > 0 ? initialModels : void 0,
         initialModes: initialModes.length > 0 ? initialModes : void 0,
         initialMode
       };
@@ -4505,6 +4862,15 @@ var SessionManager = class {
         }))
       }).catch(() => void 0);
     });
+    session.onAgentModelsChange((models) => {
+      void this.persistSnapshot(session.sessionId, {
+        agentModels: models.map((m) => ({
+          modelId: m.modelId,
+          ...m.name !== void 0 ? { name: m.name } : {},
+          ...m.description !== void 0 ? { description: m.description } : {}
+        }))
+      }).catch(() => void 0);
+    });
     this.sessions.set(session.sessionId, session);
     await this.enqueueMetaWrite(session.sessionId, async () => {
       const existing = await this.store.read(session.sessionId);
@@ -4548,6 +4914,7 @@ var SessionManager = class {
       currentUsage: persistedUsageToSnapshot(record.currentUsage),
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
+      agentModels: record.agentModels,
       createdAt: record.createdAt
     };
   }
@@ -4791,6 +5158,26 @@ var SessionManager = class {
     const record = await this.store.read(sessionId).catch(() => void 0);
     return record !== void 0;
   }
+  // Public retitle entry point that works on live AND cold sessions.
+  // - Live: routes through Session.retitle so attached clients receive
+  //   a session_info_update broadcast (and persistTitle fires from the
+  //   onTitleChange handler, just like /hydra title).
+  // - Cold: writes the new title straight into meta.json — there's
+  //   nothing in memory to broadcast to, but a later resurrect / list
+  //   will pick up the new title.
+  // Returns false when no record exists at all (live or on disk).
+  async setTitle(sessionId, title) {
+    const live = this.get(sessionId);
+    if (live) {
+      await live.retitle(title);
+      return true;
+    }
+    if (!await this.hasRecord(sessionId)) {
+      return false;
+    }
+    await this.persistTitle(sessionId, title);
+    return true;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
@@ -4843,6 +5230,7 @@ var SessionManager = class {
         ...update.currentUsage !== void 0 ? { currentUsage: update.currentUsage } : {},
         ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
         ...update.agentModes !== void 0 ? { agentModes: update.agentModes } : {},
+        ...update.agentModels !== void 0 ? { agentModels: update.agentModels } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     });
@@ -4944,6 +5332,18 @@ function mergeForPersistence(session, existing) {
     return out;
   }) : void 0;
   const agentModes = persistedModes ?? existing?.agentModes;
+  const sessionModels = session.availableModels();
+  const persistedModels = sessionModels.length > 0 ? sessionModels.map((m) => {
+    const out = { modelId: m.modelId };
+    if (m.name !== void 0) {
+      out.name = m.name;
+    }
+    if (m.description !== void 0) {
+      out.description = m.description;
+    }
+    return out;
+  }) : void 0;
+  const agentModels = persistedModels ?? existing?.agentModels;
   return recordFromMemorySession({
     sessionId: session.sessionId,
     lineageId: existing?.lineageId ?? generateLineageId(),
@@ -4960,6 +5360,7 @@ function mergeForPersistence(session, existing) {
     currentUsage: usageSnapshotToPersisted(session.currentUsage) ?? existing?.currentUsage,
     agentCommands,
     agentModes,
+    agentModels,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -5025,6 +5426,40 @@ function asString(value) {
 function nonEmptyOrUndefined(arr) {
   return arr.length > 0 ? arr : void 0;
 }
+function extractInitialModels(result) {
+  const direct = parseModelsList(result.availableModels);
+  if (direct.length > 0) {
+    return direct;
+  }
+  const models = result.models;
+  if (models && typeof models === "object" && !Array.isArray(models)) {
+    const fromModelsObj = parseModelsList(
+      models.availableModels
+    );
+    if (fromModelsObj.length > 0) {
+      return fromModelsObj;
+    }
+  }
+  const meta = result._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    for (const [key, value] of Object.entries(
+      meta
+    )) {
+      if (key === "hydra-acp") {
+        continue;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const fromMeta = parseModelsList(
+          value.availableModels
+        );
+        if (fromMeta.length > 0) {
+          return fromMeta;
+        }
+      }
+    }
+  }
+  return [];
+}
 function extractInitialModes(result) {
   const direct = parseModesList(result.availableModes);
   if (direct.length > 0) {
@@ -6247,8 +6682,55 @@ function mapToolCallUpdate(u) {
   if (status !== void 0) {
     event.status = status;
   }
+  if (status === "failed") {
+    const errorText = extractToolFailureText(u);
+    if (errorText !== null) {
+      event.errorText = errorText;
+    }
+    if (isUpstreamInterrupted(u, errorText)) {
+      event.upstreamInterrupted = true;
+    }
+  }
   return event;
 }
+function extractToolFailureText(u) {
+  const content = u.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        continue;
+      }
+      const b = block;
+      const text = extractContentText(b.content);
+      if (text !== null && text.length > 0) {
+        return text;
+      }
+    }
+  }
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object") {
+    const err = rawOutput.error;
+    if (typeof err === "string" && err.length > 0) {
+      return sanitizeWireText(err);
+    }
+  }
+  return null;
+}
+function isUpstreamInterrupted(u, errorText) {
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object") {
+    const meta = rawOutput.metadata;
+    if (meta && typeof meta === "object") {
+      if (meta.interrupted === true) {
+        return true;
+      }
+    }
+  }
+  if (errorText !== null && errorText.toLowerCase().includes("tool execution aborted")) {
+    return true;
+  }
+  return false;
+}
 function mapPlan(u) {
   const entries = u.entries;
   if (!Array.isArray(entries)) {
@@ -6629,6 +7111,35 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.patch("/v1/sessions/:id", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const body = request.body ?? {};
+    if (body.regen === true) {
+      const session = manager.get(id);
+      if (!session) {
+        reply.code(409).send({ error: "regen requires a live session" });
+        return;
+      }
+      void session.retitleFromAgent().catch((err) => {
+        app.log.warn(
+          `title regen failed for ${id}: ${err.message}`
+        );
+      });
+      reply.code(202).send();
+      return;
+    }
+    if (typeof body.title !== "string" || body.title.trim().length === 0) {
+      reply.code(400).send({ error: "title must be a non-empty string" });
+      return;
+    }
+    const ok = await manager.setTitle(id, body.title);
+    if (!ok) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    reply.code(204).send();
+  });
   app.delete("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -7216,7 +7727,8 @@ function registerAcpWsEndpoint(app, deps) {
         mcpServers: params.mcpServers,
         title: hydraMeta.name,
         agentArgs: hydraMeta.agentArgs,
-        model: hydraMeta.model
+        model: hydraMeta.model,
+        onInstallProgress: makeInstallProgressForwarder(connection)
       });
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
@@ -7232,6 +7744,7 @@ function registerAcpWsEndpoint(app, deps) {
         })();
       });
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         // session/new is implicitly an attach; mirror session/attach's
@@ -7240,6 +7753,7 @@ function registerAcpWsEndpoint(app, deps) {
         // events without an extra round-trip.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -7275,7 +7789,10 @@ function registerAcpWsEndpoint(app, deps) {
           err.code = JsonRpcErrorCodes.SessionNotFound;
           throw err;
         }
-        session = await deps.manager.resurrect(resurrectParams);
+        session = await deps.manager.resurrect({
+          ...resurrectParams,
+          onInstallProgress: makeInstallProgressForwarder(connection)
+        });
       }
       const client = bindClientToSession(
         connection,
@@ -7301,6 +7818,7 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         clientId: client.clientId,
@@ -7312,6 +7830,7 @@ function registerAcpWsEndpoint(app, deps) {
         historyPolicy: appliedPolicy,
         replayed: replay.length,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -7467,15 +7986,39 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         // Same as session/new: include clientId so the deferred-echo
         // path in queue-aware clients can recognize own broadcasts.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
+    connection.onRequest("session/set_model", async (rawParams) => {
+      const decision = decideSetModel(rawParams, deps.manager);
+      if (decision.kind === "error") {
+        app.log.warn(decision.logMessage);
+        const err = new Error(decision.message);
+        err.code = decision.code;
+        throw err;
+      }
+      if (decision.kind === "no_op") {
+        app.log.warn(decision.logMessage);
+        await connection.notify("session/update", {
+          sessionId: decision.sessionId,
+          update: {
+            sessionUpdate: "current_model_update",
+            currentModel: decision.currentModel
+          }
+        }).catch(() => void 0);
+        return null;
+      }
+      app.log.info(decision.logMessage);
+      return decision.session.forwardRequest("session/set_model", rawParams);
+    });
     connection.setDefaultHandler(async (rawParams, method) => {
       if (!method.startsWith("session/") || rawParams === null || typeof rawParams !== "object") {
         const err = new Error(`Method not found: ${method}`);
@@ -7498,6 +8041,26 @@ function registerAcpWsEndpoint(app, deps) {
     });
   });
 }
+function makeInstallProgressForwarder(connection) {
+  return (event) => {
+    const payload = {
+      agentId: event.agentId,
+      version: event.version,
+      source: event.source,
+      phase: event.phase
+    };
+    if ("receivedBytes" in event) {
+      payload.receivedBytes = event.receivedBytes;
+    }
+    if ("totalBytes" in event) {
+      payload.totalBytes = event.totalBytes;
+    }
+    if ("packageSpec" in event) {
+      payload.packageSpec = event.packageSpec;
+    }
+    void connection.notify(AGENT_INSTALL_PROGRESS_METHOD, payload).catch(() => void 0);
+  };
+}
 function buildModesPayload(session) {
   const modes = session.availableModes();
   if (modes.length === 0) {
@@ -7518,6 +8081,94 @@ function buildModesPayload(session) {
   const currentModeId = session.currentMode ?? modes[0].id;
   return { currentModeId, availableModes };
 }
+function buildModelsPayload(session) {
+  const models = session.availableModels();
+  if (models.length === 0) {
+    return void 0;
+  }
+  const availableModels = models.map((m) => {
+    const out = {
+      modelId: m.modelId
+    };
+    if (m.name !== void 0) {
+      out.name = m.name;
+    }
+    if (m.description !== void 0) {
+      out.description = m.description;
+    }
+    return out;
+  });
+  const currentModelId = session.currentModel ?? models[0].modelId;
+  return { currentModelId, availableModels };
+}
+function decideSetModel(rawParams, manager) {
+  if (!rawParams || typeof rawParams !== "object") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires params",
+      logMessage: "session/set_model rejected: params not an object"
+    };
+  }
+  const params = rawParams;
+  if (typeof params.sessionId !== "string") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires string sessionId",
+      logMessage: "session/set_model rejected: missing/non-string sessionId"
+    };
+  }
+  if (typeof params.modelId !== "string") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires string modelId",
+      logMessage: `session/set_model rejected: missing/non-string modelId sessionId=${params.sessionId}`
+    };
+  }
+  const session = manager.get(params.sessionId);
+  if (!session) {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.SessionNotFound,
+      message: `session ${params.sessionId} not found`,
+      logMessage: `session/set_model rejected: session not found sessionId=${params.sessionId}`
+    };
+  }
+  const advertised = session.availableModels();
+  if (advertised.length === 0) {
+    return {
+      kind: "ok",
+      session,
+      logMessage: `session/set_model passthrough (no availableModels) sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+    };
+  }
+  const match = advertised.find((m) => m.modelId === params.modelId);
+  if (!match) {
+    const known = advertised.map((m) => m.modelId).join(", ");
+    if (session.currentModel !== void 0 && session.currentModel.length > 0) {
+      return {
+        kind: "no_op",
+        session,
+        sessionId: params.sessionId,
+        currentModel: session.currentModel,
+        logMessage: `session/set_model no_op (resyncing client) sessionId=${params.sessionId} requested=${JSON.stringify(params.modelId)} actual=${JSON.stringify(session.currentModel)} agentId=${session.agentId} known=[${known}]`
+      };
+    }
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: `model "${params.modelId}" is not in this session's availableModels (agent ${session.agentId}); known models: ${known}`,
+      logMessage: `session/set_model rejected sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)} agentId=${session.agentId} known=[${known}] (no current model to fall back to)`
+    };
+  }
+  return {
+    kind: "ok",
+    session,
+    logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+  };
+}
 function buildResponseMeta(session) {
   const ours = {
     upstreamSessionId: session.upstreamSessionId,
@@ -7547,6 +8198,10 @@ function buildResponseMeta(session) {
   if (modes.length > 0) {
     ours.availableModes = modes;
   }
+  const models = session.availableModels();
+  if (models.length > 0) {
+    ours.availableModels = models;
+  }
   if (session.turnStartedAt !== void 0) {
     ours.turnStartedAt = session.turnStartedAt;
   }