@otterware/openclaw-otter 0.2.3 → 0.2.4

package/index.js

@@ -15,6 +15,7 @@ import { runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guar
 import { readWorkspaceFile } from "./files.js";
 import {
   accountOf,
+  chatOf,
   chatTarget,
   isNewChat,
   isOwnerConfigured,
@@ -23,8 +24,8 @@ import {
   otterTargetsNote,
   OWNER,
   pointerOf,
-  sessionOf,
   targetOf,
+  TARGETS_HINT,
   tell,
 } from "./otter.js";
 
@@ -63,15 +64,14 @@ export const otterChannel = createChatChannelPlugin({
     messaging: {
       targetResolver: {
         looksLikeId: () => true,
-        hint: '"chat:<session key>" for one of Otter\'s chats, "new" for a new chat, or "inbox"',
+        hint: TARGETS_HINT,
       },
-      // A delivery to a chat is kept in its session; to "new", in a chat it starts (the gateway
-      // routes each delivery once, and sends it to that session); any other, in the inbox.
+      // A delivery to a chat is kept in its session; to "chat:new", in a chat it starts (the gateway
+      // routes each delivery once, and sends it to that session).
       resolveOutboundSessionRoute: ({ agentId, target }) => {
         const to = targetOf(target);
-        const sessionKey = isNewChat(to)
-          ? newChatKey(agentId, randomUUID())
-          : sessionOf(target, agentId);
+        if (!to) return null;
+        const sessionKey = isNewChat(to) ? newChatKey(agentId, randomUUID()) : chatOf(to);
         return {
           sessionKey,
           baseSessionKey: sessionKey,
@@ -86,7 +86,12 @@ export const otterChannel = createChatChannelPlugin({
   },
   outbound: {
     deliveryMode: "direct",
-    resolveTarget: (params) => ({ ok: true, to: targetOf(params?.to) }),
+    resolveTarget: (params) => {
+      const to = targetOf(params?.to);
+      return to
+        ? { ok: true, to }
+        : { ok: false, error: new Error(`Otter's targets are ${TARGETS_HINT}.`) };
+    },
     sendText: (ctx) => deliver(ctx),
     sendPayload: (ctx) => deliver(ctx, ctx.payload),
   },

package/otter.js

@@ -1,10 +1,5 @@
 // What the plugin does, apart from OpenClaw's SDK, so Otter's tests can run it.
 
-/** Where an agent's deliveries to Otter are kept: one session per agent, read by Otter's apps. */
-export const inboxKey = (agentId) => `agent:${agentId}:otter:inbox`;
-
-export const OTTER_TARGET = "inbox";
-
 /** Who sends what you type in Otter: the gateway's owner once `commands.ownerAllowFrom` lists `otter:owner`. */
 export const OWNER = "owner";
 export const OWNER_ENTRY = `otter:${OWNER}`;
@@ -13,18 +8,23 @@ export const OWNER_ENTRY = `otter:${OWNER}`;
 export const chatTarget = (sessionKey) => `chat:${sessionKey}`;
 
 /** Like posting to a Slack channel rather than in a thread: each delivery starts a chat of its own. */
-export const NEW_CHAT_TARGET = "new";
+export const NEW_CHAT_TARGET = "chat:new";
+
+const bare = (to) => (typeof to === "string" ? to.trim().replace(/^otter:/, "") : "");
 
-export const isNewChat = (to) =>
-  typeof to === "string" && to.trim().replace(/^otter:/, "") === NEW_CHAT_TARGET;
+/** What's sent to the gateway's owner (`otter:owner`) starts a chat, as it names none. */
+export const isNewChat = (to) => bare(to) === NEW_CHAT_TARGET || bare(to) === OWNER;
 
-/** A target as the channel keeps it: one of Otter's chats, a new one each time, or the inbox. */
+/** A target as the channel keeps it: one of Otter's chats, or a new one each time; else none. */
 export function targetOf(to) {
   const chat = chatOf(to);
   if (chat) return chatTarget(chat);
-  return isNewChat(to) ? NEW_CHAT_TARGET : OTTER_TARGET;
+  return isNewChat(to) ? NEW_CHAT_TARGET : undefined;
 }
 
+export const TARGETS_HINT =
+  '"chat:<session key>" for one of Otter\'s chats, or "chat:new" for a new one';
+
 /** A session for a new chat, an Otter chat like one you start. */
 export const newChatKey = (agentId, id) => `agent:${agentId}:otter-mail:${id}`;
 
@@ -35,10 +35,9 @@ export const newChatKey = (agentId, id) => `agent:${agentId}:otter-mail:${id}`;
 export function otterTargetsNote(sessionKey) {
   const here = agentOf(sessionKey) ? chatTarget(sessionKey) : "chat:<session key>";
   return [
-    "Otter delivery targets (channel `otter`), like a thread or a new post in Slack:",
+    "Otter delivery targets (channel `otter`), like replying in a thread or a new post in Slack:",
     `- "${here}": this chat. Any Otter chat is "chat:<its session key>".`,
-    '- "new": a new Otter chat for each delivery (an automation that should post a fresh chat every run, such as a morning brief).',
-    '- "inbox": the agent\'s single Otter inbox chat.',
+    '- "chat:new": a new Otter chat for each delivery (an automation that should post a fresh chat every run, such as a morning brief or an alert).',
   ].join("\n");
 }
 
@@ -49,15 +48,12 @@ export const agentOf = (sessionKey) =>
 
 /** The chat a target names, if it names one. */
 export function chatOf(to) {
-  const target = typeof to === "string" ? to.trim().replace(/^otter:/, "") : "";
+  const target = bare(to);
   if (!target.startsWith("chat:")) return undefined;
   const sessionKey = target.slice("chat:".length);
   return agentOf(sessionKey) ? sessionKey : undefined;
 }
 
-/** The session a delivery to this target is kept in. */
-export const sessionOf = (to, agentId) => chatOf(to) ?? inboxKey(agentId);
-
 export const isOwnerConfigured = (cfg) =>
   Array.isArray(cfg?.commands?.ownerAllowFrom) &&
   cfg.commands.ownerAllowFrom.some((entry) => String(entry).trim() === OWNER_ENTRY);
@@ -77,7 +73,7 @@ export function pointerOf({ sessionKey, to, payload, at = Date.now() }) {
   return {
     kind: approval ? "approval" : question ? "question" : "message",
     agentId,
-    sessionKey: approval || question ? (session ?? null) : (chat ?? inboxKey(agentId)),
+    sessionKey: approval || question ? (session ?? null) : (chat ?? session ?? null),
     ...(approval && {
       approvalId: String(approval.approvalId),
       approvalKind: approval.approvalKind === "plugin" ? "plugin" : "exec",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otterware/openclaw-otter",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Otter as an OpenClaw channel: what your agents send you waits in Otter, and Otter tells your devices.",
   "license": "MIT",
   "repository": {