@ray-js/t-agent 0.2.7-beta.1 → 0.2.7-beta.11

package/README-zh_CN.md

@@ -22,12 +22,21 @@ yarn add @ray-js/t-agent @ray-js/t-agent-plugin-aistream @ray-js/t-agent-ui-ray
     "DeviceKit": "4.6.1",
     "HomeKit": "3.4.0",
     "MiniKit": "3.12.1",
-    "AIStreamKit": "1.0.0"
+    "AIStreamKit": "1.3.2"
   },
   "baseversion": "2.21.10"
 }
 ```
 
+### 小程序 kit 与功能对应表
+
+部分功能对 App 的 kit 有依赖要求，需要配置 AIStreamKit 最低才能使用这些功能
+
+| 功能       | AIStreamKit 最低版本 | 相关 API                              |
+| ---------- | -------------------- | ------------------------------------- |
+| 对话分组   | 1.3.2                | agent.plugins.aiStream.getChatId      |
+| 自定义参数 | 2.1.0                | agent.plugins.aiStream.onUserDataRead |
+
 ## package.json 依赖要求
 
 ```json
@@ -771,6 +780,7 @@ const createAgent = () => {
 - `indexId` 索引 ID，默认为 'default'
 - `homeId` 家庭 ID，不填默认当前家庭
 - `earlyStart` 是否在 onAgentStart 阶段就建立连接
+- `eventIdPrefix` eventId 前缀，用于方便云端调试和日志追踪
 - `tokenOptions` 获取 agent token 的参数
   - `api` API 接口名
   - `version` 接口版本
@@ -779,14 +789,30 @@ const createAgent = () => {
 
 方法：
 
-- `agent.plugins.aiStream.send` 向智能体发送一条消息
-- `agent.plugins.aiStream.chat` 向智能体发送一条消息，并生成提问 ChatMessage 对象和 AI 回答 ChatMessage 对象，流式更新
+- `agent.plugins.aiStream.send(blocks, signal, userData)` 向智能体发送一条消息
+  - `blocks` 输入块数组
+  - `signal` 可选的 AbortSignal，用于中断请求
+  - `userData` 可选的用户数据，会附带在发送的消息中
+- `agent.plugins.aiStream.chat(blocks, signal, options)` 向智能体发送一条消息，并生成提问 ChatMessage 对象和 AI 回答 ChatMessage 对象，流式更新
+  - `blocks` 输入块数组
+  - `signal` 可选的 AbortSignal
+  - `options.sendBy` 发送者角色，默认为 'user'
+  - `options.responseBy` 响应者角色，默认为 'assistant'
+  - `options.userData` 可选的用户数据
+- `agent.plugins.aiStream.getChatId()` 获取当前会话的 chatId，返回 Promise<string>
 
 Hooks：
 
 - `onMessageParse` 当读取历史消息，解析消息时触发，可以在这个 Hook 里修改消息
   - `msgItem` 存储的消息对象
   - `result.messages` 解析后的消息列表
+- `onChatMessageSent` 当用户消息和响应消息创建后触发
+  - `userMessage` 用户发送的消息
+  - `respMessage` AI 的响应消息
+- `onTextCompose` 当收到文本数据时触发，用于处理文本的渲染
+  - `respMsg` 响应消息
+  - `status` 消息状态
+  - `result.text` 文本内容，可以修改
 - `onSkillCompose` 当收到技能数据时触发，用于处理技能的渲染
   - `skill` 技能数据数组 (ReceivedTextSkillPacketBody[])
   - `respMsg` 响应消息
@@ -801,6 +827,47 @@ Hooks：
 - `onCardsReceived` 当收到卡片数据时触发
   - `skills` 技能数据列表 (ReceivedTextSkillPacketBody[])
   - `result.cards` 卡片列表
+- `onUserDataRead` **(0.2.x 新增)** 当需要读取用户自定义数据时触发，用于向 AI 平台传递额外的上下文信息
+  - `type` 触发类型，可以是 'create-session' 或 'start-event'
+    - `'create-session'` 创建会话时触发，只触发一次
+    - `'start-event'` 每次发送消息时触发
+  - `data` 上下文数据
+    - `data.blocks` 当 type 为 'start-event' 时，包含本次发送的输入块
+  - `result.userData` 返回的用户数据对象，会被合并后发送给 AI 平台
+
+**使用示例**：
+
+```tsx
+const agent = createChatAgent(
+  withUI(),
+  withAIStream({
+    agentId: 'your-agent-id',
+  })
+);
+
+agent.plugins.aiStream.onUserDataRead((type, data, result) => {
+  // 在创建会话时传递用户信息
+  if (type === 'create-session') {
+    result.sessionAttributes = {
+      'custom.param': {
+        userName: { value: 'John' },
+        userLevel: { value: 'Plus' },
+      },
+    };
+    return;
+  }
+  // 在每次发送消息时传递动态上下文
+  if (type === 'start-event') {
+    result.eventAttributes = {
+      'custom.param': {
+        timestamp: { value: Date.now() },
+        pid: { value: '123456' },
+      },
+    };
+    return;
+  }
+});
+```
 
 ### withBuildIn 插件
 

package/README.md

@@ -22,7 +22,7 @@ yarn add @ray-js/t-agent @ray-js/t-agent-plugin-aistream @ray-js/t-agent-ui-ray
     "DeviceKit": "4.6.1",
     "HomeKit": "3.4.0",
     "MiniKit": "3.12.1",
-    "AIStreamKit": "1.0.0"
+    "AIStreamKit": "1.3.2"
   },
   "baseversion": "2.21.10"
 }
