@agentvault/agentvault 0.13.12 → 0.14.0

package/dist/openclaw-compat.d.ts

@@ -0,0 +1,33 @@
+/**
+ * OpenClaw SDK compatibility layer — dynamic import wrappers with caching.
+ *
+ * Each wrapper attempts to import a deep SDK module at runtime. If the import
+ * fails (older gateway, missing SDK), the function returns a no-op result.
+ * Results are cached after the first attempt.
+ *
+ * IMPORTANT: All imports are guarded by try/catch — the plugin degrades
+ * gracefully on older OpenClaw versions.
+ */
+import type { AgentEventPayload, TranscriptUpdatePayload } from "./openclaw-types.js";
+/**
+ * Request an immediate heartbeat wake from the OpenClaw gateway.
+ * Returns true if the heartbeat API was available and called, false otherwise.
+ * Never throws.
+ */
+export declare function requestHeartbeatNow(opts?: {
+    reason?: string;
+}): Promise<boolean>;
+type AgentEventCallback = (event: AgentEventPayload) => void;
+/**
+ * Subscribe to agent-level events (tool_use, reasoning_complete, error, etc.).
+ * Returns an unsubscribe function, or a no-op if the API is unavailable.
+ */
+export declare function onAgentEvent(callback: AgentEventCallback): Promise<() => void>;
+type TranscriptCallback = (update: TranscriptUpdatePayload) => void;
+/**
+ * Subscribe to session transcript updates for behavioral analysis.
+ * Returns an unsubscribe function, or a no-op if the API is unavailable.
+ */
+export declare function onSessionTranscriptUpdate(callback: TranscriptCallback): Promise<() => void>;
+export {};
+//# sourceMappingURL=openclaw-compat.d.ts.map

package/dist/openclaw-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openclaw-compat.d.ts","sourceRoot":"","sources":["../src/openclaw-compat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAQtF;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBtF;AAMD,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAG7D;;;GAGG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAkBpF;AAMD,KAAK,kBAAkB,GAAG,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;AAGpE;;;GAGG;AACH,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAkBjG"}

package/dist/openclaw-entry.d.ts

@@ -7,6 +7,9 @@
  *
  * Loaded by OpenClaw via the `openclaw.extensions` field in package.json.
  */
+import type { OpenClawPluginApi } from "./openclaw-types.js";
+/** Whether OpenClaw managed HTTP routes are active (vs self-managed server). */
+export declare let isUsingManagedRoutes: boolean;
 /** Extract @mention names from plaintext. Returns lowercased names. */
 declare function _parseMentions(text: string): string[];
 /** Determine whether this agent should process a room message based on @mentions. */
@@ -18,7 +21,7 @@ declare const _default: {
     id: string;
     name: string;
     description: string;
-    register(api: any): void;
+    register(api: OpenClawPluginApi): void;
 };
 export default _default;
 //# sourceMappingURL=openclaw-entry.d.ts.map

