@payloadcms/plugin-mcp 4.0.0-canary.0 → 4.0.0-canary.2

package/src/mcp/builtin/validateEntityData.ts

@@ -0,0 +1,132 @@
+import type { CollectionSlug, GlobalSlug, PayloadRequest, SanitizedConfig } from 'payload'
+
+import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server'
+
+import type { JsonSchemaType, MCPToolResponse } from '../../types.js'
+
+import {
+  getCollectionInputSchema,
+  getGlobalInputSchema,
+} from '../../utils/schemaConversion/getEntityInputSchema.js'
+
+/**
+ * Keep the default `shortcircuit: true` - `false` makes validating nested rich text exponentially slow.
+ */
+const validator = new CfWorkerJsonSchemaValidator({ shortcircuit: true })
+
+type EntityValidator = {
+  schema: JsonSchemaType
+  validate: ReturnType<(typeof validator)['getValidator']>
+}
+
+/**
+ * - Caches each entity's schema and validator, so both are only built on the first request.
+ * - Keyed by payload config, then by entity type, slug, partial and language.
+ */
+const validatorCache = new WeakMap<SanitizedConfig, Map<string, EntityValidator>>()
+
+export const validateCollectionData = ({
+  collectionSlug,
+  data,
+  partial,
+  req,
+}: {
+  collectionSlug: CollectionSlug
+  data: Record<string, unknown>
+  partial?: boolean
+  req: PayloadRequest
+}): MCPToolResponse | null =>
+  validateData({
+    slug: collectionSlug,
+    buildSchema: () => getCollectionInputSchema({ collectionSlug, req }),
+    data,
+    entity: 'collection',
+    partial,
+    req,
+  })
+
+export const validateGlobalData = ({
+  data,
+  globalSlug,
+  req,
+}: {
+  data: Record<string, unknown>
+  globalSlug: GlobalSlug
+  req: PayloadRequest
+}): MCPToolResponse | null =>
+  validateData({
+    slug: globalSlug,
+    buildSchema: () => getGlobalInputSchema({ globalSlug, req }),
+    data,
+    entity: 'global',
+    partial: true,
+    req,
+  })
+
+const validateData = ({
+  slug,
+  buildSchema,
+  data,
+  entity,
+  partial,
+  req,
+}: {
+  buildSchema: () => JsonSchemaType | null
+  data: Record<string, unknown>
+  entity: 'collection' | 'global'
+  partial?: boolean
+  req: PayloadRequest
+  slug: string
+}): MCPToolResponse | null => {
+  let cache = validatorCache.get(req.payload.config)
+  if (!cache) {
+    cache = new Map()
+    validatorCache.set(req.payload.config, cache)
+  }
+
+  const cacheKey = `${entity}:${slug}:${partial ? 'partial' : 'full'}:${req.i18n.language}`
+  let entityValidator = cache.get(cacheKey)
+
+  if (!entityValidator) {
+    const schema = buildSchema()
+
+    if (!schema) {
+      return null
+    }
+
+    entityValidator = {
+      schema,
+      validate: validator.getValidator(partial ? withoutRequired(schema) : schema),
+    }
+    cache.set(cacheKey, entityValidator)
+  }
+
+  const result = entityValidator.validate(data)
+
+  if (result.valid) {
+    return null
+  }
+
+  const { schema } = entityValidator
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Invalid data for ${entity} "${slug}": ${result.errorMessage}\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``,
+      },
+    ],
+    isError: true,
+    structuredContent: {
+      [`${entity}Slug`]: slug,
+      errors: [{ message: result.errorMessage }],
+      schema,
+    },
+  }
+}
+
+/** Updates are partial — drop the schema's top-level `required` before validating. */
+const withoutRequired = (schema: JsonSchemaType): JsonSchemaType => {
+  const { required: _required, ...rest } = schema
+  return rest
+}

package/src/mcp/builtinTools.ts