@@ -766,6 +766,7 @@ Parameters:
 - `indexId` Index ID, defaults to 'default'
 - `homeId` Home ID, defaults to current home if not provided
 - `earlyStart` Whether to establish connection during onAgentStart phase
+- `eventIdPrefix` Event ID prefix for cloud debugging and log tracing
 - `tokenOptions` Parameters for getting agent token
   - `api` API interface name
   - `version` Interface version
@@ -774,14 +775,30 @@ Parameters:
 
 Methods:
 
-- `agent.plugins.aiStream.send`: Send a message to the agent
-- `agent.plugins.aiStream.chat`: Send a message to the agent while generating a ChatMessage object for the question and the AI's answer, updating in a streaming manner
+- `agent.plugins.aiStream.send(blocks, signal, userData)` Send a message to the agent
+  - `blocks` Input block array
+  - `signal` Optional AbortSignal for interrupting requests
+  - `userData` Optional user data to be included with the message
+- `agent.plugins.aiStream.chat(blocks, signal, options)` Send a message to the agent while generating a ChatMessage object for the question and the AI's answer, updating in a streaming manner
+  - `blocks` Input block array
+  - `signal` Optional AbortSignal
+  - `options.sendBy` Sender role, defaults to 'user'
+  - `options.responseBy` Responder role, defaults to 'assistant'
+  - `options.userData` Optional user data
+- `agent.plugins.aiStream.getChatId()` Get the current session's chatId, returns Promise<string>
 
 Hooks:
 
 - `onMessageParse` Triggered when reading history messages and parsing them, allowing for message modification in this Hook
   - `msgItem` Stored message object
   - `result.messages` Parsed message list
+- `onChatMessageSent` Triggered after user message and response message are created
+  - `userMessage` User's sent message
+  - `respMessage` AI's response message
+- `onTextCompose` Triggered when receiving text data, used for handling text rendering
+  - `respMsg` Response message
+  - `status` Message status
+  - `result.text` Text content, can be modified
 - `onSkillCompose` Triggered when receiving skill data, used for handling skill rendering
   - `skill` Skill data array (ReceivedTextSkillPacketBody[])
   - `respMsg` Response message
@@ -796,6 +813,47 @@ Hooks:
 - `onCardsReceived` Triggered when receiving card data
   - `skills` Skill data list (ReceivedTextSkillPacketBody[])
   - `result.cards` Card list
+- `onUserDataRead` **(0.2.x New)** Triggered when user custom data needs to be read, used to pass additional context information to the AI platform
+  - `type` Trigger type, can be 'create-session' or 'start-event'
+    - `'create-session'` Triggered when creating a session, only once
+    - `'start-event'` Triggered each time a message is sent
+  - `data` Context data
+    - `data.blocks` When type is 'start-event', contains the input blocks for this send
+  - `result.userData` Returned user data object, will be merged and sent to the AI platform
+
+**Usage Example**:
+
+```tsx
+const agent = createChatAgent(
+  withUI(),
+  withAIStream({
+    agentId: 'your-agent-id',
+  })
+);
+
+agent.plugins.aiStream.onUserDataRead((type, data, result) => {
+  // Pass user information when creating a session
+  if (type === 'create-session') {
+    result.sessionAttributes = {
+      'custom.param': {
+        userName: { value: 'John' },
+        userLevel: { value: 'Plus' },
+      },
+    };
+    return;
+  }
+  // Pass dynamic context each time a message is sent
+  if (type === 'start-event') {
+    result.eventAttributes = {
+      'custom.param': {
+        timestamp: { value: Date.now() },
+        pid: { value: '123456' },
+      },
+    };
+    return;
+  }
+});
+```
 
 ### withBuildIn Plugin
 

package/dist/chat/ChatAgent.js