package/dist/openclaw-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openclaw-entry.d.ts","sourceRoot":"","sources":["../src/openclaw-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyBH,uEAAuE;AACvE,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS9C;AAED,qFAAqF;AACrF,iBAAS,yBAAyB,CAChC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAcT;AAED,sFAAsF;AACtF,iBAAS,cAAc,CACrB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAiBR;AA2oBD,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,cAAc,EAAE,CAAC;;;;;kBAQrD,GAAG;;AAJnB,wBAgHE"}
+{"version":3,"file":"openclaw-entry.d.ts","sourceRoot":"","sources":["../src/openclaw-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,KAAK,EACV,iBAAiB,EASlB,MAAM,qBAAqB,CAAC;AAO7B,gFAAgF;AAChF,eAAO,IAAI,oBAAoB,SAAQ,CAAC;AAexC,uEAAuE;AACvE,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS9C;AAED,qFAAqF;AACrF,iBAAS,yBAAyB,CAChC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAcT;AAED,sFAAsF;AACtF,iBAAS,cAAc,CACrB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAiBR;AAitBD,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,cAAc,EAAE,CAAC;;;;;kBAQrD,iBAAiB;;AAJjC,wBAyQE"}

package/dist/openclaw-entry.js

@@ -1,3 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/openclaw-compat.ts
+var openclaw_compat_exports = {};
+__export(openclaw_compat_exports, {
+  onAgentEvent: () => onAgentEvent,
+  onSessionTranscriptUpdate: () => onSessionTranscriptUpdate,
+  requestHeartbeatNow: () => requestHeartbeatNow
+});
+async function requestHeartbeatNow(opts) {
+  if (_heartbeatFn === null) {
+    try {
+      const mod = await import("openclaw/dist/plugin-sdk/infra/heartbeat-wake.js");
+      _heartbeatFn = mod.requestHeartbeatNow ?? mod.default?.requestHeartbeatNow ?? false;
+    } catch {
+      _heartbeatFn = false;
+    }
+  }
+  if (typeof _heartbeatFn === "function") {
+    try {
+      await _heartbeatFn(opts);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function onAgentEvent(callback) {
+  if (_agentEventFn === null) {
+    try {
+      const mod = await import("openclaw/dist/plugin-sdk/infra/agent-events.js");
+      _agentEventFn = mod.onAgentEvent ?? mod.default?.onAgentEvent ?? false;
+    } catch {
+      _agentEventFn = false;
+    }
+  }
+  if (typeof _agentEventFn === "function") {
+    try {
+      return _agentEventFn(callback);
+    } catch {
+      return () => {
+      };
+    }
+  }
+  return () => {
+  };
+}
+async function onSessionTranscriptUpdate(callback) {
+  if (_transcriptFn === null) {
+    try {
+      const mod = await import("openclaw/dist/plugin-sdk/sessions/transcript-events.js");
+      _transcriptFn = mod.onSessionTranscriptUpdate ?? mod.default?.onSessionTranscriptUpdate ?? false;
+    } catch {
+      _transcriptFn = false;
+    }
+  }
+  if (typeof _transcriptFn === "function") {
+    try {
+      return _transcriptFn(callback);
+    } catch {
+      return () => {
+      };
+    }
+  }
+  return () => {
+  };
+}
+var _heartbeatFn, _agentEventFn, _transcriptFn;
+var init_openclaw_compat = __esm({
+  "src/openclaw-compat.ts"() {
+    "use strict";
+    _heartbeatFn = null;
+    _agentEventFn = null;
+    _transcriptFn = null;
+  }
+});
+
 // src/openclaw-entry.ts
 import { resolve } from "node:path";
 import { randomBytes } from "node:crypto";
@@ -197,10 +283,75 @@ function runWithTraceContext(ctx, fn) {
   return traceStore.run(ctx, fn);
 }
 
+// src/http-handlers.ts
+async function handleSendRequest(parsed, channel) {
+  const text = parsed.text;
+  if (!text || typeof text !== "string") {
+    return { status: 400, body: { ok: false, error: "Missing 'text' field" } };
+  }
+  try {
+    if (parsed.room_id && typeof parsed.room_id === "string") {
+      await channel.sendToRoom(parsed.room_id, text, {
+        messageType: parsed.message_type,
+        priority: parsed.priority,
+        metadata: parsed.metadata
+      });
+    } else if (parsed.file_path && typeof parsed.file_path === "string") {
+      await channel.sendWithAttachment(text, parsed.file_path, {
+        topicId: parsed.topicId
+      });
+    } else {
+      await channel.send(text, {
+        topicId: parsed.topicId,
+        messageType: parsed.message_type,
+        metadata: parsed.metadata
+      });
+    }
+    return { status: 200, body: { ok: true } };
+  } catch (err) {
+    return { status: 500, body: { ok: false, error: String(err) } };
+  }
+}
+async function handleActionRequest(parsed, channel) {
+  if (!parsed.action || typeof parsed.action !== "string") {
+    return { status: 400, body: { ok: false, error: "Missing 'action' field" } };
+  }
+  try {
+    const confirmation = {
+      action: parsed.action,
+      status: parsed.status ?? "completed",
+      decisionId: parsed.decision_id,
+      detail: parsed.detail,
+      estimated_cost: parsed.estimated_cost
+    };
+    if (parsed.room_id && typeof parsed.room_id === "string") {
+      await channel.sendActionConfirmationToRoom(parsed.room_id, confirmation);
+    } else {
+      await channel.sendActionConfirmation(confirmation);
+    }
+    return { status: 200, body: { ok: true } };
+  } catch (err) {
+    return { status: 500, body: { ok: false, error: String(err) } };
+  }
+}
+function handleStatusRequest(channel) {
+  return {
+    status: 200,
+    body: {
+      ok: true,
+      state: channel.state,
+      deviceId: channel.deviceId ?? void 0,
+      sessions: channel.sessionCount
+    }
+  };
+}
+
 // src/openclaw-entry.ts
+init_openclaw_compat();
 var _ocRuntime = null;
 var _channels = /* @__PURE__ */ new Map();
 var _messageQueue = [];
+var isUsingManagedRoutes = false;
 function _setRuntime(rt) {
   _ocRuntime = rt;
   if (_messageQueue.length > 0) {
@@ -265,10 +416,14 @@ async function handleInbound(params) {
   };
   const _instrument = {
     reportLlm: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportLlmCall({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportLlmCall(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.llm.model": opts.model ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "llm",
@@ -277,16 +432,20 @@ async function handleInbound(params) {
         start_time: new Date(Date.now() - (opts.latencyMs ?? 0)).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: opts.latencyMs ?? 0,
-        attributes: { "ai.agent.llm.model": opts.model ?? "" },
+        attributes: activityAttrs,
         tokens_input: opts.tokensInput,
         tokens_output: opts.tokensOutput
       });
     },
     reportTool: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportToolCall({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportToolCall(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.tool.name": opts.toolName ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "tool",
@@ -295,15 +454,19 @@ async function handleInbound(params) {
         start_time: new Date(Date.now() - (opts.latencyMs ?? 0)).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: opts.latencyMs ?? 0,
-        attributes: { "ai.agent.tool.name": opts.toolName ?? "" },
+        attributes: activityAttrs,
         tool_success: opts.success
       });
     },
     reportError: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportError({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportError(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.error.type": opts.errorType ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "error",
@@ -312,16 +475,20 @@ async function handleInbound(params) {
         start_time: (/* @__PURE__ */ new Date()).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: 0,
-        attributes: { "ai.agent.error.type": opts.errorType ?? "" },
+        attributes: activityAttrs,
         error_type: opts.errorType,
         error_message: opts.errorMessage
       });
     },
     reportHttp: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportHttpCall({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportHttpCall(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.http.method": opts.method ?? "", "ai.agent.http.url": opts.url ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "http",
@@ -336,17 +503,21 @@ async function handleInbound(params) {
         start_time: new Date(Date.now() - (opts.latencyMs ?? 0)).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: opts.latencyMs ?? 0,
-        attributes: { "ai.agent.http.method": opts.method ?? "", "ai.agent.http.url": opts.url ?? "" },
+        attributes: activityAttrs,
         http_method: opts.method,
         http_status_code: opts.statusCode,
         http_url: opts.url
       });
     },
     reportAction: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportActionCall({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportActionCall(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.action.type": opts.actionType ?? "", "ai.agent.action.target": opts.target ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "action",
@@ -355,16 +526,20 @@ async function handleInbound(params) {
         start_time: new Date(Date.now() - (opts.latencyMs ?? 0)).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: opts.latencyMs ?? 0,
-        attributes: { "ai.agent.action.type": opts.actionType ?? "", "ai.agent.action.target": opts.target ?? "" },
+        attributes: activityAttrs,
         action_type: opts.actionType,
         action_target: opts.target
       });
     },
     reportNav: (opts) => {
+      const enriched = { ...opts, traceId, parentSpanId: inferenceSpanId };
+      if (opts.skillName || _instrument.skillName) enriched.skillName = opts.skillName ?? _instrument.skillName;
       try {
-        channel.telemetry?.reportNavCall({ ...opts, traceId, parentSpanId: inferenceSpanId });
+        channel.telemetry?.reportNavCall(enriched);
       } catch {
       }
+      const activityAttrs = { "ai.agent.nav.to_url": opts.toUrl ?? "" };
+      if (enriched.skillName) activityAttrs["ai.agent.skill.name"] = enriched.skillName;
       _sendActivity({
         span_id: randomBytes(8).toString("hex"),
         span_type: "nav",
@@ -373,9 +548,10 @@ async function handleInbound(params) {
         start_time: new Date(Date.now() - (opts.latencyMs ?? 0)).toISOString(),
         end_time: (/* @__PURE__ */ new Date()).toISOString(),
         duration_ms: opts.latencyMs ?? 0,
-        attributes: { "ai.agent.nav.to_url": opts.toUrl ?? "" }
+        attributes: activityAttrs
       });
     },
+    skillName: void 0,
     traceId,
     parentSpanId: inferenceSpanId
   };
@@ -727,14 +903,14 @@ var agentVaultPlugin = {
     },
     startAccount: async (ctx) => {
       const { account, cfg, log, abortSignal } = ctx;
+      const _log = typeof log === "function" ? log : log?.info?.bind(log);
       if (!account.configured) {
         throw new Error(
           "AgentVault channel not configured. Run: npx @agentvault/agentvault setup --token=av_tok_...\nThen restart OpenClaw."
         );
       }
       const dataDir = resolve(account.dataDir.replace(/^~/, process.env.HOME ?? "~"));
-      log?.info(`[AgentVault] starting (dataDir=${dataDir})`);
-      const { SecureChannel } = await import("./index.js");
+      _log?.(`[AgentVault] starting (dataDir=${dataDir})`);
       await new Promise((resolve2, reject) => {
         let channel;
         const onAbort = async () => {
@@ -743,15 +919,15 @@ var agentVaultPlugin = {
           resolve2();
         };
         abortSignal?.addEventListener("abort", () => void onAbort());
-        import("./index.js").then(({ SecureChannel: SecureChannel2 }) => {
-          channel = new SecureChannel2({
+        import("./index.js").then(({ SecureChannel }) => {
+          channel = new SecureChannel({
             inviteToken: "",
             dataDir,
             apiUrl: account.apiUrl,
             agentName: account.agentName,
             onMessage: async (plaintext, metadata) => {
               if (!_ocRuntime) {
-                log?.info("[AgentVault] runtime not ready, queuing message");
+                _log?.("[AgentVault] runtime not ready, queuing message");
                 _messageQueue.push(async () => {
                   await handleInbound({ plaintext, metadata, channel, account, cfg });
                 });
@@ -760,22 +936,26 @@ var agentVaultPlugin = {
               try {
                 await handleInbound({ plaintext, metadata, channel, account, cfg });
               } catch (err) {
-                log?.info(`[AgentVault] inbound error: ${String(err)}`);
+                _log?.(`[AgentVault] inbound error: ${String(err)}`);
               }
             },
             onStateChange: (state) => {
-              log?.info(`[AgentVault] \u2192 ${state}`);
+              _log?.(`[AgentVault] \u2192 ${state}`);
               if (state === "error") reject(new Error("AgentVault channel permanent error"));
             }
           });
           _channels.set(account.accountId, channel);
           channel.on("error", (err) => {
-            log?.info(`[AgentVault] channel error (non-fatal): ${String(err)}`);
+            _log?.(`[AgentVault] channel error (non-fatal): ${String(err)}`);
           });
           const httpPort = account.httpPort ?? 18790;
           channel.on("ready", () => {
-            channel.startHttpServer(httpPort);
-            log?.info(`[AgentVault] HTTP send server listening on http://127.0.0.1:${httpPort}`);
+            if (!isUsingManagedRoutes) {
+              channel.startHttpServer(httpPort);
+              _log?.(`[AgentVault] HTTP send server listening on http://127.0.0.1:${httpPort}`);
+            } else {
+              _log?.(`[AgentVault] using OpenClaw managed HTTP routes (skipping self-managed server)`);
+            }
           });
           channel.start().catch(reject);
         }).catch(reject);
@@ -825,6 +1005,36 @@ ${mediaUrl}` : mediaUrl;
       } catch (err) {
         return { ok: false, error: String(err) };
       }
+    },
+    /** Rich payload delivery — OpenClaw v2026.3.2+ calls this for structured messages. */
+    sendPayload: async (ctx) => {
+      const { payload, accountId } = ctx;
+      const resolvedId = accountId ?? "default";
+      const ch = _channels.get(resolvedId);
+      if (!ch) return { ok: false, error: "AgentVault channel not connected" };
+      try {
+        if (payload.isReasoning) return { ok: true };
+        requestHeartbeatNow({ reason: "outbound-payload" }).catch(() => {
+        });
+        const text = (payload.text ?? "").trim();
+        if (!text && !payload.mediaUrls?.length) return { ok: true };
+        if (text) {
+          await ch.send(text);
+        }
+        if (payload.mediaUrls?.length) {
+          for (const url of payload.mediaUrls) {
+            await ch.send(url);
+          }
+        }
+        if (payload.suggestedActions?.length) {
+          const actionsText = payload.suggestedActions.map((a) => `- ${a.label}: ${a.action}`).join("\n");
+          await ch.send(`Suggested actions:
+${actionsText}`);
+        }
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, error: String(err) };
+      }
     }
   }
 };
@@ -882,6 +1092,157 @@ var openclaw_entry_default = {
       }
     });
     api.registerChannel({ plugin: agentVaultPlugin });
+    if (typeof api.registerHttpRoute === "function") {
+      try {
+        api.registerHttpRoute({
+          path: "/agentvault/send",
+          method: "POST",
+          handler: async (req) => {
+            const ch = _channels.values().next().value;
+            if (!ch) return { status: 503, body: { ok: false, error: "Channel not started" } };
+            const parsed = typeof req.body === "string" ? JSON.parse(req.body) : req.body;
+            const result = await handleSendRequest(parsed, ch);
+            return { status: result.status, body: result.body };
+          }
+        });
+        api.registerHttpRoute({
+          path: "/agentvault/action",
+          method: "POST",
+          handler: async (req) => {
+            const ch = _channels.values().next().value;
+            if (!ch) return { status: 503, body: { ok: false, error: "Channel not started" } };
+            const parsed = typeof req.body === "string" ? JSON.parse(req.body) : req.body;
+            const result = await handleActionRequest(parsed, ch);
+            return { status: result.status, body: result.body };
+          }
+        });
+        api.registerHttpRoute({
+          path: "/agentvault/status",
+          method: "GET",
+          handler: async () => {
+            const ch = _channels.values().next().value;
+            if (!ch) return { status: 503, body: { ok: false, error: "Channel not started" } };
+            const result = handleStatusRequest(ch);
+            return { status: result.status, body: result.body };
+          }
+        });
+        isUsingManagedRoutes = true;
+      } catch {
+      }
+    }
+    if (typeof api.on === "function") {
+      api.on("message_sent", async (event) => {
+        try {
+          const ch = _channels.values().next().value;
+          if (!ch?.telemetry) return;
+          ch.telemetry.reportCustomSpan({
+            traceId: randomBytes(16).toString("hex"),
+            spanId: randomBytes(8).toString("hex"),
+            name: "agentvault.message.delivered",
+            kind: "internal",
+            startTime: event.timestamp,
+            endTime: event.timestamp + 1,
+            attributes: {
+              "agentvault.message.id": event.messageId,
+              "agentvault.delivery.status": event.deliveryStatus,
+              "agentvault.channel.id": event.channelId
+            },
+            status: { code: event.deliveryStatus === "failed" ? 2 : 1 }
+          });
+        } catch {
+        }
+      });
+      api.on("session_start", async (event) => {
+        try {
+          const ch = _channels.values().next().value;
+          if (!ch?.telemetry) return;
+          ch.telemetry.reportCustomSpan({
+            traceId: randomBytes(16).toString("hex"),
+            spanId: randomBytes(8).toString("hex"),
+            name: "agentvault.session.start",
+            kind: "internal",
+            startTime: event.timestamp,
+            endTime: event.timestamp + 1,
+            attributes: {
+              "agentvault.session.key": event.sessionKey,
+              "agentvault.agent.id": event.agentId
+            },
+            status: { code: 1 }
+          });
+        } catch {
+        }
+      });
+      api.on("session_end", async (event) => {
+        try {
+          const ch = _channels.values().next().value;
+          if (!ch?.telemetry) return;
+          ch.telemetry.reportCustomSpan({
+            traceId: randomBytes(16).toString("hex"),
+            spanId: randomBytes(8).toString("hex"),
+            name: "agentvault.session.end",
+            kind: "internal",
+            startTime: event.timestamp,
+            endTime: event.timestamp + 1,
+            attributes: {
+              "agentvault.session.key": event.sessionKey,
+              "agentvault.agent.id": event.agentId,
+              ...event.reason ? { "agentvault.session.end_reason": event.reason } : {}
+            },
+            status: { code: 1 }
+          });
+        } catch {
+        }
+      });
+    }
+    Promise.resolve().then(() => (init_openclaw_compat(), openclaw_compat_exports)).then(async ({ onAgentEvent: onAgentEvent2, onSessionTranscriptUpdate: onSessionTranscriptUpdate2 }) => {
+      onAgentEvent2((event) => {
+        try {
+          const ch = _channels.values().next().value;
+          if (!ch?.telemetry) return;
+          ch.telemetry.reportCustomSpan({
+            traceId: randomBytes(16).toString("hex"),
+            spanId: randomBytes(8).toString("hex"),
+            name: `ai.agent.event.${event.type}`,
+            kind: "internal",
+            startTime: event.timestamp,
+            endTime: event.timestamp + 1,
+            attributes: {
+              "ai.agent.event.type": event.type,
+              "ai.agent.id": event.agentId,
+              ...event.data ? Object.fromEntries(
+                Object.entries(event.data).map(([k, v]) => [`ai.agent.event.${k}`, String(v)])
+              ) : {}
+            },
+            status: { code: 1 }
+          });
+        } catch {
+        }
+      }).catch(() => {
+      });
+      onSessionTranscriptUpdate2((update) => {
+        try {
+          const ch = _channels.values().next().value;
+          if (!ch?.telemetry) return;
+          ch.telemetry.reportCustomSpan({
+            traceId: randomBytes(16).toString("hex"),
+            spanId: randomBytes(8).toString("hex"),
+            name: "ai.agent.transcript.update",
+            kind: "internal",
+            startTime: update.timestamp,
+            endTime: update.timestamp + 1,
+            attributes: {
+              "agentvault.session.key": update.sessionKey,
+              "ai.agent.transcript.role": update.role ?? "unknown",
+              "ai.agent.transcript.delta_chars": update.delta.length
+            },
+            status: { code: 1 }
+          });
+        } catch {
+        }
+      }).catch(() => {
+      });
+    }).catch(() => {
+    });
     try {
       api.registerTool?.({
         name: "agentvault_status",
@@ -941,6 +1302,7 @@ export {
   _parseMentions,
   _shouldProcessRoomMessage,
   _stripMentions,
-  openclaw_entry_default as default
+  openclaw_entry_default as default,
+  isUsingManagedRoutes
 };
 //# sourceMappingURL=openclaw-entry.js.map