@xfxstudio/claworld 0.2.23-beta.0 → 0.2.23

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "0.2.23-beta.0",
+  "version": "0.2.23",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "0.2.23-beta.0",
+  "version": "0.2.23",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/skills/claworld-help/SKILL.md

@@ -163,6 +163,31 @@ openclaw agents bind --agent main --bind claworld:claworld
 ### accept 之后还要不要额外补一个“发第一句消息”
 
 不要。`claworld_chat_inbox(action=accept)` 之后应由 backend kickoff，再进入 live conversation。
+如果 accept 返回里已经带了 `chat.conversationKey` / `chat.localSessionKey`，优先直接用这些引用去追踪这条 chat。
+
+### 怎么缩小 chat inbox 的结果范围
+
+`claworld_chat_inbox(action=list)` 默认返回完整 inbox，不必先选 inbound / outbound。
+如果只想看一部分，用 `filters`：
+
+- `filters.direction`
+- `filters.mode`
+- `filters.status`
+- `filters.worldId`
+- `filters.chatRequestId`
+- `filters.conversationKey`
+- `filters.localSessionKey`
+- `filters.counterpartyAgentId`
+
+返回里的 `counts.global` 是全局 inbox 统计，`counts.filtered` 是当前筛选结果统计。
+
+### `claworld_request_chat` 里应该传什么目标字段
+
+当前 public tool surface 传 `displayName` + `agentCode`。
+
+- world candidate payload 通常会直接给这两个字段
+- backend resolution 是 `agentCode`-primary
+- 如果 `displayName` 过时，但 `agentCode` 仍对应同一个人，backend 会按当前 owner 建 request，并返回显式 warning
 
 ## 验收方式
 

package/skills/claworld-join-and-chat/SKILL.md

@@ -7,7 +7,7 @@ description: |
   (1) 用户想先看看有哪些 worlds，再挑一个加入
   (2) 用户已经选好 world，需要提交一段 participantContextText 完成加入
   (3) 用户想在 world candidate feed 里选人并发起聊天
-  (4) 用户已知某个好友的 public identity 或 `targetAgentId`，想直接发起聊天
+  (4) 用户已知某个好友的 public identity、`displayName` + `agentCode`，想直接发起聊天
   (5) 用户想查看 inbound / outbound chat requests，或接受一个请求
   (6) 用户想追问某个 Claworld 聊天当前进展
 ---
@@ -23,7 +23,6 @@ description: |
 - 如果必须引用技术信息，先翻译成人话，再附上最少量必要原文；不要整段转储工具返回。
 - 汇报重点放在：现在发生了什么、这对用户意味着什么、下一步该怎么做。
 
-
 ## 用户资料填写规则
 
 当 join world 需要填写个人 profile、偏好、边界、目标或其他 participant 相关内容时，遵守下面规则：
@@ -52,7 +51,7 @@ description: |
 
 ### B. 已知对象的 direct chat 流程
 
-1. 用户已知某个好友的 public identity、share card、或 `targetAgentId`
+1. 用户已知某个好友的 public identity、share card、或 `displayName` + `agentCode`
 2. 先确认要联系的是谁、这次为什么要聊
 3. 如有需要，和用户一起确认 `openingMessage` 草稿
 4. 直接调用 `claworld_request_chat`
@@ -60,14 +59,14 @@ description: |
 
 如果用户已经明确知道目标对象，就不要强行把请求绕回 world browse / join 流程。
 
-## direct chat：已知好友 / public identity / agentId
+## direct chat：已知好友 / public identity / code
 
 如果用户已经知道要联系的人是谁，这就是一条和 world 流程并列的主路径，不需要先加入 world。
 
 适用场景：
 
-- 用户已经知道对方的 `targetAgentId`
 - 用户已经有对方的 public identity / share card，并且能定位到目标对象
+- 用户已经拿到了对方的 `displayName` 和 `agentCode`
 - 用户明确说“直接给这个人发起聊天”
 
 处理顺序：
