rterm-backend 3.1.6 → 3.1.8

package/bin/gybackend.cjs

@@ -367406,6 +367406,10 @@ var AgentService_v2 = class {
   backgroundFileTransferCompleter = null;
   unfinishedBackgroundFileTransferProvider = null;
   imageAttachmentService = null;
+  /** Plugin tools: name → handler (injected from PluginRegistry at boot). */
+  pluginTools = /* @__PURE__ */ new Map();
+  /** Plugin tool schemas (for toolsForModel injection). */
+  pluginToolSchemas = [];
   passChatTempExportService = new PassChatTempExportService();
   fallbackCompactionHistoryExportService = null;
   activeAgentRunIdsBySession = /* @__PURE__ */ new Map();
@@ -367452,6 +367456,18 @@ var AgentService_v2 = class {
   setObservability(obs2) {
     this.observability = obs2 ?? void 0;
   }
+  /** Wire plugin tools (from PluginRegistry) so the agent can call them in chat.
+   * Each plugin tool has: name, description, params (schema), handler (async fn).
+   * The tools are injected into toolsForModel (so the model sees them) and
+   * pluginTools (so the dispatch switch's default case can call them). */
+  setPluginTools(tools2) {
+    this.pluginTools = new Map(tools2.map((t) => [t.name, t.handler]));
+    this.pluginToolSchemas = tools2.map((t) => ({
+      name: t.name,
+      description: t.description,
+      schema: t.params || {}
+    }));
+  }
   /** Wire a session-log handle so list_session_logs / read_session_log work. */
   setSessionLogger(logger) {
     this.sessionLogger = logger ?? void 0;
@@ -367640,6 +367656,7 @@ var AgentService_v2 = class {
       compactionItem?.apiKey ? compactionItem.profile : void 0
     );
     const toolsForModel = buildToolsForModel(readFileSupport);
+    const allToolsForModel = [...toolsForModel, ...this.pluginToolSchemas];
     return {
       profileId,
       model,
@@ -367653,7 +367670,7 @@ var AgentService_v2 = class {
       compactionModelSupportsStructuredOutput,
       compactionModelSupportsObjectToolChoice,
       readFileSupport,
-      toolsForModel,
+      toolsForModel: allToolsForModel,
       globalMaxTokens: typeof globalItem.maxTokens === "number" ? globalItem.maxTokens : 2e5,
       thinkingMaxTokens: typeof thinkingItem?.maxTokens === "number" ? thinkingItem.maxTokens : typeof globalItem.maxTokens === "number" ? globalItem.maxTokens : 2e5,
       compactionMaxTokens: typeof compactionItem?.maxTokens === "number" ? compactionItem.maxTokens : typeof thinkingItem?.maxTokens === "number" ? thinkingItem.maxTokens : typeof globalItem.maxTokens === "number" ? globalItem.maxTokens : 2e5
@@ -368952,8 +368969,21 @@ Actually, your intention might be different. Please re-read the description of t
           }
           break;
         }
-        default:
-          result = `Tool "${toolCall.name}" is not supported.`;
+        default: {
+          const pluginHandler = this.pluginTools.get(toolCall.name);
+          if (pluginHandler) {
+            try {
+              const pluginArgs = typeof toolCall.args === "string" ? JSON.parse(toolCall.args) : toolCall.args || {};
+              const pluginResult = await pluginHandler(pluginArgs);
+              result = typeof pluginResult === "string" ? pluginResult : JSON.stringify(pluginResult);
+            } catch (err) {
+              result = `Plugin tool "${toolCall.name}" error: ${err.message}`;
+            }
+          } else {
+            result = `Tool "${toolCall.name}" is not supported.`;
+          }
+          break;
+        }
       }
       toolMessage.content = result;
       if (shouldInterruptPendingToolsForQueuedInsertion) {
@@ -375199,6 +375229,7 @@ function normalizeSynapseSettings(raw) {
   const hasAuth = auth2 && Object.keys(auth2).length > 0;
   return {
     enabled: src.enabled !== false,
+    autoServe: src.autoServe !== false,
     ...url2 ? { url: url2 } : {},
     ...servers && servers.length > 0 ? { servers } : {},
     ...prefix ? { prefix } : {},
@@ -394721,6 +394752,27 @@ async function startGyBackend() {
   settingsService.onDidChange?.(refreshObservabilityFromSettings);
   agentService.setObservability(observability);
   terminalService.setSessionRecorder(observability.recording);
+  try {
+    const pluginRecords = await observability.pluginRegistry.reload();
+    const pluginTools = [];
+    for (const record2 of pluginRecords) {
+      if (record2.error || !record2.enabled) continue;
+      for (const tool2 of record2.tools) {
+        pluginTools.push({
+          name: tool2.name,
+          description: tool2.description ?? "",
+          params: tool2.params ?? {},
+          handler: tool2.handler
+        });
+      }
+    }
+    if (pluginTools.length > 0) {
+      agentService.setPluginTools(pluginTools);
+      console.log(`[gybackend] Wired ${pluginTools.length} plugin tools from ${pluginRecords.filter((r) => !r.error && r.enabled).length} plugins into the agent.`);
+    }
+  } catch (e) {
+    console.warn("[gybackend] Plugin tool wiring failed:", e instanceof Error ? e.message : String(e));
+  }
   if (settingsService.getSettings().sessionLogging?.enabled) {
     const logDir = import_node_path28.default.join(
       import_node_process2.default.env.GYSHELL_STORE_DIR || "",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rterm-backend",
-  "version": "3.1.6",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.6: full-duplex Synapse agent (responder, emit/subscribe, EXT-REPUTATION scoring, EXT-GOVERNANCE approvals) — RTerm speaks all six Synapse primitives + both extensions. 11 plugins. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
+  "version": "3.1.8",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.8: plugin tools wired into the agent (all 11 plugins callable in chat). 11 plugins. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
   "main": "bin/gybackend.cjs",
   "bin": { "gybackend": "bin/gybackend.cjs" },
   "license": "MIT",

package/plugins/synapse-bridge/index.mjs

@@ -46,6 +46,8 @@ export function resolveConfig(ctx = {}, env = process.env) {
     agentId: block.agentId || env.SYNAPSE_AGENT_ID || 'rterm-001',
     auth: block.auth || undefined,
     enabled: block.enabled !== false,
+    /** auto-start the full-duplex responder on boot (default true when enabled). */
+    autoServe: block.autoServe !== false,
   }
 }
 
@@ -264,20 +266,46 @@ export function register(ctx) {
   // ─── full-duplex agent capabilities (responder, emit/subscribe, reputation, governance) ───
   const repStore = new ReputationStore()
   let responderStop = null
+  let servingSkills = []
+
+  /** Start (or restart) the responder with the given skills. Idempotent. */
+  async function serveSkills(skills) {
+    const nc = await connectMesh(ctx)
+    const serveCtx = { ...ctx, rtermSkills: skills ?? ctx.rtermSkills ?? {} }
+    if (responderStop) responderStop()
+    responderStop = await startResponder(nc, cfg, serveCtx, log)
+    servingSkills = Object.keys(serveCtx.rtermSkills)
+    return servingSkills
+  }
+
+  /** Default skills RTerm serves when auto-starting (status + discover + dispatch). */
+  function defaultServeSkills() {
+    return {
+      status: async () => ({ up: true, agent: cfg.agentId, ts: new Date().toISOString() }),
+      discover: async (inp) => ({ agents: await discoverAgents(ctx, inp ?? {}) }),
+      ...(ctx.rtermSkills ?? {}),
+    }
+  }
 
   registerTool({
     name: 'synapse_serve',
-    description: 'Start RTerm as a full Synapse agent: listen on mesh.agent.{id}.inbox and respond() to incoming Synapse requests by mapping them to RTerm skills (playbooks/tools via ctx.rtermSkills / getRtermSkills). Bidirectional federation — other agents can now task RTerm.',
+    description: 'Start RTerm as a full Synapse agent: listen on mesh.agent.{id}.inbox and respond() to incoming Synapse requests by mapping them to RTerm skills (playbooks/tools via ctx.rtermSkills / getRtermSkills). Bidirectional federation — other agents can now task RTerm. Idempotent; auto-starts on boot when synapse.enabled and autoServe are true.',
     params: {
-      skills: { type: 'object', description: 'Map of skillId -> async (input, ctx) => output, the skills RTerm serves', optional: true },
+      skills: { type: 'object', description: 'Map of skillId -> async (input, ctx) => output, the skills RTerm serves (defaults to status+discover)', optional: true },
     },
     handler: async (p) => guarded(async () => {
+      const skills = await serveSkills(p?.skills ?? defaultServeSkills())
+      return { serving: true, inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills, note: 'RTerm is now a full Synapse agent (responder live)' }
+    }, log),
+  })
+
+  registerTool({
+    name: 'synapse_serve_status',
+    description: 'Report whether the Synapse responder is live (serving on mesh.agent.{id}.inbox) and which skills it serves.',
+    params: {},
+    handler: async () => guarded(async () => {
       const nc = await connectMesh(ctx)
-      const serveCtx = { ...ctx, rtermSkills: p?.skills ?? ctx.rtermSkills ?? {} }
-      if (responderStop) responderStop() // idempotent: restart with fresh skills
-      responderStop = await startResponder(nc, cfg, serveCtx, log)
-      const skillIds = Object.keys(serveCtx.rtermSkills)
-      return { serving: true, inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills: skillIds, note: 'RTerm is now a full Synapse agent (responder live)' }
+      return { serving: responderStop !== null, connected: !nc.isClosed(), inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills: servingSkills, autoServe: cfg.autoServe }
     }, log),
   })
 
@@ -382,7 +410,16 @@ export function register(ctx) {
     },
   })
 
-  log(`[synapse] synapse-bridge registered: 11 tools, 1 trigger, 1 panel (agent=${cfg.agentId}, prefix=${cfg.prefix}, full-duplex)`)
+  log(`[synapse] synapse-bridge registered: 12 tools, 1 trigger, 1 panel (agent=${cfg.agentId}, prefix=${cfg.prefix}, full-duplex)`)
+
+  // ─── auto-start the full-duplex responder on boot (when enabled + autoServe) ───
+  // Makes "be tasked by them" always-on, not opt-in per session. Best-effort: a
+  // failed auto-start logs but never blocks plugin registration (server may be down).
+  if (cfg.enabled && cfg.autoServe) {
+    serveSkills(defaultServeSkills())
+      .then((skills) => log(`[synapse] auto-started responder on ${cfg.prefix}.agent.${cfg.agentId}.inbox (skills: ${skills.join(', ')})`))
+      .catch((e) => log(`[synapse] auto-serve deferred: ${e?.message ?? e} (responder will start on first synapse_serve call)`))
+  }
 }
 
 export default { register, resolveConfig, envelope, discoverAgents, dispatchTask, registerSelf }

package/plugins/synapse-bridge/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "synapse-bridge",
   "version": "1.0.0",
-  "description": "Synapse mesh bridge for RTerm — full-duplex Synapse agent: discover live agents, dispatch tasks, register RTerm as a mesh agent, AND serve as one (respond to inbound requests), emit/subscribe mesh events, EXT-REPUTATION scoring, and EXT-GOVERNANCE approvals. Speaks the Synapse protocol (v0.3.0) over a shared NATS server using the v3.1.2 auth/request-reply/JetStream transport. Config in Settings (synapse block); secrets via the vault.",
+  "description": "Synapse mesh bridge for RTerm — full-duplex Synapse agent (auto-started on boot): discover live agents, dispatch tasks, register RTerm as a mesh agent, AND serve as one (respond to inbound requests, auto-started), emit/subscribe mesh events, EXT-REPUTATION scoring, and EXT-GOVERNANCE approvals. Speaks the Synapse protocol (v0.3.0) over a shared NATS server using the v3.1.2 auth/request-reply/JetStream transport. Config in Settings (synapse block); secrets via the vault.",
   "entry": "index.mjs",
   "tools": [
     "synapse_health",
@@ -10,6 +10,7 @@
     "synapse_register",
     "synapse_agents_summary",
     "synapse_serve",
+    "synapse_serve_status",
     "synapse_emit",
     "synapse_subscribe",
     "synapse_reputation",

package/plugins/synapse-bridge/synapse-bridge.extreme.spec.mjs

@@ -9,9 +9,28 @@ function eq(a, b, m) { if (a !== b) throw new Error(`${m ?? 'eq'}: expected ${JS
 function fakeConn() {
   const published = []
   const requests = new Map()
+  const subs = new Map()
   return {
     isClosed: () => false,
     publish(subject, data) { published.push({ subject, data: JSON.parse(new TextDecoder().decode(data)) }) },
+    subscribe(subject) {
+      const sub = {
+        async *[Symbol.asyncIterator]() {
+          while (true) {
+            const m = await new Promise((res) => {
+              const l = subs.get(subject) ?? []; subs.set(subject, l); l.push(res)
+            })
+            yield m
+          }
+        },
+        unsubscribe: () => subs.delete(subject),
+      }
+      return sub
+    },
+    _deliver(subject, env) {
+      const data = new TextEncoder().encode(JSON.stringify(env))
+      for (const fn of subs.get(subject) ?? []) fn({ data, subject, respond: (p) => { published.push({ subject: '_reply', env: JSON.parse(new TextDecoder().decode(p)) }) } })
+    },
     async request(subject, data, _opts) {
       const h = requests.get(subject)
       const reply = h ? h(JSON.parse(new TextDecoder().decode(data))) : { ok: true }
@@ -69,12 +88,12 @@ test('envelope has Synapse v0.3.0 shape', () => {
 
 // ─── register wiring ────────────────────────────────────────────────────────
 
-test('register wires 11 tools, 1 trigger, 1 panel (full-duplex)', () => {
+test('register wires 12 tools, 1 trigger, 1 panel (full-duplex)', () => {
   const conn = fakeConn()
   const { tools, triggers, panels, ctx } = mkCtx({}, conn)
   register(ctx)
-  eq(tools.size, 11, 'tool count')
-  for (const n of ['synapse_health', 'synapse_discover', 'synapse_dispatch', 'synapse_register', 'synapse_agents_summary', 'synapse_serve', 'synapse_emit', 'synapse_subscribe', 'synapse_reputation', 'synapse_request_approval', 'synapse_approve']) assert(tools.has(n), `missing ${n}`)
+  eq(tools.size, 12, 'tool count')
+  for (const n of ['synapse_health', 'synapse_discover', 'synapse_dispatch', 'synapse_register', 'synapse_agents_summary', 'synapse_serve', 'synapse_serve_status', 'synapse_emit', 'synapse_subscribe', 'synapse_reputation', 'synapse_request_approval', 'synapse_approve']) assert(tools.has(n), `missing ${n}`)
   eq(triggers.length, 1, 'trigger count')
   eq(triggers[0].name, 'synapse_mesh_event', 'trigger name')
   eq(panels.length, 1, 'panel count')
@@ -83,6 +102,7 @@ test('register wires 11 tools, 1 trigger, 1 panel (full-duplex)', () => {
 // ─── discover ───────────────────────────────────────────────────────────────
 
 test('synapse_discover returns agents from registry', async () => {
+  __setConnForTest(null)
   const conn = fakeConn()
   conn._on('mesh.registry.discover', () => [
     { id: 'grip-cli-001', name: 'Grip CLI', skills: [{ id: 'himalaya' }] },
@@ -206,6 +226,50 @@ test('a failed connect is not cached — the next call retries', async () => {
   if (attempts !== 2) throw new Error(`expected 2 attempts (fail + retry), got ${attempts}`)
 })
 
+// ─── auto-start responder on boot (serveSkills + autoServe) ─────────────────
+
+test('autoServe: register() auto-starts the responder when enabled+autoServe (default skills)', async () => {
+  __setConnForTest(null)
+  const conn = fakeConn()
+  conn._on('mesh.registry.discover', () => [])
+  const { tools, logs, ctx } = mkCtx({}, conn)
+  register(ctx)
+  // auto-start is async (serveSkills → connectMesh → startResponder) — wait for it to settle
+  await new Promise((r) => setTimeout(r, 100))
+  const r = await tools.get('synapse_serve_status').handler({})
+  eq(r.serving, true, 'responder auto-started (serving=true)')
+  assert(r.skills.includes('status'), 'default skills include status')
+  assert(r.skills.includes('discover'), 'default skills include discover')
+  eq(r.autoServe, true, 'autoServe true by default')
+})
+
+test('autoServe: disabled when synapse.autoServe=false (no auto-start)', async () => {
+  __setConnForTest(null)
+  const conn = fakeConn()
+  const { tools, ctx } = mkCtx({ autoServe: false }, conn)
+  register(ctx)
+  await new Promise((r) => setTimeout(r, 20))
+  const r = await tools.get('synapse_serve_status').handler({})
+  eq(r.serving, false, 'responder NOT auto-started when autoServe=false')
+})
+
+test('autoServe: a failed auto-start does not break register (best-effort)', async () => {
+  __setConnForTest(null)
+  let failConnect = true
+  const conn = fakeConn()
+  const ctx = {
+    settings: { synapse: { url: 'nats://down:4222' } },
+    natsConnect: async () => { if (failConnect) throw new Error('server down'); return conn },
+    registerTool: () => {}, registerTrigger: () => {}, registerPanel: () => {}, log: () => {},
+  }
+  // register() must not throw even though the auto-start connection fails
+  const { register } = await import('./index.mjs')
+  let threw = false
+  try { register(ctx) } catch { threw = true }
+  assert(!threw, 'register() must not throw on auto-serve connection failure')
+  await new Promise((r) => setTimeout(r, 20)) // let the auto-start promise reject (handled)
+})
+
 // ─── runner ─────────────────────────────────────────────────────────────────
 async function main() {
   let pass = 0, fail = 0