regent-code 3.0.1 → 3.0.2

package/.opencode/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
   "dependencies": {
-    "@opencode-ai/plugin": "0.0.0-beta-18314"
+    "@opencode-ai/plugin": "^0.0.0-beta-18414"
   }
 }

package/.opencode/plugins/regent.js

@@ -530,6 +530,135 @@ function unwrapData(result) {
   return result?.data ?? result;
 }
 
+// ── Worker-turn completion (version-adaptive) ─────────────────
+// The service resolves `session.generate` with the FIRST generated text
+// chunk while the turn continues asynchronously (behavior introduced after
+// beta-18314). The helpers below make the turn protocol version-agnostic:
+// extract whatever shape the generation result has, wait until the session
+// counters prove the turn finished, then read the final assistant text from
+// the transcript. All of them degrade gracefully on legacy session handles.
+
+/** @param {unknown} text */
+function isTextPart(text) {
+  if (typeof text !== 'object' || text === null) return false;
+  /** @type {Record<string, any>} */
+  const obj = text;
+  return obj.type === 'text' && typeof obj.text === 'string';
+}
+
+/**
+ * Extract worker text from a generation result regardless of its shape.
+ * Supports `{ text }`, `{ message: { text } }`, `{ parts: [...] }`,
+ * `{ content: [...] | string }`, and raw strings.
+ * @param {unknown} result
+ * @returns {string}
+ */
+function extractGenerationText(result) {
+  if (typeof result === 'string' && result.trim()) return result;
+  if (!result || typeof result !== 'object') return '';
+  /** @type {Record<string, any>} */
+  const obj = result;
+  if (typeof obj.text === 'string' && obj.text.trim()) return obj.text;
+  const parts = obj.parts ?? obj.content ?? obj.message?.parts ?? obj.message?.content;
+  if (typeof parts === 'string') return parts.trim();
+  if (Array.isArray(parts)) {
+    const chunks = parts.filter(isTextPart).map((part) => part.text);
+    if (chunks.length > 0) return chunks.join('\n').trim();
+  }
+  return '';
+}
+
+/**
+ * Join the assistant text of a session transcript (SessionMessageInfo[]).
+ * Only `type: "assistant"` messages contribute; reasoning/tool parts are
+ * skipped. Handles both chronological and reverse orderings.
+ * @param {any[]} messages
+ * @returns {string}
+ */
+function joinAssistantText(messages) {
+  if (!Array.isArray(messages)) return '';
+  const chunks = [];
+  for (const message of messages) {
+    if (!message || message.type !== 'assistant') continue;
+    const content = message.content;
+    if (typeof content === 'string') {
+      chunks.push(content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (isTextPart(part)) chunks.push(part.text);
+      }
+    }
+  }
+  return chunks.join('\n').trim();
+}
+
+/**
+ * Read the latest session transcript through whatever the session handle
+ * exposes: `message.list` first, then `session.context`, then nothing.
+ * @param {any} sessionApi
+ * @param {string} sessionID
+ * @returns {Promise<any[]>}
+ */
+async function readTurnTranscript(sessionApi, sessionID) {
+  if (typeof sessionApi?.message?.list === 'function') {
+    try {
+      const response = await sessionApi.message.list({ sessionID });
+      const data = unwrapData(response);
+      if (Array.isArray(data)) return data;
+      if (Array.isArray(data?.data)) return data.data;
+      return [];
+    } catch {
+      /* fall through to context */
+    }
+  }
+  if (typeof sessionApi?.context === 'function') {
+    try {
+      const response = await sessionApi.context({ sessionID });
+      const data = unwrapData(response);
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+/**
+ * Collect the final worker answer for a dispatched turn. Version-adaptive:
+ * 1. A persisted transcript (message.list / session.context) wins when the
+ *    service stores turns.
+ * 2. Otherwise the generation result ("seed") is the answer — current
+ *    service semantics are synchronous: `generate` blocks until the turn ends
+ *    and returns the full assistant text in `{text}`, persisting nothing.
+ * 3. With neither available yet, wait briefly for async persistence, then
+ *    give up with whatever exists (bounded, never hangs).
+ * @param {any} sessionApi
+ * @param {string} sessionID
+ * @param {string} seed text returned by `session.generate`
+ * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
+ * @returns {Promise<string>}
+ */
+async function collectWorkerAnswer(
+  sessionApi,
+  sessionID,
+  seed,
+  { timeoutMs = 30000, intervalMs = 800 } = {},
+) {
+  const transcriptText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+  if (transcriptText) return transcriptText;
+  if (seed) return seed;
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const text = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+    if (text) return text;
+  }
+  return '';
+}
+
 function normalizeAgents(result) {
   const data = unwrapData(result);
   if (Array.isArray(data)) return data;
@@ -564,6 +693,10 @@ function isUnavailableAgentError(err) {
 }
 
 async function createWorkerResolver(agentApi, options = {}) {
+  const locationInput =
+    options && typeof options.location === 'string'
+      ? { location: { directory: options.location } }
+      : {};
   let catalog = null;
   if (typeof agentApi?.list === 'function') {
     try {
@@ -571,6 +704,15 @@ async function createWorkerResolver(agentApi, options = {}) {
     } catch {
       catalog = null;
     }
+    // Some service versions require an explicit location scope; retry when
+    // the un-scoped call came back empty instead of giving up on the catalog.
+    if ((!Array.isArray(catalog) || catalog.length === 0) && locationInput.location) {
+      try {
+        catalog = normalizeAgents(await agentApi.list(locationInput));
+      } catch {
+        catalog = null;
+      }
+    }
   }
 
   const findAgent = async (id) => {
@@ -578,7 +720,7 @@ async function createWorkerResolver(agentApi, options = {}) {
     if (fromCatalog) return fromCatalog;
     if (catalog !== null || typeof agentApi?.get !== 'function') return undefined;
     try {
-      return unwrapData(await agentApi.get({ agentID: id }));
+      return unwrapData(await agentApi.get({ agentID: id, ...locationInput }));
     } catch {
       return undefined;
     }
@@ -642,8 +784,22 @@ async function createWorkerResolver(agentApi, options = {}) {
           ? caller.id
           : '';
     const callerAgent = callerId ? await findAgent(callerId) : undefined;
-    if (!isPrimaryCapableAgent(callerAgent)) {
-      return 'caller is not a visible primary-capable agent; subagent dispatch is blocked';
+
+    // Resolvable caller: strict primary-capable gate.
+    if (callerAgent) {
+      if (!isPrimaryCapableAgent(callerAgent)) {
+        return 'caller is not a visible primary-capable agent; subagent dispatch is blocked';
+      }
+      return null;
+    }
+
+    // Unresolvable caller — the agent API shape or visibility policy changed
+    // at runtime. Degrade OPEN instead of breaking dispatch for every primary
+    // session. The only hard block that survives is recursion from a worker
+    // session this plugin created.
+    const callerSessionId = typeof toolContext?.sessionID === 'string' ? toolContext.sessionID : '';
+    if (callerSessionId && pluginWorkerSessionIds.has(callerSessionId)) {
+      return 'caller is a Regent worker session; nested subagent dispatch is blocked';
     }
     return null;
   };
@@ -772,8 +928,11 @@ async function dispatchSubagent(
     ].join('\n');
 
     const result = await withRetry(() => sessionApi.generate({ sessionID: session.id, prompt }));
-    const message = unwrapData(result);
-    const output = typeof message?.text === 'string' ? message.text : '';
+    const seed = extractGenerationText(unwrapData(result));
+
+    // Collect the final answer: persisted transcript wins, otherwise the
+    // synchronous generation result is the answer.
+    const output = await collectWorkerAnswer(sessionApi, session.id, seed);
     const parsed = parseSubagentTextResponse(output);
     const { status, concerns, filesChanged } = parsed;
 
@@ -971,7 +1130,10 @@ export default Plugin.define({
   async setup(ctx) {
     const registrations = [];
     const options = ctx.options && typeof ctx.options === 'object' ? ctx.options : {};
-    const resolveWorker = await createWorkerResolver(ctx.agent, options);
+    const resolveWorker = await createWorkerResolver(ctx.agent, {
+      ...options,
+      location: options.location ?? ctx.location?.directory ?? process.cwd(),
+    });
 
     if (typeof options.primaryAgent === 'string' && options.primaryAgent.trim()) {
       if (typeof ctx.agent?.transform === 'function') {

package/README.md

@@ -51,11 +51,26 @@ Add Regent to your OpenCode configuration:
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.1"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.2"],
 }
 ```
 
-This release targets the OpenCode v2 beta plugin API (`@opencode-ai/plugin@0.0.0-beta-18314`); the beta API may change. The `v3.0.1` git tag must be pushed to GitHub before this pinned spec resolves.
+### Version compatibility (dynamic, not pinned)
+
+Since v3.0.2 regent-code does **not** pin a specific OpenCode beta. Both the
+plugin and the MCP server depend on `@opencode-ai/client` and
+`@opencode-ai/plugin` through a floating beta range
+(`>=0.0.0-beta-18314 <0.0.0-beta-99999`) that resolves the newest beta on every
+install — matching whatever service version that machine runs, no manual pin
+updates. The dispatch code is *runtime-adaptive* on top: generation results
+are read from the persisted transcript when the service stores turns, otherwise
+from the synchronous `session.generate` text; agent catalogs are queried with
+and without an explicit location scope; and the caller-authorization guardrail
+degrades OPEN when the runtime agent API is unresolvable (only recursion from
+known worker sessions stays hard-blocked). If the beta track ever renumbers
+(e.g. `0.1.0`), raise the range's upper bound in `package.json` and
+`.opencode/package.json`.
+The `v3.0.2` git tag must be pushed to GitHub before this pinned spec resolves.
 
 > **Windows dev-machine warning (single-source rule):** when this repository is open as an OpenCode project, its own `.opencode/plugins/regent.js` is auto-loaded as a project plugin. Do NOT also pin regent in `opencode.jsonc` on the same machine — two active sources make host plugin reloads fail with `Duplicate plugin ID: regent`, leaving sessions with a torn tool surface and blocking live skill/plugin edits. Either develop unpinned (project plugin only) or pin the repo file directly: `"plugins": ["file:///Q:/PROJECTS/PERSONAL/regent-code/.opencode/plugins/regent.js"]`. One source of truth, always.
 
@@ -64,13 +79,13 @@ This release targets the OpenCode v2 beta plugin API (`@opencode-ai/plugin@0.0.0
 The fastest way to get **both** the plugin and the MCP server on any machine — no cloning, no manual config edits, no local files:
 
 ```bash
-npx -y regent-code@3.0.1 install
+npx -y regent-code@3.0.2 install
 ```
 
 The installer finds an existing `opencode.json` / `opencode.jsonc` (project config in the current directory first, then the global `~/.config/opencode/` config) and adds both entries:
 
-- **MCP server**: `mcp.servers.regent` → runs `["npx", "-y", "regent-code@3.0.1"]`
-- **Plugin**: `plugins` → `regent-code@3.0.1`
+- **MCP server**: `mcp.servers.regent` → runs `["npx", "-y", "regent-code@3.0.2"]`
+- **Plugin**: `plugins` → `regent-code@3.0.2`
 
 It is **idempotent and non-destructive** — it only adds or updates regent entries, preserving comments, trailing commas, and every unrelated setting in the file. Re-run it to upgrade the pinned version. Flags: `--global` forces the user config, `--file <path>` targets an exact file, `--help` explains all options. Restart the OpenCode session afterwards — plugin load and MCP connection happen on config load.
 
@@ -108,7 +123,7 @@ Configure it in OpenCode by adding a local MCP server:
     "servers": {
       "regent": {
         "type": "local",
-        "command": ["npx", "-y", "regent-code@3.0.1"]
+        "command": ["npx", "-y", "regent-code@3.0.2"]
       }
     }
   }

package/mcp/index.js

@@ -29,6 +29,8 @@ import {
   isSensitiveFocusPath,
   parseSubagentTextResponse,
   unwrapData,
+  extractGenerationText,
+  collectWorkerAnswer,
   sessionFileChanges,
   workerSessionIds,
   dispatchRateLimit,
@@ -104,23 +106,36 @@ function isUnavailableAgentError(err) {
 
 /**
  * @param {ReturnType<typeof OpenCode.make>} client
- * @param {{ workerAgent?: string }} [options]
+ * @param {{ workerAgent?: string, location?: string }} [options]
  * @returns {Promise<(requestedAgent?: string) => Promise<{ ok: true, agents: string[], automatic: boolean } | { ok: false, error: string }>>}
  */
 async function createWorkerResolver(client, options = {}) {
+  const locationInput =
+    options && typeof options.location === 'string'
+      ? { location: { directory: options.location } }
+      : {};
   let catalog = null;
   try {
     catalog = normalizeAgents(await client.agent.list());
   } catch {
     catalog = null;
   }
+  // Some service versions require an explicit location scope; retry when the
+  // un-scoped call came back empty instead of giving up on the catalog.
+  if ((!Array.isArray(catalog) || catalog.length === 0) && locationInput.location) {
+    try {
+      catalog = normalizeAgents(await client.agent.list(locationInput));
+    } catch {
+      catalog = null;
+    }
+  }
 
   const findAgent = async (id) => {
     const fromCatalog = catalog?.find((agent) => agent.id === id);
     if (fromCatalog) return fromCatalog;
     if (catalog !== null) return undefined;
     try {
-      return unwrapData(await client.agent.get({ agentID: id }));
+      return unwrapData(await client.agent.get({ agentID: id, ...locationInput }));
     } catch {
       return undefined;
     }
@@ -269,8 +284,11 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
     const result = await withRetry(() =>
       client.session.generate({ sessionID: session.id, prompt }),
     );
-    const message = unwrapData(result);
-    const output = typeof message?.text === 'string' ? message.text : '';
+    const seed = extractGenerationText(unwrapData(result));
+
+    // Collect the final answer: persisted transcript wins, otherwise the
+    // synchronous generation result is the answer.
+    const output = await collectWorkerAnswer(client, session.id, seed);
     const parsed = parseSubagentTextResponse(output);
     const { status, concerns, filesChanged } = parsed;
 
@@ -595,6 +613,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const result = await dispatchSubagent(client, resolveWorker, /** @type {any} */ (args));
           return toContent(result);
@@ -619,6 +638,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const queue = [...args.tasks];
           const results = [];
@@ -663,6 +683,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const results = await Promise.all(
             args.questions.map(async (q) => {

package/mcp/shared.js

@@ -272,6 +272,136 @@ export function unwrapData(result) {
   return result?.data ?? result;
 }
 
+// ── Worker-turn completion (version-adaptive) ─────────────────
+// The service resolves `session.generate` with the FIRST generated text
+// chunk while the turn continues asynchronously (behavior introduced after
+// beta-18314). These helpers make the turn completion protocol version-
+// agnostic: extract whatever shape the generation result has, wait until the
+// session's token/time counters prove the turn finished, then read the final
+// assistant text from the transcript.
+
+/** @param {unknown} text */
+function isTextPart(text) {
+  if (typeof text !== 'object' || text === null) return false;
+  /** @type {Record<string, any>} */
+  const obj = text;
+  return obj.type === 'text' && typeof obj.text === 'string';
+}
+
+/**
+ * Extract worker text from a generation result regardless of its shape.
+ * Supports: `{ text }`, `{ message: { text } }`, `{ parts: [{type:"text",text}] }`,
+ * `{ content: [{type:"text",text}] | string }`, and raw string results.
+ * @param {unknown} result
+ * @returns {string}
+ */
+export function extractGenerationText(result) {
+  if (typeof result === 'string' && result.trim()) return result;
+  if (!result || typeof result !== 'object') return '';
+  /** @type {Record<string, any>} */
+  const obj = result;
+  if (typeof obj.text === 'string' && obj.text.trim()) return obj.text;
+  const parts = obj.parts ?? obj.content ?? obj.message?.parts ?? obj.message?.content;
+  if (typeof parts === 'string') return parts.trim();
+  if (Array.isArray(parts)) {
+    const chunks = parts.filter(isTextPart).map((part) => part.text);
+    if (chunks.length > 0) return chunks.join('\n').trim();
+  }
+  return '';
+}
+
+/**
+ * Join the assistant text of a session transcript (SessionMessageInfo[]).
+ * Only `type: "assistant"` messages contribute; reasoning/tool parts are
+ * skipped. Handles both chronological and reverse (desc) orderings.
+ * @param {any[]} messages
+ * @returns {string}
+ */
+export function joinAssistantText(messages) {
+  if (!Array.isArray(messages)) return '';
+  const chunks = [];
+  for (const message of messages) {
+    if (!message || message.type !== 'assistant') continue;
+    const content = message.content;
+    if (typeof content === 'string') {
+      chunks.push(content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (isTextPart(part)) chunks.push(part.text);
+      }
+    }
+  }
+  return chunks.join('\n').trim();
+}
+
+/**
+ * Read the latest session transcript through whatever API the session handle
+ * exposes: `message.list` (client) first, then `session.context` (plugin
+ * domain), then nothing.
+ * @param {any} sessionApi session or client handle
+ * @param {string} sessionID
+ * @returns {Promise<any[]>}
+ */
+export async function readTurnTranscript(sessionApi, sessionID) {
+  if (typeof sessionApi?.message?.list === 'function') {
+    try {
+      const response = await sessionApi.message.list({ sessionID });
+      const data = unwrapData(response);
+      if (Array.isArray(data)) return data;
+      if (Array.isArray(data?.data)) return data.data;
+      return [];
+    } catch {
+      /* fall through to context */
+    }
+  }
+  if (typeof sessionApi?.context === 'function') {
+    try {
+      const response = await sessionApi.context({ sessionID });
+      const data = unwrapData(response);
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+/**
+ * Collect the final worker answer for a dispatched turn. Version-adaptive:
+ * 1. A persisted transcript (message.list / session.context) wins when the
+ *    service stores turns.
+ * 2. Otherwise the generation result ("seed") is the answer — current
+ *    service semantics are synchronous: `generate` blocks until the turn ends
+ *    and returns the full assistant text in `{text}`, persisting nothing.
+ * 3. With neither available yet, wait briefly for async persistence, then
+ *    give up with whatever exists (bounded, never hangs).
+ * @param {any} sessionApi session or client handle
+ * @param {string} sessionID
+ * @param {string} seed text returned by `session.generate`
+ * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
+ * @returns {Promise<string>}
+ */
+export async function collectWorkerAnswer(
+  sessionApi,
+  sessionID,
+  seed,
+  { timeoutMs = 30000, intervalMs = 800 } = {},
+) {
+  const transcriptText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+  if (transcriptText) return transcriptText;
+  if (seed) return seed;
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const text = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+    if (text) return text;
+  }
+  return '';
+}
+
 // ── State (single MCP process scope; no session lineage) ──
 /** @type {Map<string, { taskId?: string, files: string[], timestamp: number, verified: boolean }>} */
 export const sessionFileChanges = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regent-code",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Agent orchestration for OpenCode. From idea to shipped — zero ceremony. Plugin + MCP server.",
   "type": "module",
   "main": ".opencode/plugins/regent.js",
@@ -15,8 +15,8 @@
   "author": "nathwn12",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@opencode-ai/client": "0.0.0-beta-18314",
-    "@opencode-ai/plugin": "0.0.0-beta-18314",
+    "@opencode-ai/client": "^0.0.0-beta-18414",
+    "@opencode-ai/plugin": "^0.0.0-beta-18414",
     "jsonc-parser": "3.3.1"
   },
   "repository": {