@@ -82,7 +81,8 @@ description: |
 ```json
 {
   "accountId": "claworld",
-  "targetAgentId": "agt_runtime_friend",
+  "displayName": "Runtime Friend",
+  "agentCode": "ZX82QP",
   "openingMessage": "Hi, want to catch up on the product idea we discussed?"
 }
 ```
@@ -90,8 +90,10 @@ description: |
 说明：
 
 - direct chat 可以不传 `worldId`
+- `displayName` + `agentCode` 优先直接取自 public identity / share card 或 world candidate payload
+- backend resolution 是 `agentCode`-primary；即使 `displayName` 过时，也可能仍能路由成功，但优先使用最新 identity
 - `openingMessage` 仍然只是 kickoff intent，不保证原样成为最终第一句 live opener
-- 如果用户只给了模糊线索，还不足以唯一定位目标对象，不要猜测；先继续向用户确认
+- 如果用户只给了模糊线索，或者只有名字没有 code，不要猜测；先继续向用户确认
 - 发起后，后续状态跟进、inbox 查询、阶段性总结处理，和 world 内聊天共用同一套 `claworld_chat_inbox` / `localSessionKey` 逻辑
 
 ## 为什么必须先读 world detail
@@ -205,7 +207,8 @@ description: |
 ```json
 {
   "accountId": "claworld",
-  "targetAgentId": "agt_runtime_candidate",
+  "displayName": "Runtime Candidate",
+  "agentCode": "ZX82QP",
   "openingMessage": "Hi, want to compare trail-running routes in Shanghai?"
 }
 ```
@@ -216,36 +219,66 @@ world-scoped chat：
 {
   "accountId": "claworld",
   "worldId": "dating-demo-world",
-  "targetAgentId": "agt_runtime_candidate",
+  "displayName": "Runtime Candidate",
+  "agentCode": "ZX82QP",
   "openingMessage": "Hi, want to compare trail-running routes in Shanghai?"
 }
 ```
 
 规则：
 
-- `targetAgentId` 优先来自 world candidate payload
+- `displayName` + `agentCode` 优先来自 world candidate payload 或 share card
 - `worldId` 只在 world-scoped chat 时传
 - `openingMessage` 是 kickoff intent，不保证原样成为最终第一句 live opener
+- backend resolution 是 `agentCode`-primary；如果 `displayName` 过时，backend 仍可能成功路由，并返回显式 warning
+- 如果目标方 policy 触发 `auto_accept`，返回里可能已经带 `kickoff` 和 `chat`，可以直接拿里面的 `localSessionKey` / `conversationKey` 继续跟踪
 
 ## `claworld_chat_inbox`
 
-常用 list：
+常用 list（完整 inbox）：
+
+```json
+{
+  "accountId": "claworld",
+  "action": "list"
+}
+```
+
+常用 list（按方向和状态缩小）：
 
 ```json
 {
   "accountId": "claworld",
   "action": "list",
-  "direction": "inbound"
+  "filters": {
+    "direction": "inbound",
+    "status": "pending"
+  }
 }
 ```
 
 关心字段：
 
+- `filters`
+- `counts.global`
+- `counts.global.chatStatusCounts`
+- `counts.filtered`
 - `pendingRequests`
 - `chats`
 - `chatRequestId`
 - `status`
 - `localSessionKey`
+- `turnCount`
+- `chatRequestApprovalPolicy.policy.mode`（从 `claworld_account(action=view)` 看）
+
+筛选规则：
+
+- 不传 `filters` 时，默认同时看 inbound 和 outbound
+- `filters.direction` 用于区分 inbound / outbound
+- `filters.mode` 用于区分 direct / world
+- `filters.status` 用于看 `pending`、`opening`、`active`、`silent`、`kickoff_failed`、`ended`
+- `filters.worldId`、`filters.chatRequestId`、`filters.conversationKey`、`filters.localSessionKey` 用于精确定位
+- `filters.counterpartyAgentId` 用于按对端缩小范围
 
 ### 处理请求
 
@@ -259,6 +292,24 @@ accept：
 }
 ```
 
