@casual-simulation/aux-records 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/AIController.js

@@ -4,35 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 import { getHumeAiFeatures, getOpenAiFeatures, getSloydAiFeatures, getSubscriptionFeatures, } from './SubscriptionConfiguration';
 import { traced } from './tracing/TracingDecorators';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
@@ -91,160 +62,158 @@ export class AIController {
         this._policyStore = configuration.policies;
         this._recordsStore = configuration.records;
     }
-    chat(request) {
+    async chat(request) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._chatProviders) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                if (!request.userId) {
+        try {
+            if (!this._chatProviders) {
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
+            }
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                };
+            }
+            if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedChatSubscriptionTiers)) {
+                if (!request.userSubscriptionTier) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                        errorCode: 'not_subscribed',
+                        errorMessage: 'The user must be subscribed in order to use this operation.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedChatSubscriptionTiers,
+                        ],
                     };
                 }
-                if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedChatSubscriptionTiers)) {
-                    if (!request.userSubscriptionTier) {
-                        return {
-                            success: false,
-                            errorCode: 'not_subscribed',
-                            errorMessage: 'The user must be subscribed in order to use this operation.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedChatSubscriptionTiers,
-                            ],
-                        };
-                    }
-                    else {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_subscription_tier',
-                            errorMessage: 'This operation is not available to the user at their current subscription tier.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedChatSubscriptionTiers,
-                            ],
-                            currentSubscriptionTier: request.userSubscriptionTier,
-                        };
-                    }
-                }
-                if (!!request.model &&
-                    !this._allowedChatModels.has(request.model)) {
+                else {
                     return {
                         success: false,
-                        errorCode: 'invalid_model',
-                        errorMessage: `The given model is not allowed for chats.`,
+                        errorCode: 'invalid_subscription_tier',
+                        errorMessage: 'This operation is not available to the user at their current subscription tier.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedChatSubscriptionTiers,
+                        ],
+                        currentSubscriptionTier: request.userSubscriptionTier,
                     };
                 }
-                const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._chatOptions.defaultModel;
-                const provider = (_b = this._allowedChatModels.get(request.model)) !== null && _b !== void 0 ? _b : this._chatOptions.defaultModelProvider;
-                const chat = this._chatProviders[provider];
-                if (!chat) {
-                    console.error('[AIController] No chat provider found for model:', model);
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'The given model is not supported.',
-                    };
+            }
+            if (!!request.model &&
+                !this._allowedChatModels.has(request.model)) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_model',
+                    errorMessage: `The given model is not allowed for chats.`,
+                };
+            }
+            const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._chatOptions.defaultModel;
+            const provider = (_b = this._allowedChatModels.get(request.model)) !== null && _b !== void 0 ? _b : this._chatOptions.defaultModelProvider;
+            const chat = this._chatProviders[provider];
+            if (!chat) {
+                console.error('[AIController] No chat provider found for model:', model);
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'The given model is not supported.',
+                };
+            }
+            else {
+                console.log('[AIController] Using chat provider:', provider, 'for model:', model);
+            }
+            const metrics = await this._metrics.getSubscriptionAiChatMetrics({
+                ownerId: request.userId,
+            });
+            const config = await this._config.getSubscriptionConfiguration();
+            const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
+            if (!allowedFeatures.ai.chat.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit AI Chat features.',
+                };
+            }
+            let maxTokens = undefined;
+            if (allowedFeatures.ai.chat.maxTokensPerPeriod) {
+                maxTokens =
+                    allowedFeatures.ai.chat.maxTokensPerPeriod -
+                        metrics.totalTokensInCurrentPeriod;
+            }
+            if (maxTokens <= 0) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The user has reached their limit for the current subscription period.`,
+                };
+            }
+            if (allowedFeatures.ai.chat.maxTokensPerRequest) {
+                if (maxTokens) {
+                    maxTokens = Math.min(maxTokens, allowedFeatures.ai.chat.maxTokensPerRequest);
                 }
                 else {
-                    console.log('[AIController] Using chat provider:', provider, 'for model:', model);
+                    maxTokens = allowedFeatures.ai.chat.maxTokensPerRequest;
                 }
-                const metrics = yield this._metrics.getSubscriptionAiChatMetrics({
-                    ownerId: request.userId,
-                });
-                const config = yield this._config.getSubscriptionConfiguration();
-                const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
-                if (!allowedFeatures.ai.chat.allowed) {
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit AI Chat features.',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                let maxTokens = undefined;
-                if (allowedFeatures.ai.chat.maxTokensPerPeriod) {
-                    maxTokens =
-                        allowedFeatures.ai.chat.maxTokensPerPeriod -
-                            metrics.totalTokensInCurrentPeriod;
-                }
-                if (maxTokens <= 0) {
+            }
+            if (allowedFeatures.ai.chat.allowedModels) {
+                const allowedModels = allowedFeatures.ai.chat.allowedModels;
+                if (!allowedModels.includes(model)) {
                     return {
                         success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The user has reached their limit for the current subscription period.`,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'The subscription does not permit the given model for AI Chat features.',
                     };
                 }