@@ -107,7 +107,8 @@ export default class ChatAgent {
         await this.hooks.callHook('onAgentDispose');
         await this.session.dispose();
         this.started = false;
-        for (const hook of this.pluginHooks) {
+        for (let i = 0; i < this.pluginHooks.length; i++) {
+          const hook = this.pluginHooks[i];
           hook.removeAllHooks();
         }
         await this.hooks.callHook('onAgentDispose:after');
@@ -216,7 +217,8 @@ export default class ChatAgent {
                   }).bubble.setText(text).update();
                 } else if (part.type === 'attachment' && attachmentCompose) {
                   const list = (await attachmentCompose(message, part)) || [];
-                  for (const m of list) {
+                  for (let i = 0; i < list.length; i++) {
+                    const m = list[i];
                     m.set({
                       status: ChatMessageStatus.FINISH
                     });
@@ -283,7 +285,8 @@ export default class ChatAgent {
     });
     this.hooks = createHooks();
     const _hooks = ['onAgentStart', 'onChatStart', 'onChatResume', 'onMessageListInit', 'onInputBlocksPush', 'onMessageChange', 'onMessagePersist', 'onTileEvent', 'onAgentDispose', 'onUserAbort', 'onError'];
-    for (const hook of _hooks) {
+    for (let i = 0; i < _hooks.length; i++) {
+      const hook = _hooks[i];
       this[hook] = (fn, type) => {
         if (type === 'before') {
           return this.hooks.hook("".concat(hook, ":before"), fn);

package/dist/chat/ChatBubbleTile.js

@@ -1,5 +1,4 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import "core-js/modules/web.dom-collections.iterator.js";
 import ChatTile from './ChatTile';
 import { BubbleTileStatus } from './types';
 import { generateId } from './utils';
@@ -56,7 +55,8 @@ export default class ChatBubbleTile extends ChatTile {
   }
   ensureTextTile() {
     if (!this.textTile) {
-      for (const child of this.children) {
+      for (let i = 0; i < this.children.length; i++) {
+        const child = this.children[i];
         if (child.type === 'text') {
           this.textTile = child;
           break;
@@ -78,7 +78,8 @@ export default class ChatBubbleTile extends ChatTile {
   initWithInputBlocks(blocks) {
     this.textTile = null;
     this.children = [];
-    for (const block of blocks) {
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
       if (block.type === 'text') {
         if (!this.textTile) {
           this.textTile = new ChatTile(this.message, 'text', {

package/dist/chat/ChatMessage.js

@@ -17,7 +17,8 @@ export default class ChatMessage {
   }
   get bubble() {
     if (!this._bubble) {
-      for (const tile of this.tiles) {
+      for (let i = 0; i < this.tiles.length; i++) {
+        const tile = this.tiles[i];
         if (tile.type === 'bubble') {
           this._bubble = tile;
           break;
@@ -47,7 +48,8 @@ export default class ChatMessage {
     this.initTiles(null, tiles || []);
   }
   initTiles(root, tiles) {
-    for (const tile of tiles) {
+    for (let i = 0; i < tiles.length; i++) {
+      const tile = tiles[i];
       let r;
       if (root) {
         r = root.addTile(tile.type, tile.data, tile.id);
@@ -81,7 +83,8 @@ export default class ChatMessage {
       }
       await this.agent.hooks.callHook('onMessageChange:before', 'update', this);
       await this.agent.hooks.callHook('onMessageChange', 'update', this);
-      for (const tile of this.tiles) {
+      for (let i = 0; i < this.tiles.length; i++) {
+        const tile = this.tiles[i];
         this.agent.session.bindTile(tile);
       }
       await this.agent.hooks.callHook('onMessageChange:after', 'update', this);
@@ -111,7 +114,8 @@ export default class ChatMessage {
     });
   }
   setTilesLocked(locked) {
-    for (const tile of this.tiles) {
+    for (let i = 0; i < this.tiles.length; i++) {
+      const tile = this.tiles[i];
       tile.setLocked(locked);
     }
     return this;
@@ -153,7 +157,8 @@ export default class ChatMessage {
   findTileByType(type) {
     const ret = [];
     const tiles = this.tiles;
-    for (const tile of tiles) {
+    for (let i = 0; i < tiles.length; i++) {
+      const tile = tiles[i];
       if (tile.type === type) {
         ret.push(tile);
       }

package/dist/chat/ChatSession.js

@@ -1,6 +1,4 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.for-each.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import { ChatMessageStatus } from './types';
 import { createHooks } from 'hookable';
@@ -36,41 +34,59 @@ export default class ChatSession {
       return ret;
     });
     _defineProperty(this, "initMessages", messages => {
-      for (const message of messages) {
+      for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
         this.bindMessage(message);
-        message.set({
-          status: ChatMessageStatus.FINISH
-        })._setIsShow();
+        // Optimization: Direct assignment to avoid object allocation and excess function calls
+        message.status = ChatMessageStatus.FINISH;
+        message._setIsShow();
       }
     });
     _defineProperty(this, "getTileById", id => {
       return this.tileIdIndex.get(id);
     });
     _defineProperty(this, "bindTile", tile => {
-      this.tileIdIndex.set(tile.id, tile);
-      for (const child of tile.children) {
-        this.bindTile(child);
+      // Iterative approach to avoid recursion overhead
+      const stack = [tile];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        this.tileIdIndex.set(current.id, current);
+
+        // Push children to stack
+        if (current.children && current.children.length > 0) {
+          for (let i = current.children.length - 1; i >= 0; i--) {
+            stack.push(current.children[i]);
+          }
+        }
       }
     });
     _defineProperty(this, "unbindTile", tile => {
-      this.tileIdIndex.delete(tile.id);
-      for (const child of tile.children) {
-        this.unbindTile(child);
+      // Iterative approach
+      const stack = [tile];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        this.tileIdIndex.delete(current.id);
+        if (current.children && current.children.length > 0) {
+          for (let i = current.children.length - 1; i >= 0; i--) {
+            stack.push(current.children[i]);
+          }
+        }
       }
     });
     _defineProperty(this, "bindMessage", message => {
       this.messages.set(message.id, message);
-      for (const tile of message.tiles) {
+      for (let i = 0; i < message.tiles.length; i++) {
+        const tile = message.tiles[i];
         this.bindTile(tile);
       }
     });
     _defineProperty(this, "unbindMessage", message => {
       this.messages.delete(message.id);
-      this.tileIdIndex.forEach(tile => {
-        if (tile.message.id === message.id) {
-          this.tileIdIndex.delete(tile.id);
-        }
-      });
+      // Optimization: Instead of full scan, just unbind tiles known to be in the message
+      for (let i = 0; i < message.tiles.length; i++) {
+        const tile = message.tiles[i];
+        this.unbindTile(tile);
+      }
     });
     _defineProperty(this, "onChange", fn => this.hooks.hook('onChange', fn));
     _defineProperty(this, "getLatestMessage", () => {
@@ -85,7 +101,8 @@ export default class ChatSession {
     this.agent = agent;
     this.hooks = createHooks();
     const hooks = ['onChange'];
-    for (const hook of hooks) {
+    for (let i = 0; i < hooks.length; i++) {
+      const hook = hooks[i];
       this[hook] = fn => this.hooks.hook(hook, fn);
     }
   }

package/dist/chat/ChatTile.js

@@ -2,7 +2,6 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.map.js";
-import "core-js/modules/web.dom-collections.iterator.js";
 import { generateId } from './utils';
 export default class ChatTile {
   constructor(message, type) {
@@ -20,7 +19,8 @@ export default class ChatTile {
   setLocked(value) {
     this.locked = value;
     // 递归锁定
-    for (const child of this.children) {
+    for (let i = 0; i < this.children.length; i++) {
+      const child = this.children[i];
       child.setLocked(value);
     }
     return this;
@@ -61,7 +61,8 @@ export default class ChatTile {
   }
   findByType(type) {
     let ret = [];
-    for (const tile of this.children) {
+    for (let i = 0; i < this.children.length; i++) {
+      const tile = this.children[i];
       if (tile.type === type) {
         ret.push(tile);
       }

package/dist/chat/createChatAgent.js

@@ -1,4 +1,3 @@
-import "core-js/modules/web.dom-collections.iterator.js";
 import ChatAgent from './ChatAgent';
 
 // 提取单个插件的返回类型（排除 hooks）
@@ -7,19 +6,15 @@ import ChatAgent from './ChatAgent';
 
 export function createChatAgent() {
   const agent = new ChatAgent();
-  for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
-    plugins[_key] = arguments[_key];
-  }
-  for (const plugin of plugins) {
+  for (let i = 0; i < arguments.length; i++) {
+    const plugin = i < 0 || arguments.length <= i ? undefined : arguments[i];
     agent.applyPlugin(plugin);
   }
   return agent;
 }
 export function applyChatAgentPlugins(agent) {
-  for (var _len2 = arguments.length, plugins = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-    plugins[_key2 - 1] = arguments[_key2];
-  }
-  for (const plugin of plugins) {
+  for (let i = 0; i < (arguments.length <= 1 ? 0 : arguments.length - 1); i++) {
+    const plugin = i + 1 < 1 || arguments.length <= i + 1 ? undefined : arguments[i + 1];
     agent.applyPlugin(plugin);
   }
   return agent;

package/dist/chat/index.d.ts

@@ -4,10 +4,11 @@ import StreamResponse from './StreamResponse';
 import ChatTile from './ChatTile';
 import ChatBubbleTile from './ChatBubbleTile';
 import ChatMessage from './ChatMessage';
-import { generateId, safeParseJSON, isAbortError, shuffleWithSeed } from './utils';
+import { generateId, isAbortError, shuffleWithSeed } from './utils';
 import Logger, { getLogger } from './Logger';
 import { Emitter, EmitterEvent } from './Emitter';
 export { createHooks, Hookable } from 'hookable';
-export { ChatAgent, ChatSession, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, safeParseJSON, getLogger, Logger, Emitter, EmitterEvent, isAbortError, shuffleWithSeed, };
+export { ChatAgent, ChatSession, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, getLogger, Logger, Emitter, EmitterEvent, isAbortError, shuffleWithSeed, };
 export * from './createChatAgent';
 export * from './types';
+export * from './json';

package/dist/chat/index.js

@@ -4,10 +4,11 @@ import StreamResponse from './StreamResponse';
 import ChatTile from './ChatTile';
 import ChatBubbleTile from './ChatBubbleTile';
 import ChatMessage from './ChatMessage';
-import { generateId, safeParseJSON, isAbortError, shuffleWithSeed } from './utils';
+import { generateId, isAbortError, shuffleWithSeed } from './utils';
 import Logger, { getLogger } from './Logger';
 import { Emitter, EmitterEvent } from './Emitter';
 export { createHooks, Hookable } from 'hookable';
-export { ChatAgent, ChatSession, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, safeParseJSON, getLogger, Logger, Emitter, EmitterEvent, isAbortError, shuffleWithSeed };
+export { ChatAgent, ChatSession, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, getLogger, Logger, Emitter, EmitterEvent, isAbortError, shuffleWithSeed };
 export * from './createChatAgent';
-export * from './types';
+export * from './types';
+export * from './json';

package/dist/chat/json.d.ts

@@ -0,0 +1,7 @@
+export declare function partialJSONParse<T = any>(input: string): T;
+export interface JsonParseResult<T = any> {
+    value: T;
+    complete: boolean;
+}
+export declare function partialJSONParseWithStatus<T = any>(input: string): JsonParseResult<T>;
+export declare function safeParseJSON<T = any>(str: any): T | undefined;

package/dist/chat/json.js

@@ -0,0 +1,540 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.regexp.flags.js";
+import "core-js/modules/es.string.trim.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+/* eslint-disable no-continue,no-bitwise,no-param-reassign */
+var TokenType = /*#__PURE__*/function (TokenType) {
+  TokenType[TokenType["Brace"] = 0] = "Brace";
+  TokenType[TokenType["Paren"] = 1] = "Paren";
+  TokenType[TokenType["Separator"] = 2] = "Separator";
+  TokenType[TokenType["Delimiter"] = 3] = "Delimiter";
+  TokenType[TokenType["String"] = 4] = "String";
+  TokenType[TokenType["Number"] = 5] = "Number";
+  TokenType[TokenType["Name"] = 6] = "Name";
+  return TokenType;
+}(TokenType || {});
+var TokenFlag = /*#__PURE__*/function (TokenFlag) {
+  TokenFlag[TokenFlag["None"] = 0] = "None";
+  TokenFlag[TokenFlag["IsKey"] = 1] = "IsKey";
+  TokenFlag[TokenFlag["IsDanglingKey"] = 2] = "IsDanglingKey";
+  return TokenFlag;
+}(TokenFlag || {}); // Parallel arrays container
+const C_BRACE_OPEN = 123; // {
+const C_BRACE_CLOSE = 125; // }
+const C_BRACKET_OPEN = 91; // [
+const C_BRACKET_CLOSE = 93; // ]
+const C_COLON = 58; // :
+const C_COMMA = 44; // ,
+const C_QUOTE = 34; // "
+const C_BACKSLASH = 92; // \
+const C_MINUS = 45; // -
+const C_PLUS = 43; // +
+const C_DOT = 46; // .
+const C_e = 101; // e
+const C_E = 69; // E
+const C_SPACE = 32;
+const C_TAB = 9;
+const C_LF = 10;
+const C_CR = 13;
+function isDigit(code) {
+  return code >= 48 && code <= 57; // 0-9
+}
+
+// Lightweight stack for tracking context during tokenization
+var ContextKind = /*#__PURE__*/function (ContextKind) {
+  ContextKind[ContextKind["Object"] = 0] = "Object";
+  ContextKind[ContextKind["Array"] = 1] = "Array";
+  return ContextKind;
+}(ContextKind || {});
+function tokenize(input) {
+  let current = 0;
+  const len = input.length;
+  const types = [];
+  const values = [];
+  const flags = [];
+
+  // Context stack for tracking JSON structure to flag keys
+  const stackKind = [];
+  const stackState = [];
+
+  // Helper to update context after a value
+  const afterValue = () => {
+    if (stackKind.length > 0) {
+      // Direct array access is faster
+      const idx = stackKind.length - 1;
+      if (stackKind[idx] === ContextKind.Object) {
+        stackState[idx] = 3; // Expect comma or end
+      } else {
+        stackState[idx] = 1; // Expect comma or end
+      }
+    }
+  };
+  while (current < len) {
+    const code = input.charCodeAt(current);
+    if (code === C_SPACE || code === C_TAB || code === C_LF || code === C_CR) {
+      current++;
+      continue;
+    }
+    if (code === C_BRACE_OPEN) {
+      types.push(TokenType.Brace);
+      values.push('{');
+      flags.push(TokenFlag.None);
+      stackKind.push(ContextKind.Object);
+      stackState.push(0); // Expect key
+      current++;
+      continue;
+    }
+    if (code === C_BRACE_CLOSE) {
+      types.push(TokenType.Brace);
+      values.push('}');
+      flags.push(TokenFlag.None);
+      stackKind.pop();
+      stackState.pop();
+      afterValue(); // Closing brace acts like a value completion for parent
+      current++;
+      continue;
+    }
+    if (code === C_BRACKET_OPEN) {
+      types.push(TokenType.Paren);
+      values.push('[');
+      flags.push(TokenFlag.None);
+      stackKind.push(ContextKind.Array);
+      stackState.push(0); // Expect value
+      current++;
+      continue;
+    }
+    if (code === C_BRACKET_CLOSE) {
+      types.push(TokenType.Paren);
+      values.push(']');
+      flags.push(TokenFlag.None);
+      stackKind.pop();
+      stackState.pop();
+      afterValue(); // Closing bracket acts like a value completion for parent
+      current++;
+      continue;
+    }
+    if (code === C_COLON) {
+      types.push(TokenType.Separator);
+      values.push(':');
+      flags.push(TokenFlag.None);
+      if (stackKind.length > 0) {
+        const idx = stackKind.length - 1;
+        if (stackKind[idx] === ContextKind.Object) {
+          stackState[idx] = 2; // Expect value
+        }
+      }
+      current++;
+      continue;
+    }
+    if (code === C_COMMA) {
+      types.push(TokenType.Delimiter);
+      values.push(',');
+      flags.push(TokenFlag.None);
+      if (stackKind.length > 0) {
+        const idx = stackKind.length - 1;
+        if (stackKind[idx] === ContextKind.Object) stackState[idx] = 0; // Expect key next
+        else stackState[idx] = 0; // Expect value next
+      }
+      current++;
+      continue;
+    }
+    if (code === C_QUOTE) {
+      let flag = TokenFlag.None;
+      let isKeyContext = false;
+      if (stackKind.length > 0) {
+        const idx = stackKind.length - 1;
+        if (stackKind[idx] === ContextKind.Object && stackState[idx] === 0) {
+          isKeyContext = true;
+          flag |= TokenFlag.IsKey;
+          stackState[idx] = 1; // Expect colon next
+        }
+      }
+      if (!isKeyContext) {
+        afterValue();
+      }
+      const start = current;
+      current++; // skip opening quote
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+      // Fast scan
+      while (current < len) {
+        const c = input.charCodeAt(current);
+        if (c === C_QUOTE) break;
+        if (c === C_BACKSLASH) {
+          current += 2; // skip backslash and next char
+        } else {
+          current++;
+        }
+      }
+      if (current >= len) {
+        // Unterminated string
+        if (flag & TokenFlag.IsKey) {
+          flag |= TokenFlag.IsDanglingKey;
+        }
+        types.push(TokenType.String);
+        values.push(input.slice(start + 1, current));
+        flags.push(flag);
+        break; // End of input
+      }
+
+      // Found closing quote
+      const contentEnd = current;
+      current++; // consume closing quote
+
+      types.push(TokenType.String);
+      values.push(input.slice(start + 1, contentEnd));
+      flags.push(flag);
+      continue;
+    }
+
+    // Numbers
+    if (isDigit(code) || code === C_MINUS) {
+      afterValue();
+      const start = current;
+      if (code === C_MINUS) current++;
+      while (current < len) {
+        const c = input.charCodeAt(current);
+        if (isDigit(c) || c === C_DOT || c === C_e || c === C_E || c === C_PLUS || c === C_MINUS) {
+          current++;
+        } else {
+          break;
+        }
+      }
+      types.push(TokenType.Number);
+      values.push(input.slice(start, current));
+      flags.push(TokenFlag.None);
+      continue;
+    }
+
+    // true / false / null
+    if (code === 116 /* t */) {
+      if (input.startsWith('true', current)) {
+        afterValue();
+        types.push(TokenType.Name);
+        values.push('true');
+        flags.push(TokenFlag.None);
+        current += 4;
+        continue;
+      }
+    }
+    if (code === 102 /* f */) {
+      if (input.startsWith('false', current)) {
+        afterValue();
+        types.push(TokenType.Name);
+        values.push('false');
+        flags.push(TokenFlag.None);
+        current += 5;
+        continue;
+      }
+    }
+    if (code === 110 /* n */) {
+      if (input.startsWith('null', current)) {
+        afterValue();
+        types.push(TokenType.Name);
+        values.push('null');
+        flags.push(TokenFlag.None);
+        current += 4;
+        continue;
+      }
+    }
+
+    // Invalid or unknown
+    if (code >= 65 && code <= 90 ||
+    // A-Z
+    code >= 97 && code <= 122 // a-z
+    ) {
+      let value = '';
+      while (current < len) {
+        const c = input.charCodeAt(current);
+        if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+          value += input[current];
+          current++;
+        } else {
+          break;
+        }
+      }
+      throw new Error("Invalid token: ".concat(value, " is not a valid token!"));
+    }
+    current++;
+  }
+  return {
+    types,
+    values,
+    flags
+  };
+}
+function strip(tokens) {
+  const {
+    types,
+    values,
+    flags
+  } = tokens;
+  if (types.length === 0) return tokens;
+  while (types.length > 0) {
+    const idx = types.length - 1;
+    const t = types[idx];
+    const v = values[idx];
+    const f = flags[idx];
+    if (t === TokenType.Separator) {
+      types.pop();
+      values.pop();
+      flags.pop();
+      continue;
+    }
+    if (t === TokenType.Number) {
+      // Check for trailing dot or minus
+      const lastChar = v.charCodeAt(v.length - 1);
+      if (lastChar === C_DOT || lastChar === C_MINUS) {
+        types.pop();
+        values.pop();
+        flags.pop();
+        continue;
+      }
+      break;
+    }
+    if (t === TokenType.String) {
+      if (f & TokenFlag.IsKey) {
+        // Dangling key
+        // Check "aggressive" strip for empty objects logic from original
+        const n = types.length;
+        if (n >= 2) {
+          const t2Type = types[n - 2];
+          const t2Val = values[n - 2];
+          if (t2Type === TokenType.Brace && t2Val === '{') {
+            if (n >= 3 && types[n - 3] === TokenType.Delimiter) {
+              // , { "key" -> pop 3
+              types.length -= 3;
+              values.length -= 3;
+              flags.length -= 3;
+              continue;
+            }
+          }
+          if (t2Type === TokenType.Paren && t2Val === '[') {
+            if (n >= 3 && types[n - 3] === TokenType.Delimiter) {
+              // , [ "key" -> pop 3
+              types.length -= 3;
+              values.length -= 3;
+              flags.length -= 3;
+              continue;
+            }
+          }
+        }
+        types.pop();
+        values.pop();
+        flags.pop();
+        continue;
+      }
+      break;
+    }
+    if (t === TokenType.Delimiter) {
+      types.pop();
+      values.pop();
+      flags.pop();
+      continue;
+    }
+    if (t === TokenType.Brace) {
+      if (v === '{') {
+        if (types.length >= 2 && types[types.length - 2] === TokenType.Delimiter) {
+          types.length -= 2;
+          values.length -= 2;
+          flags.length -= 2;
+          continue;
+        }
+      }
+      break;
+    }
+    if (t === TokenType.Paren) {
+      if (v === '[') {
+        if (types.length >= 2 && types[types.length - 2] === TokenType.Delimiter) {
+          types.length -= 2;
+          values.length -= 2;
+          flags.length -= 2;
+          continue;
+        }
+      }
+      break;
+    }
+    break;
+  }
+  return tokens;
+}
+function unstrip(tokens) {
+  const {
+    types,
+    values,
+    flags
+  } = tokens;
+  const stack = []; // Stack of expected closing chars
+
+  // Forward pass to build stack
+  const len = types.length;
+  for (let i = 0; i < len; i++) {
+    const t = types[i];
+    const v = values[i];
+    if (t === TokenType.Brace) {
+      if (v === '{') {
+        stack.push('}');
+      } else if (v === '}') {
+        // Optimistic matching: just pop the top expectation
+        // If stack is empty or mismatch, we just assume it closes the last open
+        stack.pop();
+      }
+    } else if (t === TokenType.Paren) {
+      if (v === '[') {
+        stack.push(']');
+      } else if (v === ']') {
+        stack.pop();
+      }
+    }
+  }
+
+  // Reverse complete
+  while (stack.length > 0) {
+    const char = stack.pop();
+    if (char === '}') {
+      types.push(TokenType.Brace);
+      values.push('}');
+      flags.push(TokenFlag.None);
+    } else {
+      types.push(TokenType.Paren);
+      values.push(']');
+      flags.push(TokenFlag.None);
+    }
+  }
+  return tokens;
+}
+function generate(tokens) {
+  const {
+    types,
+    values
+  } = tokens;
+  const parts = [];
+  const len = types.length;
+  for (let i = 0; i < len; i++) {
+    const t = types[i];
+    const v = values[i];
+
+    // Trailing comma check
+    if (t === TokenType.Delimiter && i + 1 < len) {
+      const nextT = types[i + 1];
+      const nextV = values[i + 1];
+      if (nextT === TokenType.Brace && nextV === '}' || nextT === TokenType.Paren && nextV === ']') {
+        // Check if prev was opening brace/paren
+        if (i > 0) {
+          const prevT = types[i - 1];
+          const prevV = values[i - 1];
+          if (prevT === TokenType.Brace && prevV === '{' || prevT === TokenType.Paren && prevV === '[') {
+            parts.push(v);
+            continue;
+          }
+        }
+        continue; // Skip trailing comma
+      }
+    }
+    if (t === TokenType.String) {
+      parts.push('"' + v + '"');
+    } else {
+      parts.push(v);
+    }
+  }
+  return parts.join('');
+}
+
+/** * Best-effort partial JSON parser: tries to complete dangling structures * and then JSON.parse */
+function stripCodeFence(input) {
+  if (typeof input !== 'string') return input;
+  const trimmed = input.trim();
+
+  // 只处理以 ``` 或 ~~~ 开头的
+  const fenceMatch = trimmed.match(/^(```|~~~)/);
+  if (!fenceMatch) return input;
+  const fence = fenceMatch[1]; // ``` 或 ~~~
+
+  // 找到第一行结束位置（开头 fence 那一整行，包括语言信息）
+  const firstNewlineIndex = trimmed.indexOf('\n');
+  if (firstNewlineIndex === -1) {
+    // 只有一行，比如 "```json" 这种，说明没内容
+    return '';
+  }
+
+  // 去掉开头那一行 fence + 语言说明，剩下正文+结尾 fence+垃圾
+  const body = trimmed.slice(firstNewlineIndex + 1);
+
+  // 在正文中找最后一个同类型 fence
+  const lastFenceIndex = body.lastIndexOf(fence);
+  if (lastFenceIndex === -1) {
+    // 没有闭合 fence，就当只有开头 fence，剩下全是正文
+    return body.trim();
+  }
+
+  // 截到最后一个 fence 之前，后面统统当垃圾扔掉
+  const content = body.slice(0, lastFenceIndex);
+  return content.trim();
+}
+export function partialJSONParse(input) {
+  if (!input || typeof input !== 'string') {
+    return {};
+  }
+  // Pipeline
+  const tokens = tokenize(input);
+  const cleaned = strip(tokens);
+  const closed = unstrip(cleaned);
+  // normalizeTrailingCommas is integrated into generate
+  const jsonish = generate(closed);
+  return JSON.parse(jsonish);
+}
+export function partialJSONParseWithStatus(input) {
+  if (typeof input !== 'string') {
+    return {
+      value: {},
+      complete: true
+    };
+  }
+  input = stripCodeFence(input.trim());
+  if (input === '') {
+    return {
+      value: {},
+      complete: false
+    };
+  }
+
+  // 1) 先尝试“原文”是否就是完整 JSON
+  try {
+    const direct = JSON.parse(input);
+    return {
+      value: direct,
+      complete: true
+    };
+  } catch (_unused) {
+    // noop，继续走容错流程
+  }
+
+  // 2) 走 partial 流程
+  try {
+    const value = partialJSONParse(input);
+    // 既然原文 parse 失败，则这是“修复后”才能成功，标记为不完整
+    return {
+      value,
+      complete: false
+    };
+  } catch (e) {
+    // 按你的“尽力而为”语义：失败就返回空对象 & 不完整
+    return {
+      value: {},
+      complete: false
+    };
+  }
+}
+export function safeParseJSON(str) {
+  if (str && typeof str === 'string') {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      console.warn('safeParseJSON error:', e);
+    }
+  }
+  if (str && typeof str === 'object') {
+    return str;
+  }
+  return undefined;
+}

package/dist/chat/utils.d.ts

@@ -1,6 +1,5 @@
 export declare function generateId(length?: number): string;
 export declare function deepCloneToPlainObject(obj: any, visited?: WeakMap<object, any>): any;
-export declare function safeParseJSON<T = any>(str: any): T | undefined;
 export declare function deepMerge(target: any, source: any): any;
 export declare function isAbortError(reason: any): any;
 export declare function shuffleWithSeed<T>(array: T[], seed: string): T[];

package/dist/chat/utils.js

@@ -86,19 +86,6 @@ export function deepCloneToPlainObject(obj) {
   }
   return clonedObj;
 }
-export function safeParseJSON(str) {
-  if (str && typeof str === 'string') {
-    try {
-      return JSON.parse(str);
-    } catch (e) {
-      console.warn('safeParseJSON error:', e);
-    }
-  }
-  if (str && typeof str === 'object') {
-    return str;
-  }
-  return undefined;
-}
 export function deepMerge(target, source) {
   if (typeof target !== 'object' || target === null) {
     return source; // 如果目标不是对象，直接返回来源

package/dist/plugins/ui.d.ts

@@ -11,7 +11,7 @@ export interface UIEventMap {
     scrollToBottom: {
         animation?: boolean;
         follow?: boolean;
-        tickValue?: number;
+        scene?: string;
     };
     sendMessage: {
         blocks: InputBlock[];

package/dist/plugins/ui.js

@@ -1,6 +1,5 @@
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.map.js";
-import "core-js/modules/web.dom-collections.iterator.js";
 import { Emitter, EmitterEvent } from '../chat';
 import { createHooks } from 'hookable';
 export function withUI() {
@@ -33,7 +32,8 @@ export function withUI() {
     }, 'after');
     agent.onAgentDispose(() => {
       const types = Object.keys(emitter.listeners);
-      for (const type of types) {
+      for (let i = 0; i < types.length; i++) {
+        const type = types[i];
         delete emitter.listeners[type];
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/t-agent",
-  "version": "0.2.7-beta.1",
+  "version": "0.2.7-beta.11",
   "author": "Tuya.inc",
   "license": "MIT",
   "private": false,
@@ -26,5 +26,5 @@
     "build": "ray build --type=component --output dist",
     "clean": "rimraf ./dist"
   },
-  "gitHead": "d7754f9879a7ec837eb343ac759a08734cc789d3"
+  "gitHead": "10d81d0352c88b6b2eff7168ed046a065416dc4f"
 }