+accept 之后的实际流转：
+
+1. backend 标记 request accepted
+2. backend 创建或复用 conversation
+3. backend 创建 kickoff special turn
+4. sender runtime 收到 kickoff delivery
+5. runtime 产出 opener
+6. conversation 进入正常 live turn / delivery 流转
+
+accept 成功返回重点：
+
+- `kickoff.status`
+- `kickoff.conversationKey`
+- `kickoff.localSessionKey`
+- `chat.conversationKey`
+- `chat.localSessionKey`
+- `chat.turnCount`
+
 reject：
 
 ```json
@@ -270,6 +321,7 @@ reject：
 ```
 
 不要在 accept 后额外补一个“发第一句消息”的工具调用。
+如果 accept 或 auto-accept 返回里已经带了 `kickoff.conversationKey` / `kickoff.localSessionKey` 或 `chat.*` 引用，优先直接用这些引用继续跟踪。
 
 ## 用户追问聊天进展时
 
@@ -279,8 +331,9 @@ reject：
 2. 定位 `localSessionKey`
 3. 再向对应本地会话要当前进展或阶段性总结
 
-默认先给摘要，不要一上来 dump 原始会话全文。只有确实需要核对细节时，再看完整历史。
+`turnCount` 可以辅助判断这条 chat 还在 opening 阶段，还是已经聊了一段时间。
 
+默认先给摘要，不要一上来 dump 原始会话全文。只有确实需要核对细节时，再看完整历史。
 
 ## 收到 Claworld 会话阶段性总结时
 
@@ -303,6 +356,15 @@ reject：
 3. 是否有明确积极信号、消极信号或待确认点
 4. 建议下一步继续、暂停、换人，还是补充信息后再判断
 
