briyah 1.0.0

package/dist/server/src/ai/LLM/deepseek.service.js

@@ -0,0 +1,279 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepSeekAiService = void 0;
+const common_1 = require("@nestjs/common");
+const deepseek_1 = require("@ai-sdk/deepseek");
+const ai_1 = require("ai");
+const base_ai_service_1 = require("./base-ai.service");
+const zod_1 = require("zod");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let DeepSeekAiService = class DeepSeekAiService extends base_ai_service_1.BaseAiService {
+    deepseekClient;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['DEEPSEEK_API_KEY'];
+            if (!apiKey) {
+                console.warn('DEEPSEEK_API_KEY environment variable not set. DeepSeek service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            this.deepseekClient = (0, deepseek_1.createDeepSeek)({
+                apiKey: apiKey,
+            });
+        }
+        catch (error) {
+            console.error('Error initializing DeepSeek service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'DeepSeek';
+    }
+    async fetchModelsFromApi() {
+        try {
+            const apiKey = process.env['DEEPSEEK_API_KEY'];
+            if (!apiKey) {
+                throw new Error('DEEPSEEK_API_KEY not configured');
+            }
+            const response = await fetch('https://api.deepseek.com/models', {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`DeepSeek API returned ${response.status}: ${response.statusText}`);
+            }
+            const list = await response.json();
+            return list?.data?.map((model) => {
+                return {
+                    name: model.id,
+                    description: model.id,
+                    model: model.id,
+                    service: 'DeepSeek',
+                };
+            });
+        }
+        catch (error) {
+            console.error('Error fetching DeepSeek models from API:', error);
+            throw error;
+        }
+    }
+    addToConversationHistory(agent, message, fromSelf = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        agent.history.push({
+            role: fromSelf ? 'assistant' : 'user',
+            content: message,
+        });
+        agent.trimHistoryIfNeeded();
+    }
+    jsonSchemaToZod(jsonSchema) {
+        if (!jsonSchema || !jsonSchema.type) {
+            return zod_1.z.any();
+        }
+        switch (jsonSchema.type) {
+            case 'object':
+                const shape = {};
+                if (jsonSchema.properties) {
+                    for (const [key, propSchema] of Object.entries(jsonSchema.properties)) {
+                        shape[key] = this.jsonSchemaToZod(propSchema);
+                        if (jsonSchema.required && !jsonSchema.required.includes(key)) {
+                            shape[key] = shape[key].optional();
+                        }
+                    }
+                }
+                return zod_1.z.object(shape);
+            case 'array':
+                if (jsonSchema.items) {
+                    return zod_1.z.array(this.jsonSchemaToZod(jsonSchema.items));
+                }
+                return zod_1.z.array(zod_1.z.any());
+            case 'string':
+                let stringSchema = zod_1.z.string();
+                if (jsonSchema.minLength !== undefined) {
+                    stringSchema = stringSchema.min(jsonSchema.minLength);
+                }
+                if (jsonSchema.maxLength !== undefined) {
+                    stringSchema = stringSchema.max(jsonSchema.maxLength);
+                }
+                if (jsonSchema.pattern) {
+                    stringSchema = stringSchema.regex(new RegExp(jsonSchema.pattern));
+                }
+                if (jsonSchema.enum) {
+                    return zod_1.z.enum(jsonSchema.enum);
+                }
+                return stringSchema;
+            case 'number':
+            case 'integer':
+                let numberSchema = jsonSchema.type === 'integer' ? zod_1.z.number().int() : zod_1.z.number();
+                if (jsonSchema.minimum !== undefined) {
+                    numberSchema = numberSchema.min(jsonSchema.minimum);
+                }
+                if (jsonSchema.maximum !== undefined) {
+                    numberSchema = numberSchema.max(jsonSchema.maximum);
+                }
+                return numberSchema;
+            case 'boolean':
+                return zod_1.z.boolean();
+            case 'null':
+                return zod_1.z.null();
+            default:
+                return zod_1.z.any();
+        }
+    }
+    async textPrompt(agent, prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, _cacheConfig = null, maxOutputChars = 0) {
+        if (agent.balanceService && !agent.disableBalanceCheck) {
+            const hasSufficientBalance = agent.balanceService.hasSufficientBalance();
+            if (!hasSufficientBalance) {
+                throw new errors_1.InsufficientBalanceError('Insufficient balance. Please add funds to continue using AI services.');
+            }
+        }
+        const identity = `Your agent identity is ${agent.agentName}: ${agent.description}`;
+        const instructions = promptInstructions || agent.systemInstruction;
+        const messages = [];
+        if (instructions)
+            messages.push({ role: 'system', content: instructions });
+        messages.push({ role: 'user', content: identity });
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.fileData) {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    messages.push({
+                        role: 'user',
+                        content: `Attached file "${file.fileName}":\n\n${textContent}`,
+                    });
+                }
+            }
+        }
+        if (agent.attachedArtifacts && agent.attachedArtifacts.length > 0) {
+            for (const artifactId of agent.attachedArtifacts) {
+                const content = agent.artifactService.getArtifact(artifactId);
+                if (content && typeof content === 'string') {
+                    const metadata = agent.artifactService.getArtifactMetadata(artifactId);
+                    const fileName = metadata ? `${metadata.name}.md` : 'artifact.md';
+                    messages.push({
+                        role: 'user',
+                        content: `Attached document: ${fileName}\n\n${content}`,
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({
+                role: 'user',
+                content: prompt,
+            });
+        }
+        let reasoningEffort = agent.reasoningEffort ? agent.reasoningEffort : undefined;
+        try {
+            if (jsonSchema) {
+                const result = await (0, ai_1.generateObject)({
+                    model: this.deepseekClient(agent.modelName),
+                    messages: messages,
+                    temperature: 0,
+                    schema: jsonSchema,
+                    providerOptions: {
+                        deepseek: {
+                            reasoningEffort: reasoningEffort,
+                        },
+                    },
+                });
+                if (result.usage) {
+                    this.computeMessageCost(agent, result.usage);
+                }
+                if (saveResponse) {
+                    this.addToConversationHistory(agent, prompt, false);
+                    this.addToConversationHistory(agent, JSON.stringify(result.object), true);
+                }
+                return result.object;
+            }
+            else {
+                const result = await (0, ai_1.generateText)({
+                    model: this.deepseekClient(agent.modelName),
+                    messages: messages,
+                    temperature: 0,
+                    providerOptions: {
+                        deepseek: {
+                            reasoningEffort: reasoningEffort,
+                        },
+                    },
+                });
+                if (result.usage) {
+                    this.computeMessageCost(agent, result.usage);
+                }
+                if (saveResponse) {
+                    this.addToConversationHistory(agent, prompt, false);
+                    this.addToConversationHistory(agent, result.text, true);
+                }
+                return result.text;
+            }
+        }
+        catch (error) {
+            console.error('Error generating response from DeepSeek:', error);
+            throw error;
+        }
+    }
+    async attachDocument(agent, fileName, fileData) {
+        if (agent === null) {
+            throw new Error('Shared document attachment not supported by the DeepSeek service');
+        }
+        return super.attachDocument(agent, fileName, fileData);
+    }
+    computeMessageCost(agent, usage) {
+        const totalInputTokens = usage.inputTokens || 0;
+        const cachedTokens = usage.cachedInputTokens || 0;
+        const uncachedInputTokens = totalInputTokens - cachedTokens;
+        const outputTokens = usage.outputTokens || 0;
+        let modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo && !agent.modelName.startsWith('deepseek/')) {
+            modelInfo = model_prices_1.default[`deepseek/${agent.modelName}`];
+        }
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName} or deepseek/${agent.modelName}`);
+            return;
+        }
+        const uncachedCost = uncachedInputTokens * modelInfo.input_cost_per_token;
+        const cachedCost = cachedTokens *
+            (modelInfo.cache_read_input_token_cost || modelInfo.input_cost_per_token * 0.25);
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = uncachedCost + cachedCost + outputCost + markup;
+        agent.totalInputTokens += totalInputTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for ${agent.agentName} message: ${cost} (markup: ${markup.toFixed(4)})`);
+        if (cachedTokens > 0) {
+            console.log(`Cache metrics for ${agent.agentName}: cached=${cachedTokens}, uncached=${uncachedInputTokens}`);
+        }
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+};
+exports.DeepSeekAiService = DeepSeekAiService;
+exports.DeepSeekAiService = DeepSeekAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], DeepSeekAiService);