-                if (allowedFeatures.ai.chat.maxTokensPerRequest) {
-                    if (maxTokens) {
-                        maxTokens = Math.min(maxTokens, allowedFeatures.ai.chat.maxTokensPerRequest);
-                    }
-                    else {
-                        maxTokens = allowedFeatures.ai.chat.maxTokensPerRequest;
-                    }
-                }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                if (allowedFeatures.ai.chat.allowedModels) {
-                    const allowedModels = allowedFeatures.ai.chat.allowedModels;
-                    if (!allowedModels.includes(model)) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'The subscription does not permit the given model for AI Chat features.',
-                        };
-                    }
-                }
-                const result = yield chat.chat({
-                    messages: request.messages,
-                    model: model,
-                    temperature: request.temperature,
-                    topP: request.topP,
-                    frequencyPenalty: request.frequencyPenalty,
-                    presencePenalty: request.presencePenalty,
-                    stopWords: request.stopWords,
+            }
+            const result = await chat.chat({
+                messages: request.messages,
+                model: model,
+                temperature: request.temperature,
+                topP: request.topP,
+                frequencyPenalty: request.frequencyPenalty,
+                presencePenalty: request.presencePenalty,
+                stopWords: request.stopWords,
+                userId: request.userId,
+                maxTokens,
+            });
+            if (result.totalTokens > 0) {
+                const adjustedTokens = this._calculateTokenCost(result, model);
+                await this._metrics.recordChatMetrics({
                     userId: request.userId,
-                    maxTokens,
+                    createdAtMs: Date.now(),
+                    tokens: adjustedTokens,
                 });
-                if (result.totalTokens > 0) {
-                    const adjustedTokens = this._calculateTokenCost(result, model);
-                    yield this._metrics.recordChatMetrics({
-                        userId: request.userId,
-                        createdAtMs: Date.now(),
-                        tokens: adjustedTokens,
-                    });
-                }
-                return {
-                    success: true,
-                    choices: result.choices,
-                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling chat request:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
+            return {
+                success: true,
+                choices: result.choices,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling chat request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     _calculateTokenCost(result, model) {
         var _a;
@@ -254,854 +223,830 @@ export class AIController {
         const adjustedTokens = modifier * totalTokens;
         return adjustedTokens;
     }
-    chatStream(request) {
+    async *chatStream(request) {
         var _a, _b;
-        return __asyncGenerator(this, arguments, function* chatStream_1() {
-            var _c, e_1, _d, _e;
-            try {
-                if (!this._chatProviders) {
-                    return yield __await({
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    });
-                }
-                if (!request.userId) {
-                    return yield __await({
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
-                    });
-                }
-                if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedChatSubscriptionTiers)) {
-                    if (!request.userSubscriptionTier) {
-                        return yield __await({
-                            success: false,
-                            errorCode: 'not_subscribed',
-                            errorMessage: 'The user must be subscribed in order to use this operation.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedChatSubscriptionTiers,
-                            ],
-                        });
-                    }
-                    else {
-                        return yield __await({
-                            success: false,
-                            errorCode: 'invalid_subscription_tier',
-                            errorMessage: 'This operation is not available to the user at their current subscription tier.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedChatSubscriptionTiers,
-                            ],
-                            currentSubscriptionTier: request.userSubscriptionTier,
-                        });
-                    }
-                }
-                if (!!request.model &&
-                    !this._allowedChatModels.has(request.model)) {
-                    return yield __await({
-                        success: false,
-                        errorCode: 'invalid_model',
-                        errorMessage: `The given model is not allowed for chats.`,
-                    });
-                }
-                const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._chatOptions.defaultModel;
-                const provider = (_b = this._allowedChatModels.get(request.model)) !== null && _b !== void 0 ? _b : this._chatOptions.defaultModelProvider;
-                const chat = this._chatProviders[provider];
-                if (!chat) {
-                    console.error('[AIController] No chat provider found for model:', model);
-                    return yield __await({
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'The given model is not supported.',
-                    });
-                }
-                else if (!chat.chatStream) {
-                    console.error('[AIController] Chat provider does not support chatStream for model:', model);
-                    return yield __await({
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'The given model does not support streaming.',
-                    });
-                }
-                else {
-                    console.log('[AIController] Using chat provider:', provider, 'for model:', model);
-                }
-                const metrics = yield __await(this._metrics.getSubscriptionAiChatMetrics({
-                    ownerId: request.userId,
-                }));
-                const config = yield __await(this._config.getSubscriptionConfiguration());
-                const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
-                if (!allowedFeatures.ai.chat.allowed) {
-                    return yield __await({
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit AI Chat features.',
-                    });
-                }
-                if (allowedFeatures.ai.chat.allowedModels) {
-                    const allowedModels = allowedFeatures.ai.chat.allowedModels;
-                    if (!allowedModels.includes(model)) {
-                        return yield __await({
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'The subscription does not permit the given model for AI Chat features.',
-                        });
-                    }
-                }
-                let maxTokens = undefined;
-                if (allowedFeatures.ai.chat.maxTokensPerPeriod) {
-                    maxTokens =
-                        allowedFeatures.ai.chat.maxTokensPerPeriod -
-                            metrics.totalTokensInCurrentPeriod;
-                }
-                if (maxTokens <= 0) {
-                    return yield __await({
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The user has reached their limit for the current subscription period.`,
-                    });
-                }
-                if (allowedFeatures.ai.chat.maxTokensPerRequest) {
-                    if (maxTokens) {
-                        maxTokens = Math.min(maxTokens, allowedFeatures.ai.chat.maxTokensPerRequest);
-                    }
-                    else {
-                        maxTokens = allowedFeatures.ai.chat.maxTokensPerRequest;
-                    }
-                }
-                if (this._policyStore) {
-                    const privacyFeatures = yield __await(this._policyStore.getUserPrivacyFeatures(request.userId));
-                    if (!privacyFeatures.allowAI) {
-                        return yield __await({
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        });
-                    }
-                }
-                const result = chat.chatStream({
-                    messages: request.messages,
-                    model: model,
-                    temperature: request.temperature,
-                    topP: request.topP,
-                    frequencyPenalty: request.frequencyPenalty,
-                    presencePenalty: request.presencePenalty,
-                    stopWords: request.stopWords,
-                    userId: request.userId,
-                    maxTokens,
-                });
-                try {
-                    for (var _f = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = yield __await(result_1.next()), _c = result_1_1.done, !_c; _f = true) {
-                        _e = result_1_1.value;
-                        _f = false;
-                        let chunk = _e;
-                        if (chunk.totalTokens > 0) {
-                            const adjustedTokens = this._calculateTokenCost(chunk, model);
-                            yield __await(this._metrics.recordChatMetrics({
-                                userId: request.userId,
-                                createdAtMs: Date.now(),
-                                tokens: adjustedTokens,
-                            }));
-                        }
-                        yield yield __await({
-                            choices: chunk.choices,
-                        });
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_f && !_c && (_d = result_1.return)) yield __await(_d.call(result_1));
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                return yield __await({
-                    success: true,
-                });
+        try {
+            if (!this._chatProviders) {
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling chat stream request:', err);
-                return yield __await({
+            if (!request.userId) {
+                return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                });
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                };
             }
-        });
-    }
-    generateSkybox(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._generateSkybox) {
+            if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedChatSubscriptionTiers)) {
+                if (!request.userSubscriptionTier) {
                     return {
                         success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
+                        errorCode: 'not_subscribed',
+                        errorMessage: 'The user must be subscribed in order to use this operation.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedChatSubscriptionTiers,
+                        ],
                     };
                 }
-                if (!request.userId) {
+                else {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                        errorCode: 'invalid_subscription_tier',
+                        errorMessage: 'This operation is not available to the user at their current subscription tier.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedChatSubscriptionTiers,
+                        ],
+                        currentSubscriptionTier: request.userSubscriptionTier,
                     };
                 }
-                if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedGenerateSkyboxSubscriptionTiers)) {
-                    if (!request.userSubscriptionTier) {
-                        return {
-                            success: false,
-                            errorCode: 'not_subscribed',
-                            errorMessage: 'The user must be subscribed in order to use this operation.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedGenerateSkyboxSubscriptionTiers,
-                            ],
-                        };
-                    }
-                    else {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_subscription_tier',
-                            errorMessage: 'This operation is not available to the user at their current subscription tier.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedGenerateSkyboxSubscriptionTiers,
-                            ],
-                            currentSubscriptionTier: request.userSubscriptionTier,
-                        };
-                    }
-                }
-                const metrics = yield this._metrics.getSubscriptionAiSkyboxMetrics({
-                    ownerId: request.userId,
-                });
-                const config = yield this._config.getSubscriptionConfiguration();
-                const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
-                if (!allowedFeatures.ai.skyboxes.allowed) {
+            }
+            if (!!request.model &&
+                !this._allowedChatModels.has(request.model)) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_model',
+                    errorMessage: `The given model is not allowed for chats.`,
+                };
+            }
+            const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._chatOptions.defaultModel;
+            const provider = (_b = this._allowedChatModels.get(request.model)) !== null && _b !== void 0 ? _b : this._chatOptions.defaultModelProvider;
+            const chat = this._chatProviders[provider];
+            if (!chat) {
+                console.error('[AIController] No chat provider found for model:', model);
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'The given model is not supported.',
+                };
+            }
+            else if (!chat.chatStream) {
+                console.error('[AIController] Chat provider does not support chatStream for model:', model);
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'The given model does not support streaming.',
+                };
+            }
+            else {
+                console.log('[AIController] Using chat provider:', provider, 'for model:', model);
+            }
+            const metrics = await this._metrics.getSubscriptionAiChatMetrics({
+                ownerId: request.userId,
+            });
+            const config = await this._config.getSubscriptionConfiguration();
+            const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
+            if (!allowedFeatures.ai.chat.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit AI Chat features.',
+                };
+            }
+            if (allowedFeatures.ai.chat.allowedModels) {
+                const allowedModels = allowedFeatures.ai.chat.allowedModels;
+                if (!allowedModels.includes(model)) {
                     return {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit AI Skybox features.',
+                        errorMessage: 'The subscription does not permit the given model for AI Chat features.',
                     };
                 }
-                if (allowedFeatures.ai.skyboxes.maxSkyboxesPerPeriod > 0 &&
-                    metrics.totalSkyboxesInCurrentPeriod + 1 >
-                        allowedFeatures.ai.skyboxes.maxSkyboxesPerPeriod) {
+            }
+            let maxTokens = undefined;
+            if (allowedFeatures.ai.chat.maxTokensPerPeriod) {
+                maxTokens =
+                    allowedFeatures.ai.chat.maxTokensPerPeriod -
+                        metrics.totalTokensInCurrentPeriod;
+            }
+            if (maxTokens <= 0) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The user has reached their limit for the current subscription period.`,
+                };
+            }
+            if (allowedFeatures.ai.chat.maxTokensPerRequest) {
+                if (maxTokens) {
+                    maxTokens = Math.min(maxTokens, allowedFeatures.ai.chat.maxTokensPerRequest);
+                }
+                else {
+                    maxTokens = allowedFeatures.ai.chat.maxTokensPerRequest;
+                }
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The user has reached their limit for the current subscription period.`,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                const result = yield this._generateSkybox.generateSkybox({
-                    prompt: request.prompt,
-                    negativePrompt: request.negativePrompt,
-                    blockadeLabs: request.blockadeLabs,
-                });
-                if (result.success === true) {
-                    yield this._metrics.recordSkyboxMetrics({
+            }
+            const result = chat.chatStream({
+                messages: request.messages,
+                model: model,
+                temperature: request.temperature,
+                topP: request.topP,
+                frequencyPenalty: request.frequencyPenalty,
+                presencePenalty: request.presencePenalty,
+                stopWords: request.stopWords,
+                userId: request.userId,
+                maxTokens,
+            });
+            for await (let chunk of result) {
+                if (chunk.totalTokens > 0) {
+                    const adjustedTokens = this._calculateTokenCost(chunk, model);
+                    await this._metrics.recordChatMetrics({
                         userId: request.userId,
                         createdAtMs: Date.now(),
-                        skyboxes: 1,
+                        tokens: adjustedTokens,
                     });
-                    return {
-                        success: true,
-                        skyboxId: result.skyboxId,
-                    };
-                }
-                else {
-                    return result;
                 }
+                yield {
+                    choices: chunk.choices,
+                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling generate skybox request:', err);
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling chat stream request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async generateSkybox(request) {
+        try {
+            if (!this._generateSkybox) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
                 };
             }
-        });
-    }
-    getSkybox(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._generateSkybox) {
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                };
+            }
+            if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedGenerateSkyboxSubscriptionTiers)) {
+                if (!request.userSubscriptionTier) {
                     return {
                         success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
+                        errorCode: 'not_subscribed',
+                        errorMessage: 'The user must be subscribed in order to use this operation.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedGenerateSkyboxSubscriptionTiers,
+                        ],
                     };
                 }
-                if (!request.userId) {
+                else {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                        errorCode: 'invalid_subscription_tier',
+                        errorMessage: 'This operation is not available to the user at their current subscription tier.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedGenerateSkyboxSubscriptionTiers,
+                        ],
+                        currentSubscriptionTier: request.userSubscriptionTier,
                     };
                 }
-                if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedGenerateSkyboxSubscriptionTiers)) {
-                    if (!request.userSubscriptionTier) {
-                        return {
-                            success: false,
-                            errorCode: 'not_subscribed',
-                            errorMessage: 'The user must be subscribed in order to use this operation.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedGenerateSkyboxSubscriptionTiers,
-                            ],
-                        };
-                    }
-                    else {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_subscription_tier',
-                            errorMessage: 'This operation is not available to the user at their current subscription tier.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedGenerateSkyboxSubscriptionTiers,
-                            ],
-                            currentSubscriptionTier: request.userSubscriptionTier,
-                        };
-                    }
-                }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                const result = yield this._generateSkybox.getSkybox(request.skyboxId);
-                if (result.success === true) {
-                    return {
-                        success: true,
-                        status: result.status,
-                        fileUrl: result.fileUrl,
-                        thumbnailUrl: result.thumbnailUrl,
-                    };
-                }
-                else {
-                    return result;
-                }
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling get skybox request:', err);
+            const metrics = await this._metrics.getSubscriptionAiSkyboxMetrics({
+                ownerId: request.userId,
+            });
+            const config = await this._config.getSubscriptionConfiguration();
+            const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
+            if (!allowedFeatures.ai.skyboxes.allowed) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit AI Skybox features.',
                 };
             }
-        });
-    }
-    generateImage(request) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._imageProviders) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
-                    };
-                }
-                if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedImageSubscriptionTiers)) {
-                    if (!request.userSubscriptionTier) {
-                        return {
-                            success: false,
-                            errorCode: 'not_subscribed',
-                            errorMessage: 'The user must be subscribed in order to use this operation.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedImageSubscriptionTiers,
-                            ],
-                        };
-                    }
-                    else {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_subscription_tier',
-                            errorMessage: 'This operation is not available to the user at their current subscription tier.',
-                            allowedSubscriptionTiers: [
-                                ...this
-                                    ._allowedImageSubscriptionTiers,
-                            ],
-                            currentSubscriptionTier: request.userSubscriptionTier,
-                        };
-                    }
-                }
-                const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._imageOptions.defaultModel;
-                if (!this._allowedImageModels.has(model)) {
-                    return {
-                        success: false,
-                        errorCode: 'invalid_model',
-                        errorMessage: `The given model is not allowed for images.`,
-                    };
-                }
-                const providerId = this._allowedImageModels.get(model);
-                const provider = this._imageProviders[providerId];
-                if (!provider) {
-                    return {
-                        success: false,
-                        errorCode: 'invalid_model',
-                        errorMessage: `The given model is not allowed for images.`,
-                    };
-                }
-                const width = Math.min((_b = request.width) !== null && _b !== void 0 ? _b : this._imageOptions.defaultWidth, this._imageOptions.maxWidth);
-                const height = Math.min((_c = request.height) !== null && _c !== void 0 ? _c : this._imageOptions.defaultHeight, this._imageOptions.maxHeight);
-                const numberOfImages = Math.min((_d = request.numberOfImages) !== null && _d !== void 0 ? _d : 1, this._imageOptions.maxImages);
-                const totalPixels = Math.max(width, height) * numberOfImages;
-                const metrics = yield this._metrics.getSubscriptionAiImageMetrics({
-                    ownerId: request.userId,
-                });
-                const config = yield this._config.getSubscriptionConfiguration();
-                const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
-                if (!allowedFeatures.ai.images.allowed) {
+            if (allowedFeatures.ai.skyboxes.maxSkyboxesPerPeriod > 0 &&
+                metrics.totalSkyboxesInCurrentPeriod + 1 >
+                    allowedFeatures.ai.skyboxes.maxSkyboxesPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The user has reached their limit for the current subscription period.`,
+                };
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit AI Image features.',
-                    };
-                }
-                if (allowedFeatures.ai.images.maxSquarePixelsPerRequest > 0 &&
-                    totalPixels >
-                        allowedFeatures.ai.images.maxSquarePixelsPerRequest) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The request exceeds allowed subscription limits.`,
-                    };
-                }
-                if (allowedFeatures.ai.images.maxSquarePixelsPerPeriod > 0 &&
-                    totalPixels + metrics.totalSquarePixelsInCurrentPeriod >
-                        allowedFeatures.ai.images.maxSquarePixelsPerPeriod) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The user has reached their limit for the current subscription period.`,
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                const result = yield provider.generateImage({
-                    model: model,
-                    prompt: request.prompt,
-                    negativePrompt: request.negativePrompt,
-                    width: width,
-                    height: height,
-                    numberOfImages: numberOfImages,
-                    seed: request.seed,
-                    steps: Math.min((_e = request.steps) !== null && _e !== void 0 ? _e : 30, this._imageOptions.maxSteps),
-                    cfgScale: request.cfgScale,
-                    sampler: request.sampler,
-                    clipGuidancePreset: request.clipGuidancePreset,
-                    stylePreset: request.stylePreset,
-                    userId: request.userId,
-                });
-                if (!result.success) {
-                    return result;
-                }
-                yield this._metrics.recordImageMetrics({
+            }
+            const result = await this._generateSkybox.generateSkybox({
+                prompt: request.prompt,
+                negativePrompt: request.negativePrompt,
+                blockadeLabs: request.blockadeLabs,
+            });
+            if (result.success === true) {
+                await this._metrics.recordSkyboxMetrics({
                     userId: request.userId,
                     createdAtMs: Date.now(),
-                    squarePixels: totalPixels,
+                    skyboxes: 1,
                 });
                 return {
                     success: true,
-                    images: result.images,
+                    skyboxId: result.skyboxId,
                 };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling generate image request:', err);
+            else {
+                return result;
+            }
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling generate skybox request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async getSkybox(request) {
+        try {
+            if (!this._generateSkybox) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
                 };
             }
-        });
-    }
-    getHumeAccessToken(request) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._humeInterface) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                if (!request.userId) {
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                };
+            }
+            if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedGenerateSkyboxSubscriptionTiers)) {
+                if (!request.userSubscriptionTier) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                        errorCode: 'not_subscribed',
+                        errorMessage: 'The user must be subscribed in order to use this operation.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedGenerateSkyboxSubscriptionTiers,
+                        ],
                     };
                 }
