@lobehub/chat 1.1.16 → 1.1.18

package/src/store/tool/selectors/tool.test.ts

@@ -230,4 +230,18 @@ describe('toolSelectors', () => {
       expect(toolSelectors.getManifestLoadingStatus('non-existent')(mockState)).toBe('error');
     });
   });
+
+  describe('isToolHasUI', () => {
+    it('should return false if the tool has no UI', () => {
+      expect(toolSelectors.isToolHasUI('plugin-1')(mockState)).toBe(false);
+    });
+
+    it('should return true if the tool has UI', () => {
+      expect(toolSelectors.isToolHasUI('builtin-1')(mockState)).toBe(true);
+    });
+
+    it('should return false if the tool does not exist', () => {
+      expect(toolSelectors.isToolHasUI('non-existent')(mockState)).toBe(false);
+    });
+  });
 });

package/src/store/tool/selectors/tool.ts

@@ -100,11 +100,24 @@ const getManifestLoadingStatus = (id: string) => (s: ToolStoreState) => {
   if (!!manifest) return 'success';
 };
 
+const isToolHasUI = (id: string) => (s: ToolStoreState) => {
+  const manifest = getManifestById(id)(s);
+  if (!manifest) return false;
+  const builtinTool = s.builtinTools.find((tool) => tool.identifier === id);
+
+  if (builtinTool && builtinTool.type === 'builtin') {
+    return true;
+  }
+
+  return !!manifest.ui;
+};
+
 export const toolSelectors = {
   enabledSchema,
   enabledSystemRoles,
   getManifestById,
   getManifestLoadingStatus,
   getMetaById,
+  isToolHasUI,
   metaList,
 };

package/src/tools/docks.ts

@@ -0,0 +1,3 @@
+import { BuiltinDock } from '@/types/tool';
+
+export const BuiltinToolsDocks: Record<string, BuiltinDock> = {};

package/src/types/tool/builtin.ts

@@ -27,7 +27,8 @@ export interface LobeBuiltinTool {
   type: 'builtin';
 }
 