package/dist/server/src/ai/LLM/fal.module.d.ts

@@ -0,0 +1,2 @@
+export declare class FalAiModule {
+}

package/dist/server/src/ai/LLM/fal.module.js

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FalAiModule = void 0;
+const common_1 = require("@nestjs/common");
+const fal_service_1 = require("./fal.service");
+let FalAiModule = class FalAiModule {
+};
+exports.FalAiModule = FalAiModule;
+exports.FalAiModule = FalAiModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        providers: [fal_service_1.FalAiService],
+        exports: [fal_service_1.FalAiService],
+    })
+], FalAiModule);

package/dist/server/src/ai/LLM/fal.service.d.ts

@@ -0,0 +1,17 @@
+import { BaseAiService } from './base-ai.service';
+import { Agent } from '../agent';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class FalAiService extends BaseAiService {
+    constructor();
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean, developer?: boolean): void;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    private computeMessageCost;
+    private computeImageCost;
+    generateImage(agent: Agent, prompt: string, width: number, height: number, quality: string, referenceImageArtifactIds?: string[]): Promise<{
+        artifactId?: string;
+        error?: any;
+    }>;
+}

package/dist/server/src/ai/LLM/fal.service.js

@@ -0,0 +1,314 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FalAiService = void 0;
+const common_1 = require("@nestjs/common");
+const client_1 = require("@fal-ai/client");
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let FalAiService = class FalAiService extends base_ai_service_1.BaseAiService {
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['FAL_API_KEY'];
+            if (!apiKey) {
+                console.warn('FAL_API_KEY environment variable not set. Fal AI service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            client_1.fal.config({ credentials: apiKey });
+            console.log('Fal AI service initialized successfully');
+        }
+        catch (error) {
+            console.error('Error initializing Fal AI service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'FalAI';
+    }
+    supportsImageGeneration() {
+        return true;
+    }
+    async fetchModelsFromApi() {
+        try {
+            const apiKey = process.env['FAL_API_KEY'];
+            if (!apiKey) {
+                console.warn('FAL_API_KEY not set, cannot fetch models');
+                return [];
+            }
+            const response = await fetch('https://api.fal.ai/v1/models', {
+                headers: {
+                    Authorization: `Key ${apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                console.error(`Fal API error: ${response.status} ${response.statusText}`);
+                return [];
+            }
+            const data = await response.json();
+            const models = [];
+            if (data.models && Array.isArray(data.models)) {
+                for (const model of data.models) {
+                    models.push({
+                        name: model.metadata.display_name,
+                        description: model.metadata.description,
+                        model: model.endpoint_id,
+                        service: 'FalAI',
+                    });
+                }
+            }
+            console.log(`Fetched ${models.length} active models from Fal AI`);
+            return models;
+        }
+        catch (error) {
+            console.error('Error fetching Fal AI models:', error);
+            return [];
+        }
+    }
+    addToConversationHistory(agent, message, fromSelf = false, developer = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        let role = fromSelf ? 'assistant' : 'user';
+        if (developer)
+            role = 'system';
+        agent.history.push({
+            role: role,
+            content: message,
+        });
+        agent.trimHistoryIfNeeded();
+    }
+    async textPrompt(agent, prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, _cacheConfig = null, maxOutputChars = 0) {
+        if (agent.balanceService && !agent.disableBalanceCheck) {
+            const hasSufficientBalance = agent.balanceService.hasSufficientBalance();
+            if (!hasSufficientBalance) {
+                throw new errors_1.InsufficientBalanceError('Insufficient balance. Please add funds to continue using AI services.');
+            }
+        }
+        const identity = `Your agent identity is ${agent.agentName}: ${agent.description}`;
+        const instructions = promptInstructions || agent.systemInstruction;
+        let fullPrompt = '';
+        if (instructions) {
+            fullPrompt += instructions + '\n\n';
+        }
+        fullPrompt += identity + '\n\n';
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.fileData) {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    fullPrompt += `Attached file "${file.fileName}":\n\n${textContent}\n\n`;
+                }
+            }
+        }
+        for (const msg of agent.history) {
+            fullPrompt += `${msg.role}: ${msg.content}\n\n`;
+        }
+        if (jsonSchema) {
+            fullPrompt += `You must respond with valid JSON matching this schema: ${JSON.stringify(jsonSchema)}\n\n`;
+        }
+        if (prompt) {
+            fullPrompt += `user: ${prompt}\n\n`;
+        }
+        fullPrompt += 'assistant: ';
+        let responseText;
+        let estimatedInputTokens = 0;
+        let estimatedOutputTokens = 0;
+        try {
+            estimatedInputTokens = Math.ceil(fullPrompt.length / 4);
+            const result = (await client_1.fal.subscribe('fal-ai/any-llm', {
+                input: {
+                    model: agent.modelName,
+                    prompt: fullPrompt,
+                },
+            }));
+            if (result.output) {
+                responseText = result.output;
+            }
+            else if (result.text) {
+                responseText = result.text;
+            }
+            else if (typeof result === 'string') {
+                responseText = result;
+            }
+            else {
+                responseText = '';
+            }
+            estimatedOutputTokens = Math.ceil(responseText.length / 4);
+            if (jsonSchema) {
+                responseText = this.trimToJson(responseText);
+                responseText = this.sanitizeJsonString(responseText);
+            }
+            else {
+                responseText = this.trimResponseText(responseText);
+            }
+            const usage = result.usage || {
+                prompt_tokens: estimatedInputTokens,
+                completion_tokens: estimatedOutputTokens,
+            };
+            this.computeMessageCost(agent, usage, estimatedInputTokens, estimatedOutputTokens);
+        }
+        catch (error) {
+            console.error('Error calling Fal AI:', error);
+            if (error.message?.includes('authentication') ||
+                error.message?.includes('unauthorized')) {
+                throw new Error('Fal AI authentication failed. Check FAL_API_KEY.');
+            }
+            else if (error.message?.includes('rate limit')) {
+                throw new Error('Fal AI rate limit exceeded.');
+            }
+            throw error;
+        }
+        if (saveResponse) {
+            this.addToConversationHistory(agent, prompt, false);
+            this.addToConversationHistory(agent, responseText, true);
+        }
+        if (jsonSchema) {
+            try {
+                return JSON.parse(responseText);
+            }
+            catch (parseError) {
+                console.error('Failed to parse JSON response:', parseError);
+                console.error('Response text:', responseText);
+                throw new Error('Failed to parse JSON response from Fal AI');
+            }
+        }
+        return responseText;
+    }
+    computeMessageCost(agent, usage, estimatedInputTokens, estimatedOutputTokens) {
+        const inputTokens = usage?.prompt_tokens || estimatedInputTokens || 0;
+        const outputTokens = usage?.completion_tokens || estimatedOutputTokens || 0;
+        let modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo && !agent.modelName.startsWith('fal_ai/')) {
+            modelInfo = model_prices_1.default[`fal_ai/${agent.modelName}`];
+        }
+        if (!modelInfo) {
+            console.warn(`No price info found for model ${agent.modelName}. Skipping cost tracking.`);
+            return;
+        }
+        const inputCost = inputTokens * (modelInfo.input_cost_per_token || 0);
+        const outputCost = outputTokens * (modelInfo.output_cost_per_token || 0);
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = inputCost + outputCost + markup;
+        agent.totalInputTokens += inputTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        if (!usage?.prompt_tokens) {
+            console.log(`Cost for ${agent.agentName} message (estimated): ${cost.toFixed(4)} (markup: ${markup.toFixed(4)})`);
+        }
+        else {
+            console.log(`Cost for ${agent.agentName} message: ${cost.toFixed(4)} (markup: ${markup.toFixed(4)})`);
+        }
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+    computeImageCost(agent) {
+        let modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo && !agent.modelName.startsWith('fal_ai/')) {
+            modelInfo = model_prices_1.default[`fal_ai/${agent.modelName}`];
+        }
+        if (!modelInfo || !modelInfo.output_cost_per_image) {
+            console.warn(`No image price info found for ${agent.modelName}. Skipping cost tracking.`);
+            return;
+        }
+        const cost = modelInfo.output_cost_per_image;
+        const markup = 0;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for image generation: ${cost.toFixed(4)} (markup: ${markup.toFixed(4)})`);
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+    async generateImage(agent, prompt, width, height, quality, referenceImageArtifactIds) {
+        if (agent.balanceService && !agent.disableBalanceCheck) {
+            const hasSufficientBalance = agent.balanceService.hasSufficientBalance();
+            if (!hasSufficientBalance) {
+                throw new errors_1.InsufficientBalanceError('Insufficient balance for image generation. Please add funds to continue.');
+            }
+        }
+        try {
+            let endpoint = agent.modelName;
+            if (!endpoint.startsWith('fal-ai/')) {
+                endpoint = `fal-ai/${endpoint}`;
+            }
+            const input = {
+                prompt: prompt,
+                image_size: {
+                    width: width,
+                    height: height,
+                },
+                num_images: 1,
+                output_format: 'png',
+            };
+            if (referenceImageArtifactIds && referenceImageArtifactIds.length > 0) {
+                input.image_urls = await this.loadReferenceImages(agent, referenceImageArtifactIds);
+                if (!endpoint.endsWith('/edit'))
+                    endpoint += '/edit';
+            }
+            const result = (await client_1.fal.subscribe(endpoint, {
+                input: input,
+            }));
+            this.computeImageCost(agent);
+            let base64Data;
+            if (result.data.images && result.data.images[0]) {
+                const image = result.data.images[0];
+                if (image.url) {
+                    const imageResponse = await fetch(image.url);
+                    const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
+                    base64Data = imageBuffer.toString('base64');
+                }
+                else if (image.content) {
+                    base64Data = image.content;
+                }
+                else {
+                    throw new Error('No image data found in response');
+                }
+            }
+            else if (result.data.image) {
+                if (result.data.image.url) {
+                    const imageResponse = await fetch(result.data.image.url);
+                    const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
+                    base64Data = imageBuffer.toString('base64');
+                }
+                else if (result.data.image.content) {
+                    base64Data = result.data.image.content;
+                }
+                else {
+                    throw new Error('No image data found in response');
+                }
+            }
+            else {
+                throw new Error('Unexpected response format from Fal AI');
+            }
+            const artifactId = await this.saveImageAsArtifact(agent, base64Data, prompt);
+            return { artifactId };
+        }
+        catch (error) {
+            console.error('Error generating image with Fal AI:', error.message || error);
+            return { error };
+        }
+    }
+};
+exports.FalAiService = FalAiService;
+exports.FalAiService = FalAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], FalAiService);

package/dist/server/src/ai/LLM/googleai.module.d.ts

@@ -0,0 +1,2 @@
+export declare class GoogleAiModule {
+}

package/dist/server/src/ai/LLM/googleai.module.js

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAiModule = void 0;
+const common_1 = require("@nestjs/common");
+const googleai_service_1 = require("./googleai.service");
+let GoogleAiModule = class GoogleAiModule {
+};
+exports.GoogleAiModule = GoogleAiModule;
+exports.GoogleAiModule = GoogleAiModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        providers: [googleai_service_1.GoogleAiService],
+        exports: [googleai_service_1.GoogleAiService],
+    })
+], GoogleAiModule);

package/dist/server/src/ai/LLM/googleai.service.d.ts

@@ -0,0 +1,20 @@
+import { BaseAiService } from './base-ai.service';
+import { Agent } from '../agent';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class GoogleAiService extends BaseAiService {
+    private googleAI;
+    constructor();
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    supportsPromptCaching(): boolean;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean): void;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    generateImage(agent: Agent, prompt: string, width: number, height: number, quality: string, _referenceImageArtifactIds?: string[]): Promise<{
+        artifactId?: string;
+        error?: any;
+    }>;
+    private computeMessageCost;
+    private computeImageCost;
+    formatMessage(message: any): string;
+}