@yemi33/minions 0.1.2382 → 0.1.2384

package/engine/acp-transport.js

@@ -2,12 +2,12 @@
  * engine/acp-transport.js — Shared ACP (Agent Client Protocol) transport layer
  * (P-4c6e8a72, extracted from engine/cc-worker-pool.js).
  *
- * `copilot --acp` is a long-lived JSON-RPC server over stdin/stdout. This
- * module owns the protocol-level plumbing that is identical regardless of
- * WHO is pooling the worker (a CC/doc-chat tab vs. a fleet agent dispatch):
+ * ACP-capable harnesses expose a long-lived JSON-RPC server over stdin/stdout.
+ * This module owns protocol plumbing that is identical regardless of which
+ * adapter or consumer is using the worker:
  *
- *   - process spawn (`spawnAcp`) — resolves the `copilot` binary via the
- *     runtime adapter and launches it with `--acp`.
+ *   - process spawn (`spawnAcp`) — delegates binary and argv construction to
+ *     the selected runtime adapter.
  *   - newline-delimited JSON-RPC framing, request/response correlation, and
  *     `session/update` notification dispatch (the `Worker` class).
  *   - typed error envelope (`ERROR_CODES` / `typedError`).
@@ -45,6 +45,12 @@
 
 const { spawn } = require('child_process');
 const crypto = require('crypto');
+const { normalizeExecutionModel } = require('./execution-model');
+const {
+  resolveRuntime,
+  resolveRuntimeByCapability,
+  buildWorkerArgs,
+} = require('./runtimes');
 
 // W-mpmwxni2000c25c7-c — typed error codes the transport emits through every
 // failure exit so a consumer (CC streaming handler / doc-chat pool wrapper /
