@strapi/admin 5.24.2 → 5.26.0

package/dist/admin/src/index.d.ts

@@ -50,6 +50,8 @@ export { useClipboard } from './hooks/useClipboard';
 export { useElementOnScreen } from './hooks/useElementOnScreen';
 export { useAdminUsers } from './services/users';
 export { useGetCountDocumentsQuery } from './services/homepage';
+/** @internal */
+export { useAIAvailability } from './hooks/useAIAvailability';
 /**
  * Types
  */

package/dist/admin/src/pages/Marketplace/hooks/useMarketplaceData.d.ts

@@ -78,8 +78,8 @@ interface MarketplaceResponse<TData extends Plugin | Provider> {
 declare function useMarketplaceData({ npmPackageType, debouncedSearch, query, tabQuery, strapiVersion, }: UseMarketplaceDataParams): {
     pluginsResponse: MarketplaceResponse<Plugin> | null | undefined;
     providersResponse: MarketplaceResponse<Provider> | undefined;
-    pluginsStatus: "error" | "loading" | "success" | "idle";
-    providersStatus: "error" | "loading" | "success" | "idle";
+    pluginsStatus: "success" | "loading" | "error" | "idle";
+    providersStatus: "success" | "loading" | "error" | "idle";
     possibleCollections: {};
     possibleCategories: {};
     pagination: {

package/dist/admin/src/services/admin.d.ts

@@ -15,6 +15,7 @@ declare const useInitQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks
     useTypescriptOnServer: boolean;
     useTypescriptOnAdmin: boolean;
     isHostedOnStrapiCloud: boolean;
+    aiLicenseKey?: string | undefined;
     numberOfAllContentTypes: number;
     numberOfComponents: number;
     numberOfDynamicZones: number;

package/dist/admin/src/services/homepage.d.ts

@@ -1,3 +1,4 @@
+import * as Homepage from '../../../shared/contracts/homepage';
 declare const useGetKeyStatisticsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("..").QueryArguments, unknown, import("..").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics" | "CountDocuments", {
     assets: number;
     contentTypes: number;
@@ -10,5 +11,5 @@ declare const useGetKeyStatisticsQuery: import("@reduxjs/toolkit/dist/query/reac
     draft: number;
     published: number;
     modified: number;
-}, "adminApi">>;
-export { useGetKeyStatisticsQuery, useGetCountDocumentsQuery };
+}, "adminApi">>, useGetHomepageLayoutQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("..").QueryArguments, unknown, import("..").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics" | "CountDocuments", Homepage.Homepage.Layout, "adminApi">>, useUpdateHomepageLayoutMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Homepage.Homepage.LayoutWrite, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("..").QueryArguments, unknown, import("..").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics" | "CountDocuments", Homepage.Homepage.Layout, "adminApi">>;
+export { useGetKeyStatisticsQuery, useGetCountDocumentsQuery, useGetHomepageLayoutQuery, useUpdateHomepageLayoutMutation, };

package/dist/ee/admin/src/components/GlobalNotifications.d.ts

@@ -0,0 +1 @@
+export declare const GlobalNotifications: () => null;

package/dist/ee/admin/src/hooks/useAIAvailability.d.ts

@@ -0,0 +1 @@
+export declare const useAIAvailability: () => boolean;

package/dist/ee/admin/src/hooks/useAIUsageWarning.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Triggers a warning notification if AI usage is above a threshold (default 80%).
+ * @param threshold - Usage percentage (0-1) at which to warn. Default: 0.8 (80%)
+ */
+export declare function useAIUsageWarning(threshold?: number): void;

package/dist/ee/admin/src/hooks/useLicenseLimits.d.ts

@@ -14,7 +14,7 @@ declare function useLicenseLimits({ enabled }?: UseLicenseLimitsArgs): {
         type: string;
         isTrial: boolean;
     } | undefined;
-    getFeature: <T>(name: "review-workflows" | "sso" | "cms-content-history" | "audit-logs" | "cms-content-releases") => Record<string, T> | undefined;
+    getFeature: <T>(name: "review-workflows" | "sso" | "audit-logs" | "cms-content-releases" | "cms-content-history") => Record<string, T> | undefined;
     isError: boolean;
     isLoading: boolean;
     isTrial: boolean;

package/dist/ee/admin/src/pages/SettingsPage/pages/ApplicationInfoPage/components/AIUsage.d.ts

@@ -0,0 +1 @@
+export declare const AIUsage: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/ee/admin/src/services/ai.d.ts

@@ -0,0 +1,9 @@
+import { GetAiUsage } from '../../../../shared/contracts/ai';
+declare const useGetAIUsageQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("src").QueryArguments, unknown, import("src").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics", GetAiUsage.Response, "adminApi">>, useGetAiTokenQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("src").QueryArguments, unknown, import("src").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics", {
+    token: string;
+    expiresAt?: string | undefined;
+}, "adminApi">>, useLazyGetAiTokenQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseLazyQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("src").QueryArguments, unknown, import("src").BaseQueryError>, "GuidedTourMeta" | "HomepageKeyStatistics", {
+    token: string;
+    expiresAt?: string | undefined;
+}, "adminApi">>;
+export { useGetAIUsageQuery, useGetAiTokenQuery, useLazyGetAiTokenQuery };

package/dist/ee/server/src/ai/controllers/ai.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from 'koa';
+declare const _default: {
+    getAiToken(ctx: Context): Promise<Context | undefined>;
+    getAiUsage(ctx: Context): Promise<Context | undefined>;
+};
+export default _default;
+//# sourceMappingURL=ai.d.ts.map

package/dist/ee/server/src/ai/controllers/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../../../ee/server/src/ai/controllers/ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;oBAQX,OAAO;oBA+IP,OAAO;;AAhJ/B,wBA2QE"}

package/dist/ee/server/src/ai/routes/ai.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: string[];
+        };
+    }[];
+};
+export default _default;
+//# sourceMappingURL=ai.d.ts.map