-                const recordName = (_a = request.recordName) !== null && _a !== void 0 ? _a : request.userId;
-                const context = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: recordName,
-                    userId: request.userId,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const authResult = yield this._policies.authorizeSubjectUsingContext(context.context, {
-                    resourceKind: 'ai.hume',
-                    action: 'create',
-                    markers: null,
-                    subjectId: request.userId,
-                    subjectType: 'user',
-                });
-                if (authResult.success === false) {
-                    return authResult;
-                }
-                let metricsFilter = {};
-                if (context.context.recordStudioId) {
-                    metricsFilter.studioId = context.context.recordStudioId;
-                }
                 else {
-                    metricsFilter.ownerId = context.context.recordOwnerId;
-                }
-                const metrics = yield this._metrics.getSubscriptionRecordMetrics(metricsFilter);
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getHumeAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
-                if (!features.allowed) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit Hume AI features.',
+                        errorCode: 'invalid_subscription_tier',
+                        errorMessage: 'This operation is not available to the user at their current subscription tier.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedGenerateSkyboxSubscriptionTiers,
+                        ],
+                        currentSubscriptionTier: request.userSubscriptionTier,
                     };
                 }
-                let humeConfig;
-                if (context.context.recordStudioId) {
-                    humeConfig = yield this._recordsStore.getStudioHumeConfig(context.context.recordStudioId);
-                }
-                humeConfig !== null && humeConfig !== void 0 ? humeConfig : (humeConfig = this._humeConfig);
-                if (!humeConfig) {
-                    if (context.context.recordStudioId) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_request',
-                            errorMessage: 'The studio does not have a Hume configuration.',
-                        };
-                    }
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit Hume AI features.',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                const result = yield this._humeInterface.getAccessToken({
-                    apiKey: humeConfig.apiKey,
-                    secretKey: humeConfig.secretKey,
-                });
-                if (result.success) {
-                    return {
-                        success: true,
-                        accessToken: result.accessToken,
-                        expiresIn: result.expiresIn,
-                        issuedAt: result.issuedAt,
-                        tokenType: result.tokenType,
-                    };
-                }
-                else {
-                    return result;
-                }
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[AIController] Error handling get hume access token request:', err);
+            const result = await this._generateSkybox.getSkybox(request.skyboxId);
+            if (result.success === true) {
                 return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    success: true,
+                    status: result.status,
+                    fileUrl: result.fileUrl,
+                    thumbnailUrl: result.thumbnailUrl,
                 };
             }