@@ -56,8 +62,7 @@ const ERROR_CODES = Object.freeze({
   // because a transient PATH / fs glitch may recover.
   WORKER_SPAWN_FAILED: 'worker-spawn-failed',
   // The worker process exited DURING the ACP handshake (initialize or
-  // session/new) — usually `copilot login` is incomplete or the CLI
-  // version is too old. Also fires when session/new returns no
+  // session/new), or session/new returned no
   // sessionId. Retriable: the caller swaps to a fallback model / a re-auth
   // may unblock the next attempt.
   ACP_HANDSHAKE_FAILED: 'acp-handshake-failed',
@@ -88,26 +93,37 @@ function typedError(message, code, retriable = true) {
 // consumers that pre-warm (like cc-worker-pool.js's warmTab) can share the
 // same knob instead of hardcoding their own copy.
 const WARM_MAX_CONCURRENT = 3;
+const ACP_HANDSHAKE_TIMEOUT_MS = 60000;
+const SESSION_LOAD_RETRY_ATTEMPTS = 10;
+const SESSION_LOAD_RETRY_DELAY_MS = 100;
+const SESSION_ROTATION_CANCEL_WAIT_MS = 1000;
+
+function resolveWorkerRuntime(runtime) {
+  const adapter = typeof runtime === 'string'
+    ? resolveRuntime(runtime)
+    : (runtime || resolveRuntimeByCapability('acpWorkerPool'));
+  if (adapter?.capabilities?.acpWorkerPool !== true) {
+    throw new Error(`Runtime "${adapter?.name || '<unknown>'}" does not support ACP workers`);
+  }
+  return adapter;
+}
 
-// Real spawn implementation — resolves `copilot` through the runtime adapter
-// so every ACP transport consumer gets the SAME native/leadingArgs contract
-// as the only other spawn site (engine/spawn-agent.js ~line 595). A bare
-// `spawn('copilot', {shell:false})` cannot exec a `.cmd`/`.ps1`/extensionless
-// npm shim on Windows — it ENOENTs instantly (copilot issue #2370 /
-// W-mqid8uev). resolveBinary() resolves the real JS entry
-// (node_modules/@github/copilot/index.js) and reports whether to spawn it
-// directly (native) or under the current Node process (shim).
-function spawnAcp({ cwd, env } = {}) {
-  const copilot = require('./runtimes/copilot');
+// Real spawn implementation. Binary resolution and worker argv are both
+// adapter-owned so harness CLI flag changes do not leak into the transport.
+function spawnAcp({ runtime, cwd, env, workerOptions } = {}) {
+  const adapter = resolveWorkerRuntime(runtime);
   const workerEnv = env || process.env;
-  const resolved = copilot.resolveBinary({ env: workerEnv });
+  const resolved = adapter.resolveBinary({ env: workerEnv });
   if (!resolved || !resolved.bin) {
     throw new Error(
-      `copilot binary not resolvable -- ${copilot.installHint || 'install the GitHub Copilot CLI'}`
+      `${adapter.name} binary not resolvable -- ${adapter.installHint || `install the ${adapter.name} CLI`}`
     );
   }
   const { bin, native, leadingArgs = [] } = resolved;
-  const acpArgs = [...leadingArgs, '--acp', '--allow-all', '--max-autopilot-continues', '1'];
+  const acpArgs = [
+    ...leadingArgs,
+    ...buildWorkerArgs(adapter, { ...(workerOptions || {}), cwd, env: workerEnv }),
+  ];
   // Mirror engine/spawn-agent.js: native binaries run directly; a non-native
   // (JS entry / npm shim) runs under process.execPath as `node <bin> ...`.
   const execBin = native ? bin : process.execPath;
@@ -134,6 +150,10 @@ function killImmediate(proc) {
   }
 }
 
+function killRoot(proc) {
+  try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+}
+
 function hashMcpServers(mcpServers) {
   // Stable hash via JSON.stringify; mcpServers is an array of plain objects
   // in practice (name/command/env) so the natural key order is fine.
@@ -141,18 +161,31 @@ function hashMcpServers(mcpServers) {
   return crypto.createHash('sha256').update(json).digest('hex');
 }
 
-function _stableObject(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+function _stableValue(value) {
+  if (Array.isArray(value)) return value.map(_stableValue);
+  if (!value || typeof value !== 'object') return value;
   return Object.fromEntries(
     Object.entries(value)
       .filter(([, entry]) => entry !== undefined)
       .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, entry]) => [key, _stableValue(entry)])
   );
 }
 
-function hashProcessContext(processEnv) {
+function _stableObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return _stableValue(value);
+}
+
+function hashProcessContext(processEnv, processOptions) {
+  const context = processOptions === undefined
+    ? _stableObject(processEnv)
+    : {
+      env: _stableObject(processEnv),
+      options: _stableValue(processOptions),
+    };
   return crypto.createHash('sha256')
-    .update(JSON.stringify(_stableObject(processEnv)))
+    .update(JSON.stringify(context))
     .digest('hex');
 }
 
@@ -181,6 +214,23 @@ function buildSessionNewParams({ cwd, mcpServers, model, effort }) {
   return params;
 }
 
+function extractSessionModel(result) {
+  for (const value of [
+    result?.models?.currentModelId,
+    result?.currentModelId,
+    result?.modelId,
+    result?.model,
+  ]) {
+    const model = normalizeExecutionModel(value);
+    if (model) return model;
+  }
+  return null;
+}
+
+function buildSessionLoadParams({ sessionId, cwd, mcpServers }) {
+  return { sessionId, cwd, mcpServers: mcpServers || [] };
+}
+
 function extractChunkText(content) {
   if (content == null) return '';
   if (typeof content === 'string') return content;
@@ -246,9 +296,11 @@ function mapAcpToolCallToToolUse(update) {
  */
 class Worker {
   constructor({
+    runtime,
     id, model, effort, mcpServers, mcpServersHash, processEnv, processContextHash,
-    systemPromptHash, cwd, internals, trace,
+    workerOptions, resumeSessionId, systemPromptHash, cwd, processCwd, internals, trace,
   }) {
+    this.runtime = resolveWorkerRuntime(runtime);
     this.id = id;
     this.model = model;
     this.effort = effort;
@@ -256,12 +308,16 @@ class Worker {
     this.mcpServersHash = mcpServersHash;
     this.processEnv = processEnv;
     this.processContextHash = processContextHash;
+    this.workerOptions = workerOptions && typeof workerOptions === 'object' ? { ...workerOptions } : {};
+    this.resumeSessionId = resumeSessionId || null;
     this.systemPromptHash = systemPromptHash;
     this.cwd = cwd || process.cwd();
+    this.processCwd = processCwd || this.cwd;
     this._internals = internals;
     this._trace = typeof trace === 'function' ? trace : () => {};
 
     this.proc = null;
+    this.processStartedAt = 0;
     this.sessionId = null;
     this.pending = new Map();      // id → { resolve, reject }
     this.inflight = null;          // current { id, sessionId, onChunk, onDone, onError, signal, signalHandler, settled }
@@ -271,6 +327,7 @@ class Worker {
     this.killed = false;
     this.spawnError = null;
     this.firstSystemPromptSent = false;
+    this.preservedDescendantPids = new Set();
     // In-flight spawn+initialize+session/new promise. Set by the consumer
     // before the worker is registered in its own pool bookkeeping, cleared
     // after the handshake settles. Racing callers await this to avoid the
@@ -283,13 +340,16 @@ class Worker {
   async _spawnAndInit() {
     let proc;
     try {
-      proc = this._internals.spawnAcp({ cwd: this.cwd, env: this.processEnv });
+      proc = this._internals.spawnAcp({
+        runtime: this.runtime,
+        cwd: this.processCwd,
+        env: this.processEnv,
+        workerOptions: this.workerOptions,
+      });
     } catch (err) {
-      // spawn() threw synchronously — typically ENOENT (copilot binary not
-      // on PATH) or EACCES. Surface as worker-spawn-failed so the consumer
-      // can show "install the CLI / fix PATH" guidance.
+      const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
       throw typedError(
-        `copilot --acp failed -- ensure copilot CLI >=1.0.46 and copilot login is complete (${err.message})`,
+        `${hint} (${err.message})`,
         ERROR_CODES.WORKER_SPAWN_FAILED,
         true
       );
@@ -307,11 +367,9 @@ class Worker {
     const earlyExitPromise = new Promise((_, reject) => {
       earlyExitReject = (code) => {
         this.killed = true;
-        // Early exit DURING the handshake = acp-handshake-failed (almost
-        // always missing `copilot login`, stale CLI, or daemon crash on
-        // boot). Retriable so re-auth or a CLI upgrade can recover.
+        const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
         const err = typedError(
-          `copilot --acp failed -- ensure copilot CLI >=1.0.46 and copilot login is complete (exit ${code})`,
+          `${hint} (exit ${code})`,
           ERROR_CODES.ACP_HANDSHAKE_FAILED,
           true
         );
@@ -327,8 +385,9 @@ class Worker {
       // proc 'error' event fires when the OS can't actually start the child
       // (ENOENT after a successful spawn() call, etc.). Treat as a spawn
       // failure even though we made it past the synchronous spawn() above.
+      const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
       const wrapped = typedError(
-        `copilot --acp failed -- ensure copilot CLI >=1.0.46 and copilot login is complete (${err.message})`,
+        `${hint} (${err.message})`,
         ERROR_CODES.WORKER_SPAWN_FAILED,
         true
       );
@@ -338,28 +397,63 @@ class Worker {
     };
     proc.on('error', errorHandler);
 
+    const configuredHandshakeTimeout = Number(this._internals.handshakeTimeoutMs);
+    const handshakeTimeoutMs = Number.isFinite(configuredHandshakeTimeout) && configuredHandshakeTimeout > 0
+      ? configuredHandshakeTimeout
+      : ACP_HANDSHAKE_TIMEOUT_MS;
+    let handshakeTimer;
+    const handshakeTimeoutPromise = new Promise((_, reject) => {
+      handshakeTimer = setTimeout(() => {
+        reject(typedError(
+          `copilot --acp handshake timed out after ${handshakeTimeoutMs}ms`,
+          ERROR_CODES.ACP_HANDSHAKE_FAILED,
+          true
+        ));
+      }, handshakeTimeoutMs);
+    });
+
     try {
       await Promise.race([
         this._call('initialize', { protocolVersion: 1, clientCapabilities: {} }),
         earlyExitPromise,
+        handshakeTimeoutPromise,
       ]);
+      const sessionMethod = this.resumeSessionId ? 'session/load' : 'session/new';
+      const sessionParams = this.resumeSessionId
+        ? buildSessionLoadParams({
+          sessionId: this.resumeSessionId,
+          cwd: this.cwd,
+          mcpServers: this.mcpServers,
+        })
+        : buildSessionNewParams({
+          cwd: this.cwd,
+          mcpServers: this.mcpServers,
+          model: this.model,
+          effort: this.effort,
+        });
+      const sessionPromise = sessionMethod === 'session/load'
+        ? this._loadSession(sessionParams)
+        : this._call(sessionMethod, sessionParams);
       const result = await Promise.race([
-        this._call('session/new', buildSessionNewParams({
-          cwd: this.cwd, mcpServers: this.mcpServers, model: this.model, effort: this.effort,
-        })),
+        sessionPromise,
         earlyExitPromise,
+        handshakeTimeoutPromise,
       ]);
-      this.sessionId = result && result.sessionId;
+      this.sessionId = (result && result.sessionId) || this.resumeSessionId;
+      this.currentModel = extractSessionModel(result) || normalizeExecutionModel(this.model);
       if (!this.sessionId) {
         // Handshake completed without an error but the daemon didn't hand
         // back a sessionId — protocol violation or partial init failure.
+        const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
         throw typedError(
-          'copilot --acp failed -- session/new returned no sessionId',
+          `${hint} (${sessionMethod} returned no sessionId)`,
           ERROR_CODES.ACP_HANDSHAKE_FAILED,
           true
         );
       }
+      this.firstSystemPromptSent = !!this.resumeSessionId;
     } finally {
+      clearTimeout(handshakeTimer);
       // Either the handshake finished (swap to a persistent exit handler that
       // just marks killed) or it failed (proc is dying anyway).
       proc.removeListener('exit', earlyExitHandler);
@@ -369,7 +463,7 @@ class Worker {
       // Post-handshake exit = the daemon died mid-conversation. Retriable
       // because the next call will cold-spawn a fresh worker.
       const err = typedError(
-        'copilot --acp process exited',
+        `${this.runtime.name} persistent worker process exited`,
         ERROR_CODES.WORKER_DIED,
         true
       );
@@ -408,9 +502,13 @@ class Worker {
   _handleMessage(obj) {
     // Response (matches an outbound id)
     if (obj.id != null && this.pending.has(obj.id)) {
-      const { resolve, reject } = this.pending.get(obj.id);
+      const { resolve, reject, method } = this.pending.get(obj.id);
       this.pending.delete(obj.id);
-      if (obj.error) reject(new Error(obj.error.message || 'ACP error'));
+      if (obj.error) {
+        const err = new Error(obj.error.message || 'ACP error');
+        err.acpMethod = method || null;
+        reject(err);
+      }
       else resolve(obj.result);
       return;
     }
@@ -460,10 +558,35 @@ class Worker {
     catch { /* pipe may be broken; exit handler will fire */ }
   }
 
-  _call(method, params) {
+  _call(method, params, timeoutMs) {
+    if (this.killed || !this.proc?.stdin || this.proc.stdin.destroyed) {
+      return Promise.reject(new Error('acp-transport: worker is closed'));
+    }
     return new Promise((resolve, reject) => {
       const id = this.nextReqId++;
-      this.pending.set(id, { resolve, reject });
+      let timer;
+      const settle = (callback, value) => {
+        if (timer) clearTimeout(timer);
+        callback(value);
+      };
+      this.pending.set(id, {
+        resolve: (value) => settle(resolve, value),
+        reject: (err) => settle(reject, err),
+        method,
+      });
+      const parsedTimeout = Number(timeoutMs);
+      if (Number.isFinite(parsedTimeout) && parsedTimeout > 0) {
+        timer = setTimeout(() => {
+          if (!this.pending.delete(id)) return;
+          const err = typedError(
+            `acp-transport: ${method} timed out after ${parsedTimeout}ms`,
+            ERROR_CODES.ACP_HANDSHAKE_FAILED,
+            true
+          );
+          err.acpMethod = method;
+          reject(err);
+        }, parsedTimeout);
+      }
       this._writeFrame({ jsonrpc: '2.0', id, method, params });
     });
   }
@@ -472,6 +595,20 @@ class Worker {
     this._writeFrame({ jsonrpc: '2.0', method, params });
   }
 
+  async _loadSession(params) {
+    let lastError;
+    for (let attempt = 0; attempt < SESSION_LOAD_RETRY_ATTEMPTS; attempt++) {
+      try {
+        return await this._call('session/load', params, ACP_HANDSHAKE_TIMEOUT_MS);
+      } catch (err) {
+        lastError = err;
+        if (!/already loaded/i.test(String(err && err.message))) throw err;
+        await new Promise((resolve) => setTimeout(resolve, SESSION_LOAD_RETRY_DELAY_MS));
+      }
+    }
+    throw lastError;
+  }
+
   // ── Stream a single turn ───────────────────────────────────────────────
   stream(promptText, opts = {}) {
     const {
@@ -496,8 +633,11 @@ class Worker {
     // message remains correct.
     let prompt = promptText;
     const trustedContextText = buildTrustedSessionContext(trustedSessionContext);
-    const trustedSystemText = [systemPromptText, trustedContextText].filter(Boolean).join('\n\n');
-    if (!this.firstSystemPromptSent && trustedSystemText) {
+    const trustedSystemText = [
+      !this.firstSystemPromptSent ? systemPromptText : null,
+      trustedContextText,
+    ].filter(Boolean).join('\n\n');
+    if (trustedSystemText) {
       prompt = `<system>\n${trustedSystemText}\n</system>\n\n${promptText}`;
     }
     if (!deferSystemPrompt) this.firstSystemPromptSent = true;
@@ -563,7 +703,8 @@ class Worker {
     this._notify('session/cancel', { sessionId: this.inflight.sessionId });
   }
 
-  async newSession({ mcpServers, systemPromptHash, model, effort, cwd }) {
+  async _prepareSession(options = {}) {
+    const { sessionId, mcpServers, systemPromptHash, model, effort, cwd } = options;
     // Cancel any inflight before swapping the underlying session.
     if (this.inflight) {
       this.cancel();
@@ -573,28 +714,91 @@ class Worker {
       await new Promise((resolve) => {
         const start = this._internals.now();
         const wait = () => {
-          if (!inflight || inflight.settled || this._internals.now() - start > 1000) resolve();
+          if (!inflight || inflight.settled
+              || this._internals.now() - start > SESSION_ROTATION_CANCEL_WAIT_MS) resolve();
           else setTimeout(wait, 5);
         };
         wait();
       });
+      if (!inflight.settled) {
+        throw new Error('acp-transport: cancelled prompt did not settle before session rotation');
+      }
     }
     // Bug B (issue #2479): if the caller is rotating the session because the
     // system prompt changed, they may also be passing a fresh model/effort —
     // update bookkeeping BEFORE session/new so the new fields land on the
-    // daemon. Falls through to whatever we already had when callers omit them.
-    if (model !== undefined) this.model = model;
+    // daemon. An explicit `model: undefined` clears a prior pooled override and
+    // lets the new session select its own default.
+    if (Object.prototype.hasOwnProperty.call(options, 'model')) this.model = model;
     if (effort !== undefined) this.effort = effort;
     // agent-worker-pool.js reuses a warm worker across dispatches with
     // different cwds (unlike cc-worker-pool.js, whose tabs never change
     // cwd) — allow the caller to rotate it in on a session swap.
-    if (cwd !== undefined && cwd !== null && cwd !== '') this.cwd = cwd;
-    const result = await this._call('session/new', buildSessionNewParams({
-      cwd: this.cwd, mcpServers: mcpServers || [], model: this.model, effort: this.effort,
-    }));
-    this.sessionId = result && result.sessionId;
+    const nextCwd = cwd !== undefined && cwd !== null && cwd !== '' ? cwd : this.cwd;
+    if (sessionId && this.sessionId === sessionId) {
+      if (nextCwd !== this.cwd) {
+        const err = new Error('acp-transport: loaded session cannot change cwd without a worker respawn');
+        err.acpMethod = 'session/load';
+        throw err;
+      }
+      this.systemPromptHash = systemPromptHash;
+      this.firstSystemPromptSent = true;
+      return;
+    }
+    this.cwd = nextCwd;
+    const method = sessionId ? 'session/load' : 'session/new';
+    const params = sessionId
+      ? buildSessionLoadParams({ sessionId, cwd: this.cwd, mcpServers: mcpServers || [] })
+      : buildSessionNewParams({
+        cwd: this.cwd,
+        mcpServers: mcpServers || [],
+        model: this.model,
+        effort: this.effort,
+      });
+    const result = method === 'session/load'
+      ? await this._loadSession(params)
+      : await this._call(method, params, ACP_HANDSHAKE_TIMEOUT_MS);
+    this.sessionId = (result && result.sessionId) || sessionId;
+    if (!this.sessionId) {
+      const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
+      throw typedError(
+        `${hint} (${method} returned no sessionId)`,
+        ERROR_CODES.ACP_HANDSHAKE_FAILED,
+        true
+      );
+    }
+    this.currentModel = extractSessionModel(result) || normalizeExecutionModel(this.model);
     this.systemPromptHash = systemPromptHash;
-    this.firstSystemPromptSent = false;
+    this.firstSystemPromptSent = !!sessionId;
+  }
+
+  async newSession(opts) {
+    return this._prepareSession({ ...opts, sessionId: null });
+  }
+
+  async loadSession(sessionId, opts) {
+    return this._prepareSession({ ...opts, sessionId });
+  }
+
+  preserveDescendants(pids) {
+    for (const pid of pids || []) {
+      const value = Number(pid);
+      if (Number.isInteger(value) && value > 0) this.preservedDescendantPids.add(value);
+    }
+  }
+
+  abandon() {
+    if (this.killed) return;
+    this.killed = true;
+    try { this.proc?.stdin?.end(); } catch { /* pipe already closed */ }
+    const err = new Error('acp-transport: unverified worker abandoned');
+    this._failAllPending(err);
+    if (this.inflight && !this.inflight.settled) {
+      const cb = this.inflight.onError;
+      this.inflight.settled = true;
+      this.inflight = null;
+      if (cb) try { cb(err); } catch { /* swallow */ }
+    }
   }
 
   close() {
@@ -607,7 +811,13 @@ class Worker {
       catch { /* swallow */ }
     }
     if (this.proc) {
-      try { this._internals.killImmediate(this.proc); } catch { /* already dead */ }
+      try {
+        if (this.preservedDescendantPids.size > 0 && typeof this._internals.killRoot === 'function') {
+          this._internals.killRoot(this.proc);
+        } else {
+          this._internals.killImmediate(this.proc);
+        }
+      } catch { /* already dead */ }
     }
     this._failAllPending(new Error('acp-transport: worker closed'));
     if (this.inflight && !this.inflight.settled) {
@@ -623,13 +833,18 @@ module.exports = {
   ERROR_CODES,
   typedError,
   spawnAcp,
+  resolveWorkerRuntime,
   killImmediate,
+  killRoot,
   hashMcpServers,
   hashProcessContext,
   buildTrustedSessionContext,
   buildSessionNewParams,
+  extractSessionModel,
+  buildSessionLoadParams,
   extractChunkText,
   mapAcpToolCallToToolUse,
   Worker,
   WARM_MAX_CONCURRENT,
+  ACP_HANDSHAKE_TIMEOUT_MS,
 };

package/engine/ado-comment.js

@@ -106,6 +106,7 @@ async function _defaultAcquireToken() {
  * @param {string} args.agentId        minions agent id (marker)
  * @param {string} args.kind           comment kind (marker)
  * @param {string} [args.workItemId]   originating work-item id (marker)
+ * @param {string} [args.model]        concrete runtime execution model
  * @param {number} [args.timeoutMs=30000]
  * @param {Function} [args.acquireToken]  () => Promise<string> — injectable token source
  * @param {Function} [args.fetchImpl=fetch] injectable fetch
@@ -120,6 +121,7 @@ async function postAdoPrComment({
   agentId,
   kind,
   workItemId,
+  model,
   resolved = false,
   timeoutMs = 30000,
   acquireToken = _defaultAcquireToken,
@@ -131,7 +133,7 @@ async function postAdoPrComment({
   _validatePrNumber(prNumber);
 
   // buildMinionsCommentBody validates marker fields and throws on bad input.
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
 
   const token = await acquireToken();
   if (!token || typeof token !== 'string') {