@@ -1,4 +1,4 @@
-import type { CollectionTool, GlobalTool } from '../types.js'
+import type { CollectionTool, GlobalTool, Tool } from '../types.js'
 
 import {
   authCollectionTool,
@@ -8,62 +8,72 @@ import {
   unlockCollectionTool,
   verifyCollectionTool,
 } from './builtin/collections/authTools.js'
-import { createCollectionTool } from './builtin/collections/createTool.js'
-import { deleteCollectionTool } from './builtin/collections/deleteTool.js'
-import { findCollectionTool } from './builtin/collections/findTool.js'
-import { updateCollectionTool } from './builtin/collections/updateTool.js'
+import { createDocumentTool } from './builtin/collections/createTool.js'
+import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
+import { findDocumentsTool } from './builtin/collections/findTool.js'
+import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
+import { updateDocumentTool } from './builtin/collections/updateTool.js'
+import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
 import { findGlobalTool } from './builtin/globals/findTool.js'
+import { getGlobalSchemaTool } from './builtin/globals/getGlobalSchemaTool.js'
 import { updateGlobalTool } from './builtin/globals/updateTool.js'
 
+export const TOOL_BUILTINS = {
+  getConfigInfo: { label: 'Config Info', mcpName: 'getConfigInfo', tool: getConfigInfoTool },
+} satisfies Record<string, { label: string; mcpName: string; tool: Tool }>
+
 /**
  * The static built-in collection CRUD tools. Keys here are the source of truth
  * for `MCPCollectionBuiltinName` — adding/removing an entry updates the type
  * automatically.
  */
-export const COLLECTION_BUILTINS: Record<MCPCollectionBuiltinName, CollectionTool> = {
-  create: createCollectionTool,
-  delete: deleteCollectionTool,
-  find: findCollectionTool,
-  update: updateCollectionTool,
-}
+export const COLLECTION_BUILTINS = {
+  create: { mcpName: 'createDocument', tool: createDocumentTool },
+  delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
+  find: { mcpName: 'findDocuments', tool: findDocumentsTool },
+  getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  update: { mcpName: 'updateDocument', tool: updateDocumentTool },
+} satisfies Record<string, { mcpName: string; tool: CollectionTool }>
 
 /**
  * The static auth tools surfaced under auth-enabled collections. Each entry
  * carries the admin-UI label alongside the tool. Keys are the source of truth
  * for `MCPCollectionAuthToolName`.
  */
-export const COLLECTION_AUTH_BUILTINS: Record<
-  MCPCollectionAuthToolName,
-  { label: string; tool: CollectionTool }
-> = {
-  auth: { label: 'Check Auth Status', tool: authCollectionTool },
-  forgotPassword: { label: 'Forgot Password', tool: forgotPasswordCollectionTool },
-  login: { label: 'User Login', tool: loginCollectionTool },
-  resetPassword: { label: 'Reset Password', tool: resetPasswordCollectionTool },
-  unlock: { label: 'Unlock Account', tool: unlockCollectionTool },
-  verify: { label: 'Email Verification', tool: verifyCollectionTool },
-}
+export const COLLECTION_AUTH_BUILTINS = {
+  auth: { label: 'Check Auth Status', mcpName: 'auth', tool: authCollectionTool },
+  forgotPassword: {
+    label: 'Forgot Password',
+    mcpName: 'forgotPassword',
+    tool: forgotPasswordCollectionTool,
+  },
+  login: { label: 'User Login', mcpName: 'login', tool: loginCollectionTool },
+  resetPassword: {
+    label: 'Reset Password',
+    mcpName: 'resetPassword',
+    tool: resetPasswordCollectionTool,
+  },
+  unlock: { label: 'Unlock Account', mcpName: 'unlock', tool: unlockCollectionTool },
+  verify: { label: 'Email Verification', mcpName: 'verify', tool: verifyCollectionTool },
+} satisfies Record<string, { label: string; mcpName: string; tool: CollectionTool }>
 
 /**
  * The static built-in global tools. Keys are the source of truth for
  * `MCPGlobalBuiltinName`.
  */
-export const GLOBAL_BUILTINS: Record<MCPGlobalBuiltinName, GlobalTool> = {
-  find: findGlobalTool,
-  update: updateGlobalTool,
-}
+export const GLOBAL_BUILTINS = {
+  find: { mcpName: 'findGlobal', tool: findGlobalTool },
+  getGlobalSchema: { mcpName: 'getGlobalSchema', tool: getGlobalSchemaTool },
+  update: { mcpName: 'updateGlobal', tool: updateGlobalTool },
+} satisfies Record<string, { mcpName: string; tool: GlobalTool }>
+
+export type MCPCollectionBuiltinName = keyof typeof COLLECTION_BUILTINS
 
-export type MCPCollectionBuiltinName = 'create' | 'delete' | 'find' | 'update'
+export type MCPCollectionAuthToolName = keyof typeof COLLECTION_AUTH_BUILTINS
 
-export type MCPCollectionAuthToolName =
-  | 'auth'
-  | 'forgotPassword'
-  | 'login'
-  | 'resetPassword'
-  | 'unlock'
-  | 'verify'
+export type MCPGlobalBuiltinName = keyof typeof GLOBAL_BUILTINS
 
-export type MCPGlobalBuiltinName = 'find' | 'update'
+export type MCPTopLevelBuiltinName = keyof typeof TOOL_BUILTINS
 
 /**
  * Pre-typed `Object.entries` for each registry. The cast from `string` to the
@@ -71,14 +81,18 @@ export type MCPGlobalBuiltinName = 'find' | 'update'
  * cast — TypeScript's `Object.entries` always widens keys to `string`, which
  * defeats the narrow type lookups on `MCPCollectionToolsMap`.
  */
+export const TOOL_BUILTIN_ENTRIES = Object.entries(TOOL_BUILTINS) as Array<
+  [MCPTopLevelBuiltinName, (typeof TOOL_BUILTINS)[MCPTopLevelBuiltinName]]
+>
+
 export const COLLECTION_BUILTIN_ENTRIES = Object.entries(COLLECTION_BUILTINS) as Array<
-  [MCPCollectionBuiltinName, CollectionTool]
+  [MCPCollectionBuiltinName, (typeof COLLECTION_BUILTINS)[MCPCollectionBuiltinName]]
 >
 
 export const COLLECTION_AUTH_BUILTIN_ENTRIES = Object.entries(COLLECTION_AUTH_BUILTINS) as Array<
-  [MCPCollectionAuthToolName, { label: string; tool: CollectionTool }]
+  [MCPCollectionAuthToolName, (typeof COLLECTION_AUTH_BUILTINS)[MCPCollectionAuthToolName]]
 >
 
 export const GLOBAL_BUILTIN_ENTRIES = Object.entries(GLOBAL_BUILTINS) as Array<
-  [MCPGlobalBuiltinName, GlobalTool]
+  [MCPGlobalBuiltinName, (typeof GLOBAL_BUILTINS)[MCPGlobalBuiltinName]]
 >

package/src/mcp/sanitizeMCPConfig.ts

@@ -8,13 +8,12 @@ import type {
 } from 'payload'
 
 import type {
+  CollectionMCPItem,
   CollectionTool,
+  GlobalMCPItem,
   GlobalTool,
-  MCPBuiltInToolOverride,
   MCPItem,
-  MCPPluginCollectionConfig,
   MCPPluginConfig,
-  MCPPluginGlobalConfig,
   SanitizedMCPPluginConfig,
 } from '../types.js'
 
@@ -25,6 +24,8 @@ import {
   COLLECTION_BUILTINS,
   GLOBAL_BUILTIN_ENTRIES,
   GLOBAL_BUILTINS,
+  TOOL_BUILTIN_ENTRIES,
+  TOOL_BUILTINS,
 } from './builtinTools.js'
 
 /**
@@ -54,29 +55,45 @@ export const sanitizeMCPConfig = ({
     items.push(...sanitizeGlobalConfig({ global, pluginConfig }))
   }
 
-  for (const [key, tool] of Object.entries(pluginConfig.tools ?? {})) {
+  for (const [configKey, { label, mcpName, tool }] of TOOL_BUILTIN_ENTRIES) {
     items.push({
       type: 'tool',
-      key,
-      label: key,
+      configKey,
+      label,
+      mcpName,
       tool,
     })
   }
 
-  for (const [key, prompt] of Object.entries(pluginConfig.prompts ?? {})) {
+  for (const [configKey, tool] of Object.entries(pluginConfig.tools ?? {})) {
+    if (configKey in TOOL_BUILTINS) {
+      continue
+    }
+    items.push({
+      type: 'tool',
+      configKey,
+      label: configKey,
+      mcpName: configKey,
+      tool,
+    })
+  }
+
+  for (const [configKey, prompt] of Object.entries(pluginConfig.prompts ?? {})) {
     items.push({
       type: 'prompt',
-      key,
-      label: prompt.title ?? key,
+      configKey,
+      label: prompt.title ?? configKey,
+      mcpName: configKey,
       prompt,
     })
   }
 
-  for (const [key, resource] of Object.entries(pluginConfig.resources ?? {})) {
+  for (const [configKey, resource] of Object.entries(pluginConfig.resources ?? {})) {
     items.push({
       type: 'resource',
-      key,
-      label: resource.title ?? key,
+      configKey,
+      label: resource.title ?? configKey,
+      mcpName: configKey,
       resource,
     })
   }
@@ -101,30 +118,39 @@ const sanitizeCollectionConfig = ({
 }: {
   collection: CollectionConfig | SanitizedCollectionConfig
   pluginConfig: MCPPluginConfig
-}): MCPItem[] => {
+}): CollectionMCPItem[] => {
   if (collection.slug === 'payload-mcp-api-keys') {
     return []
   }
   const slug = collection.slug
   const collectionPluginConfig = pluginConfig.collections?.[slug]
-  const items: MCPItem[] = []
+  const items: CollectionMCPItem[] = []
 
-  for (const [toolKey, tool] of COLLECTION_BUILTIN_ENTRIES) {
+  for (const [toolKey, { mcpName, tool }] of COLLECTION_BUILTIN_ENTRIES) {
     const matchedConfigEntry = collectionPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue
     }
+    const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
     items.push({
       type: 'collectionTool',
       collectionSlug: slug,
-      key: toolKey,
+      configKey: toolKey,
       label: capitalize(toolKey),
-      tool: overrideBuiltinTool(tool, matchedConfigEntry, collectionPluginConfig),
+      mcpName,
+      tool: {
+        ...tool,
+        description: override?.description ?? tool.description,
+        overrideResponse:
+          override?.overrideResponse ??
+          collectionPluginConfig?.overrideResponse ??
+          tool.overrideResponse,
+      },
     })
   }
 
   if (collection.auth) {
-    for (const [authToolKey, { label, tool }] of COLLECTION_AUTH_BUILTIN_ENTRIES) {
+    for (const [authToolKey, { label, mcpName, tool }] of COLLECTION_AUTH_BUILTIN_ENTRIES) {
       const matchedConfigEntry = collectionPluginConfig?.tools?.[authToolKey]
       if (!matchedConfigEntry) {
         continue
@@ -134,9 +160,17 @@ const sanitizeCollectionConfig = ({
       items.push({
         type: 'collectionTool',
         collectionSlug: slug,
-        key: authToolKey,
+        configKey: authToolKey,
         label,
-        tool: overrideBuiltinTool(tool, override, collectionPluginConfig),
+        mcpName,
+        tool: {
+          ...tool,
+          description: override?.description ?? tool.description,
+          overrideResponse:
+            override?.overrideResponse ??
+            collectionPluginConfig?.overrideResponse ??
+            tool.overrideResponse,
+        },
       })
     }
   }
@@ -146,8 +180,8 @@ const sanitizeCollectionConfig = ({
   const customEntries = Object.entries(collectionPluginConfig?.tools ?? {}) as Array<
     [string, CollectionTool | undefined]
   >
-  for (const [key, customTool] of customEntries) {
-    if (key in COLLECTION_BUILTINS || key in COLLECTION_AUTH_BUILTINS) {
+  for (const [configKey, customTool] of customEntries) {
+    if (configKey in COLLECTION_BUILTINS || configKey in COLLECTION_AUTH_BUILTINS) {
       continue
     }
     if (!customTool) {
@@ -156,8 +190,9 @@ const sanitizeCollectionConfig = ({
     items.push({
       type: 'collectionTool',
       collectionSlug: slug,
-      key,
-      label: key,
+      configKey,
+      label: configKey,
+      mcpName: configKey,
       tool: customTool,
     })
   }
@@ -171,30 +206,39 @@ const sanitizeGlobalConfig = ({
 }: {
   global: GlobalConfig | SanitizedGlobalConfig
   pluginConfig: MCPPluginConfig
-}): MCPItem[] => {
+}): GlobalMCPItem[] => {
   const slug = global.slug
   const globalPluginConfig = pluginConfig.globals?.[slug]
-  const items: MCPItem[] = []
+  const items: GlobalMCPItem[] = []
 
-  for (const [toolKey, baseTool] of GLOBAL_BUILTIN_ENTRIES) {
+  for (const [toolKey, { mcpName, tool }] of GLOBAL_BUILTIN_ENTRIES) {
     const matchedConfigEntry = globalPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue
     }
+    const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
     items.push({
       type: 'globalTool',
+      configKey: toolKey,
       globalSlug: slug,
-      key: toolKey,
       label: capitalize(toolKey),
-      tool: overrideBuiltinTool(baseTool, matchedConfigEntry, globalPluginConfig),
+      mcpName,
+      tool: {
+        ...tool,
+        description: override?.description ?? tool.description,
+        overrideResponse:
+          override?.overrideResponse ??
+          globalPluginConfig?.overrideResponse ??
+          tool.overrideResponse,
+      },
     })
   }
 
   const customEntries = Object.entries(globalPluginConfig?.tools ?? {}) as Array<
     [string, GlobalTool | undefined]
   >
-  for (const [key, customTool] of customEntries) {
-    if (key in GLOBAL_BUILTINS) {
+  for (const [configKey, customTool] of customEntries) {
+    if (configKey in GLOBAL_BUILTINS) {
       continue
     }
     if (!customTool) {
@@ -202,9 +246,10 @@ const sanitizeGlobalConfig = ({
     }
     items.push({
       type: 'globalTool',
+      configKey,
       globalSlug: slug,
-      key,
-      label: key,
+      label: configKey,
+      mcpName: configKey,
       tool: customTool,
     })
   }
@@ -213,27 +258,3 @@ const sanitizeGlobalConfig = ({
 }
 
 const capitalize = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1)
-
-/**
- * Spread the static built-in tool and apply consumer-side overrides.
- * Precedence: per-tool override > scope-level (collection/global) override >
- * the static tool's defaults. `toolEntry` is whatever the user put under
- * `tools: { find: ... }` — could be `true`, `false`, or an override object —
- * so it's narrowed internally.
- */
-const overrideBuiltinTool = <TTool extends CollectionTool | GlobalTool>(
-  tool: TTool,
-  toolOverride?: MCPBuiltInToolOverride,
-  entityPluginConfig?: TTool extends CollectionTool
-    ? MCPPluginCollectionConfig<any>
-    : MCPPluginGlobalConfig,
-): TTool => {
-  return {
-    ...tool,
-    description: toolOverride?.description ?? entityPluginConfig?.description ?? tool.description,
-    overrideResponse:
-      toolOverride?.overrideResponse ??
-      entityPluginConfig?.overrideResponse ??
-      tool.overrideResponse,
-  }
-}

package/src/translations/index.ts

@@ -0,0 +1,108 @@
+import type {
+  NestedKeysStripped,
+  SupportedLanguages,
+} from '@payloadcms/translations'
+
+import type { PluginDefaultTranslationsObject } from './types.js'
+
+import { ar } from './languages/ar.js'
+import { az } from './languages/az.js'
+import { bg } from './languages/bg.js'
+import { bnBd } from './languages/bnBd.js'
+import { bnIn } from './languages/bnIn.js'
+import { ca } from './languages/ca.js'
+import { cs } from './languages/cs.js'
+import { da } from './languages/da.js'
+import { de } from './languages/de.js'
+import { en } from './languages/en.js'
+import { es } from './languages/es.js'
+import { et } from './languages/et.js'
+import { fa } from './languages/fa.js'
+import { fr } from './languages/fr.js'
+import { he } from './languages/he.js'
+import { hr } from './languages/hr.js'
+import { hu } from './languages/hu.js'
+import { hy } from './languages/hy.js'
+import { id } from './languages/id.js'
+import { is } from './languages/is.js'
+import { it } from './languages/it.js'
+import { ja } from './languages/ja.js'
+import { ko } from './languages/ko.js'
+import { lt } from './languages/lt.js'
+import { lv } from './languages/lv.js'
+import { my } from './languages/my.js'
+import { nb } from './languages/nb.js'
+import { nl } from './languages/nl.js'
+import { pl } from './languages/pl.js'
+import { pt } from './languages/pt.js'
+import { ro } from './languages/ro.js'
+import { rs } from './languages/rs.js'
+import { rsLatin } from './languages/rsLatin.js'
+import { ru } from './languages/ru.js'
+import { sk } from './languages/sk.js'
+import { sl } from './languages/sl.js'
+import { sv } from './languages/sv.js'
+import { ta } from './languages/ta.js'
+import { th } from './languages/th.js'
+import { tr } from './languages/tr.js'
+import { uk } from './languages/uk.js'
+import { vi } from './languages/vi.js'
+import { zh } from './languages/zh.js'
+import { zhTw } from './languages/zhTw.js'
+
+export const translations = {
+  id,
+  ar,
+  az,
+  bg,
+  'bn-BD': bnBd,
+  'bn-IN': bnIn,
+  ca,
+  cs,
+  da,
+  de,
+  en,
+  es,
+  et,
+  fa,
+  fr,
+  he,
+  hr,
+  hu,
+  hy,
+  is,
+  it,
+  ja,
+  ko,
+  lt,
+  lv,
+  my,
+  nb,
+  nl,
+  pl,
+  pt,
+  ro,
+  rs,
+  'rs-latin': rsLatin,
+  ru,
+  sk,
+  sl,
+  sv,
+  ta,
+  th,
+  tr,
+  uk,
+  vi,
+  zh,
+  'zh-TW': zhTw,
+} as SupportedLanguages<PluginDefaultTranslationsObject>
+
+export type PluginMCPTranslations = PluginDefaultTranslationsObject
+
+export type PluginMCPTranslationKeys = NestedKeysStripped<PluginMCPTranslations>
+
+declare module '@payloadcms/translations' {
+  interface CustomTranslationKeys {
+    'plugin-mcp': PluginMCPTranslationKeys
+  }
+}

package/src/translations/languages/ar.ts

@@ -0,0 +1,35 @@
+import type { PluginLanguage } from '../types.js'
+
+export const arTranslations = {
+  'plugin-mcp': {
+    apiKeyDescription: 'تتحكم مفاتيح API في المجموعات والموارد والأدوات والمطالبات التي يمكن لعملاء MCP الوصول إليها.',
+    apiKeys: 'مفاتيح API',
+    authentication: 'المصادقة',
+    description: 'الوصف',
+    descriptionDescription: 'صف الغرض من مفتاح API.',
+    dismiss: 'إغلاق',
+    keepKeyPrivate: 'حافظ على سرية مفتاحك.',
+    keyPrivateDescription: 'هذا المفتاح يمنح MCP إمكانية الوصول إلى محتواك. لا تشاركه مع الآخرين!',
+    lastUsed: 'آخر استخدام',
+    manageAPIKeys: 'إدارة مفاتيح API',
+    mcp: 'MCP',
+    noAPIKeys: 'لا توجد مفاتيح API',
+    operations: 'العمليات',
+    overrideAccess: 'تجاوز التحكم في الوصول',
+    overrideAccessDescription: 'عند تفعيله، يتجاوز هذا المفتاح تحكم Payload في الوصول لكل عملية ينفذها. اتركه غير مفعل ما لم يكن لديك سبب محدد.',
+    permissions: 'الأذونات',
+    permissionsDescription: 'اسمح لعملاء MCP بالوصول إلى المجموعات والأدوات والموارد والمطالبات التالية.',
+    prompts: 'المطالبات',
+    resources: 'الموارد',
+    server: 'الخادم',
+    title: 'العنوان',
+    titleDescription: 'اسم مستعار مفيد لمفتاح API.',
+    tools: 'الأدوات',
+    userDescription: 'المستخدم الذي سيعمل MCP بصفته.',
+  },
+}
+
+export const ar: PluginLanguage = {
+  dateFNSKey: 'ar',
+  translations: arTranslations,
+}