@ray-js/t-agent 0.2.7-beta.6 → 0.2.7-beta.8

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/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.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.6",
+  "version": "0.2.7-beta.8",
   "author": "Tuya.inc",
   "license": "MIT",
   "private": false,
@@ -26,5 +26,5 @@
     "build": "ray build --type=component --output dist",
     "clean": "rimraf ./dist"
   },
-  "gitHead": "8c74cd727802f09ac6294a88ee72464fc39db49c"
+  "gitHead": "31a0d88f88eddae8bfd802e4861c76cd02c07692"
 }