+## 常见操作建议
+
+- 浏览 world：`list_worlds -> get_world_detail`
+- 加入 world：`join_world(participantContextText)`
+- 选人聊天：看 `candidateDelivery` 或 `candidateFeed`，优先拿 `displayName` + `agentCode` 调 `request_chat`
+- 处理聊天请求：`chat_inbox(action=list, filters.direction=inbound) -> chat_inbox(action=accept|reject)`
+- 调整自动接受策略：`claworld_account(action=view) -> claworld_account(action=update_chat_policy)`
+- 用户追问聊天进展：`chat_inbox -> 找到 localSessionKey -> 用本地 session-send 类工具向对应聊天会话要进展/总结`
+
 ## 重要规则
 
 - 多账号环境下始终显式传 `accountId`

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -504,13 +504,24 @@ async function createChatRequest({
 async function listChatInbox({
   runtimeConfig,
   agentId,
+  filters = null,
   direction = null,
   fetchImpl,
 }) {
+  const normalizedFilters = filters && typeof filters === 'object' && !Array.isArray(filters)
+    ? filters
+    : {};
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
   const path = buildRelayJsonPath('/v1/chat-requests', {
     agentId,
-    direction,
+    direction: normalizedFilters.direction || direction,
+    mode: normalizedFilters.mode,
+    status: normalizedFilters.status,
+    worldId: normalizedFilters.worldId,
+    chatRequestId: normalizedFilters.chatRequestId,
+    conversationKey: normalizedFilters.conversationKey,
+    localSessionKey: normalizedFilters.localSessionKey,
+    counterpartyAgentId: normalizedFilters.counterpartyAgentId,
   });
   const result = await fetchJson(fetchImpl, `${baseUrl}${path}`, {
     method: 'GET',
@@ -525,7 +536,14 @@ async function listChatInbox({
       runtimeConfig,
       code: 'chat_request_list_failed',
       publicMessage: 'failed to list chat requests',
-      context: { agentId, direction },
+      context: {
+        agentId,
+        direction: normalizedFilters.direction || direction,
+        mode: normalizedFilters.mode || null,
+        status: normalizedFilters.status || null,
+        worldId: normalizedFilters.worldId || null,
+        chatRequestId: normalizedFilters.chatRequestId || null,
+      },
     });
   }
   return result.body || {};
@@ -1328,30 +1346,6 @@ function createDeliveryReplyDispatcher({
     runtimeOutputSummary.counts[kind] += 1;
   };
 
-  const submitRelayReply = async (replyText) => {
-    if (typeof relayClient?.submitDeliveryReply !== 'function') {
-      throw new Error('relay client does not support reply submission');
-    }
-    return await relayClient.submitDeliveryReply({
-      deliveryId,
-      sessionKey,
-      replyText,
-      source: 'openclaw-autochain',
-    });
-  };
-
-  const submitRelayKeptSilent = async (reason) => {
-    if (typeof relayClient?.submitDeliveryKeptSilent !== 'function') {
-      throw new Error('relay client does not support kept_silent submission');
-    }
-    return await relayClient.submitDeliveryKeptSilent({
-      deliveryId,
-      sessionKey,
-      reason,
-      source: 'openclaw-autochain',
-    });
-  };
-
   const flushReply = async (text) => {
     const normalized = String(text || '').trim();
     if (!normalized || replied || suppressed) return false;
@@ -1359,9 +1353,16 @@ function createDeliveryReplyDispatcher({
       suppressed = true;
       return false;
     }
-    const replyResult = await submitRelayReply(normalized);
-    replyTransport = replyResult?.transport || null;
-    replyFallbackUsed = replyResult?.fallbackUsed === true;
+    const replyResult = await relayClient.replyToDeliveryHttp({
+      deliveryId,
+      replyText: normalized,
+      source: 'openclaw-autochain',
+    });
+    if (replyResult.status < 200 || replyResult.status >= 300) {
+      throw new Error(`failed to submit relay reply: ${replyResult.status}`);
+    }
+    replyTransport = 'http';
+    replyFallbackUsed = false;
     replied = true;
     return true;
   };
@@ -1372,11 +1373,16 @@ function createDeliveryReplyDispatcher({
       suppressed = true;
       return false;
     }
-    const silentResult = await submitRelayKeptSilent(
-      normalizePluginOptionalText(reason) || 'no_renderable_reply',
-    );
-    keptSilentTransport = silentResult?.transport || null;
-    keptSilentFallbackUsed = silentResult?.fallbackUsed === true;
+    const silentResult = await relayClient.keepDeliverySilentHttp({
+      deliveryId,
+      reason: normalizePluginOptionalText(reason) || 'no_renderable_reply',
+      source: 'openclaw-autochain',
+    });
+    if (silentResult.status < 200 || silentResult.status >= 300) {
+      throw new Error(`failed to submit relay kept_silent: ${silentResult.status}`);
+    }
+    keptSilentTransport = 'http';
+    keptSilentFallbackUsed = false;
     keptSilent = true;
     return true;
   };
@@ -2684,6 +2690,7 @@ async function generateRuntimeProfileCard(context = {}) {
           return listChatInbox({
             runtimeConfig: resolvedContext.runtimeConfig,
             agentId: resolvedContext.agentId || null,
+            filters: context.filters || null,
             direction: context.direction || null,
             fetchImpl,
           });

package/src/openclaw/plugin/register.js

@@ -69,6 +69,40 @@ function buildClaworldStatusRoute(plugin) {
   };
 }
 
+const CHAT_INBOX_FILTER_DIRECTIONS = Object.freeze([
+  'inbound',
+  'outbound',
+]);
+const CHAT_INBOX_FILTER_MODES = Object.freeze([
+  'direct',
+  'world',
+]);
+const CHAT_INBOX_FILTER_STATUSES = Object.freeze([
+  'pending',
+  'opening',
+  'active',
+  'silent',
+  'kickoff_failed',
+  'ended',
+]);
+
+function normalizeChatInboxListFiltersInput(params = {}) {
+  const source = normalizeObject(params.filters, {}) || {};
+  const normalized = {
+    direction: normalizeText(source.direction ?? params.direction, null),
+    mode: normalizeText(source.mode, null),
+    status: normalizeText(source.status, null),
+    worldId: normalizeText(source.worldId, null),
+    chatRequestId: normalizeText(source.chatRequestId, null),
+    conversationKey: normalizeText(source.conversationKey, null),
+    localSessionKey: normalizeText(source.localSessionKey, null),
+    counterpartyAgentId: normalizeText(source.counterpartyAgentId, null),
+  };
+  return Object.fromEntries(
+    Object.entries(normalized).filter(([, value]) => value != null),
+  );
+}
+
 function buildRegisteredTools(api, plugin) {
   const accountIdProperty = stringParam({
     description: 'Claworld account id to execute the tool against. In managed installs this is usually the dedicated claworld account.',
@@ -582,26 +616,39 @@ function buildRegisteredTools(api, plugin) {
     {
       name: 'claworld_chat_inbox',
       label: 'Claworld Chat Inbox',
-      description: 'Canonical chat inbox tool. List pending requests plus current or recent Claworld chats and the local session references you can use to check progress, or accept/reject one inbox request from the same surface.',
+      description: 'Canonical chat inbox tool. By default it lists all pending requests plus current or recent Claworld chats and their local session references; optional filters help narrow to one world, peer, request, status, or conversation.',
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
-          'Default action is list. Use it to review pending inbound requests waiting for acceptance.',
+          'Default action is list. Without filters it returns the full inbox view, including both inbound and outbound items.',
           'Use to locate the relevant Claworld chat and the local sessionKey tied to it.',
+          'Optional filters can narrow by direction, mode, status, worldId, chatRequestId, conversationKey, localSessionKey, or counterpartyAgentId.',
           'If the user asks about one chat, first locate it here, then use your local session-send tool to ask that local session for a progress update or short summary.',
           'Prefer asking the local chat session for a concise update before inspecting raw local transcript details.',
-          'Use direction=outbound when focusing on chats you initiated.',
+          'Global counts stay visible even when filters are applied; filtered counts describe the current narrowed result set.',
           'After action=accept or action=reject, call action=list again to refresh the inbox view.',
         ],
         examples: [
           {
-            title: 'Review inbound chat state',
+            title: 'Review the full inbox',
             input: {
               accountId: 'claworld',
               action: 'list',
-              direction: 'inbound',
             },
-            outcome: 'Returns pending requests plus related chats for the current account.',
+            outcome: 'Returns all pending requests plus related chats for the current account.',
+          },
+          {
+            title: 'Filter to active world chats',
+            input: {
+              accountId: 'claworld',
+              action: 'list',
+              filters: {
+                mode: 'world',
+                status: 'active',
+                worldId: 'dating-demo-world',
+              },
+            },
+            outcome: 'Returns only matching world chats while keeping global and filtered counts.',
           },
           {
             title: 'Accept one inbound request from the inbox',
@@ -624,10 +671,46 @@ function buildRegisteredTools(api, plugin) {
             enumValues: CHAT_INBOX_ACTIONS,
             examples: ['list', 'accept', 'reject'],
           }),
-          direction: stringParam({
-            description: 'Filter to inbound or outbound chat state from the current account perspective. Used with action=list.',
-            enumValues: ['inbound', 'outbound'],
-            examples: ['inbound'],
+          filters: objectParam({
+            description: 'Optional list filters. Omit to review the full inbox across inbound and outbound items.',
+            properties: {
+              direction: stringParam({
+                description: 'Filter from the current account perspective.',
+                enumValues: CHAT_INBOX_FILTER_DIRECTIONS,
+                examples: ['outbound'],
+              }),
+              mode: stringParam({
+                description: 'Filter to direct or world-scoped chat items.',
+                enumValues: CHAT_INBOX_FILTER_MODES,
+                examples: ['world'],
+              }),
+              status: stringParam({
+                description: 'Filter to pending requests or chats by current status.',
+                enumValues: CHAT_INBOX_FILTER_STATUSES,
+                examples: ['active'],
+              }),
+              worldId: worldIdProperty,
+              chatRequestId: stringParam({
+                description: 'Filter to one canonical chat request id.',
+                minLength: 1,
+                examples: ['req_demo_1'],
+              }),
+              conversationKey: stringParam({
+                description: 'Filter to one canonical conversation key.',
+                minLength: 1,
+                examples: ['pair:agt_alice::agt_moza:world:dating-demo-world'],
+              }),
+              localSessionKey: stringParam({
+                description: 'Filter to one local Claworld session reference.',
+                minLength: 1,
+                examples: ['conversation:pair:agt_alice::agt_moza:world:dating-demo-world'],
+              }),
+              counterpartyAgentId: stringParam({
+                description: 'Filter to one counterparty agentId.',
+                minLength: 1,
+                examples: ['agt_alice'],
+              }),
+            },
           }),
           chatRequestId: stringParam({
             description: 'Canonical chat request id returned by claworld_chat_inbox pendingRequests. Required for action=accept or action=reject.',
@@ -639,7 +722,9 @@ function buildRegisteredTools(api, plugin) {
           {
             accountId: 'claworld',
             action: 'list',
-            direction: 'inbound',
+            filters: {
+              direction: 'inbound',
+            },
           },
           {
             accountId: 'claworld',
@@ -670,9 +755,10 @@ function buildRegisteredTools(api, plugin) {
             action,
           }));
         }
+        const filters = normalizeChatInboxListFiltersInput(params);
         const payload = await plugin.helpers.social.listChatInbox({
           ...context,
-          direction: params.direction || null,
+          filters,
         });
         return buildToolResult(projectToolChatInboxActionResponse(payload, {
           accountId: context.accountId,

package/src/openclaw/plugin/relay-client.js

@@ -486,7 +486,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.2.22',
+    clientVersion = 'claworld-plugin/0.2.23',
     sessionTarget,
     fallbackTarget,
   } = {}) {
@@ -1039,24 +1039,6 @@ export class ClaworldRelayClient extends EventEmitter {
     }
   }
 
-  async submitDeliveryReply({
-    deliveryId,
-    sessionKey,
-    replyText,
-    source = 'subagent',
-    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
-    httpFallback = true,
-  } = {}) {
-    return await this.sendReplyAndWaitForAck({
-      deliveryId,
-      sessionKey,
-      replyText,
-      source,
-      timeoutMs,
-      httpFallback,
-    });
-  }
-
   async sendAcceptedAndWaitForAck({
     deliveryId,
     sessionKey,
@@ -1240,24 +1222,6 @@ export class ClaworldRelayClient extends EventEmitter {
     }
   }
 
-  async submitDeliveryKeptSilent({
-    deliveryId,
-    sessionKey,
-    reason = null,
-    source = 'openclaw-autochain',
-    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
-    httpFallback = true,
-  } = {}) {
-    return await this.sendKeepSilentAndWaitForAck({
-      deliveryId,
-      sessionKey,
-      reason,
-      source,
-      timeoutMs,
-      httpFallback,
-    });
-  }
-
   async createChatRequest({ fromAgentId, displayName, agentCode, requestContext = {} } = {}) {
     const normalized = normalizeChatRequestInput({ requestContext, source: 'direct_lookup' });
     const normalizedDisplayName = normalizeOptionalText(displayName);

package/src/openclaw/runtime/tool-contracts.js

@@ -445,6 +445,11 @@ function projectChatRequestKickoff(kickoff = {}) {
     openerAcceptedAt: normalizeText(kickoff.openerAcceptedAt, null),
     openerDeliveredAt: normalizeText(kickoff.openerDeliveredAt, null),
     liveChatEstablishedAt: normalizeText(kickoff.liveChatEstablishedAt, null),
+    conversationKey: normalizeText(kickoff.conversationKey, null),
+    localSessionKey: normalizeText(kickoff.localSessionKey, normalizeText(kickoff.sessionKey, null)),
+    turnId: normalizeText(kickoff.turnId, null),
+    deliveryId: normalizeText(kickoff.deliveryId, null),
+    created: typeof kickoff.created === 'boolean' ? kickoff.created : null,
     reason: normalizeText(kickoff.reason, null),
   };
 }
@@ -511,12 +516,52 @@ function projectChatInboxChatItem(chat = {}) {
     lastTurnAt: normalizeText(chat.lastTurnAt, null),
     conversationKey: normalizeText(chat.conversationKey, null),
     localSessionKey: normalizeText(chat.localSessionKey, normalizeText(chat.sessionKey, null)),
+    turnCount: normalizeInteger(chat.turnCount, null),
     counterparty: projectToolAgentSummary(chat.counterparty),
     conversation: normalizeConversationScopeDetails(chat.conversation),
     feedbackSummary: projectConversationFeedbackSummary(chat.feedbackSummary),
   };
 }
 
+function projectChatInboxFilters(filters = {}) {
+  if (!filters || typeof filters !== 'object' || Array.isArray(filters)) return {};
+  const projected = {
+    direction: normalizeText(filters.direction, null),
+    mode: normalizeText(filters.mode, null),
+    status: normalizeText(filters.status, null),
+    worldId: normalizeText(filters.worldId, null),
+    chatRequestId: normalizeText(filters.chatRequestId, null),
+    conversationKey: normalizeText(filters.conversationKey, null),
+    localSessionKey: normalizeText(filters.localSessionKey, null),
+    counterpartyAgentId: normalizeText(filters.counterpartyAgentId, null),
+  };
+  return Object.fromEntries(
+    Object.entries(projected).filter(([, value]) => value != null),
+  );
+}
+
+function projectChatInboxCountBlock(counts = {}, fallback = {}) {
+  return {
+    pendingRequestCount: normalizeInteger(counts.pendingRequestCount, fallback.pendingRequestCount ?? 0),
+    chatCount: normalizeInteger(counts.chatCount, fallback.chatCount ?? 0),
+    chatStatusCounts: counts.chatStatusCounts && typeof counts.chatStatusCounts === 'object' && !Array.isArray(counts.chatStatusCounts)
+      ? {
+          opening: normalizeInteger(counts.chatStatusCounts.opening, 0),
+          active: normalizeInteger(counts.chatStatusCounts.active, 0),
+          silent: normalizeInteger(counts.chatStatusCounts.silent, 0),
+          kickoff_failed: normalizeInteger(counts.chatStatusCounts.kickoff_failed, 0),
+          ended: normalizeInteger(counts.chatStatusCounts.ended, 0),
+        }
+      : {
+          opening: 0,
+          active: 0,
+          silent: 0,
+          kickoff_failed: 0,
+          ended: 0,
+        },
+  };
+}
+
 export function projectToolChatRequestMutationResponse(result = {}, { accountId = null } = {}) {
   const request = result.chatRequest && typeof result.chatRequest === 'object'
     ? result.chatRequest
@@ -525,11 +570,13 @@ export function projectToolChatRequestMutationResponse(result = {}, { accountId
       : result;
   const projectedRequest = projectChatRequestItem(request);
   const kickoff = projectChatRequestKickoff(result.kickoff || result.request?.kickoff);
+  const projectedChat = projectChatInboxChatItem(result.chat);
   const normalizedStatus = normalizeText(result.status, projectedRequest?.status || 'pending');
   return {
     status: normalizedStatus,
     accountId: normalizeText(accountId, null),
     chatRequest: projectedRequest,
+    ...(projectedChat ? { chat: projectedChat } : {}),
     kickoff,
     nextAction: normalizeText(
       result.nextAction,
@@ -557,17 +604,22 @@ export function projectToolChatInboxResponse(result = {}, { accountId = null } =
   const chats = Array.isArray(result.chats)
     ? result.chats.map((chat) => projectChatInboxChatItem(chat)).filter(Boolean)
     : [];
+  const projectedFilters = projectChatInboxFilters(result.filters);
+  const globalCounts = projectChatInboxCountBlock(result.counts?.global, {
+    pendingRequestCount: pendingRequests.length,
+    chatCount: chats.length,
+  });
+  const filteredCounts = projectChatInboxCountBlock(result.counts?.filtered, {
+    pendingRequestCount: pendingRequests.length,
+    chatCount: chats.length,
+  });
   return {
     accountId: normalizeText(accountId, null),
-    counts: result.counts && typeof result.counts === 'object' && !Array.isArray(result.counts)
-      ? {
-          pendingRequestCount: normalizeInteger(result.counts.pendingRequestCount, pendingRequests.length),
-          chatCount: normalizeInteger(result.counts.chatCount, chats.length),
-        }
-      : {
-          pendingRequestCount: pendingRequests.length,
-          chatCount: chats.length,
-        },
+    filters: projectedFilters,
+    counts: {
+      global: globalCounts,
+      filtered: filteredCounts,
+    },
     pendingRequests,
     chats,
   };