Fix/server should return better error codes when generating open ai images

CHANGELOG.md

@@ -1,5 +1,17 @@
 # CasualOS Changelog
 
+## V3.3.16
+
+#### Date: TBD
+
+### :rocket: Features
+
+### :bug: Bug Fixes
+
+-   Improved error handling for `ai.generateImage` requests with unacceptable parameters.
+    -   The server now returns an `invalid_request` error code when the parameters provided are not accepted by the selected model (e.g., OpenAI, Google).
+    -   This ensures that users receive clear and actionable feedback when their requests fail due to invalid parameters.
+
 ## V3.3.15
 
 #### Date: 12/19/2024

src/aux-records/AIController.spec.ts

@@ -2765,6 +2765,7 @@ describe('AIController', () => {
         it('should return the result from the generateImage interface', async () => {
             generateImageInterface.generateImage.mockReturnValueOnce(
                 Promise.resolve({
+                    success: true,
                     images: [
                         {
                             base64: 'base64',
@@ -2860,6 +2861,7 @@ describe('AIController', () => {
 
             otherInterface.generateImage.mockReturnValueOnce(
                 Promise.resolve({
+                    success: true,
                     images: [
                         {
                             base64: 'base64',
@@ -2979,6 +2981,7 @@ describe('AIController', () => {
         it('should work when the controller is configured to allow all subscription tiers and the user does not have a subscription', async () => {
             generateImageInterface.generateImage.mockReturnValueOnce(
                 Promise.resolve({
+                    success: true,
                     images: [
                         {
                             base64: 'base64',
@@ -3090,6 +3093,7 @@ describe('AIController', () => {
 
                 generateImageInterface.generateImage.mockReturnValueOnce(
                     Promise.resolve({
+                        success: true,
                         images: [
                             {
                                 base64: 'base64',
@@ -3120,6 +3124,7 @@ describe('AIController', () => {
             it('should reject the request if it would exceed the subscription request limits', async () => {
                 generateImageInterface.generateImage.mockReturnValueOnce(
                     Promise.resolve({
+                        success: true,
                         images: [
                             {
                                 base64: 'base64',
@@ -3150,6 +3155,7 @@ describe('AIController', () => {
             it('should reject the request if it would exceed the subscription period limits', async () => {
                 generateImageInterface.generateImage.mockReturnValueOnce(
                     Promise.resolve({
+                        success: true,
                         images: [
                             {
                                 base64: 'base64',

src/aux-records/AIController.ts

@@ -12,7 +12,6 @@ import {
     AIChatInterfaceResponse,
     AIChatInterfaceStreamResponse,
     AIChatMessage,
-    AIChatStreamMessage,
 } from './AIChatInterface';
 import {
     AIGenerateSkyboxInterface,
@@ -1074,7 +1073,7 @@ export class AIController {
             }
 
             const result = await provider.generateImage({
-                model,
+                model: model,
                 prompt: request.prompt,
                 negativePrompt: request.negativePrompt,
                 width: width,
@@ -1092,6 +1091,10 @@ export class AIController {
                 userId: request.userId,
             });
 
+            if (!result.success) {
+                return result;
+            }
+
             await this._metrics.recordImageMetrics({
                 userId: request.userId,
                 createdAtMs: Date.now(),
@@ -1702,6 +1705,7 @@ export interface AIGenerateImageFailure {
         | NotSupportedError
         | SubscriptionLimitReached
         | NotAuthorizedError
+        | 'invalid_request'
         | 'invalid_model';
     errorMessage: string;
 

src/aux-records/AIImageInterface.ts

@@ -1,3 +1,13 @@
+import {
+    InvalidSubscriptionTierError,
+    NotAuthorizedError,
+    NotLoggedInError,
+    NotSubscribedError,
+    NotSupportedError,
+    ServerError,
+    SubscriptionLimitReached,
+} from '@casual-simulation/aux-common/Errors';
+
 /**
  * Defines an interface that is able to generate images from text prompts.
  */
@@ -79,13 +89,30 @@ export interface AIGenerateImageInterfaceRequest {
     userId?: string;
 }
 
-export interface AIGenerateImageInterfaceResponse {
-    /**
-     * The list of images that were generated.
-     */
+export type AIGenerateImageInterfaceResponse =
+    | AIGenerateImageInterfaceSuccess
+    | AIGenerateImageInterfaceFailure;
+
+export interface AIGenerateImageInterfaceSuccess {
+    success: true;
     images: AIGeneratedImage[];
 }
 
+export interface AIGenerateImageInterfaceFailure {
+    success: false;
+    errorCode:
+        | ServerError
+        | NotLoggedInError
+        | NotSubscribedError
+        | InvalidSubscriptionTierError
+        | NotSupportedError
+        | SubscriptionLimitReached
+        | NotAuthorizedError
+        | 'invalid_request'
+        | 'invalid_model';
+    errorMessage: string;
+}
+
 /**
  * Defines an image that was generated by the AI.
  */

src/aux-records/OpenAIImageInterface.ts

@@ -13,7 +13,12 @@ import {
 } from './AIImageInterface';
 import { handleAxiosErrors } from './Utils';
 import { traced } from './tracing/TracingDecorators';
-import { SpanKind, SpanOptions } from '@opentelemetry/api';
+import {
+    SpanKind,
+    SpanOptions,
+    SpanStatusCode,
+    trace,
+} from '@opentelemetry/api';
 
 const TRACE_NAME = 'OpenAIImageInterface';
 const SPAN_OPTIONS: SpanOptions = {
@@ -93,9 +98,26 @@ export class OpenAIImageInterface implements AIImageInterface {
             );
 
             return {
+                success: true,
                 images,
             };
         } catch (err) {
+            if (axios.isAxiosError(err)) {
+                if (err.response.status === 400) {
+                    const span = trace.getActiveSpan();
+                    span?.recordException(err);
+                    span?.setStatus({ code: SpanStatusCode.ERROR });
+
+                    console.error(
+                        `[OpenAIChatInterface] [${request.userId}] [generateImage]: Bad request: ${err.response.data.error.message}`
+                    );
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: err.response.data.error.message,
+                    };
+                }
+            }
             handleAxiosErrors(err);
         }
     }

src/aux-records/RecordsServer.spec.ts

@@ -16239,6 +16239,7 @@ describe('RecordsServer', () => {
             });
 
             imageInterface.generateImage.mockResolvedValueOnce({
+                success: true,
                 images: [
                     {
                         base64: 'base64',

src/aux-records/StabilityAIImageInterface.ts

@@ -9,6 +9,7 @@ import axios from 'axios';
 import { handleAxiosErrors } from './Utils';
 import { traced } from './tracing/TracingDecorators';
 import { z } from 'zod';
+import { SpanStatusCode, trace } from '@opentelemetry/api';
 
 const TRACE_NAME = 'StabilityAIImageInterface';
 
@@ -115,9 +116,26 @@ export class StabilityAIImageInterface implements AIImageInterface {
             );
 
             return {
+                success: true,
                 images,
             };
         } catch (err) {
+            if (axios.isAxiosError(err)) {
+                if (err.response.status === 400) {
+                    const span = trace.getActiveSpan();
+                    span?.recordException(err);
+                    span?.setStatus({ code: SpanStatusCode.ERROR });
+
+                    console.error(
+                        `[StabilityAIChatIngerface] [${request.userId}] [generateImage]: Bad request: ${err.response.data.error.message}`
+                    );
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: err.response.data.error.message,
+                    };
+                }
+            }
             handleAxiosErrors(err);
         }
     }
@@ -157,6 +175,7 @@ export class StabilityAIImageInterface implements AIImageInterface {
         const data = schema.parse(result.data);
 
         return {
+            success: true,
             images: [
                 {
                     base64: data.image,
@@ -203,6 +222,7 @@ export class StabilityAIImageInterface implements AIImageInterface {
         const data = schema.parse(result.data);
 
         return {
+            success: true,
             images: [
                 {
                     base64: data.image,
@@ -252,6 +272,7 @@ export class StabilityAIImageInterface implements AIImageInterface {
         const data = schema.parse(result.data);
 
         return {
+            success: true,
             images: [
                 {
                     base64: data.image,