@occum-net/occumclaw 0.4.0 → 0.5.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;
@@ -155,8 +153,7 @@ interface OpenClawPluginApi {
 //   5. undefined → fall back to global  (tools.allow / tools.profile)
 //
 // Config path:
-//   channels.occum.accounts.<accountId>.groups.<channelId>.tools
-//   channels.occum.accounts.<accountId>.groups.<channelId>.toolsBySender
+//   plugins.entries.occumclaw.config.groups.<channelId>.tools
 //
 // Per-sender key format:
 //   "id:<senderId>"       — match by user/agent ID
@@ -263,15 +260,16 @@ function resolveToolsBySender(
 /**
  * Resolve the effective tool policy for an inbound occum.net message.
  *
- * Looks up config at: channels.occum.accounts.<accountId>.groups.<groupId>
- * with fallback to wildcard "*" group, then per-sender overrides.
+ * 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;
 
-  const acctId = accountId ?? "default";
   const groups: Record<string, OccumGroupConfig> | undefined =
-    cfg?.channels?.occum?.accounts?.[acctId]?.groups;
+    cfg?.plugins?.entries?.occumclaw?.config?.groups;
 
   if (!groups || typeof groups !== "object") return undefined;
 
@@ -308,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 {
@@ -336,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"];
@@ -352,6 +330,10 @@ function listAccountIds(cfg: any): string[] {
 // ─── Channel Plugin ─────────────────────────────────────────────────────────
 
 function createOccumChannelPlugin(logger: PluginLogger) {
+  // Shared state: set by startAccount, read by resolveTarget/sendText.
+  // All outbound delivery routes to the agent's control channel.
+  let controlChannelId: string | null = null;
+
   return {
     id: "occum" as const,
 
@@ -381,6 +363,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;
@@ -390,8 +388,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",
@@ -426,11 +425,10 @@ function createOccumChannelPlugin(logger: PluginLogger) {
 
         // 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}`);
@@ -540,12 +538,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),
@@ -577,15 +577,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/openclaw.plugin.json

@@ -9,7 +9,39 @@
     "additionalProperties": false,
     "properties": {
       "agentToken": { "type": "string" },
-      "apiUrl": { "type": "string", "default": "https://api.occum.net" }
+      "apiUrl": { "type": "string", "default": "https://api.occum.net" },
+      "groups": {
+        "type": "object",
+        "description": "Per-channel and per-sender tool policy overrides. Keys are channel IDs or \"*\" for wildcard.",
+        "additionalProperties": {
+          "type": "object",
+          "properties": {
+            "tools": {
+              "type": "object",
+              "properties": {
+                "allow": { "type": "array", "items": { "type": "string" } },
+                "alsoAllow": { "type": "array", "items": { "type": "string" } },
+                "deny": { "type": "array", "items": { "type": "string" } }
+              },
+              "additionalProperties": false
+            },
+            "toolsBySender": {
+              "type": "object",
+              "description": "Per-sender overrides keyed by id:<val>, username:<val>, name:<val>, or *",
+              "additionalProperties": {
+                "type": "object",
+                "properties": {
+                  "allow": { "type": "array", "items": { "type": "string" } },
+                  "alsoAllow": { "type": "array", "items": { "type": "string" } },
+                  "deny": { "type": "array", "items": { "type": "string" } }
+                },
+                "additionalProperties": false
+              }
+            }
+          },
+          "additionalProperties": false
+        }
+      }
     },
     "required": []
   },

package/package.json

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