-export interface BuiltinRenderProps<Content = any, State = any> {
+export interface BuiltinRenderProps<Content = any, Arguments = any, State = any> {
+  args: Arguments;
   content: Content;
   identifier?: string;
   messageId: string;
@@ -35,3 +36,12 @@ export interface BuiltinRenderProps<Content = any, State = any> {
 }
 
 export type BuiltinRender = <T = any>(props: BuiltinRenderProps<T>) => ReactNode;
+
+export interface BuiltinDockProps<Arguments = Record<string, any>, State = any> {
+  arguments: Arguments;
+  identifier: string;
+  messageId: string;
+  state: State;
+}
+
+export type BuiltinDock = <T = any>(props: BuiltinDockProps<T>) => ReactNode;

package/src/utils/safeParseJSON.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { safeParseJSON } from './safeParseJSON';
+
+describe('safeParseJSON', () => {
+  it('should parse a valid JSON string', () => {
+    const validJSON = '{"name": "John", "age": 30}';
+    const result = safeParseJSON(validJSON);
+    expect(result).toEqual({ name: 'John', age: 30 });
+  });
+
+  it('should return undefined for invalid JSON', () => {
+    const invalidJSON = '{name: John}';
+    const result = safeParseJSON(invalidJSON);
+    expect(result).toBeUndefined();
+  });
+
+  it('should parse an empty object', () => {
+    const emptyObject = '{}';
+    const result = safeParseJSON(emptyObject);
+    expect(result).toEqual({});
+  });
+
+  it('should parse an array', () => {
+    const arrayJSON = '[1, 2, 3]';
+    const result = safeParseJSON(arrayJSON);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('should parse nested objects', () => {
+    const nestedJSON = '{"user": {"name": "John", "age": 30}}';
+    const result = safeParseJSON(nestedJSON);
+    expect(result).toEqual({ user: { name: 'John', age: 30 } });
+  });
+
+  it('should return undefined for an empty string', () => {
+    const result = safeParseJSON('');
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined for non-string input', () => {
+    // @ts-expect-error: Testing with invalid input type
+    const result = safeParseJSON(123);
+    expect(result).toBeUndefined();
+  });
+
+  it('should parse JSON with special characters', () => {
+    const specialJSON = '{"message": "Hello, \\"world\\"!"}';
+    const result = safeParseJSON(specialJSON);
+    expect(result).toEqual({ message: 'Hello, "world"!' });
+  });
+
+  it('should parse large JSON without throwing an error', () => {
+    const largeJSON = JSON.stringify({ data: Array(1000).fill('test') });
+    const result = safeParseJSON(largeJSON);
+    expect(result).toHaveProperty('data');
+    expect(Array.isArray(result!.data)).toBe(true);
+    expect(result!.data).toHaveLength(1000);
+  });
+
+  it('should handle JSON with different data types', () => {
+    const mixedJSON = '{"string": "text", "number": 42, "boolean": true, "null": null}';
+    const result = safeParseJSON(mixedJSON);
+    expect(result).toEqual({
+      string: 'text',
+      number: 42,
+      boolean: true,
+      null: null,
+    });
+  });
+});

package/src/utils/safeParseJSON.ts

@@ -0,0 +1,12 @@
+export const safeParseJSON = <T = Record<string, any>>(text: string) => {
+  if (typeof text !== 'string') return undefined;
+
+  let json: T;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+
+  return json;
+};

package/src/const/message.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { testFunctionMessageAtEnd } from './message';
-
-describe('testFunctionMessageAtEnd', () => {
-  it('should extract tool_calls JSON when present', () => {
-    const content = 'Some content before {"tool_calls": [{"tool": "example", "args": ["arg1"]}]}';
-    const result = testFunctionMessageAtEnd(content);
-    expect(result).toEqual({
-      content: '{"tool_calls": [{"tool": "example", "args": ["arg1"]}]}',
-      valid: true,
-    });
-  });
-
-  it('should extract tool_calls JSON when there are space at end', () => {
-    const content =
-      'Some content before {"tool_calls": [{"tool": "example", "args": ["arg1"]}]}     ';
-    const result = testFunctionMessageAtEnd(content);
-    expect(result).toEqual({
-      content: '{"tool_calls": [{"tool": "example", "args": ["arg1"]}]}',
-      valid: true,
-    });
-  });
-
-  it('should not extract tool_calls JSON when in middle', () => {
-    const content =
-      'Some content before {"tool_calls": [{"tool": "example", "args": ["arg1"]}]}, here are some end content';
-    const result = testFunctionMessageAtEnd(content);
-    expect(result).toEqual({ content: '', valid: false });
-  });
-
-  it('should return an empty string and valid false when JSON is not present', () => {
-    const content = 'Some content without the JSON structure';
-    const result = testFunctionMessageAtEnd(content);
-    expect(result).toEqual({ content: '', valid: false });
-  });
-
-  it('should return an empty string and valid false when content is empty', () => {
-    const content = '';
-    const result = testFunctionMessageAtEnd(content);
-
-    expect(result).toEqual({ content: '', valid: false });
-  });
-
-  it('should handle null or undefined content gracefully', () => {
-    const nullContent = null;
-    const undefinedContent = undefined;
-
-    const resultWithNull = testFunctionMessageAtEnd(nullContent as any);
-    const resultWithUndefined = testFunctionMessageAtEnd(undefinedContent as any);
-
-    expect(resultWithNull).toEqual({ content: '', valid: false });
-    expect(resultWithUndefined).toEqual({ content: '', valid: false });
-  });
-});

package/src/features/Conversation/Plugins/Render/BuiltinType/index.tsx

@@ -1,30 +0,0 @@
-import { memo } from 'react';
-
-import { BuiltinToolsRenders } from '@/tools/renders';
-
-import Loading from '../Loading';
-import { useParseContent } from '../useParseContent';
-
-export interface BuiltinTypeProps {
-  content: string;
-  id: string;
-  identifier?: string;
-  loading?: boolean;
-  pluginState?: any;
-}
-
-const BuiltinType = memo<BuiltinTypeProps>(({ content, pluginState, id, identifier, loading }) => {
-  const { isJSON, data } = useParseContent(content);
-
-  if (!isJSON) {
-    return loading && <Loading />;
-  }
-
-  const Render = BuiltinToolsRenders[identifier || ''];
-
-  if (!Render) return;
-
-  return <Render content={data} identifier={identifier} messageId={id} pluginState={pluginState} />;
-});
-
-export default BuiltinType;