rterm-backend 3.8.7 → 3.8.8

package/bin/gybackend.cjs

@@ -366235,6 +366235,15 @@ var AgentHelpers = class {
   setEventPublisher(publisher) {
     this.eventPublisher = publisher;
   }
+  /**
+   * Current event publisher (or null). Lets a runtime CHAIN onto the
+   * publisher temporarily — e.g. the plugin runAgentTask hook captures
+   * `say` events for one mesh-invoke session while passing everything
+   * through to the gateway's broadcast unchanged.
+   */
+  getEventPublisher() {
+    return this.eventPublisher;
+  }
   /**
    * Build a temporary history for the action model to make decisions.
    * This includes the last 3 special marker messages and recent execution details.
@@ -368273,6 +368282,11 @@ var AgentService_v2 = class {
   setEventPublisher(publisher) {
     this.helpers.setEventPublisher(publisher);
   }
+  /** Current event publisher (or null) — lets a runtime chain onto it
+   * temporarily (plugin runAgentTask hook) without replacing it. */
+  getEventPublisher() {
+    return this.helpers.getEventPublisher();
+  }
   /** Wire the connection manager so `manage_ssh_connection` can mutate saved
    * connections + notify the UI. Optional; only needed in full runtimes. */
   setConnectionManager(manager) {
@@ -392163,7 +392177,7 @@ var PluginRegistry = class {
   }
   /** Build the default PluginContext for a record (registers into the record's
    * capability lists; exec/readLedger/log are delegated to the injected fns). */
-  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings) {
+  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings, runAgentTask) {
     return {
       registerTool: (tool2) => {
         record2.tools.push(tool2);
@@ -392184,7 +392198,8 @@ var PluginRegistry = class {
       ...spawnProcess ? { spawnProcess } : {},
       ...getSettings ? { getSettings, get settings() {
         return getSettings();
-      } } : {}
+      } } : {},
+      ...runAgentTask ? { runAgentTask } : {}
     };
   }
 };
@@ -394723,7 +394738,50 @@ function createObservability(deps) {
         });
       },
       // Live settings snapshot for plugins that read config blocks (webIntel, agentspan, …).
