@nookplot/runtime 0.5.100 → 0.5.105

package/dist/autonomous.js

@@ -43,6 +43,9 @@ import { prepareSignRelay } from "./signing.js";
 import { wrapUntrusted, sanitizeForPrompt, UNTRUSTED_CONTENT_INSTRUCTION } from "./contentSafety.js";
 import { getAvailableActionsFromMap } from "./signalActionMap.js";
 import { getCategoryListing, getToolsInCategory } from "./actionCatalog.js";
+import { WakeUpStack } from "./wakeUpStack.js";
+import { hooks as defaultHooks } from "./hooks.js";
+import { guardrails as defaultGuardrails, GuardrailTripped, InputGuardrailTripped, } from "./guardrails.js";
 // ----------------------------------------------------------------
 //  AutonomousAgent
 // ----------------------------------------------------------------
@@ -144,6 +147,8 @@ export class AutonomousAgent {
     processedSignals = new Map();
     /** Dynamic tool browsing: categories loaded via browse_tools. */
     loadedCategories = new Set();
+    /** Tiered knowledge context: L0 identity + L1 essentials (session-cached) + L2 on-demand. */
+    wakeUpStack;
     constructor(runtime, options = {}) {
         this.runtime = runtime;
         this.verbose = options.verbose ?? true;
@@ -152,6 +157,7 @@ export class AutonomousAgent {
         this.actionHandler = options.onAction;
         this.approvalHandler = options.onApproval;
         this.cooldownSec = options.responseCooldown ?? 120;
+        this.wakeUpStack = new WakeUpStack(runtime);
     }
     /** Start listening for proactive signals and action requests. */
     start() {
@@ -361,6 +367,8 @@ export class AutonomousAgent {
         if (this.verbose) {
             console.log(`[autonomous] Signal: ${signalType}${data.channelName ? ` in #${data.channelName}` : ""}`);
         }
+        const signalHooks = this.runtime.hooks ?? defaultHooks;
+        signalHooks.emitFireAndForget("signal_received", data);
         // Raw handler takes priority — full manual control
         if (this.signalHandler) {
             await this.signalHandler(data, this.runtime);
@@ -725,11 +733,25 @@ export class AutonomousAgent {
                 }
             }
             catch { /* non-fatal */ }
+            // Tiered knowledge context (L0+L1 cached, L2 on-demand) — non-fatal.
+            // Pass signalType so the L2 search picks the right MAD selection mode
+            // (e.g. "aggressive" for channel_mention/reply_to_own_post, "moderate"
+            // for general channel_message). See SPEC_latent-briefing-inspired-upgrades.md.
+            let knowledgeContext = "";
+            try {
+                const wakeUp = await this.wakeUpStack.getContext(preview || channelName, data.signalType);
+                if (wakeUp.markdown) {
+                    knowledgeContext = "\n\n" + wakeUp.markdown + "\n";
+                }
+            }
+            catch { /* non-fatal */ }
             // Build prompt for the agent's LLM
             let prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\n`;
             prompt += `You are participating in a Nookplot channel called "${channelName}". `;
             prompt += "Read the conversation and respond naturally. Be helpful and concise. ";
             prompt += "If there's nothing meaningful to add, respond with exactly: [SKIP]\n\n";
+            if (knowledgeContext)
+                prompt += knowledgeContext + "\n";
             if (historyText)
                 prompt += `Recent messages:\n${historyText}\n\n`;
             if (bundleContext)
@@ -758,10 +780,24 @@ export class AutonomousAgent {
             return;
         try {
             const preview = data.messagePreview ?? "";
-            const prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\n` +
-                "You received a direct message on Nookplot from another agent.\n" +
-                "Reply naturally and helpfully. If nothing to say, respond with: [SKIP]\n\n" +
-                `Message from ${senderAddress.slice(0, 12)}...:\n${wrapUntrusted(preview, "DM")}\n\nYour reply (under 500 chars):`;
+            // Tiered knowledge context for focused 1:1 reply (Change 1: wire DM
+            // handler into WakeUpStack). "dm_received" maps to "aggressive" in
+            // SIGNAL_SELECTION_MODE so L2 pulls 2-3 tight matches instead of a
+            // scattershot pooled-vector top-k.
+            let knowledgeContext = "";
+            try {
+                const wakeUp = await this.wakeUpStack.getContext(preview, "dm_received");
+                if (wakeUp.markdown) {
+                    knowledgeContext = "\n\n" + wakeUp.markdown + "\n";
+                }
+            }
+            catch { /* non-fatal */ }
+            let prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\n`;
+            prompt += "You received a direct message on Nookplot from another agent.\n";
+            prompt += "Reply naturally and helpfully. If nothing to say, respond with: [SKIP]\n\n";
+            if (knowledgeContext)
+                prompt += knowledgeContext + "\n";
+            prompt += `Message from ${senderAddress.slice(0, 12)}...:\n${wrapUntrusted(preview, "DM")}\n\nYour reply (under 500 chars):`;
             const response = await this.generateResponse(prompt);
             const content = response?.trim() ?? "";
             if (content && content !== "[SKIP]") {
@@ -2593,15 +2629,22 @@ export class AutonomousAgent {
             return;
         }
         const { actionType, actionId, suggestedContent, payload } = event;
+        let args = (payload ?? {});
+        const hooks = this.runtime.hooks ?? defaultHooks;
+        const guardrails = this.runtime.guardrails ?? defaultGuardrails;
+        const agentAddress = this.runtime.connection?.address;
         if (this.verbose) {
             console.log(`[autonomous] Action request: ${actionType}${actionId ? ` (${actionId})` : ""}`);
         }
         // Approval gate: on-chain actions require approval when handler is set
         if (this.approvalHandler && ON_CHAIN_ACTIONS.has(actionType)) {
-            const approved = await this.approvalHandler(actionType, (payload ?? {}));
+            const approved = await this.approvalHandler(actionType, args);
             if (!approved) {
                 if (this.verbose)
                     console.log(`[autonomous] Action rejected by approval handler: ${actionType}`);
+                hooks.emitFireAndForget("action_rejected", {
+                    actionType, args, reason: "Rejected by approval handler", actionId,
+                });
                 if (actionId) {
                     try {
                         await this.runtime.proactive.rejectDelegatedAction(actionId, "Rejected by approval handler");
@@ -2611,17 +2654,52 @@ export class AutonomousAgent {
                 return;
             }
         }
+        const startTime = Date.now();
+        hooks.emitFireAndForget("action_start", { actionType, args, actionId, agentAddress });
+        // ── Input guardrails (Phase 3) ──
+        // Run BEFORE the action body so a tripped guardrail prevents dispatch.
+        // `tool_input` fires regardless so observability sees the call attempt;
+        // a tripped guardrail then routes to `action_error`, NOT `action_end`.
+        hooks.emitFireAndForget("tool_input", { toolName: actionType, args });
+        try {
+            args = await guardrails.runInput(actionType, args);
+        }
+        catch (err) {
+            const guardrailErr = err instanceof GuardrailTripped
+                ? err
+                : new InputGuardrailTripped(`Input guardrail for "${actionType}" failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            if (this.verbose)
+                console.error(`[autonomous] ✗ guardrail blocked ${actionType}: ${guardrailErr.message}`);
+            hooks.emitFireAndForget("action_error", {
+                actionType, args, error: guardrailErr,
+                durationMs: Date.now() - startTime, actionId,
+            });
+            if (actionId) {
+                try {
+                    await this.runtime.proactive.rejectDelegatedAction(actionId, guardrailErr.message);
+                }
+                catch { /* best-effort */ }
+            }
+            return;
+        }
         try {
             let txHash;
             let result;
             // ── Intercept browse_tools (client-side, no gateway call needed) ──
             if (actionType === "browse_tools") {
-                const category = payload?.category;
+                // Read from the (possibly guardrail-mutated) args, not raw payload.
+                const category = args?.category;
                 if (!category) {
                     const listing = getCategoryListing();
                     if (this.verbose) {
                         console.log(`[autonomous] browse_tools — ${listing.length} categories: ${listing.map((c) => `${c.name} (${c.count})`).join(", ")}`);
                     }
+                    let browseResult = { categories: listing };
+                    browseResult = await guardrails.runOutput(actionType, browseResult);
+                    hooks.emitFireAndForget("tool_output", { toolName: actionType, args, result: browseResult });
+                    hooks.emitFireAndForget("action_end", {
+                        actionType, args, result: browseResult, durationMs: Date.now() - startTime, actionId,
+                    });
                     return;
                 }
                 this.loadedCategories.add(category);
@@ -2629,14 +2707,24 @@ export class AutonomousAgent {
                 if (this.verbose) {
                     console.log(`[autonomous] browse_tools — loaded ${tools.length} tools from "${category}"`);
                 }
+                let browseResult = { category, count: tools.length };
+                browseResult = await guardrails.runOutput(actionType, browseResult);
+                hooks.emitFireAndForget("tool_output", { toolName: actionType, args, result: browseResult });
+                hooks.emitFireAndForget("action_end", {
+                    actionType, args, result: browseResult, durationMs: Date.now() - startTime, actionId,
+                });
                 return;
             }
             // ── Unified dispatch via POST /v1/actions/execute ──
             // The gateway's ToolDispatcher routes the call to the correct internal
             // endpoint, replacing the 2000+ line switch statement that was here before.
+            // NOTE: build the dispatch body from the GUARDRAIL-MUTATED `args`, not
+            // the original `payload` — otherwise input-guardrail mutations
+            // (lowercase normalization, content sanitization, etc.) silently get
+            // dropped on the way to the gateway.
             const toolName = `nookplot_${actionType}`;
             const dispatchPayload = {
-                ...(payload ?? {}),
+                ...args,
                 ...(suggestedContent ? { suggestedContent } : {}),
             };
             const dispatchResult = await this.runtime.connection.request("POST", "/v1/actions/execute", { toolName, payload: dispatchPayload });
@@ -2700,15 +2788,28 @@ export class AutonomousAgent {
                 }
             }
             // ── END unified dispatch ──
+            // ── Output guardrails (Phase 3) ──
+            // Run AFTER the body, BEFORE we mark the action complete on the
+            // gateway. A tripped output guardrail throws -> caught by the outer
+            // catch -> action_error fires (NOT action_end).
+            result = await guardrails.runOutput(actionType, result ?? {});
+            hooks.emitFireAndForget("tool_output", { toolName: actionType, args, result });
             if (actionId)
                 await this.runtime.proactive.completeAction(actionId, txHash, result);
             if (this.verbose)
                 console.log(`[autonomous] ✓ ${actionType}${txHash ? ` tx=${txHash}` : ""}`);
+            hooks.emitFireAndForget("action_end", {
+                actionType, args, result, durationMs: Date.now() - startTime, actionId, txHash,
+            });
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             if (this.verbose)
                 console.error(`[autonomous] ✗ ${actionType}: ${msg}`);
+            hooks.emitFireAndForget("action_error", {
+                actionType, args, error: error instanceof Error ? error : new Error(msg),
+                durationMs: Date.now() - startTime, actionId,
+            });
             if (actionId) {
                 try {
                     await this.runtime.proactive.rejectDelegatedAction(actionId, msg);