All files / api/src/ai-providers/siliconflow image-generate.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import {
  generateErrorResponse,
  generateInvalidProviderResponseError,
} from '@api/utils/ai-provider';
import type {
  AIProviderFunctionConfig,
  ResponseTransformFunction,
} from '@shared/types/ai-providers/config';
import type { GenerateImageResponseBody } from '@shared/types/api/routes/images-api/response';
import { AIProvider } from '@shared/types/constants';
 
export const siliconFlowImageGenerateConfig: AIProviderFunctionConfig = {
  prompt: {
    param: 'prompt',
    required: true,
  },
  model: {
    param: 'model',
    required: true,
    default: 'Kwai-Kolors/Kolors',
  },
  n: {
    param: 'batch_size',
    default: 1,
    min: 1,
    max: 4,
  },
  size: {
    param: 'image_size',
    default: '1024x1024',
  },
  num_inference_steps: {
    param: 'num_inference_steps',
    default: 50,
  },
  negative_prompt: {
    param: 'negative_prompt',
  },
  seed: {
    param: 'seed',
  },
  quality: {
    param: 'quality',
  },
  response_format: {
    param: 'response_format',
    default: 'b64_json',
  },
  style: {
    param: 'style',
  },
  user: {
    param: 'user',
  },
};
 
interface SiliconFlowImageResponse {
  images: string[];
  timings?: {
    inference: number;
  };
  seed?: number;
  nsfw_content_detected?: boolean;
}
 
export const siliconFlowImageGenerateResponseTransform: ResponseTransformFunction =
  (aiProviderResponseBody, aiProviderResponseStatus) => {
    if (aiProviderResponseStatus !== 200) {
      if ('message' in aiProviderResponseBody) {
        return generateErrorResponse(
          {
            message: aiProviderResponseBody.message as string,
            type: (aiProviderResponseBody.type as string) || 'api_error',
            param: aiProviderResponseBody.param as string | undefined,
            code: (aiProviderResponseBody.code as string) || undefined,
          },
          AIProvider.SILICONFLOW,
        );
      }
 
      return generateErrorResponse(
        {
          message: 'Image generation failed',
          type: 'api_error',
          param: undefined,
          code: undefined,
        },
        AIProvider.SILICONFLOW,
      );
    }
 
    if ('images' in aiProviderResponseBody) {
      const siliconFlowResponse =
        aiProviderResponseBody as unknown as SiliconFlowImageResponse;
 
      const responseBody: GenerateImageResponseBody = {
        created: Math.floor(Date.now() / 1000),
        data: siliconFlowResponse.images.map((imageBase64) => ({
          b64_json: imageBase64,
          url: undefined,
          revised_prompt: undefined,
        })),
      };
 
      Object.defineProperty(responseBody, 'provider', {
        value: AIProvider.SILICONFLOW,
        enumerable: true,
      });
 
      return responseBody;
    }
 
    return generateInvalidProviderResponseError(
      aiProviderResponseBody as Record<string, unknown>,
      AIProvider.SILICONFLOW,
    );
  };