-      () => deps.settingsService?.getSettings?.() ?? {}
+      () => deps.settingsService?.getSettings?.() ?? {},
+      // Real agent turns for plugins that serve an inbound `invoke` skill
+      // (reactorpro-bridge): a mesh peer sends a prompt, RTerm runs it as a
+      // genuine agent turn and the answer goes back over the mesh.
+      // Chained onto the agent's event publisher for the duration of the
+      // turn: `say` events for OUR session are captured, everything passes
+      // through to the original (gateway) publisher unchanged, and the
+      // publisher is restored in finally. dispatchTask resolves when the
+      // run completes, so the last captured `say` is the final answer.
+      deps.agentService ? async (prompt, opts) => {
+        const agent = deps.agentService;
+        const sessionId = opts?.sessionId ?? `mesh-invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const timeoutMs = Math.min(Math.max(opts?.timeoutMs ?? 17e4, 5e3), 6e5);
+        const previous = agent.getEventPublisher();
+        const sayParts = [];
+        const chained = (sid, ev) => {
+          if (sid === sessionId && ev?.type === "say" && typeof ev.content === "string" && ev.content) {
+            sayParts.push(ev.content);
+          }
+          if (previous) {
+            try {
+              previous(sid, ev);
+            } catch {
+            }
+          }
+        };
+        agent.setEventPublisher(chained);
+        let timer;
+        try {
+          await Promise.race([
+            deps.gatewayService.dispatchTask(sessionId, prompt, void 0),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error(`agent turn timed out after ${timeoutMs}ms`)), timeoutMs);
+            })
+          ]);
+        } finally {
+          if (timer) clearTimeout(timer);
+          agent.setEventPublisher((sid, ev) => {
+            if (previous) previous(sid, ev);
+          });
+        }
+        const answer = sayParts.join("");
+        return { ok: answer.trim() !== "", answer, sessionId };
+      } : void 0
     ),
     onLog: deps.onLog
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.7",
+  "version": "3.8.8",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",

package/plugins/reactorpro-bridge/index.mjs

@@ -406,7 +406,7 @@ export async function register(ctx) {
     const nc = await connectMesh(ctx)
     const identity = loadOrCreateIdentity(cfg)
     const effCfg = { ...cfg, fingerprint: identity.fingerprint }
-    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt }), identity, getSkills: () => serveCtx.skills }
+    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt, runAgentTask: ctx.runAgentTask }), identity, getSkills: () => serveCtx.skills }
     if (responderStop) responderStop()
     responderStop = await startResponder(nc, effCfg, serveCtx, log)
     if (heartbeatStop) heartbeatStop()
@@ -426,7 +426,7 @@ export async function register(ctx) {
       skills: { type: 'object', description: 'Map of skillId -> async (input, ctx) => output (defaults to ping/describe/status/invoke)', optional: true },
     },
     handler: async (p) => guarded(async () => {
-      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt })
+      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })
       const skills = p?.skills ?? base
       const served = await serveSkills(skills)
       return { serving: true, inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills: served, note: 'RTerm is now a full ReactorPro mesh citizen (responder + heartbeat + registry live)' }
@@ -487,7 +487,7 @@ export async function register(ctx) {
   if (cfg.enabled && cfg.autoServe) {
     setTimeout(() => {
       Promise.race([
-        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt })),
+        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })),
         new Promise((_, reject) => setTimeout(() => reject(new Error('auto-serve connect timeout (5s)')), 5000)),
       ])
         .then((skills) => log(`[reactorpro] auto-started citizen on ${cfg.prefix}.agent.${cfg.agentId}.inbox (skills: ${skills.join(', ')})`))

package/plugins/reactorpro-bridge/reactorpro-bridge.extreme.spec.mts

@@ -29,6 +29,7 @@ import {
   buildManifest,
   buildRespond,
   checkIdentity,
+  defaultServeSkills,
   envelope,
   fingerprintFor,
   mintIdentity,
@@ -267,6 +268,85 @@ function ok(cond: unknown, label: string, note = ''): void {
   }
 }
 
+// ─── A3. Inbound invoke skill (v3.8.8) ───────────────────────────────────────
+// Found live: the manifest ADVERTISED invoke but defaultServeSkills had no
+// handler, so a peer dispatching invoke got SKILL_NOT_FOUND while the
+// manifest promised it. These pin the corrected contract.
+
+{
+  // A3.1 invoke exists in the default skills and routes to runAgentTask.
+  const cfg = { agentId: 'rterm/xcheck/invoke', dispatchTimeout: 180000 }
+  const skills = defaultServeSkills(cfg, {
+    startedAt: Date.now(),
+    runAgentTask: async (prompt: string, opts?: { sessionId?: string; timeoutMs?: number }) => {
+      ok(prompt === 'Reply with exactly one word: PONG',
+        'invoke passes the prompt through to runAgentTask (arguments.prompt)',
+        JSON.stringify({ prompt }))
+      ok(typeof opts?.timeoutMs === 'number' && opts.timeoutMs === 170000,
+        'invoke stays under the mesh dispatch budget (dispatchTimeout - 10s)',
+        JSON.stringify(opts))
+      return { ok: true, answer: 'PONG', sessionId: 'mesh-invoke-test' }
+    },
+  })
+  ok(typeof skills.invoke === 'function', 'defaultServeSkills includes an invoke handler')
+
+  const r1 = await skills.invoke({ arguments: { prompt: 'Reply with exactly one word: PONG' } } as never)
+  ok(r1?.output === 'PONG', 'invoke returns the agent answer as output', JSON.stringify(r1))
+  ok(r1?.conversation_id === 'mesh-invoke-test', 'invoke returns conversation_id for session persistence')
+
+  // A3.2 prompt extraction: text/ prompt/ message all work.
+  const skills2 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (prompt: string) => ({ ok: true, answer: `got:${prompt}`, sessionId: 's' }),
+  })
+  const viaText = await skills2.invoke({ text: 'hello' } as never)
+  ok(viaText?.output === 'got:hello', 'invoke extracts input.text')
+  const viaPrompt = await skills2.invoke({ prompt: 'hi' } as never)
+  ok(viaPrompt?.output === 'got:hi', 'invoke extracts input.prompt')
+  const viaString = await skills2.invoke('plain' as never)
+  ok(viaString?.output === 'got:plain', 'invoke extracts a bare string input')
+
+  // A3.3 conversation_id routes the follow-up to the same agent session.
+  const seenSessions: Array<string | undefined> = []
+  const skills3 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (_p: string, o?: { sessionId?: string }) => {
+      seenSessions.push(o?.sessionId)
+      return { ok: true, answer: 'x', sessionId: o?.sessionId ?? 'new' }
+    },
+  })
+  const first = await skills3.invoke({ text: 'one' } as never)
+  // First call: no conversation_id yet -> the hook generates a session.
+  ok(seenSessions[0] === undefined, 'first invoke has no session yet (the hook mints one)')
+  await skills3.invoke({ text: 'two', conversation_id: first.conversation_id } as never)
+  ok(seenSessions[1] === first.conversation_id && first.conversation_id !== undefined,
+    'conversation_id reuses the same agent session on the follow-up',
+    JSON.stringify({ seenSessions, firstId: first.conversation_id }))
+
+  // A3.4 no runAgentTask hook -> a CLEAR error, not SKILL_NOT_FOUND.
+  const skills4 = defaultServeSkills({ agentId: 'a' }, {})
+  const r4 = await skills4.invoke({ text: 'x' } as never)
+  ok(r4?.error?.code === 3002 && String(r4?.error?.message).includes('INVOKE_UNAVAILABLE'),
+    'invoke without the runAgentTask hook returns INVOKE_UNAVAILABLE (not SKILL_NOT_FOUND)',
+    JSON.stringify(r4))
+
+  // A3.5 empty prompt -> a clear error.
+  const skills5 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: true, answer: 'should not run', sessionId: 's' }),
+  })
+  const r5 = await skills5.invoke({} as never)
+  ok(r5?.error?.code === 3003 && String(r5?.error?.message).includes('INVOKE_NEEDS_PROMPT'),
+    'invoke with no prompt returns INVOKE_NEEDS_PROMPT without running the agent',
+    JSON.stringify(r5))
+
+  // A3.6 a failed agent turn -> a retryable error carrying the reason.
+  const skills6 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: false, answer: '', error: 'model offline', sessionId: 's' }),
+  })
+  const r6 = await skills6.invoke({ text: 'x' } as never)
+  ok(r6?.error?.code === 5001 && String(r6?.error?.message).includes('model offline'),
+    'a failed agent turn surfaces as a retryable error with the reason',
+    JSON.stringify(r6))
+}
+
 // ─── B. Go cross-check against the REAL gateway ──────────────────────────────
 
 const RP_CHECKOUT = process.env.RP_CHECKOUT ?? join(process.env.HOME ?? '', 'work', 'ReactorPro')

package/plugins/reactorpro-bridge/reactorproAgent.mjs

@@ -224,6 +224,39 @@ export function defaultServeSkills(cfg, deps = {}) {
       skills: ['ping', 'describe', 'status', 'invoke'],
       uptime_seconds: Math.floor((Date.now() - (deps.startedAt ?? Date.now())) / 1000),
     }),
+    // `invoke` routes a prompt into a REAL RTerm agent turn (tools, policy,
+    // audit all apply) and returns the final assistant text. Requires the
+    // runAgentTask PluginContext hook — present on the daemon and desktop,
+    // absent in bare test harnesses. When absent, return a clear error
+    // instead of pretending: a peer must know invoke is unavailable here.
+    invoke: async (input = {}) => {
+      const runner = deps.runAgentTask
+      if (typeof runner !== 'function') {
+        return { error: { code: 3002, message: 'INVOKE_UNAVAILABLE: this runtime does not expose agent turns (runAgentTask hook absent)', retryable: false } }
+      }
+      const prompt = input?.arguments?.prompt
+        ?? input?.prompt
+        ?? input?.text
+        ?? input?.message
+        ?? (typeof input === 'string' ? input : '')
+      if (!prompt || !String(prompt).trim()) {
+        return { error: { code: 3003, message: 'INVOKE_NEEDS_PROMPT: pass arguments.prompt (or text)', retryable: false } }
+      }
+      const conversationId = typeof input?.conversation_id === 'string' ? input.conversation_id : undefined
+      const result = await runner(String(prompt), {
+        sessionId: conversationId,
+        // Stay under the mesh dispatch budget (180s default) so the reply
+        // reaches the caller before its own timeout fires.
+        timeoutMs: Math.max(5_000, (cfg.dispatchTimeout ?? 180_000) - 10_000),
+      })
+      if (!result?.ok) {
+        return { error: { code: 5001, message: result?.error || 'agent turn produced no answer', retryable: true } }
+      }
+      return {
+        output: result.answer,
+        conversation_id: result.sessionId,
+      }
+    },
     ...(deps.skills ?? {}),
   }
 }