@lobehub/lobehub 2.0.0-next.183 → 2.0.0-next.185

package/src/app/[variants]/(main)/chat/_layout/Sidebar/Topic/index.tsx

@@ -1,10 +1,10 @@
 'use client';
 
-import { AccordionItem, ActionIcon, Dropdown, Flexbox, Text } from '@lobehub/ui';
-import { Loader2Icon } from 'lucide-react';
+import { AccordionItem, Dropdown, Flexbox, Text } from '@lobehub/ui';
 import React, { Suspense, memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import SkeletonList from '@/features/NavPanel/components/SkeletonList';
 import { useFetchTopics } from '@/hooks/useFetchTopics';
 import { useChatStore } from '@/store/chat';
@@ -45,7 +45,7 @@ const Topic = memo<TopicProps>(({ itemKey }) => {
           <Text ellipsis fontSize={12} type={'secondary'} weight={500}>
             {`${t('title')} ${topicCount > 0 ? topicCount : ''}`}
           </Text>
-          {isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+          {isRevalidating && <NeuralNetworkLoading size={14} />}
         </Flexbox>
       }
     >

package/src/app/[variants]/(main)/group/_layout/Sidebar/Topic/index.tsx

@@ -1,10 +1,10 @@
 'use client';
 
-import { AccordionItem, ActionIcon, Dropdown, Flexbox, Text } from '@lobehub/ui';
-import { Loader2Icon } from 'lucide-react';
+import { AccordionItem, Dropdown, Flexbox, Text } from '@lobehub/ui';
 import React, { Suspense, memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import SkeletonList from '@/features/NavPanel/components/SkeletonList';
 import { useFetchTopics } from '@/hooks/useFetchTopics';
 import { useChatStore } from '@/store/chat';
@@ -45,7 +45,7 @@ const Topic = memo<TopicProps>(({ itemKey }) => {
           <Text ellipsis fontSize={12} type={'secondary'} weight={500}>
             {`${t('title')} ${topicCount > 0 ? topicCount : ''}`}
           </Text>
-          {isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+          {isRevalidating && <NeuralNetworkLoading size={14} />}
         </Flexbox>
       }
     >

package/src/app/[variants]/(main)/home/_layout/Body/Agent/index.tsx

@@ -1,10 +1,10 @@
 'use client';
 
-import { AccordionItem, ActionIcon, Dropdown, Flexbox, Text } from '@lobehub/ui';
-import { Loader2Icon } from 'lucide-react';
+import { AccordionItem, Dropdown, Flexbox, Text } from '@lobehub/ui';
 import React, { Suspense, memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useFetchAgentList } from '@/hooks/useFetchAgentList';
 
 import SkeletonList from '../../../../../../../features/NavPanel/components/SkeletonList';
@@ -56,7 +56,7 @@ const Agent = memo<AgentProps>(({ itemKey }) => {
           <Text ellipsis fontSize={12} type={'secondary'} weight={500}>
             {t('navPanel.agent')}
           </Text>
-          {isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+          {isRevalidating && <NeuralNetworkLoading size={14} />}
         </Flexbox>
       }
     >

package/src/app/[variants]/(main)/home/features/RecentPage/index.tsx

@@ -1,12 +1,13 @@
 'use client';
 
 import { ActionIcon, Dropdown } from '@lobehub/ui';
-import { FileTextIcon, Loader2Icon, MoreHorizontal } from 'lucide-react';
+import { FileTextIcon, MoreHorizontal } from 'lucide-react';
 import { Suspense, memo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
 
 import { useResourceManagerStore } from '@/app/[variants]/(main)/resource/features/store';
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useInitRecentPage } from '@/hooks/useInitRecentPage';
 import { useHomeStore } from '@/store/home';
 import { homeRecentSelectors } from '@/store/home/selectors';
@@ -35,7 +36,7 @@ const RecentPage = memo(() => {
     <GroupBlock
       action={
         <>
-          {isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+          {isRevalidating && <NeuralNetworkLoading size={14} />}
           <Dropdown
             menu={{
               items: [

package/src/app/[variants]/(main)/home/features/RecentResource/index.tsx

@@ -1,12 +1,13 @@
 'use client';
 
 import { ActionIcon, Dropdown } from '@lobehub/ui';
-import { Clock, Loader2Icon, MoreHorizontal } from 'lucide-react';
+import { Clock, MoreHorizontal } from 'lucide-react';
 import { Suspense, memo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
 
 import { useResourceManagerStore } from '@/app/[variants]/(main)/resource/features/store';
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useInitRecentResource } from '@/hooks/useInitRecentResource';
 import { useHomeStore } from '@/store/home';
 import { homeRecentSelectors } from '@/store/home/selectors';
@@ -35,7 +36,7 @@ const RecentResource = memo(() => {
     <GroupBlock
       action={
         <>
-          {isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+          {isRevalidating && <NeuralNetworkLoading size={14} />}
           <Dropdown
             menu={{
               items: [

package/src/app/[variants]/(main)/home/features/RecentTopic/index.tsx

@@ -1,8 +1,8 @@
-import { ActionIcon } from '@lobehub/ui';
-import { BotMessageSquareIcon, Loader2Icon } from 'lucide-react';
+import { BotMessageSquareIcon } from 'lucide-react';
 import { Suspense, memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useInitRecentTopic } from '@/hooks/useInitRecentTopic';
 import { useHomeStore } from '@/store/home';
 import { homeRecentSelectors } from '@/store/home/selectors';
@@ -26,7 +26,7 @@ const RecentTopic = memo(() => {
 
   return (
     <GroupBlock
-      action={isRevalidating && <ActionIcon icon={Loader2Icon} loading size={'small'} />}
+      action={isRevalidating && <NeuralNetworkLoading size={14} />}
       icon={BotMessageSquareIcon}
       title={t('topic.recent')}
     >

package/src/components/NeuralNetworkLoading/index.tsx

@@ -0,0 +1,181 @@
+'use client';
+
+import { createStaticStyles, keyframes } from 'antd-style';
+import { CSSProperties, memo } from 'react';
+
+const pulseAnim = keyframes`
+  0%, 100% {
+    opacity: 0.3;
+  }
+  50% {
+    opacity: 1;
+  }
+`;
+
+const flowAnim = keyframes`
+  0% {
+    transform: translateX(0);
+    opacity: 0.5;
+  }
+  50% {
+    opacity: 1;
+  }
+  100% {
+    transform: translateX(var(--flow-distance));
+    opacity: 0.5;
+  }
+`;
+
+const rotateAnim = keyframes`
+  100% {
+    transform: rotate(360deg);
+  }
+`;
+
+const scaleAnim = keyframes`
+  0%, 100% {
+    transform: scale(0.8);
+    opacity: 0.5;
+  }
+  50% {
+    transform: scale(1);
+    opacity: 1;
+  }
+`;
+
+const styles = createStaticStyles(({ css, cssVar }) => ({
+  center: css`
+    fill: ${cssVar.colorTextSecondary};
+    animation: ${scaleAnim} 2s infinite;
+  `,
+
+  connection: css`
+    opacity: 0.3;
+    stroke: ${cssVar.colorTextSecondary};
+    stroke-width: 0.5;
+  `,
+
+  container: css`
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  `,
+
+  node: css`
+    fill: ${cssVar.colorTextSecondary};
+    animation: ${pulseAnim} 2s infinite;
+  `,
+
+  particle: css`
+    fill: ${cssVar.colorTextSecondary};
+    animation: ${flowAnim} 2s infinite;
+  `,
+
+  ring: css`
+    transform-origin: center;
+
+    fill: none;
+    stroke: ${cssVar.colorFill};
+    stroke-dasharray: 0 8;
+    stroke-width: 1;
+
+    animation: ${rotateAnim} 20s infinite linear;
+  `,
+
+  svg: css`
+    width: 100%;
+    height: 100%;
+  `,
+}));
+
+interface NeuralNetworkLoadingProps {
+  size?: number;
+}
+
+const NeuralNetworkLoading = memo<NeuralNetworkLoadingProps>(({ size = 16 }) => {
+  const nodeCount = 3;
+  const layerCount = 3;
+
+  // Generate nodes for each layer
+  const nodes = [];
+  for (let layerIndex = 0; layerIndex < layerCount; layerIndex++) {
+    for (let nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) {
+      const x = 25 + layerIndex * 25;
+      const y = 25 + nodeIndex * 25;
+      const delay = (layerIndex * nodeCount + nodeIndex) * 0.2;
+      nodes.push(
+        <circle
+          className={styles.node}
+          cx={x}
+          cy={y}
+          key={`node-${layerIndex}-${nodeIndex}`}
+          r="3"
+          style={{ animationDelay: `${delay}s` }}
+        />,
+      );
+    }
+  }
+
+  // Generate connections between layers
+  const connections = [];
+  for (let layerIndex = 0; layerIndex < layerCount - 1; layerIndex++) {
+    for (let nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) {
+      const x1 = 25 + layerIndex * 25;
+      const y1 = 25 + nodeIndex * 25;
+      for (let targetIndex = 0; targetIndex < nodeCount; targetIndex++) {
+        const x2 = 25 + (layerIndex + 1) * 25;
+        const y2 = 25 + targetIndex * 25;
+        connections.push(
+          <line
+            className={styles.connection}
+            key={`connection-${layerIndex}-${nodeIndex}-${targetIndex}`}
+            x1={x1}
+            x2={x2}
+            y1={y1}
+            y2={y2}
+          />,
+        );
+      }
+    }
+  }
+
+  // Generate particles
+  const particles = [0, 1, 2].map((index) => (
+    <circle
+      className={styles.particle}
+      cx={25}
+      cy={50}
+      key={`particle-${index}`}
+      r="1.5"
+      style={
+        {
+          '--flow-distance': '50px',
+          'animationDelay': `${index * 0.6}s`,
+        } as CSSProperties
+      }
+    />
+  ));
+
+  return (
+    <div className={styles.container} style={{ height: size, width: size }}>
+      <svg className={styles.svg} viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
+        {/* Connections */}
+        {connections}
+
+        {/* Nodes */}
+        {nodes}
+
+        {/* Particles */}
+        {particles}
+
+        {/* Central processing unit */}
+        <rect className={styles.center} height="6" width="6" x="47" y="47" />
+
+        {/* Rotating outer ring */}
+        <circle className={styles.ring} cx="50" cy="50" r="40" />
+      </svg>
+    </div>
+  );
+});
+
+export default NeuralNetworkLoading;

package/src/libs/swr/index.ts

@@ -1,6 +1,5 @@
 import useSWR, { type SWRHook } from 'swr';
 
-import { isDesktop } from '@/const/version';
 
 /**
  * This type of request method is relatively flexible data, which will be triggered on the first time
@@ -27,13 +26,7 @@ export const useClientDataSWR: SWRHook = (key, fetch, config) =>
     // Cause issue like this: https://github.com/lobehub/lobe-chat/issues/532
     // we need to set it to 0.
     dedupingInterval: 0,
-    focusThrottleInterval:
-      // FIXME: desktop 云同步模式也是走 edge 请求，也应该增大延迟
-      // desktop 1.5s
-      isDesktop
-        ? 1500
-        : // web 300s
-          5 * 60 * 1000,
+    focusThrottleInterval: 5 * 60 * 1000,
     // Custom error retry logic: don't retry on 401 errors
     onErrorRetry: (error: any, key: any, config: any, revalidate: any, { retryCount }: any) => {
       // Check if error is marked as non-retryable (e.g., 401 authentication errors)

package/src/store/image/utils/size.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest';
+
+import { adaptSizeToRatio, parseRatio } from './size';
+
+describe('size utils', () => {
+  describe('parseRatio', () => {
+    it('should parse valid ratio string correctly', () => {
+      expect(parseRatio('16:9')).toBe(16 / 9);
+      expect(parseRatio('4:3')).toBe(4 / 3);
+      expect(parseRatio('1:1')).toBe(1);
+      expect(parseRatio('21:9')).toBe(21 / 9);
+    });
+
+    it('should handle square ratio correctly', () => {
+      expect(parseRatio('1:1')).toBe(1);
+      expect(parseRatio('100:100')).toBe(1);
+      expect(parseRatio('512:512')).toBe(1);
+    });
+
+    it('should handle wide ratios correctly', () => {
+      expect(parseRatio('16:9')).toBeCloseTo(16 / 9, 6);
+      expect(parseRatio('2:1')).toBe(2);
+      expect(parseRatio('3:1')).toBe(3);
+    });
+
+    it('should handle tall ratios correctly', () => {
+      expect(parseRatio('9:16')).toBeCloseTo(0.5625, 4);
+      expect(parseRatio('1:2')).toBe(0.5);
+      expect(parseRatio('3:4')).toBe(0.75);
+    });
+
+    it('should handle decimal values in ratio string', () => {
+      expect(parseRatio('1.5:1')).toBe(1.5);
+      expect(parseRatio('16.5:9.5')).toBeCloseTo(16.5 / 9.5, 6);
+    });
+
+    it('should return 1 for invalid ratio string formats', () => {
+      expect(parseRatio('16')).toBe(1); // Missing colon
+      expect(parseRatio('16-9')).toBe(1); // Wrong separator
+      expect(parseRatio('16:9:1')).toBe(1); // Too many parts
+      expect(parseRatio('')).toBe(1); // Empty string
+      expect(parseRatio(':')).toBe(1); // Only separator
+    });
+
+    it('should return 1 for invalid input types', () => {
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(null)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(undefined)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio(123)).toBe(1);
+      // @ts-expect-error - testing runtime behavior with invalid types
+      expect(parseRatio({})).toBe(1);
+    });
+
+    it('should return 1 for non-numeric ratio parts', () => {
+      expect(parseRatio('abc:def')).toBe(1);
+      expect(parseRatio('16:abc')).toBe(1);
+      expect(parseRatio('abc:9')).toBe(1);
+      expect(parseRatio('NaN:9')).toBe(1);
+      expect(parseRatio('16:NaN')).toBe(1);
+    });
+
+    it('should return 1 for zero or negative values', () => {
+      expect(parseRatio('0:9')).toBe(1);
+      expect(parseRatio('16:0')).toBe(1);
+      expect(parseRatio('0:0')).toBe(1);
+      expect(parseRatio('-16:9')).toBe(1);
+      expect(parseRatio('16:-9')).toBe(1);
+      expect(parseRatio('-16:-9')).toBe(1);
+    });
+
+    it('should return 1 for Infinity values', () => {
+      expect(parseRatio('Infinity:9')).toBe(1);
+      expect(parseRatio('16:Infinity')).toBe(1);
+      expect(parseRatio('Infinity:Infinity')).toBe(1);
+    });
+  });
+
+  describe('adaptSizeToRatio', () => {
+    describe('valid inputs', () => {
+      it('should keep width and adjust height when target ratio is wider', () => {
+        // 16:9 (1.777) is wider than 4:3 (1.333)
+        const result = adaptSizeToRatio(16 / 9, 800, 600);
+        expect(result).toEqual({ width: 800, height: 450 });
+      });
+
+      it('should keep height and adjust width when target ratio is taller', () => {
+        // 4:3 (1.333) is taller than 16:9 (1.777)
+        const result = adaptSizeToRatio(4 / 3, 800, 450);
+        expect(result).toEqual({ width: 600, height: 450 });
+      });
+
+      it('should maintain dimensions when ratio matches current ratio', () => {
+        // 16:9 matches 1920:1080
+        const result = adaptSizeToRatio(16 / 9, 1920, 1080);
+        expect(result).toEqual({ width: 1920, height: 1080 });
+      });
+
+      it('should handle square ratio (1:1) correctly', () => {
+        // Current ratio: 800/600 = 1.333, target ratio: 1
+        // Since 1 < 1.333, keeps height (600), adjusts width to 600
+        const result = adaptSizeToRatio(1, 800, 600);
+        expect(result).toEqual({ width: 600, height: 600 });
+
+        // Current ratio: 600/800 = 0.75, target ratio: 1
+        // Since 1 > 0.75, keeps width (600), adjusts height to 600
+        const result2 = adaptSizeToRatio(1, 600, 800);
+        expect(result2).toEqual({ width: 600, height: 600 });
+      });
+
+      it('should round dimensions to nearest integer', () => {
+        // Current ratio: 1000/800 = 1.25, target ratio: 1.5
+        // Since 1.5 > 1.25, keeps width (1000), adjusts height to 1000/1.5 = 666.67 -> 667
+        const result = adaptSizeToRatio(1.5, 1000, 800);
+        expect(result.width).toBe(1000);
+        expect(result.height).toBe(667);
+        expect(Number.isInteger(result.width)).toBe(true);
+        expect(Number.isInteger(result.height)).toBe(true);
+      });
+
+      it('should handle very wide ratios correctly', () => {
+        const result = adaptSizeToRatio(3, 1200, 800);
+        expect(result).toEqual({ width: 1200, height: 400 });
+      });
+
+      it('should handle very tall ratios correctly', () => {
+        const result = adaptSizeToRatio(1 / 3, 1200, 800);
+        expect(result).toEqual({ width: 267, height: 800 });
+      });
+
+      it('should handle small dimensions', () => {
+        const result = adaptSizeToRatio(16 / 9, 320, 240);
+        expect(result).toEqual({ width: 320, height: 180 });
+      });
+
+      it('should handle large dimensions', () => {
+        const result = adaptSizeToRatio(16 / 9, 3840, 2880);
+        expect(result).toEqual({ width: 3840, height: 2160 });
+      });
+
+      it('should handle decimal ratio values', () => {
+        const result = adaptSizeToRatio(1.5, 900, 600);
+        expect(result).toEqual({ width: 900, height: 600 });
+      });
+    });
+
+    describe('error handling - invalid ratio', () => {
+      it('should throw error for zero ratio', () => {
+        expect(() => adaptSizeToRatio(0, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative ratio', () => {
+        expect(() => adaptSizeToRatio(-1.5, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN ratio', () => {
+        expect(() => adaptSizeToRatio(NaN, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity ratio', () => {
+        expect(() => adaptSizeToRatio(Infinity, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+        expect(() => adaptSizeToRatio(-Infinity, 800, 600)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - invalid defaultWidth', () => {
+      it('should throw error for zero defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 0, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, -800, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, NaN, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity defaultWidth', () => {
+        expect(() => adaptSizeToRatio(16 / 9, Infinity, 600)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - invalid defaultHeight', () => {
+      it('should throw error for zero defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, 0)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for negative defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, -600)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for NaN defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, NaN)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+
+      it('should throw error for Infinity defaultHeight', () => {
+        expect(() => adaptSizeToRatio(16 / 9, 800, Infinity)).toThrow(
+          'Invalid defaultHeight: must be a positive finite number',
+        );
+      });
+    });
+
+    describe('error handling - multiple invalid parameters', () => {
+      it('should validate ratio first before other parameters', () => {
+        // When multiple params are invalid, ratio is checked first
+        expect(() => adaptSizeToRatio(0, 0, 0)).toThrow(
+          'Invalid ratio: must be a positive finite number',
+        );
+      });
+
+      it('should validate defaultWidth before defaultHeight', () => {
+        // When ratio is valid but width and height are invalid
+        expect(() => adaptSizeToRatio(1.5, 0, 0)).toThrow(
+          'Invalid defaultWidth: must be a positive finite number',
+        );
+      });
+    });
+  });
+});

package/src/tools/inspectors.ts

@@ -7,16 +7,17 @@ import {
   GroupManagementManifest,
 } from '@lobechat/builtin-tool-group-management/client';
 import { GTDInspectors, GTDManifest } from '@lobechat/builtin-tool-gtd/client';
-import { LocalSystemManifest } from '@lobechat/builtin-tool-local-system';
-import { PageAgentIdentifier, PageAgentInspectors } from '@lobechat/builtin-tool-page-agent/client';
+import {
+  LocalSystemInspectors,
+  LocalSystemManifest,
+} from '@lobechat/builtin-tool-local-system/client';
+import { PageAgentInspectors, PageAgentManifest } from '@lobechat/builtin-tool-page-agent/client';
 import {
   WebBrowsingInspectors,
   WebBrowsingManifest,
 } from '@lobechat/builtin-tool-web-browsing/client';
 import { type BuiltinInspector } from '@lobechat/types';
 
-import { LocalSystemInspectors } from './local-system/Inspector';
-
 /**
  * Builtin tools inspector registry
  * Organized by toolset (identifier) -> API name
@@ -32,7 +33,7 @@ const BuiltinToolInspectors: Record<string, Record<string, BuiltinInspector>> =
   >,
   [GTDManifest.identifier]: GTDInspectors as Record<string, BuiltinInspector>,
   [LocalSystemManifest.identifier]: LocalSystemInspectors as Record<string, BuiltinInspector>,
-  [PageAgentIdentifier]: PageAgentInspectors as Record<string, BuiltinInspector>,
+  [PageAgentManifest.identifier]: PageAgentInspectors as Record<string, BuiltinInspector>,
   [WebBrowsingManifest.identifier]: WebBrowsingInspectors as Record<string, BuiltinInspector>,
 };
 

package/src/tools/interventions.ts

@@ -9,13 +9,14 @@ import {
   GroupManagementManifest,
 } from '@lobechat/builtin-tool-group-management/client';
 import { GTDInterventions, GTDManifest } from '@lobechat/builtin-tool-gtd/client';
-import { LocalSystemManifest } from '@lobechat/builtin-tool-local-system';
+import {
+  LocalSystemIdentifier,
+  LocalSystemInterventions,
+} from '@lobechat/builtin-tool-local-system/client';
 import { NotebookManifest } from '@lobechat/builtin-tool-notebook';
 import { NotebookInterventions } from '@lobechat/builtin-tool-notebook/client';
 import { type BuiltinIntervention } from '@lobechat/types';
 
-import { LocalSystemInterventions } from './local-system/Intervention';
-
 /**
  * Builtin tools interventions registry
  * Organized by toolset (identifier) -> API name
@@ -26,7 +27,7 @@ export const BuiltinToolInterventions: Record<string, Record<string, any>> = {
   [CloudSandboxManifest.identifier]: CloudSandboxInterventions,
   [GroupManagementManifest.identifier]: GroupManagementInterventions,
   [GTDManifest.identifier]: GTDInterventions,
-  [LocalSystemManifest.identifier]: LocalSystemInterventions,
+  [LocalSystemIdentifier]: LocalSystemInterventions,
   [NotebookManifest.identifier]: NotebookInterventions,
 };
 

package/src/tools/placeholders.ts

@@ -1,21 +1,23 @@
-import { LocalSystemApiName, LocalSystemManifest } from '@lobechat/builtin-tool-local-system';
+import {
+  LocalSystemApiName,
+  LocalSystemIdentifier,
+  LocalSystemListFilesPlaceholder,
+  LocalSystemSearchFilesPlaceholder,
+} from '@lobechat/builtin-tool-local-system/client';
 import {
   WebBrowsingManifest,
   WebBrowsingPlaceholders,
 } from '@lobechat/builtin-tool-web-browsing/client';
 import { type BuiltinPlaceholder } from '@lobechat/types';
 
-import { ListFiles as LocalSystemListFiles } from './local-system/Placeholder/ListFiles';
-import LocalSystemSearchFiles from './local-system/Placeholder/SearchFiles';
-
 /**
  * Builtin tools placeholders registry
  * Organized by toolset (identifier) -> API name
  */
 export const BuiltinToolPlaceholders: Record<string, Record<string, any>> = {
-  [LocalSystemManifest.identifier]: {
-    [LocalSystemApiName.searchLocalFiles]: LocalSystemSearchFiles,
-    [LocalSystemApiName.listLocalFiles]: LocalSystemListFiles,
+  [LocalSystemIdentifier]: {
+    [LocalSystemApiName.searchLocalFiles]: LocalSystemSearchFilesPlaceholder,
+    [LocalSystemApiName.listLocalFiles]: LocalSystemListFilesPlaceholder,
   },
   [WebBrowsingManifest.identifier]: WebBrowsingPlaceholders as Record<string, any>,
 };