ATOCore/openclaw-plugins/atocore-capture/index.js

import { definePluginEntry } from "openclaw/plugin-sdk/core";

const DEFAULT_BASE_URL = process.env.ATOCORE_BASE_URL || "http://dalidou:8100";
const DEFAULT_MIN_PROMPT_LENGTH = 15;
const DEFAULT_MAX_RESPONSE_LENGTH = 50_000;
// Phase 7I — context injection: cap how much AtoCore context we stuff
// back into the prompt. The /context/build endpoint respects a budget
// parameter too, but we keep a client-side safety net.
const DEFAULT_CONTEXT_CHAR_BUDGET = 4_000;
const DEFAULT_INJECT_CONTEXT = true;

function trimText(value) {
  return typeof value === "string" ? value.trim() : "";
}

function truncateResponse(text, maxLength) {
  if (!text || text.length <= maxLength) return text;
  return `${text.slice(0, maxLength)}\n\n[truncated]`;
}

function shouldCapturePrompt(prompt, minLength) {
  const text = trimText(prompt);
  if (!text) return false;
  if (text.startsWith("<")) return false;
  return text.length >= minLength;
}

async function postInteraction(baseUrl, payload, logger) {
  try {
    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/interactions`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(payload),
      signal: AbortSignal.timeout(10_000)
    });
    if (!res.ok) {
      logger?.debug?.("atocore_capture_post_failed", { status: res.status });
      return false;
    }
    return true;
  } catch (error) {
    logger?.debug?.("atocore_capture_post_error", {
      error: error instanceof Error ? error.message : String(error)
    });
    return false;
  }
}

// Phase 7I — fetch a context pack for the incoming prompt so the agent
// answers grounded in what AtoCore already knows. Fail-open: if the
// request times out or errors, we just don't inject; the agent runs as
// before. Never block the user's turn on AtoCore availability.
async function fetchContextPack(baseUrl, prompt, project, charBudget, logger) {
  try {
    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/context/build`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        prompt,
        project: project || "",
        char_budget: charBudget
      }),
      signal: AbortSignal.timeout(5_000)
    });
    if (!res.ok) {
      logger?.debug?.("atocore_context_fetch_failed", { status: res.status });
      return null;
    }
    const data = await res.json();
    const pack = trimText(data?.formatted_context || "");
    return pack || null;
  } catch (error) {
    logger?.debug?.("atocore_context_fetch_error", {
      error: error instanceof Error ? error.message : String(error)
    });
    return null;
  }
}

export default definePluginEntry({
  register(api) {
    const logger = api.logger;
    const pendingBySession = new Map();

    api.on("before_agent_start", async (event, ctx) => {
      if (ctx?.trigger && ctx.trigger !== "user") return;
      const config = api.getConfig?.() || {};
      const minPromptLength = Number(config.minPromptLength || DEFAULT_MIN_PROMPT_LENGTH);
      const prompt = trimText(event?.prompt || "");
      if (!shouldCapturePrompt(prompt, minPromptLength)) {
        pendingBySession.delete(ctx.sessionId);
        return;
      }

      // Phase 7I — inject AtoCore context into the agent's prompt so it
      // answers grounded in what the brain already knows. Config-gated
      // (injectContext: false disables). Fail-open.
      const baseUrl = trimText(config.baseUrl) || DEFAULT_BASE_URL;
      const injectContext = config.injectContext !== false && DEFAULT_INJECT_CONTEXT;
      const charBudget = Number(config.contextCharBudget || DEFAULT_CONTEXT_CHAR_BUDGET);
      if (injectContext && event && typeof event === "object") {
        const pack = await fetchContextPack(baseUrl, prompt, "", charBudget, logger);
        if (pack) {
          // Prepend to the event's prompt so the agent sees grounded info
          // before the user's question. OpenClaw's agent receives
          // event.prompt as its primary input; modifying it here grounds
          // whatever LLM the agent delegates to (sonnet, opus, codex,
          // local model — doesn't matter).
          event.prompt = `${pack}\n\n---\n\n${prompt}`;
          logger?.debug?.("atocore_context_injected", { chars: pack.length });
        }
      }

      // Record the ORIGINAL user prompt (not the injected version) so
      // captured interactions stay clean for later extraction.
      pendingBySession.set(ctx.sessionId, {
        prompt,
        sessionId: ctx.sessionId,
        sessionKey: ctx.sessionKey || "",
        project: ""
      });
    });

    api.on("llm_output", async (event, ctx) => {
      if (ctx?.trigger && ctx.trigger !== "user") return;
      const pending = pendingBySession.get(ctx.sessionId);
      if (!pending) return;

      const assistantTexts = Array.isArray(event?.assistantTexts) ? event.assistantTexts : [];
      const response = truncateResponse(trimText(assistantTexts.join("\n\n")), Number((api.getConfig?.() || {}).maxResponseLength || DEFAULT_MAX_RESPONSE_LENGTH));
      if (!response) return;

      const config = api.getConfig?.() || {};
      const baseUrl = trimText(config.baseUrl) || DEFAULT_BASE_URL;
      const payload = {
        prompt: pending.prompt,
        response,
        client: "openclaw",
        session_id: pending.sessionKey || pending.sessionId,
        project: pending.project || "",
        reinforce: true
      };

      await postInteraction(baseUrl, payload, logger);
      pendingBySession.delete(ctx.sessionId);
    });

    api.on("session_end", async (event) => {
      if (event?.sessionId) pendingBySession.delete(event.sessionId);
    });
  }
});