-        });
+            else {
+                return result;
+            }
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling get skybox request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
-    sloydGenerateModel(request) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._sloydInterface) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                if (!request.userId) {
+    async generateImage(request) {
+        var _a, _b, _c, _d, _e;
+        try {
+            if (!this._imageProviders) {
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
+            }
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey or a recordKey.',
+                };
+            }
+            if (!this._matchesSubscriptionTiers(request.userSubscriptionTier, this._allowedImageSubscriptionTiers)) {
+                if (!request.userSubscriptionTier) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                        errorCode: 'not_subscribed',
+                        errorMessage: 'The user must be subscribed in order to use this operation.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedImageSubscriptionTiers,
+                        ],
                     };
                 }
-                const context = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: request.recordName,
-                    userId: request.userId,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const authResult = yield this._policies.authorizeSubjectUsingContext(context.context, {
-                    resourceKind: 'ai.sloyd',
-                    action: 'create',
-                    markers: null,
-                    subjectId: request.userId,
-                    subjectType: 'user',
-                });
-                if (authResult.success === false) {
-                    return authResult;
-                }
-                let metricsFilter = {};
-                if (context.context.recordStudioId) {
-                    metricsFilter.studioId = context.context.recordStudioId;
-                }
                 else {
-                    metricsFilter.ownerId = context.context.recordOwnerId;
-                }
-                const metrics = yield this._metrics.getSubscriptionAiSloydMetrics(metricsFilter);
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getSloydAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
-                if (!features.allowed) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit Sloyd AI features.',
-                    };
-                }
-                console.log(`[AIController] [sloydGenerateModel] [maxModelsPerPeriod: ${features.maxModelsPerPeriod} totalModelsInCurrentPeriod: ${metrics.totalModelsInCurrentPeriod}]`);
-                if (typeof features.maxModelsPerPeriod === 'number' &&
-                    metrics.totalModelsInCurrentPeriod >=
-                        features.maxModelsPerPeriod) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The request exceeds allowed subscription limits.`,
+                        errorCode: 'invalid_subscription_tier',
+                        errorMessage: 'This operation is not available to the user at their current subscription tier.',
+                        allowedSubscriptionTiers: [
+                            ...this
+                                ._allowedImageSubscriptionTiers,
+                        ],
+                        currentSubscriptionTier: request.userSubscriptionTier,
                     };
                 }
-                if (this._policyStore) {
-                    const privacyFeatures = yield this._policyStore.getUserPrivacyFeatures(request.userId);
-                    if (!privacyFeatures.allowAI) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'AI Access is not allowed',
-                        };
-                    }
-                }
-                const result = yield (request.baseModelId
-                    ? this._sloydInterface.editModel({
-                        prompt: request.prompt,
-                        modelMimeType: request.outputMimeType,
-                        levelOfDetail: request.levelOfDetail,
-                        thumbnailPreviewExportType: (_a = request.thumbnail) === null || _a === void 0 ? void 0 : _a.type,
-                        thumbnailPreviewSizeX: (_b = request.thumbnail) === null || _b === void 0 ? void 0 : _b.width,
-                        thumbnailPreviewSizeY: (_c = request.thumbnail) === null || _c === void 0 ? void 0 : _c.height,
-                        interactionId: request.baseModelId,
-                    })
-                    : this._sloydInterface.createModel({
-                        prompt: request.prompt,
-                        modelMimeType: request.outputMimeType,
-                        levelOfDetail: request.levelOfDetail,
-                        thumbnailPreviewExportType: (_d = request.thumbnail) === null || _d === void 0 ? void 0 : _d.type,
-                        thumbnailPreviewSizeX: (_e = request.thumbnail) === null || _e === void 0 ? void 0 : _e.width,
-                        thumbnailPreviewSizeY: (_f = request.thumbnail) === null || _f === void 0 ? void 0 : _f.height,
-                    }));
-                if (result.success === false) {
-                    return result;
-                }
-                const response = {
-                    success: true,
-                    modelId: result.interactionId,
-                    mimeType: request.outputMimeType,
-                    modelData: typeof result.modelData === 'string'
-                        ? result.modelData
-                        : fromByteArray(result.modelData),
-                    thumbnailBase64: result.previewImage,
+            }
+            const model = (_a = request.model) !== null && _a !== void 0 ? _a : this._imageOptions.defaultModel;
+            if (!this._allowedImageModels.has(model)) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_model',
+                    errorMessage: `The given model is not allowed for images.`,
                 };
-                if ('name' in result && typeof result.name === 'string') {
-                    response.name = result.name;
-                    response.confidence = result.confidenceScore;
-                }
-                yield this._metrics.recordSloydMetrics({
-                    userId: (_g = context.context.recordOwnerId) !== null && _g !== void 0 ? _g : undefined,
-                    studioId: (_h = context.context.recordStudioId) !== null && _h !== void 0 ? _h : undefined,
-                    modelId: response.modelId,
-                    confidence: response.confidence,
-                    mimeType: response.mimeType,
-                    modelData: response.modelData,
-                    name: response.name,
-                    thumbnailBase64: response.thumbnailBase64,
-                    createdAtMs: Date.now(),
-                    baseModelId: request.baseModelId,
-                    modelsCreated: 1,
-                });
-                return response;
             }
-            catch (err) {
-                console.error('[AIController] Error handling sloyd create model request:', err);
+            const providerId = this._allowedImageModels.get(model);
+            const provider = this._imageProviders[providerId];
+            if (!provider) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'invalid_model',
+                    errorMessage: `The given model is not allowed for images.`,
                 };
             }
-        });
-    }
-    createOpenAIRealtimeSessionToken(request) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._openAIRealtimeInterface) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                if (!request.userId) {
+            const width = Math.min((_b = request.width) !== null && _b !== void 0 ? _b : this._imageOptions.defaultWidth, this._imageOptions.maxWidth);
+            const height = Math.min((_c = request.height) !== null && _c !== void 0 ? _c : this._imageOptions.defaultHeight, this._imageOptions.maxHeight);
+            const numberOfImages = Math.min((_d = request.numberOfImages) !== null && _d !== void 0 ? _d : 1, this._imageOptions.maxImages);
+            const totalPixels = Math.max(width, height) * numberOfImages;
+            const metrics = await this._metrics.getSubscriptionAiImageMetrics({
+                ownerId: request.userId,
+            });
+            const config = await this._config.getSubscriptionConfiguration();
+            const allowedFeatures = getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'user');
+            if (!allowedFeatures.ai.images.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit AI Image features.',
+                };
+            }
+            if (allowedFeatures.ai.images.maxSquarePixelsPerRequest > 0 &&
+                totalPixels >
+                    allowedFeatures.ai.images.maxSquarePixelsPerRequest) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The request exceeds allowed subscription limits.`,
+                };
+            }
+            if (allowedFeatures.ai.images.maxSquarePixelsPerPeriod > 0 &&
+                totalPixels + metrics.totalSquarePixelsInCurrentPeriod >
+                    allowedFeatures.ai.images.maxSquarePixelsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The user has reached their limit for the current subscription period.`,
+                };
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                        errorCode: 'not_authorized',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                const context = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: request.recordName,
-                    userId: request.userId,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const authResult = yield this._policies.authorizeSubjectUsingContext(context.context, {
-                    resourceKind: 'ai.openai.realtime',
-                    action: 'create',
-                    markers: null,
-                    subjectId: request.userId,
-                    subjectType: 'user',
-                });
-                if (authResult.success === false) {
-                    return authResult;
-                }
-                let metricsFilter = {};
+            }
+            const result = await provider.generateImage({
+                model: model,
+                prompt: request.prompt,
+                negativePrompt: request.negativePrompt,
+                width: width,
+                height: height,
+                numberOfImages: numberOfImages,
+                seed: request.seed,
+                steps: Math.min((_e = request.steps) !== null && _e !== void 0 ? _e : 30, this._imageOptions.maxSteps),
+                cfgScale: request.cfgScale,
+                sampler: request.sampler,
+                clipGuidancePreset: request.clipGuidancePreset,
+                stylePreset: request.stylePreset,
+                userId: request.userId,
+            });
+            if (!result.success) {
+                return result;
+            }
+            await this._metrics.recordImageMetrics({
+                userId: request.userId,
+                createdAtMs: Date.now(),
+                squarePixels: totalPixels,
+            });
+            return {
+                success: true,
+                images: result.images,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling generate image request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async getHumeAccessToken(request) {
+        var _a;
+        try {
+            if (!this._humeInterface) {
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
+            }
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                };
+            }
+            const recordName = (_a = request.recordName) !== null && _a !== void 0 ? _a : request.userId;
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const authResult = await this._policies.authorizeSubjectUsingContext(context.context, {
+                resourceKind: 'ai.hume',
+                action: 'create',
+                markers: null,
+                subjectId: request.userId,
+                subjectType: 'user',
+            });
+            if (authResult.success === false) {
+                return authResult;
+            }
+            let metricsFilter = {};
+            if (context.context.recordStudioId) {
+                metricsFilter.studioId = context.context.recordStudioId;
+            }
+            else {
+                metricsFilter.ownerId = context.context.recordOwnerId;
+            }
+            const metrics = await this._metrics.getSubscriptionRecordMetrics(metricsFilter);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getHumeAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
+            if (!features.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit Hume AI features.',
+                };
+            }
+            let humeConfig;
+            if (context.context.recordStudioId) {
+                humeConfig = await this._recordsStore.getStudioHumeConfig(context.context.recordStudioId);
+            }
+            humeConfig !== null && humeConfig !== void 0 ? humeConfig : (humeConfig = this._humeConfig);
+            if (!humeConfig) {
                 if (context.context.recordStudioId) {
-                    metricsFilter.studioId = context.context.recordStudioId;
-                }
-                else {
-                    metricsFilter.ownerId = context.context.recordOwnerId;
-                }
-                const metrics = yield this._metrics.getSubscriptionAiOpenAIRealtimeMetrics(metricsFilter);
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getOpenAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
-                if (!features.realtime.allowed) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit OpenAI Realtime features.',
+                        errorCode: 'invalid_request',
+                        errorMessage: 'The studio does not have a Hume configuration.',
                     };
                 }
-                if (typeof features.realtime.maxSessionsPerPeriod === 'number' &&
-                    metrics.totalSessionsInCurrentPeriod >=
-                        features.realtime.maxSessionsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit Hume AI features.',
+                };
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: `The request exceeds allowed subscription limits.`,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                if (typeof features.realtime.allowedModels !== 'undefined' &&
-                    !features.realtime.allowedModels.includes(request.request.model)) {
+            }
+            const result = await this._humeInterface.getAccessToken({
+                apiKey: humeConfig.apiKey,
+                secretKey: humeConfig.secretKey,
+            });
+            if (result.success) {
+                return {
+                    success: true,
+                    accessToken: result.accessToken,
+                    expiresIn: result.expiresIn,
+                    issuedAt: result.issuedAt,
+                    tokenType: result.tokenType,
+                };
+            }
+            else {
+                return result;
+            }
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[AIController] Error handling get hume access token request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async sloydGenerateModel(request) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        try {
+            if (!this._sloydInterface) {
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
+            }
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                };
+            }
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const authResult = await this._policies.authorizeSubjectUsingContext(context.context, {
+                resourceKind: 'ai.sloyd',
+                action: 'create',
+                markers: null,
+                subjectId: request.userId,
+                subjectType: 'user',
+            });
+            if (authResult.success === false) {
+                return authResult;
+            }
+            let metricsFilter = {};
+            if (context.context.recordStudioId) {
+                metricsFilter.studioId = context.context.recordStudioId;
+            }
+            else {
+                metricsFilter.ownerId = context.context.recordOwnerId;
+            }
+            const metrics = await this._metrics.getSubscriptionAiSloydMetrics(metricsFilter);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getSloydAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
+            if (!features.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit Sloyd AI features.',
+                };
+            }
+            console.log(`[AIController] [sloydGenerateModel] [maxModelsPerPeriod: ${features.maxModelsPerPeriod} totalModelsInCurrentPeriod: ${metrics.totalModelsInCurrentPeriod}]`);
+            if (typeof features.maxModelsPerPeriod === 'number' &&
+                metrics.totalModelsInCurrentPeriod >=
+                    features.maxModelsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The request exceeds allowed subscription limits.`,
+                };
+            }
+            if (this._policyStore) {
+                const privacyFeatures = await this._policyStore.getUserPrivacyFeatures(request.userId);
+                if (!privacyFeatures.allowAI) {
                     return {
                         success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: "The subscription doesn't support the given model.",
+                        errorCode: 'not_authorized',
+                        errorMessage: 'AI Access is not allowed',
                     };
                 }
-                const tokenRequest = Object.assign(Object.assign({}, request.request), { maxResponseOutputTokens: (_b = (_a = features.realtime.maxResponseOutputTokens) !== null && _a !== void 0 ? _a : request.request.maxResponseOutputTokens) !== null && _b !== void 0 ? _b : undefined });
-                const result = yield this._openAIRealtimeInterface.createRealtimeSessionToken(tokenRequest);
-                if (result.success === false) {
-                    return result;
-                }
-                yield this._metrics.recordOpenAIRealtimeMetrics({
-                    userId: (_c = context.context.recordOwnerId) !== null && _c !== void 0 ? _c : undefined,
-                    studioId: (_d = context.context.recordStudioId) !== null && _d !== void 0 ? _d : undefined,
-                    sessionId: result.sessionId,
-                    createdAtMs: Date.now(),
-                    request: tokenRequest,
-                });
+            }
+            const result = await (request.baseModelId
+                ? this._sloydInterface.editModel({
+                    prompt: request.prompt,
+                    modelMimeType: request.outputMimeType,
+                    levelOfDetail: request.levelOfDetail,
+                    thumbnailPreviewExportType: (_a = request.thumbnail) === null || _a === void 0 ? void 0 : _a.type,
+                    thumbnailPreviewSizeX: (_b = request.thumbnail) === null || _b === void 0 ? void 0 : _b.width,
+                    thumbnailPreviewSizeY: (_c = request.thumbnail) === null || _c === void 0 ? void 0 : _c.height,
+                    interactionId: request.baseModelId,
+                })
+                : this._sloydInterface.createModel({
+                    prompt: request.prompt,
+                    modelMimeType: request.outputMimeType,
+                    levelOfDetail: request.levelOfDetail,
+                    thumbnailPreviewExportType: (_d = request.thumbnail) === null || _d === void 0 ? void 0 : _d.type,
+                    thumbnailPreviewSizeX: (_e = request.thumbnail) === null || _e === void 0 ? void 0 : _e.width,
+                    thumbnailPreviewSizeY: (_f = request.thumbnail) === null || _f === void 0 ? void 0 : _f.height,
+                }));
+            if (result.success === false) {
+                return result;
+            }
+            const response = {
+                success: true,
+                modelId: result.interactionId,
+                mimeType: request.outputMimeType,
+                modelData: typeof result.modelData === 'string'
+                    ? result.modelData
+                    : fromByteArray(result.modelData),
+                thumbnailBase64: result.previewImage,
+            };
+            if ('name' in result && typeof result.name === 'string') {
+                response.name = result.name;
+                response.confidence = result.confidenceScore;
+            }
+            await this._metrics.recordSloydMetrics({
+                userId: (_g = context.context.recordOwnerId) !== null && _g !== void 0 ? _g : undefined,
+                studioId: (_h = context.context.recordStudioId) !== null && _h !== void 0 ? _h : undefined,
+                modelId: response.modelId,
+                confidence: response.confidence,
+                mimeType: response.mimeType,
+                modelData: response.modelData,
+                name: response.name,
+                thumbnailBase64: response.thumbnailBase64,
+                createdAtMs: Date.now(),
+                baseModelId: request.baseModelId,
+                modelsCreated: 1,
+            });
+            return response;
+        }
+        catch (err) {
+            console.error('[AIController] Error handling sloyd create model request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async createOpenAIRealtimeSessionToken(request) {
+        var _a, _b, _c, _d;
+        try {
+            if (!this._openAIRealtimeInterface) {
                 return {
-                    success: true,
-                    sessionId: result.sessionId,
-                    clientSecret: result.clientSecret,
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
+                };
+            }
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in. Please provide a sessionKey.',
+                };
+            }
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const authResult = await this._policies.authorizeSubjectUsingContext(context.context, {
+                resourceKind: 'ai.openai.realtime',
+                action: 'create',
+                markers: null,
+                subjectId: request.userId,
+                subjectType: 'user',
+            });
+            if (authResult.success === false) {
+                return authResult;
+            }
+            let metricsFilter = {};
+            if (context.context.recordStudioId) {
+                metricsFilter.studioId = context.context.recordStudioId;
+            }
+            else {
+                metricsFilter.ownerId = context.context.recordOwnerId;
+            }
+            const metrics = await this._metrics.getSubscriptionAiOpenAIRealtimeMetrics(metricsFilter);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getOpenAiFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, context.context.recordStudioId ? 'studio' : 'user');
+            if (!features.realtime.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit OpenAI Realtime features.',
+                };
+            }
+            if (typeof features.realtime.maxSessionsPerPeriod === 'number' &&
+                metrics.totalSessionsInCurrentPeriod >=
+                    features.realtime.maxSessionsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: `The request exceeds allowed subscription limits.`,
                 };
             }
