@occum-net/occumclaw 0.4.1 → 0.6.0

package/index.ts

@@ -8,12 +8,8 @@
  * occum.net.
  *
  * Configuration (set via `openclaw config set`):
- *   channels.occum.accounts.default.agentToken  — Agent bearer token (occ_...)
- *   channels.occum.accounts.default.apiUrl      — API base URL (default: https://api.occum.net)
- *
- * Legacy config path (auto-migrated):
- *   plugins.entries.occumclaw.config.agentToken
- *   plugins.entries.occumclaw.config.apiUrl
+ *   plugins.entries.occumclaw.config.agentToken  — Agent bearer token (occ_...)
+ *   plugins.entries.occumclaw.config.apiUrl      — API base URL (default: https://api.occum.net)
  */
 
 import { OccumWsClient, type OccumEvent, type AuthOkData } from "./ws-client";
@@ -69,12 +65,14 @@ interface MsgContext {
   BodyForAgent?: string;
   CommandBody?: string;
   From?: string;
-  To?: string;
+  OriginatingChannel?: string;
+  OriginatingTo?: string;
+  Surface?: string;
   SessionKey?: string;
   AccountId?: string;
   Provider?: string;
   ChatType?: string;
-  GroupId?: string;
+  GroupChannel?: string;
   SenderId?: string;
   SenderName?: string;
   SenderUsername?: string;
@@ -154,8 +152,7 @@ interface OpenClawPluginApi {
 //   4. Wildcard tool policy             (groups.*.tools)
 //   5. undefined → fall back to global  (tools.allow / tools.profile)
 //
-// Config path (either works; plugin-style avoids config validation issues):
-//   channels.occum.accounts.<accountId>.groups.<channelId>.tools
+// Config path:
 //   plugins.entries.occumclaw.config.groups.<channelId>.tools
 //
 // Per-sender key format:
@@ -263,20 +260,16 @@ function resolveToolsBySender(
 /**
  * Resolve the effective tool policy for an inbound occum.net message.
  *
- * Looks up groups config from (in order):
- *   1. channels.occum.accounts.<accountId>.groups   (channel-style, if OpenClaw validates it)
- *   2. plugins.entries.occumclaw.config.groups       (plugin-style, always safe)
+ * Looks up groups config from:
+ *   plugins.entries.occumclaw.config.groups
  *
  * Then resolves per-channel and per-sender overrides with wildcard fallback.
  */
 function resolveOccumToolPolicy(params: ChannelGroupContext): GroupToolPolicyConfig | undefined {
   const { cfg, groupId, accountId, senderId, senderName, senderUsername, senderE164 } = params;
 
-  // Try channel-style config first, then fall back to plugin config
-  const acctId = accountId ?? "default";
   const groups: Record<string, OccumGroupConfig> | undefined =
-    cfg?.channels?.occum?.accounts?.[acctId]?.groups
-    ?? cfg?.plugins?.entries?.occumclaw?.config?.groups;
+    cfg?.plugins?.entries?.occumclaw?.config?.groups;
 
   if (!groups || typeof groups !== "object") return undefined;
 
@@ -313,22 +306,8 @@ function resolveApiUrl(raw?: string): string {
   return (raw ?? "https://api.occum.net").replace(/\/+$/, "") + "/v1";
 }
 
-/**
- * Resolve account config from OpenClaw config.
- * Supports both channel-style config and legacy plugin config.
- */
-function resolveAccount(cfg: any, accountId?: string | null): OccumAccount {
-  // Channel-style: channels.occum.accounts.<accountId>
-  const acctId = accountId ?? "default";
-  const channelAcct = cfg?.channels?.occum?.accounts?.[acctId];
-  if (channelAcct?.agentToken) {
-    return {
-      agentToken: channelAcct.agentToken,
-      apiUrl: resolveApiUrl(channelAcct.apiUrl),
-    };
-  }
-
-  // Plugin config: plugins.entries.occumclaw.config
+/** Resolve account config from plugins.entries.occumclaw.config. */
+function resolveAccount(cfg: any, _accountId?: string | null): OccumAccount {
   const pluginCfg = cfg?.plugins?.entries?.occumclaw?.config;
   if (pluginCfg?.agentToken) {
     return {
@@ -341,12 +320,6 @@ function resolveAccount(cfg: any, accountId?: string | null): OccumAccount {
 }
 
 function listAccountIds(cfg: any): string[] {
-  // Channel-style accounts
-  const channelAccounts = cfg?.channels?.occum?.accounts;
-  if (channelAccounts && typeof channelAccounts === "object") {
-    return Object.keys(channelAccounts);
-  }
-  // Plugin config: single implicit account
   const pluginCfg = cfg?.plugins?.entries?.occumclaw?.config;
   if (pluginCfg?.agentToken) {
     return ["default"];
@@ -354,9 +327,86 @@ function listAccountIds(cfg: any): string[] {
   return [];
 }
 
+// ─── Directory Helpers ───────────────────────────────────────────────────────
+
+interface DirectoryEntry {
+  kind: "user" | "group" | "channel";
+  id: string;
+  name?: string;
+  handle?: string;
+  avatarUrl?: string;
+  rank?: number;
+}
+
+/** Case-insensitive substring filter on id, name, and handle. */
+function filterEntries(entries: DirectoryEntry[], query?: string | null, limit?: number | null): DirectoryEntry[] {
+  if (query) {
+    const q = query.trim().toLowerCase();
+    entries = entries.filter(
+      (e) =>
+        e.id.toLowerCase().includes(q) ||
+        e.name?.toLowerCase().includes(q) ||
+        e.handle?.toLowerCase().includes(q),
+    );
+  }
+  if (limit && limit > 0) entries = entries.slice(0, limit);
+  return entries;
+}
+
+/** Convert an occum.net channel member to a directory entry. */
+function memberToEntry(m: any): DirectoryEntry {
+  return {
+    kind: "user",
+    id: m.memberType === "agent" ? m.agentId : m.userId,
+    name: m.displayName ?? m.invitedName ?? undefined,
+    handle: m.memberType === "agent" ? m.agentId : undefined,
+    avatarUrl: m.avatarUrl ?? undefined,
+  };
+}
+
+/** Convert an occum.net channel to a directory group entry. */
+function channelToEntry(ch: any): DirectoryEntry {
+  return {
+    kind: "group",
+    id: ch.id,
+    name: ch.name ?? undefined,
+  };
+}
+
+/**
+ * Build a ToolConfig from either the gateway closure or from the cfg param.
+ * The gateway sets cachedConfig/controlChannelId at startup; the CLI resolver
+ * only has cfg, so we fall back to resolveAccount + /agents/me.
+ */
+async function resolveDirectoryContext(
+  cachedConfig: ToolConfig | null,
+  controlChannelId: string | null,
+  cfg?: any,
+): Promise<{ config: ToolConfig; controlChannelId: string } | null> {
+  if (cachedConfig && controlChannelId) {
+    return { config: cachedConfig, controlChannelId };
+  }
+  // Fallback: build config from cfg param (used by CLI commands)
+  const account = resolveAccount(cfg ?? {});
+  if (!account.agentToken) return null;
+  const config: ToolConfig = { agentToken: account.agentToken, apiUrl: account.apiUrl };
+  try {
+    const me = await apiRequest(config, "/agents/me");
+    if (!me.controlChannelId) return null;
+    return { config, controlChannelId: me.controlChannelId };
+  } catch {
+    return null;
+  }
+}
+
 // ─── Channel Plugin ─────────────────────────────────────────────────────────
 
 function createOccumChannelPlugin(logger: PluginLogger) {
+  // Shared state: set by startAccount, read by resolveTarget/sendText/directory.
+  // All outbound delivery routes to the agent's control channel.
+  let controlChannelId: string | null = null;
+  let cachedConfig: ToolConfig | null = null;
+
   return {
     id: "occum" as const,
 
@@ -376,6 +426,132 @@ function createOccumChannelPlugin(logger: PluginLogger) {
       resolveToolPolicy: resolveOccumToolPolicy,
     },
 
+    directory: {
+      async self(params: { cfg?: any }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return null;
+        try {
+          const me = await apiRequest(ctx.config, "/agents/me");
+          return { kind: "user" as const, id: me.id, name: me.name ?? undefined };
+        } catch {
+          return null;
+        }
+      },
+
+      async listPeers(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listPeersLive(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroups(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const channels: any[] = await apiRequest(ctx.config, "/channels");
+          const entries = channels.map(channelToEntry);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroupsLive(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const channels: any[] = await apiRequest(ctx.config, "/channels");
+          const entries = channels.map(channelToEntry);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroupMembers(params: { cfg?: any; groupId: string; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${params.groupId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return params.limit && params.limit > 0 ? entries.slice(0, params.limit) : entries;
+        } catch {
+          return [];
+        }
+      },
+    },
+
+    resolver: {
+      async resolveTargets(params: {
+        cfg?: any;
+        accountId?: string | null;
+        inputs: string[];
+        kind: "user" | "group";
+      }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) {
+          return params.inputs.map((input) => ({ input, resolved: false, note: "Not configured" }));
+        }
+        if (params.kind === "group") {
+          try {
+            const channels: any[] = await apiRequest(ctx.config, "/channels");
+            return params.inputs.map((input) => {
+              const q = input.trim().toLowerCase();
+              const match = channels.find(
+                (ch) => ch.id === input || ch.name?.toLowerCase().includes(q),
+              );
+              return match
+                ? { input, resolved: true, id: match.id, name: match.name ?? undefined }
+                : { input, resolved: false };
+            });
+          } catch {
+            return params.inputs.map((input) => ({ input, resolved: false }));
+          }
+        }
+        // kind === "user"
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          return params.inputs.map((input) => {
+            const q = input.trim().toLowerCase();
+            const match = members.find(
+              (m) =>
+                m.userId === input ||
+                m.agentId === input ||
+                m.displayName?.toLowerCase().includes(q) ||
+                m.invitedName?.toLowerCase().includes(q),
+            );
+            if (!match) return { input, resolved: false };
+            return {
+              input,
+              resolved: true,
+              id: match.memberType === "agent" ? match.agentId : match.userId,
+              name: match.displayName ?? match.invitedName ?? undefined,
+            };
+          });
+        } catch {
+          return params.inputs.map((input) => ({ input, resolved: false }));
+        }
+      },
+    },
+
     config: {
       listAccountIds: (cfg: any) => listAccountIds(cfg),
       resolveAccount: (cfg: any, accountId?: string | null) => resolveAccount(cfg, accountId),
@@ -386,6 +562,22 @@ function createOccumChannelPlugin(logger: PluginLogger) {
     outbound: {
       deliveryMode: "direct" as const,
 
+      resolveTarget(params: {
+        cfg?: any;
+        to?: string;
+        allowFrom?: string[];
+        accountId?: string | null;
+        mode?: string;
+      }): { ok: true; to: string } | { ok: false; error: Error } {
+        // All outbound delivery routes to the control channel.
+        // OpenClaw may pass a user ID (e.g. from "channel": "last" cron
+        // delivery) — we resolve it to the control channel regardless.
+        if (!controlChannelId) {
+          return { ok: false, error: new Error("Occum.net agent not connected yet (no control channel)") };
+        }
+        return { ok: true, to: controlChannelId };
+      },
+
       async sendText(ctx: {
         cfg: any;
         to: string;
@@ -395,8 +587,9 @@ function createOccumChannelPlugin(logger: PluginLogger) {
         const account = resolveAccount(ctx.cfg, ctx.accountId);
         const config: ToolConfig = { agentToken: account.agentToken, apiUrl: account.apiUrl };
 
-        // `to` is the occum.net channel ID (UUIDv7 string)
-        const channelId = ctx.to;
+        // Use control channel if `to` doesn't look like a channel ID
+        // (e.g. OpenClaw passed a user ID from "channel: last" resolution)
+        const channelId = controlChannelId ?? ctx.to;
 
         const event = await apiRequest(config, `/channels/${channelId}/messages`, {
           method: "POST",
@@ -428,14 +621,14 @@ function createOccumChannelPlugin(logger: PluginLogger) {
 
         const channelRuntime = ctx.channelRuntime;
         const config: ToolConfig = { agentToken: account.agentToken, apiUrl: account.apiUrl };
+        cachedConfig = config;
 
         // Discover agent identity
         let agentId: string | null = null;
-        let controlChannelId: string | null = null;
         try {
           const me = await apiRequest(config, "/agents/me");
           agentId = me.id;
-          controlChannelId = me.controlChannelId;
+          controlChannelId = me.controlChannelId ?? null;
           log?.info?.(`Agent identity: ${me.name} (${agentId}), control channel #${controlChannelId}`);
         } catch (err) {
           log?.warn?.(`Failed to discover agent identity: ${err}`);
@@ -545,12 +738,14 @@ function createOccumChannelPlugin(logger: PluginLogger) {
               From: event.senderType === "user"
                 ? `user:${event.senderUserId}`
                 : `agent:${event.senderAgentId}`,
-              To: replyChannelId,
+              OriginatingChannel: "occum",
+              OriginatingTo: replyChannelId,
+              Surface: "occum",
               SessionKey: `occum-${ctx.accountId}-${event.channelId}`,
               AccountId: ctx.accountId,
               Provider: "occum",
               ChatType: "direct",
-              GroupId: event.channelId,
+              GroupChannel: event.channelId,
               SenderId: event.senderType === "user"
                 ? String(event.senderUserId)
                 : String(event.senderAgentId),
@@ -582,15 +777,46 @@ function createOccumChannelPlugin(logger: PluginLogger) {
                     ctx: msgCtx,
                     cfg,
                     dispatcherOptions: {
-                      deliver: async (payload: ReplyPayload) => {
+                      deliver: async (payload: ReplyPayload, info: ReplyDispatchKindInfo) => {
                         if (!payload.text) return;
+
+                        // Reasoning/thinking blocks → work update
+                        if (payload.isReasoning) {
+                          log?.info?.(`[occum] Work update (thinking, ${payload.text.length} chars)`);
+                          apiRequest(config, `/channels/${event.channelId}/work/${sessionId}/update`, {
+                            method: "POST",
+                            body: JSON.stringify({ updateType: "thinking", content: payload.text }),
+                          }).catch((err) => log?.warn?.(`[occum] Failed to post thinking update: ${err}`));
+                          return;
+                        }
+
+                        // Tool results and intermediate blocks → work updates
+                        if (info.kind === "tool") {
+                          log?.info?.(`[occum] Work update (tool, ${payload.text.length} chars)`);
+                          apiRequest(config, `/channels/${event.channelId}/work/${sessionId}/update`, {
+                            method: "POST",
+                            body: JSON.stringify({ updateType: "tool_use", content: payload.text }),
+                          }).catch((err) => log?.warn?.(`[occum] Failed to post tool update: ${err}`));
+                          return;
+                        }
+
+                        if (info.kind === "block") {
+                          log?.info?.(`[occum] Work update (text, ${payload.text.length} chars)`);
+                          apiRequest(config, `/channels/${event.channelId}/work/${sessionId}/update`, {
+                            method: "POST",
+                            body: JSON.stringify({ updateType: "text", content: payload.text }),
+                          }).catch((err) => log?.warn?.(`[occum] Failed to post text update: ${err}`));
+                          return;
+                        }
+
+                        // Final reply → send as actual channel message
                         replyText += payload.text;
                         try {
                           await apiRequest(config, `/channels/${event.channelId}/messages`, {
                             method: "POST",
                             body: JSON.stringify({ text: payload.text }),
                           });
-                          log?.info?.(`[occum] Reply sent to #${event.channelId} (${payload.text.length} chars)`);
+                          log?.info?.(`[occum] Final reply sent to #${event.channelId} (${payload.text.length} chars)`);
                         } catch (err) {
                           log?.error?.(`[occum] Failed to send reply: ${err}`);
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@occum-net/occumclaw",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "publishConfig": {
     "access": "public"
   },