chore: import upstream snapshot with attribution

apps/sim/tools/knowledge/list_chunks.ts

@@ -0,0 +1,144 @@
+import type { KnowledgeListChunksResponse } from '@/tools/knowledge/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const knowledgeListChunksTool: ToolConfig<any, KnowledgeListChunksResponse> = {
+  id: 'knowledge_list_chunks',
+  name: 'Knowledge List Chunks',
+  description:
+    'List chunks for a document in a knowledge base with optional filtering and pagination',
+  version: '1.0.0',
+
+  params: {
+    knowledgeBaseId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'ID of the knowledge base',
+    },
+    documentId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'ID of the document to list chunks from',
+    },
+    search: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Search query to filter chunks by content',
+    },
+    enabled: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Filter by enabled status: "true", "false", or "all" (default: "all")',
+    },
+    limit: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Maximum number of chunks to return (1-100, default: 50)',
+    },
+    offset: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Number of chunks to skip for pagination (default: 0)',
+    },
+  },
+
+  request: {
+    url: (params) => {
+      const queryParams = new URLSearchParams()
+      if (params.search) queryParams.set('search', params.search)
+      if (params.enabled) queryParams.set('enabled', params.enabled)
+      if (params.limit)
+        queryParams.set('limit', String(Math.max(1, Math.min(100, Number(params.limit)))))
+      if (params.offset != null) queryParams.set('offset', String(params.offset))
+      const qs = queryParams.toString()
+      return `/api/knowledge/${params.knowledgeBaseId}/documents/${params.documentId}/chunks${qs ? `?${qs}` : ''}`
+    },
+    method: 'GET',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+  },
+
+  transformResponse: async (response, params): Promise<KnowledgeListChunksResponse> => {
+    const result = await response.json()
+    const chunks = result.data || []
+    const pagination = result.pagination || {}
+
+    return {
+      success: true,
+      output: {
+        knowledgeBaseId: params?.knowledgeBaseId ?? '',
+        documentId: params?.documentId ?? '',
+        chunks: chunks.map(
+          (chunk: {
+            id: string
+            chunkIndex: number
+            content: string
+            contentLength: number
+            tokenCount: number
+            enabled: boolean
+            createdAt: string
+            updatedAt: string
+          }) => ({
+            id: chunk.id,
+            chunkIndex: chunk.chunkIndex ?? 0,
+            content: chunk.content,
+            contentLength: chunk.contentLength ?? 0,
+            tokenCount: chunk.tokenCount ?? 0,
+            enabled: chunk.enabled ?? true,
+            createdAt: chunk.createdAt ?? null,
+            updatedAt: chunk.updatedAt ?? null,
+          })
+        ),
+        totalChunks: pagination.total ?? chunks.length,
+        limit: pagination.limit ?? 50,
+        offset: pagination.offset ?? 0,
+      },
+    }
+  },
+
+  outputs: {
+    knowledgeBaseId: {
+      type: 'string',
+      description: 'ID of the knowledge base',
+    },
+    documentId: {
+      type: 'string',
+      description: 'ID of the document',
+    },
+    chunks: {
+      type: 'array',
+      description: 'Array of chunks in the document',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Chunk ID' },
+          chunkIndex: { type: 'number', description: 'Index of the chunk within the document' },
+          content: { type: 'string', description: 'Chunk text content' },
+          contentLength: { type: 'number', description: 'Content length in characters' },
+          tokenCount: { type: 'number', description: 'Token count for the chunk' },
+          enabled: { type: 'boolean', description: 'Whether the chunk is enabled' },
+          createdAt: { type: 'string', description: 'Creation timestamp' },
+          updatedAt: { type: 'string', description: 'Last update timestamp' },
+        },
+      },
+    },
+    totalChunks: {
+      type: 'number',
+      description: 'Total number of chunks matching the filter',
+    },
+    limit: {
+      type: 'number',
+      description: 'Page size used',
+    },
+    offset: {
+      type: 'number',
+      description: 'Offset used for pagination',
+    },
+  },
+}