chore: import upstream snapshot with attribution

apps/sim/tools/knowledge/list_documents.ts

@@ -0,0 +1,159 @@
+import type { KnowledgeListDocumentsResponse } from '@/tools/knowledge/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const knowledgeListDocumentsTool: ToolConfig<any, KnowledgeListDocumentsResponse> = {
+  id: 'knowledge_list_documents',
+  name: 'Knowledge List Documents',
+  description: 'List documents in a knowledge base with optional filtering, search, and pagination',
+  version: '1.0.0',
+
+  params: {
+    knowledgeBaseId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'ID of the knowledge base to list documents from',
+    },
+    search: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Search query to filter documents by filename',
+    },
+    enabledFilter: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Filter by enabled status: "all", "enabled", or "disabled"',
+    },
+    limit: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Maximum number of documents to return (default: 50)',
+    },
+    offset: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Number of documents to skip for pagination (default: 0)',
+    },
+  },
+
+  request: {
+    url: (params) => {
+      const queryParams = new URLSearchParams()
+      if (params.search) queryParams.set('search', params.search)
+      if (params.enabledFilter) queryParams.set('enabledFilter', params.enabledFilter)
+      if (params.limit != null) queryParams.set('limit', String(params.limit))
+      if (params.offset != null) queryParams.set('offset', String(params.offset))
+      const qs = queryParams.toString()
+      return `/api/knowledge/${params.knowledgeBaseId}/documents${qs ? `?${qs}` : ''}`
+    },
+    method: 'GET',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+  },
+
+  transformResponse: async (response, params): Promise<KnowledgeListDocumentsResponse> => {
+    const result = await response.json()
+    const data = result.data || {}
+    const documents = data.documents || []
+    const pagination = data.pagination || {}
+
+    return {
+      success: true,
+      output: {
+        knowledgeBaseId: params?.knowledgeBaseId ?? '',
+        documents: documents.map(
+          (doc: {
+            id: string
+            filename: string
+            fileSize: number
+            mimeType: string
+            enabled: boolean
+            processingStatus: string
+            chunkCount: number
+            tokenCount: number
+            uploadedAt: string
+            updatedAt: string
+            connectorId: string | null
+            connectorType: string | null
+            sourceUrl: string | null
+          }) => ({
+            id: doc.id,
+            filename: doc.filename,
+            fileSize: doc.fileSize ?? 0,
+            mimeType: doc.mimeType ?? null,
+            enabled: doc.enabled ?? true,
+            processingStatus: doc.processingStatus ?? null,
+            chunkCount: doc.chunkCount ?? 0,
+            tokenCount: doc.tokenCount ?? 0,
+            uploadedAt: doc.uploadedAt ?? null,
+            updatedAt: doc.updatedAt ?? null,
+            connectorId: doc.connectorId ?? null,
+            connectorType: doc.connectorType ?? null,
+            sourceUrl: doc.sourceUrl ?? null,
+          })
+        ),
+        totalDocuments: pagination.total ?? documents.length,
+        limit: pagination.limit ?? 50,
+        offset: pagination.offset ?? 0,
+      },
+    }
+  },
+
+  outputs: {
+    knowledgeBaseId: {
+      type: 'string',
+      description: 'ID of the knowledge base',
+    },
+    documents: {
+      type: 'array',
+      description: 'Array of documents in the knowledge base',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Document ID' },
+          filename: { type: 'string', description: 'Document filename' },
+          fileSize: { type: 'number', description: 'File size in bytes' },
+          mimeType: { type: 'string', description: 'MIME type of the document' },
+          enabled: { type: 'boolean', description: 'Whether the document is enabled' },
+          processingStatus: {
+            type: 'string',
+            description: 'Processing status (pending, processing, completed, failed)',
+          },
+          chunkCount: { type: 'number', description: 'Number of chunks in the document' },
+          tokenCount: { type: 'number', description: 'Total token count across chunks' },
+          uploadedAt: { type: 'string', description: 'Upload timestamp' },
+          updatedAt: { type: 'string', description: 'Last update timestamp' },
+          connectorId: {
+            type: 'string',
+            description: 'Connector ID if document was synced from an external source',
+          },
+          connectorType: {
+            type: 'string',
+            description: 'Connector type (e.g. notion, github, confluence) if synced',
+          },
+          sourceUrl: {
+            type: 'string',
+            description: 'Original URL in the source system if synced from a connector',
+          },
+        },
+      },
+    },
+    totalDocuments: {
+      type: 'number',
+      description: 'Total number of documents matching the filter',
+    },
+    limit: {
+      type: 'number',
+      description: 'Page size used',
+    },
+    offset: {
+      type: 'number',
+      description: 'Offset used for pagination',
+    },
+  },
+}