-            catch (err) {
-                console.error('[AIController] Error handling createOpenAIRealtimeSessionToken request:', err);
+            if (typeof features.realtime.allowedModels !== 'undefined' &&
+                !features.realtime.allowedModels.includes(request.request.model)) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: "The subscription doesn't support the given model.",
                 };
             }
-        });
+            const tokenRequest = {
+                ...request.request,
+                maxResponseOutputTokens: (_b = (_a = features.realtime.maxResponseOutputTokens) !== null && _a !== void 0 ? _a : request.request.maxResponseOutputTokens) !== null && _b !== void 0 ? _b : undefined,
+            };
+            const result = await this._openAIRealtimeInterface.createRealtimeSessionToken(tokenRequest);
+            if (result.success === false) {
+                return result;
+            }
+            await this._metrics.recordOpenAIRealtimeMetrics({
+                userId: (_c = context.context.recordOwnerId) !== null && _c !== void 0 ? _c : undefined,
+                studioId: (_d = context.context.recordStudioId) !== null && _d !== void 0 ? _d : undefined,
+                sessionId: result.sessionId,
+                createdAtMs: Date.now(),
+                request: tokenRequest,
+            });
+            return {
+                success: true,
+                sessionId: result.sessionId,
+                clientSecret: result.clientSecret,
+            };
+        }
+        catch (err) {
+            console.error('[AIController] Error handling createOpenAIRealtimeSessionToken request:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     _matchesSubscriptionTiers(tier, allowedTiers) {
         return allowedTiers === true || allowedTiers.has(tier);