package/dist/ee/server/src/ai/routes/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../../../ee/server/src/ai/routes/ai.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,wBAsBE"}

package/dist/ee/server/src/controllers/admin.d.ts

@@ -9,6 +9,7 @@ declare const _default: {
             }[];
             flags: {};
             type: string | null | undefined;
+            ai: {};
         };
     } | {
         data: {
@@ -17,6 +18,7 @@ declare const _default: {
             flags: {};
             isTrial?: undefined;
             type?: undefined;
+            ai?: undefined;
         };
     }>;
     licenseLimitInformation(): Promise<{
@@ -28,6 +30,7 @@ declare const _default: {
             shouldStopCreate: boolean;
             licenseLimitStatus: string | null;
             isHostedOnStrapiCloud: boolean;
+            aiLicenseKey: unknown;
             type: string | null | undefined;
             isTrial: boolean;
             features: {

package/dist/ee/server/src/controllers/admin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/admin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wBA6DE"}
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/admin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAgEE"}

package/dist/ee/server/src/controllers/index.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
                 }[];
                 flags: {};
                 type: string | null | undefined;
+                ai: {};
             };
         } | {
             data: {
@@ -35,6 +36,7 @@ declare const _default: {
                 flags: {};
                 isTrial?: undefined;
                 type?: undefined;
+                ai?: undefined;
             };
         }>;
         licenseLimitInformation(): Promise<{
@@ -46,6 +48,7 @@ declare const _default: {
                 shouldStopCreate: boolean;
                 licenseLimitStatus: string | null;
                 isHostedOnStrapiCloud: boolean;
+                aiLicenseKey: unknown;
                 type: string | null | undefined;
                 isTrial: boolean;
                 features: {

package/dist/ee/server/src/controllers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBAKE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBAKE"}

package/dist/ee/server/src/index.d.ts

@@ -1,99 +1,15 @@
 /// <reference types="koa" />
 import type { Core } from '@strapi/types';
 declare const getAdminEE: () => {
-    register: ({ strapi }: {
-        strapi: Core.Strapi;
-    }) => Promise<void>;
-    bootstrap: (args: any) => Promise<void>;
-    destroy: ({ strapi }: {
-        strapi: Core.Strapi;
-    }) => Promise<void>;
-    contentTypes: {
-        'audit-log': {
-            schema: {
-                kind: string;
-                collectionName: string;
-                info: {
-                    singularName: string;
-                    pluralName: string;
-                    displayName: string;
-                };
-                options: {
-                    timestamps: boolean;
-                };
-                pluginOptions: {
-                    'content-manager': {
-                        visible: boolean;
-                    };
-                    'content-type-builder': {
-                        visible: boolean;
-                    };
-                };
-                attributes: {
-                    action: {
-                        type: string;
-                        required: boolean;
-                    };
-                    date: {
-                        type: string;
-                        required: boolean;
-                    };
-                    user: {
-                        type: string;
-                        relation: string;
-                        target: string;
-                    };
-                    payload: {
-                        type: string;
-                    };
-                };
-            };
-        };
-    };
-    services: {
-        auth: {
-            forgotPassword: ({ email }?: any) => Promise<any>;
-            resetPassword: ({ resetPasswordToken, password }?: any) => Promise<any>;
-        };
-        passport: {
-            providerRegistry: Map<any, any>;
-            getStrategyCallbackURL: (providerName: string) => string;
-            syncProviderRegistryWithConfig: () => void;
-            authEventsMapper: {
-                onSSOAutoRegistration: string;
-                onConnectionSuccess: string;
-                onConnectionError: string;
-            };
-            getPassportStrategies: () => any[];
-        };
-        role: {
-            ssoCheckRolesIdForDeletion: (ids: any) => Promise<void>;
-        };
-        user: {
-            updateEEDisabledUsersList: (id: string, input: any) => Promise<void>;
-            removeFromEEDisabledUsersList: (ids: unknown) => Promise<void>;
-            getCurrentActiveUserCount: () => Promise<number>;
-            deleteByIds: (ids: any) => Promise<any[]>;
-            deleteById: (id: unknown) => Promise<any>;
-            updateById: (id: any, attributes: any) => Promise<any>;
-        };
-        metrics: {
-            startCron: (strapi: Core.Strapi) => void;
-            getSSOProvidersList: () => Promise<any>;
-            sendUpdateProjectInformation: (strapi: Core.Strapi) => Promise<void>;
-        };
-        'seat-enforcement': {
-            seatEnforcementWorkflow: () => Promise<void>;
-            getDisabledUserList: () => Promise<unknown>;
-        };
-        'persist-tables': {
-            persistTablesWithPrefix: (tableNamePrefix: string) => Promise<void>;
-            removePersistedTablesWithSuffix: (tableNameSuffix: string) => Promise<void>;
-            persistTables: (tables: (string | import("./services/persist-tables").PersistedTable)[]) => Promise<void>;
-            findTables: typeof import("./services/persist-tables").findTables;
-        };
-    };
     controllers: {
+        ai?: {
+            getAiToken(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            getAiUsage(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+        } | undefined;
+        'audit-logs'?: {
+            findMany(ctx: import("koa").Context): Promise<void>;
+            findOne(ctx: import("koa").Context): Promise<void>;
+        } | undefined;
         authentication: {
             getProviders(ctx: import("koa").Context): Promise<void>;
             getProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
@@ -121,6 +37,7 @@ declare const getAdminEE: () => {
                     }[];
                     flags: {};
                     type: string | null | undefined;
+                    ai: {};
                 };
             } | {
                 data: {
@@ -129,6 +46,7 @@ declare const getAdminEE: () => {
                     flags: {};
                     isTrial?: undefined;
                     type?: undefined;
+                    ai?: undefined;
                 };
             }>;
             licenseLimitInformation(): Promise<{
@@ -140,6 +58,7 @@ declare const getAdminEE: () => {
                     shouldStopCreate: boolean;
                     licenseLimitStatus: string | null;
                     isHostedOnStrapiCloud: boolean;
+                    aiLicenseKey: unknown;
                     type: string | null | undefined;
                     isTrial: boolean;
                     features: {
@@ -151,34 +70,7 @@ declare const getAdminEE: () => {
         };
     };
     routes: {
-        sso: {
-            type: string;
-            routes: ({
-                method: string;
-                path: string;
-                handler: string;
-                config: {
-                    middlewares: Core.MiddlewareHandler[];
-                    auth: boolean;
-                    policies?: undefined;
-                };
-            } | {
-                method: string;
-                path: string;
-                handler: string;
-                config: {
-                    middlewares: Core.MiddlewareHandler[];
-                    policies: (string | {
-                        name: string;
-                        config: {
-                            actions: string[];
-                        };
-                    })[];
-                    auth?: undefined;
-                };
-            })[];
-        };
-        'license-limit': {
+        ai?: {
             type: string;
             routes: {
                 method: string;
@@ -188,72 +80,8 @@ declare const getAdminEE: () => {
                     policies: string[];
                 };
             }[];
-        };
-    };
-} | {
-    controllers: {
-        'audit-logs': {
-            findMany(ctx: import("koa").Context): Promise<void>;
-            findOne(ctx: import("koa").Context): Promise<void>;
-        };
-        authentication: {
-            getProviders(ctx: import("koa").Context): Promise<void>;
-            getProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
-            updateProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
-            providerLogin(ctx: import("koa").Context, next: import("koa").Next): any;
-        };
-        role: {
-            create(ctx: import("koa").Context): Promise<void>;
-            deleteOne(ctx: import("koa").Context): Promise<any>;
-            deleteMany(ctx: import("koa").Context): Promise<any>;
-        };
-        user: {
-            create(ctx: import("koa").Context): Promise<void>;
-            update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
-            isSSOLocked(ctx: import("koa").Context): Promise<void>;
-        };
-        admin: {
-            getProjectType(): Promise<{
-                data: {
-                    isEE: boolean | undefined;
-                    isTrial: boolean;
-                    features: {
-                        [key: string]: any;
-                        name: string;
-                    }[];
-                    flags: {};
-                    type: string | null | undefined;
-                };
-            } | {
-                data: {
-                    isEE: boolean;
-                    features: never[];
-                    flags: {};
-                    isTrial?: undefined;
-                    type?: undefined;
-                };
-            }>;
-            licenseLimitInformation(): Promise<{
-                data: {
-                    enforcementUserCount: any;
-                    currentActiveUserCount: any;
-                    permittedSeats: number | null | undefined;
-                    shouldNotify: boolean;
-                    shouldStopCreate: boolean;
-                    licenseLimitStatus: string | null;
-                    isHostedOnStrapiCloud: boolean;
-                    type: string | null | undefined;
-                    isTrial: boolean;
-                    features: {
-                        [key: string]: any;
-                        name: string;
-                    }[];
-                };
-            }>;
-        };
-    };
-    routes: {
-        'audit-logs': {
+        } | undefined;
+        'audit-logs'?: {
             type: string;
             routes: {
                 method: string;
@@ -269,7 +97,7 @@ declare const getAdminEE: () => {
                     })[];
                 };
             }[];
-        };
+        } | undefined;
         sso: {
             type: string;
             routes: ({

package/dist/ee/server/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../ee/server/src/index.ts"],"names":[],"mappings":";AAYA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8BiB;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;wBAWxB;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtD,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../ee/server/src/index.ts"],"names":[],"mappings":";AAcA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgCe;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;wBAaxB;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOpD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/server/ee/server/src/ai/controllers/ai.js

@@ -0,0 +1,218 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var crypto = require('crypto');
+
+var aiController = {
+    async getAiToken (ctx) {
+        const ERROR_PREFIX = 'AI token request failed:';
+        const USER_ERROR_MESSAGE = 'AI token request failed. Check server logs for details.';
+        try {
+            // Security check: Ensure user is authenticated and has proper permissions
+            if (!ctx.state.user) {
+                return ctx.unauthorized('Authentication required');
+            }
+            // Check if EE features are enabled first
+            if (!strapi.ee?.isEE) {
+                strapi.log.error(`${ERROR_PREFIX} Enterprise Edition features are not enabled`);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            // Get the EE license
+            // First try environment variable, then try reading from file
+            let eeLicense = process.env.STRAPI_LICENSE;
+            if (!eeLicense) {
+                try {
+                    const licensePath = path.join(strapi.dirs.app.root, 'license.txt');
+                    eeLicense = fs.readFileSync(licensePath).toString();
+                } catch (error) {
+                // License file doesn't exist or can't be read
+                }
+            }
+            if (!eeLicense) {
+                strapi.log.error(`${ERROR_PREFIX} No EE license found. Please ensure STRAPI_LICENSE environment variable is set or license.txt file exists.`);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            const aiServerUrl = process.env.STRAPI_AI_URL || 'https://strapi-ai.apps.strapi.io';
+            if (!aiServerUrl) {
+                strapi.log.error(`${ERROR_PREFIX} AI server URL not configured. Please set STRAPI_AI_URL environment variable.`);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            // Get the current user
+            const user = ctx.state.user;
+            // Create a secure user identifier using only user ID
+            const userIdentifier = user.id.toString();
+            // Get project ID
+            const projectId = strapi.config.get('uuid');
+            if (!projectId) {
+                strapi.log.error(`${ERROR_PREFIX} Project ID not configured`);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            strapi.log.http('Contacting AI Server for token generation');
+            try {
+                // Call the AI server's getAiJWT endpoint
+                const response = await fetch(`${aiServerUrl}/auth/getAiJWT`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        // No authorization header needed for public endpoint
+                        // Add request ID for tracing
+                        'X-Request-Id': crypto.randomUUID()
+                    },
+                    body: JSON.stringify({
+                        eeLicense,
+                        userIdentifier,
+                        projectId
+                    })
+                });
+                if (!response.ok) {
+                    let errorData;
+                    let errorText;
+                    try {
+                        errorText = await response.text();
+                        errorData = JSON.parse(errorText);
+                    } catch  {
+                        errorData = {
+                            error: errorText || 'Failed to parse error response'
+                        };
+                    }
+                    strapi.log.error(`${ERROR_PREFIX} ${errorData?.error || 'Unknown error'}`, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        error: errorData,
+                        errorText,
+                        projectId
+                    });
+                    return ctx.internalServerError(USER_ERROR_MESSAGE);
+                }
+                let data;
+                try {
+                    data = await response.json();
+                } catch (parseError) {
+                    strapi.log.error(`${ERROR_PREFIX} Failed to parse AI server response`, parseError);
+                    return ctx.internalServerError(USER_ERROR_MESSAGE);
+                }
+                if (!data.jwt) {
+                    strapi.log.error(`${ERROR_PREFIX} Invalid response: missing JWT token`);
+                    return ctx.internalServerError(USER_ERROR_MESSAGE);
+                }
+                strapi.log.info('AI token generated successfully', {
+                    userId: user.id,
+                    expiresAt: data.expiresAt
+                });
+                // Return the AI JWT with metadata
+                // Note: Token expires in 1 hour, client should handle refresh
+                ctx.body = {
+                    data: {
+                        token: data.jwt,
+                        expiresAt: data.expiresAt
+                    }
+                };
+            } catch (fetchError) {
+                if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+                    strapi.log.error(`${ERROR_PREFIX} Request to AI server timed out`);
+                    return ctx.internalServerError(USER_ERROR_MESSAGE);
+                }
+                throw fetchError;
+            }
+        } catch (error) {
+            strapi.log.error(`${ERROR_PREFIX} ${error instanceof Error ? error.message : 'Unknown error'}`, error);
+            return ctx.internalServerError(USER_ERROR_MESSAGE);
+        }
+    },
+    async getAiUsage (ctx) {
+        const ERROR_PREFIX = 'AI usage data request failed:';
+        const USER_ERROR_MESSAGE = 'AI usage data request failed. Check server logs for details.';
+        // Security check: Ensure user is authenticated and has proper permissions
+        if (!ctx.state.user) {
+            return ctx.unauthorized('Authentication required');
+        }
+        // Check if EE features are enabled first
+        if (!strapi.ee?.isEE) {
+            strapi.log.error(`${ERROR_PREFIX} Enterprise Edition features are not enabled`);
+            return ctx.internalServerError(USER_ERROR_MESSAGE);
+        }
+        // Get the EE license
+        // First try environment variable, then try reading from file
+        let eeLicense = process.env.STRAPI_LICENSE;
+        if (!eeLicense) {
+            try {
+                const licensePath = path.join(strapi.dirs.app.root, 'license.txt');
+                eeLicense = fs.readFileSync(licensePath).toString();
+            } catch (error) {
+            // License file doesn't exist or can't be read
+            }
+        }
+        if (!eeLicense) {
+            strapi.log.error(`${ERROR_PREFIX} No EE license found. Please ensure STRAPI_LICENSE environment variable is set or license.txt file exists.`);
+            return ctx.internalServerError(USER_ERROR_MESSAGE);
+        }
+        const aiServerUrl = process.env.STRAPI_AI_URL || 'https://strapi-ai.apps.strapi.io';
+        if (!aiServerUrl) {
+            strapi.log.error(`${ERROR_PREFIX} AI server URL not configured. Please set STRAPI_AI_URL or STRAPI_AI_URL environment variable.`);
+            return ctx.internalServerError(USER_ERROR_MESSAGE);
+        }
+        // Get project ID
+        const projectId = strapi.config.get('uuid');
+        if (!projectId) {
+            strapi.log.error(`${ERROR_PREFIX} Project ID not configured`);
+            return ctx.internalServerError(USER_ERROR_MESSAGE);
+        }
+        try {
+            // Call the AI server's getAiJWT endpoint
+            const response = await fetch(`${aiServerUrl}/cms/ai-data`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    // No authorization header needed for public endpoint
+                    // Add request ID for tracing
+                    'X-Request-Id': crypto.randomUUID()
+                },
+                body: JSON.stringify({
+                    eeKey: eeLicense,
+                    projectId
+                })
+            });
+            if (!response.ok) {
+                let errorData;
+                let errorText;
+                try {
+                    errorText = await response.text();
+                    errorData = JSON.parse(errorText);
+                } catch  {
+                    errorData = {
+                        error: errorText || 'Failed to parse error response'
+                    };
+                }
+                strapi.log.error(`${ERROR_PREFIX} ${errorData?.error || 'Unknown error'}`, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    error: errorData,
+                    errorText,
+                    projectId
+                });
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            let data;
+            try {
+                data = await response.json();
+            } catch (parseError) {
+                strapi.log.error(`${ERROR_PREFIX} Failed to parse AI server response`, parseError);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            ctx.body = {
+                ...data.data,
+                subscription: data.subscription
+            };
+        } catch (fetchError) {
+            if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+                strapi.log.error(`${ERROR_PREFIX} Request to AI server timed out`);
+                return ctx.internalServerError(USER_ERROR_MESSAGE);
+            }
+            throw fetchError;
+        }
+    }
+};
+
+module.exports = aiController;
+//# sourceMappingURL=ai.js.map