@sonzai-labs/openclaw-context 1.0.3

package/dist/index.cjs

@@ -0,0 +1,670 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var agents = require('@sonzai-labs/agents');
+require('readline');
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/plugin.ts
+
+// src/config.ts
+var DEFAULTS = {
+  baseUrl: "https://api.sonz.ai",
+  agentName: "openclaw-agent",
+  defaultUserId: "owner",
+  contextTokenBudget: 2e3
+};
+function resolveConfig(raw) {
+  const apiKey = raw?.apiKey || env("SONZAI_API_KEY") || env("SONZAI_OPENCLAW_API_KEY");
+  if (!apiKey) {
+    throw new Error(
+      "[@sonzai-labs/openclaw-context] Missing API key. Set apiKey in plugin config or SONZAI_API_KEY environment variable."
+    );
+  }
+  return {
+    apiKey,
+    agentId: raw?.agentId || env("SONZAI_AGENT_ID") || void 0,
+    baseUrl: raw?.baseUrl || env("SONZAI_BASE_URL") || DEFAULTS.baseUrl,
+    agentName: raw?.agentName || env("SONZAI_AGENT_NAME") || DEFAULTS.agentName,
+    defaultUserId: raw?.defaultUserId || DEFAULTS.defaultUserId,
+    contextTokenBudget: raw?.contextTokenBudget ?? DEFAULTS.contextTokenBudget,
+    disable: raw?.disable ?? {},
+    extractionProvider: raw?.extractionProvider || env("SONZAI_EXTRACTION_PROVIDER") || void 0,
+    extractionModel: raw?.extractionModel || env("SONZAI_EXTRACTION_MODEL") || void 0
+  };
+}
+function env(key) {
+  try {
+    return typeof process !== "undefined" ? process.env[key] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cache.ts
+var SessionCache = class {
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    this.store.set(key, {
+      value,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/context-builder.ts
+var SECTION_ORDER = [
+  "habits",
+  "interests",
+  "goals",
+  "relationships",
+  "mood",
+  "memories",
+  "personality"
+];
+var formatters = {
+  personality: formatPersonality,
+  mood: formatMood,
+  relationships: formatRelationships,
+  memories: formatMemories,
+  goals: formatGoals,
+  interests: formatInterests,
+  habits: formatHabits
+};
+function buildSystemPromptAddition(sources, tokenBudget) {
+  const sections = [];
+  for (const key of [...SECTION_ORDER].reverse()) {
+    const data = sources[key];
+    if (!data) continue;
+    const text = formatters[key](data);
+    if (text) sections.push({ key, text });
+  }
+  if (sections.length === 0) return "";
+  let result = "<sonzai-context>\n" + sections.map((s) => s.text).join("\n\n") + "\n</sonzai-context>";
+  while (estimateTokens(result) > tokenBudget && sections.length > 1) {
+    const dropKey = SECTION_ORDER.find(
+      (k) => sections.some((s) => s.key === k)
+    );
+    if (!dropKey) break;
+    const idx = sections.findIndex((s) => s.key === dropKey);
+    if (idx === -1) break;
+    sections.splice(idx, 1);
+    result = "<sonzai-context>\n" + sections.map((s) => s.text).join("\n\n") + "\n</sonzai-context>";
+  }
+  if (estimateTokens(result) > tokenBudget) {
+    const maxChars = tokenBudget * 4;
+    result = result.slice(0, maxChars) + "\n[...truncated]\n</sonzai-context>";
+  }
+  return result;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function formatPersonality(data) {
+  const resp = data;
+  const p = resp?.profile;
+  if (!p) return null;
+  const lines = ["## Personality"];
+  lines.push(`Name: ${p.name}`);
+  if (p.bio) lines.push(`Bio: ${p.bio}`);
+  if (p.primary_traits?.length) lines.push(`Traits: ${p.primary_traits.join(", ")}`);
+  if (p.speech_patterns?.length) lines.push(`Speech patterns: ${p.speech_patterns.join(", ")}`);
+  if (p.personality_prompt) lines.push(`Character: ${p.personality_prompt}`);
+  if (p.big5) {
+    const b5 = p.big5;
+    const traits = [
+      `O:${b5.openness?.score ?? "?"}`,
+      `C:${b5.conscientiousness?.score ?? "?"}`,
+      `E:${b5.extraversion?.score ?? "?"}`,
+      `A:${b5.agreeableness?.score ?? "?"}`,
+      `N:${b5.neuroticism?.score ?? "?"}`
+    ];
+    lines.push(`Big5: ${traits.join(" ")}`);
+  }
+  if (p.preferences) {
+    const pref = p.preferences;
+    lines.push(
+      `Style: pace=${pref.pace}, formality=${pref.formality}, humor=${pref.humor_style}, expression=${pref.emotional_expression}`
+    );
+  }
+  const evo = resp?.evolution;
+  if (evo?.length) {
+    lines.push("Recent shifts:");
+    for (const d of evo.slice(0, 3)) {
+      lines.push(`- ${d.change} (${d.reason})`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatMood(data) {
+  const mood = data;
+  if (!mood || Object.keys(mood).length === 0) return null;
+  const lines = ["## Current Mood"];
+  for (const [key, value] of Object.entries(mood)) {
+    if (key.startsWith("_") || value === null || value === void 0) continue;
+    if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : null;
+}
+function formatRelationships(data) {
+  const rels = data;
+  if (!rels || Object.keys(rels).length === 0) return null;
+  const lines = ["## Relationship"];
+  for (const [key, value] of Object.entries(rels)) {
+    if (key.startsWith("_") || value === null || value === void 0) continue;
+    if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : null;
+}
+function formatMemories(data) {
+  const resp = data;
+  if (!resp?.results?.length) return null;
+  const lines = ["## Relevant Memories"];
+  for (const mem of resp.results.slice(0, 10)) {
+    const score = mem.score ? ` (score: ${mem.score.toFixed(2)})` : "";
+    lines.push(`- ${mem.content}${score}`);
+  }
+  return lines.join("\n");
+}
+function formatGoals(data) {
+  const resp = data;
+  if (!resp?.goals?.length) return null;
+  const lines = ["## Goals"];
+  for (const g of resp.goals.filter((g2) => g2.status === "active").slice(0, 5)) {
+    lines.push(`- ${g.title}: ${g.description} [${g.type}, priority=${g.priority}]`);
+  }
+  return lines.length > 1 ? lines.join("\n") : null;
+}
+function formatInterests(data) {
+  const interests = data;
+  if (!interests || Object.keys(interests).length === 0) return null;
+  const lines = ["## Interests"];
+  for (const [key, value] of Object.entries(interests)) {
+    if (key.startsWith("_") || value === null || value === void 0) continue;
+    if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : null;
+}
+function formatHabits(data) {
+  const habits = data;
+  if (!habits || Object.keys(habits).length === 0) return null;
+  const lines = ["## Habits"];
+  for (const [key, value] of Object.entries(habits)) {
+    if (key.startsWith("_") || value === null || value === void 0) continue;
+    if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : null;
+}
+function buildSystemPromptFromContext(ctx, tokenBudget, disable = {}) {
+  const sections = [];
+  if (!disable.personality && ctx.personality_prompt) {
+    const lines = ["## Personality"];
+    lines.push(`Character: ${ctx.personality_prompt}`);
+    if (ctx.primary_traits?.length) lines.push(`Traits: ${ctx.primary_traits.join(", ")}`);
+    if (ctx.speech_patterns?.length) lines.push(`Speech patterns: ${ctx.speech_patterns.join(", ")}`);
+    if (ctx.big5) {
+      const b5 = ctx.big5;
+      const traits = ["openness", "conscientiousness", "extraversion", "agreeableness", "neuroticism"].map((t) => `${t[0].toUpperCase()}:${b5[t]?.score ?? "?"}`).join(" ");
+      lines.push(`Big5: ${traits}`);
+    }
+    sections.push({ key: "personality", text: lines.join("\n"), priority: 7 });
+  }
+  if (!disable.memory) {
+    const facts = ctx.loaded_facts;
+    if (facts?.length) {
+      const lines = ["## Relevant Memories"];
+      for (const f of facts.slice(0, 10)) {
+        const text = f.atomic_text || f.content || JSON.stringify(f);
+        lines.push(`- ${text}`);
+      }
+      sections.push({ key: "memories", text: lines.join("\n"), priority: 6 });
+    }
+  }
+  if (!disable.mood && ctx.current_mood) {
+    const mood = ctx.current_mood;
+    const lines = ["## Current Mood"];
+    for (const [key, value] of Object.entries(mood)) {
+      if (key.startsWith("_") || value === null || value === void 0) continue;
+      lines.push(`${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`);
+    }
+    if (lines.length > 1) sections.push({ key: "mood", text: lines.join("\n"), priority: 5 });
+  }
+  if (!disable.relationships && ctx.relationship_narrative) {
+    const lines = ["## Relationship"];
+    lines.push(ctx.relationship_narrative);
+    if (ctx.love_from_agent !== void 0) lines.push(`Love (agent->user): ${ctx.love_from_agent}`);
+    if (ctx.love_from_user !== void 0) lines.push(`Love (user->agent): ${ctx.love_from_user}`);
+    if (ctx.relationship_status) lines.push(`Status: ${ctx.relationship_status}`);
+    sections.push({ key: "relationships", text: lines.join("\n"), priority: 4 });
+  }
+  if (!disable.goals) {
+    const goals = ctx.active_goals;
+    if (goals?.length) {
+      const lines = ["## Goals"];
+      for (const g of goals.slice(0, 5)) {
+        lines.push(`- ${g.title}: ${g.description} [${g.type}]`);
+      }
+      sections.push({ key: "goals", text: lines.join("\n"), priority: 3 });
+    }
+  }
+  if (!disable.interests && ctx.true_interests?.length) {
+    sections.push({ key: "interests", text: `## Interests
+${ctx.true_interests.join(", ")}`, priority: 2 });
+  }
+  if (!disable.habits) {
+    const ctxHabits = ctx.habits;
+    if (ctxHabits?.length) {
+      const lines = ["## Habits"];
+      for (const h of ctxHabits.slice(0, 5)) {
+        lines.push(`- ${h.name}: ${h.description || h.category || ""}`);
+      }
+      sections.push({ key: "habits", text: lines.join("\n"), priority: 1 });
+    }
+  }
+  if (sections.length === 0) return "";
+  sections.sort((a, b) => b.priority - a.priority);
+  let result = "<sonzai-context>\n" + sections.map((s) => s.text).join("\n\n") + "\n</sonzai-context>";
+  while (estimateTokens(result) > tokenBudget && sections.length > 1) {
+    sections.pop();
+    result = "<sonzai-context>\n" + sections.map((s) => s.text).join("\n\n") + "\n</sonzai-context>";
+  }
+  if (estimateTokens(result) > tokenBudget) {
+    const maxChars = tokenBudget * 4;
+    result = result.slice(0, maxChars) + "\n[...truncated]\n</sonzai-context>";
+  }
+  return result;
+}
+
+// src/session-key.ts
+function parseSessionKey(sessionId, defaultUserId) {
+  const parts = sessionId.split(":");
+  if (parts[0] === "agent" && parts.length >= 3) {
+    const agentId = parts[1] ?? null;
+    const directIdx = parts.indexOf("direct");
+    if (directIdx !== -1 && directIdx + 1 < parts.length) {
+      const channel = directIdx >= 3 ? parts[2] : null;
+      const peerId = parts.slice(directIdx + 1).join(":");
+      return {
+        agentId,
+        userId: peerId,
+        channel,
+        sessionType: "dm"
+      };
+    }
+    const groupIdx = parts.indexOf("group");
+    if (groupIdx !== -1 && groupIdx + 1 < parts.length) {
+      const channel = groupIdx >= 3 ? parts[2] : null;
+      const groupId = parts.slice(groupIdx + 1).join(":");
+      return {
+        agentId,
+        userId: groupId,
+        channel,
+        sessionType: "group"
+      };
+    }
+    return {
+      agentId,
+      userId: defaultUserId,
+      channel: null,
+      sessionType: "cli"
+    };
+  }
+  if (parts[0] === "cron") {
+    return {
+      agentId: null,
+      userId: defaultUserId,
+      channel: null,
+      sessionType: "cron"
+    };
+  }
+  if (parts[0] === "hook") {
+    return {
+      agentId: null,
+      userId: defaultUserId,
+      channel: null,
+      sessionType: "webhook"
+    };
+  }
+  return {
+    agentId: null,
+    userId: defaultUserId,
+    channel: null,
+    sessionType: "unknown"
+  };
+}
+
+// src/engine.ts
+var AGENT_CACHE_TTL = 30 * 60 * 1e3;
+var SonzaiContextEngine = class {
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  info = {
+    id: "sonzai",
+    name: "Sonzai Mind Layer",
+    ownsCompaction: true
+  };
+  sessions = /* @__PURE__ */ new Map();
+  agentCache = new SessionCache(AGENT_CACHE_TTL);
+  // -------------------------------------------------------------------------
+  // bootstrap — initialize session, optionally auto-provision agent
+  // -------------------------------------------------------------------------
+  async bootstrap({ sessionId }) {
+    try {
+      const parsed = parseSessionKey(sessionId, this.config.defaultUserId);
+      const agentId = await this.resolveAgentId(parsed.agentId);
+      await this.client.agents.sessions.start(agentId, {
+        userId: parsed.userId,
+        sessionId
+      });
+      this.sessions.set(sessionId, {
+        agentId,
+        userId: parsed.userId,
+        sonzaiSessionId: sessionId,
+        startedAt: Date.now(),
+        turnCount: 0,
+        lastProcessedIndex: 0,
+        lastMessages: []
+      });
+    } catch (err) {
+      console.warn("[@sonzai-labs/openclaw-context] bootstrap failed:", err);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // ingest — no-op; processing happens in afterTurn with full conversation
+  // -------------------------------------------------------------------------
+  async ingest(_args) {
+    return { ingested: true };
+  }
+  // -------------------------------------------------------------------------
+  // assemble — fetch enriched context and inject as systemPromptAddition
+  // -------------------------------------------------------------------------
+  async assemble({
+    sessionId,
+    messages,
+    tokenBudget,
+    origin
+  }) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return { messages, estimatedTokens: 0 };
+    }
+    session.lastMessages = messages;
+    try {
+      const { agentId, userId } = session;
+      const lastUserMsg = findLastUserMessage(messages);
+      const budget = Math.min(tokenBudget, this.config.contextTokenBudget);
+      const effectiveUserId = origin?.from && origin?.provider ? `${origin.provider}:${origin.from}` : userId;
+      const context = await this.client.agents.getContext(agentId, {
+        userId: effectiveUserId,
+        sessionId: session.sonzaiSessionId,
+        query: lastUserMsg
+      });
+      const systemPromptAddition = buildSystemPromptFromContext(
+        context,
+        budget,
+        this.config.disable
+      );
+      return {
+        messages,
+        estimatedTokens: estimateTokens(systemPromptAddition),
+        systemPromptAddition: systemPromptAddition || void 0
+      };
+    } catch (err) {
+      console.warn("[@sonzai-labs/openclaw-context] assemble failed:", err);
+      return { messages, estimatedTokens: 0 };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // compact — trigger Sonzai's consolidation pipeline
+  // -------------------------------------------------------------------------
+  async compact({ sessionId }) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return { ok: false, compacted: false };
+    }
+    try {
+      await this.client.agents.consolidate(session.agentId);
+      return { ok: true, compacted: true };
+    } catch (err) {
+      console.warn("[@sonzai-labs/openclaw-context] compact failed:", err);
+      return { ok: false, compacted: false };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // afterTurn — send new messages for fact extraction
+  // -------------------------------------------------------------------------
+  async afterTurn({ sessionId }) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    try {
+      session.turnCount++;
+      const newMessages = session.lastMessages.slice(session.lastProcessedIndex);
+      session.lastProcessedIndex = session.lastMessages.length;
+      if (newMessages.length === 0) return;
+      await this.client.agents.process(session.agentId, {
+        userId: session.userId,
+        sessionId: session.sonzaiSessionId,
+        messages: newMessages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        provider: this.config.extractionProvider,
+        model: this.config.extractionModel
+      });
+    } catch (err) {
+      console.warn("[@sonzai-labs/openclaw-context] afterTurn failed:", err);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // dispose — end all active sessions and clear caches
+  // -------------------------------------------------------------------------
+  async dispose() {
+    const endPromises = [...this.sessions.entries()].map(
+      async ([_sessionId, session]) => {
+        try {
+          await this.client.agents.sessions.end(session.agentId, {
+            userId: session.userId,
+            sessionId: session.sonzaiSessionId,
+            totalMessages: session.turnCount,
+            durationSeconds: Math.floor(
+              (Date.now() - session.startedAt) / 1e3
+            )
+          });
+        } catch {
+        }
+      }
+    );
+    await Promise.allSettled(endPromises);
+    this.sessions.clear();
+    this.agentCache.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Resolve the Sonzai agent ID: use config if provided, otherwise
+   * auto-provision via the idempotent create endpoint.
+   *
+   * Idempotency guarantee: the backend derives a deterministic UUID v5 from
+   * `SHA1(namespace, tenantID + "/" + lowercase(name))`. Same API key (tenant)
+   * + same name → same UUID on every call, even across restarts or pod
+   * replacements.
+   *
+   * The name used is always `config.agentName` (default: "openclaw-agent").
+   * This is stable because it comes from the plugin config / env var, not
+   * from any runtime state like pod IDs or session UUIDs.
+   *
+   * If a B2B client needs multiple distinct agents under one API key, they
+   * set a unique `agentName` per OpenClaw instance in their config.
+   */
+  async resolveAgentId(_sessionAgentId) {
+    if (this.config.agentId) {
+      return this.config.agentId;
+    }
+    const name = this.config.agentName;
+    const cached = this.agentCache.get(name);
+    if (cached) return cached;
+    const agent = await this.client.agents.create({ name });
+    this.agentCache.set(name, agent.agent_id);
+    return agent.agent_id;
+  }
+};
+function findLastUserMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      return messages[i].content;
+    }
+  }
+  return void 0;
+}
+
+// src/plugin.ts
+function register(api) {
+  api.registerContextEngine("sonzai", () => {
+    const config = resolveConfig();
+    const client = new agents.Sonzai({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl
+    });
+    return new SonzaiContextEngine(client, config);
+  });
+}
+async function setup(options) {
+  const baseUrl = options.baseUrl || "https://api.sonz.ai";
+  const agentName = options.agentName || "openclaw-agent";
+  const writeConfig = options.writeConfig ?? true;
+  const configPath = options.configPath || "./openclaw.json";
+  const client = new agents.Sonzai({ apiKey: options.apiKey, baseUrl });
+  let agentId;
+  if (options.agentId) {
+    const agent = await client.agents.get(options.agentId);
+    agentId = agent.agent_id;
+  } else {
+    const agent = await client.agents.create({ name: agentName });
+    agentId = agent.agent_id;
+  }
+  const pluginConfig = buildOpenClawConfig(options.apiKey, agentId);
+  let written = false;
+  if (writeConfig) {
+    mergeOpenClawConfig(configPath, pluginConfig);
+    written = true;
+  }
+  return {
+    agentId,
+    agentName,
+    config: pluginConfig,
+    configPath: written ? path__namespace.resolve(configPath) : void 0,
+    written
+  };
+}
+function buildOpenClawConfig(_apiKey, agentId) {
+  return {
+    plugins: {
+      slots: {
+        contextEngine: "sonzai"
+      },
+      entries: {
+        sonzai: {
+          enabled: true,
+          agentId
+          // apiKey is intentionally NOT written to the config file —
+          // it should be set via SONZAI_API_KEY env var for security.
+        }
+      }
+    }
+  };
+}
+function mergeOpenClawConfig(configPath, pluginConfig) {
+  let existing = {};
+  const resolvedPath = path__namespace.resolve(configPath);
+  if (fs__namespace.existsSync(resolvedPath)) {
+    try {
+      const raw = fs__namespace.readFileSync(resolvedPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const merged = { ...existing };
+  const existingPlugins = merged.plugins || {};
+  const newPlugins = pluginConfig.plugins;
+  const existingSlots = existingPlugins.slots || {};
+  const newSlots = newPlugins.slots || {};
+  const existingEntries = existingPlugins.entries || {};
+  const newEntries = newPlugins.entries || {};
+  merged.plugins = {
+    ...existingPlugins,
+    slots: { ...existingSlots, ...newSlots },
+    entries: { ...existingEntries, ...newEntries }
+  };
+  fs__namespace.writeFileSync(resolvedPath, JSON.stringify(merged, null, 2) + "\n");
+}
+
+exports.SessionCache = SessionCache;
+exports.SonzaiContextEngine = SonzaiContextEngine;
+exports.buildSystemPromptAddition = buildSystemPromptAddition;
+exports.default = register;
+exports.estimateTokens = estimateTokens;
+exports.parseSessionKey = parseSessionKey;
+exports.resolveConfig = resolveConfig;
+exports.setup = setup;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map