captify 0.1.15

package/dist/agents/services/service.js

@@ -0,0 +1,883 @@
+import { createAgentUIStreamResponse, generateObject, streamObject, stepCountIs, ToolLoopAgent, } from "ai";
+import { TABLES } from "../../constants/tables";
+import { AGENT_DEFAULTS, buildAgentSK, buildTenantPK } from "../constants";
+import { agentIdentifierSchema, aiGeneratedConfigSchema, createAgentSchema, deleteAgentSchema, generateAgentConfigSchema, generateTextSchema, getAgentSchema, listAgentsSchema, updateAgentSchema, } from "../schemas";
+import { getToolsByNames, TOOL_REGISTRY } from "./tools";
+import { DynamoDbInstances } from "../../services/dynamodb/services/dynamodb.singleton";
+import { UpdateExpressionBuilder } from "../../services/dynamodb/utilities";
+import { getLLMService } from "../../llm-providers/services";
+import { LoggerFactory } from "../../services/logger";
+import { NotFoundError, ValidationError } from "../../services/shared/errors";
+import { BaseAwsService } from "../../services/shared/services";
+/**
+ * Service for managing AI Agents and their configurations.
+ * Provides CRUD operations and AI chat capabilities using Vercel AI SDK.
+ */
+export class AgentsService extends BaseAwsService {
+    constructor(deps) {
+        var _a, _b;
+        super({ logger: deps.logger });
+        this.db = (_a = deps.db) !== null && _a !== void 0 ? _a : DynamoDbInstances.getInstance(TABLES.agents);
+        this.llmService = (_b = deps.llmService) !== null && _b !== void 0 ? _b : getLLMService();
+    }
+    /**
+     * Get all agents for a tenant
+     */
+    async getAllAgents(params) {
+        const validated = listAgentsSchema.parse({ tenantId: params.tenantId });
+        this.logger.info("Fetching all agents", {
+            tenantId: params.tenantId,
+        });
+        const { Items } = await this.db.queryItems({
+            KeyConditionExpression: "PK = :pk AND begins_with(SK, :prefix)",
+            ExpressionAttributeValues: {
+                ":pk": buildTenantPK(validated.tenantId),
+                ":prefix": "METADATA#AGENT#",
+            },
+        }, { userCredentials: params.userCredentials });
+        const agents = (Items !== null && Items !== void 0 ? Items : []);
+        this.logger.info("Fetched agents successfully", {
+            tenantId: validated.tenantId,
+            count: agents.length,
+        });
+        return agents;
+    }
+    /**
+     * Get a specific agent by ID
+     */
+    async getAgentById(params) {
+        const validated = getAgentSchema.parse({
+            agentId: params.agentId,
+            tenantId: params.tenantId,
+        });
+        this.logger.info("Fetching agent by ID", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        const { Item } = await this.db.getItem({
+            PK: buildTenantPK(validated.tenantId),
+            SK: buildAgentSK(validated.agentId),
+        }, { userCredentials: params.userCredentials });
+        if (!Item) {
+            this.logger.warn("Agent not found", {
+                tenantId: validated.tenantId,
+                agentId: validated.agentId,
+            });
+            return null;
+        }
+        this.logger.info("Fetched agent successfully", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        return Item;
+    }
+    /**
+     * Create a new agent
+     */
+    async createAgent(params) {
+        const validated = createAgentSchema.parse(params);
+        this.logger.info("Creating agent", {
+            tenantId: validated.tenantId,
+            name: validated.name,
+        });
+        // Validate that provider and model exist in the system
+        const provider = await this.llmService.getProviderById(validated.tenantId, validated.providerId, {
+            userCredentials: params.userCredentials,
+        });
+        if (!provider) {
+            throw new NotFoundError(`Provider with ID ${validated.providerId} not found`);
+        }
+        if (!provider.isEnabled) {
+            throw new ValidationError(`Provider ${provider.name} is disabled`);
+        }
+        const model = await this.llmService.getModel(validated.tenantId, validated.providerId, validated.modelId, { userCredentials: params.userCredentials });
+        if (!model) {
+            throw new NotFoundError(`Model with ID ${validated.modelId} not found`);
+        }
+        if (!model.isAvailable) {
+            throw new ValidationError(`Model ${model.name} is not available`);
+        }
+        const id = crypto.randomUUID();
+        const now = Date.now();
+        const newAgent = {
+            id,
+            tenantId: validated.tenantId,
+            name: validated.name,
+            description: validated.description,
+            instructions: validated.instructions,
+            tools: validated.tools,
+            maxSteps: validated.maxSteps,
+            toolChoice: validated.toolChoice,
+            modelId: validated.modelId,
+            providerId: validated.providerId,
+            temperature: validated.temperature,
+            maxTokens: validated.maxTokens,
+            responseType: validated.responseType,
+            topP: validated.topP,
+            presencePenalty: validated.presencePenalty,
+            frequencyPenalty: validated.frequencyPenalty,
+            status: validated.status,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.putItem(Object.assign({ PK: buildTenantPK(validated.tenantId), SK: buildAgentSK(id) }, newAgent), { userCredentials: params.userCredentials });
+        this.logger.info("Agent created successfully", {
+            tenantId: validated.tenantId,
+            agentId: id,
+            name: validated.name,
+        });
+        return newAgent;
+    }
+    /**
+     * Update an existing agent
+     */
+    async updateAgent(params) {
+        var _a;
+        const validated = updateAgentSchema.parse(Object.assign({ agentId: params.agentId, tenantId: params.tenantId }, params.updates));
+        this.logger.info("Updating agent", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        // Check if agent exists
+        const current = await this.getAgentById({
+            agentId: validated.agentId,
+            tenantId: validated.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        if (!current) {
+            throw new NotFoundError(`Agent with ID ${validated.agentId} not found`);
+        }
+        // Validate provider if being updated
+        if (validated.providerId !== undefined) {
+            const provider = await this.llmService.getProviderById(validated.tenantId, validated.providerId, { userCredentials: params.userCredentials });
+            if (!provider) {
+                throw new NotFoundError(`Provider with ID ${validated.providerId} not found`);
+            }
+            if (!provider.isEnabled) {
+                throw new ValidationError(`Provider ${provider.name} is disabled`);
+            }
+        }
+        // Validate model if being updated (use new provider if provided, otherwise use current)
+        if (validated.modelId !== undefined) {
+            const providerId = (_a = validated.providerId) !== null && _a !== void 0 ? _a : current.providerId;
+            const model = await this.llmService.getModel(validated.tenantId, providerId, validated.modelId, { userCredentials: params.userCredentials });
+            if (!model) {
+                throw new NotFoundError(`Model with ID ${validated.modelId} not found`);
+            }
+            if (!model.isAvailable) {
+                throw new ValidationError(`Model ${model.name} is not available`);
+            }
+        }
+        // Build update expression
+        const updateBuilder = new UpdateExpressionBuilder();
+        const now = Date.now();
+        updateBuilder
+            .set("updatedAt", now)
+            .setOptional("name", validated.name)
+            .setOptional("description", validated.description)
+            .setOptional("instructions", validated.instructions)
+            .setOptional("tools", validated.tools)
+            .setOptional("maxSteps", validated.maxSteps)
+            .setOptional("toolChoice", validated.toolChoice)
+            .setOptional("modelId", validated.modelId)
+            .setOptional("providerId", validated.providerId)
+            .setOptional("temperature", validated.temperature)
+            .setOptional("maxTokens", validated.maxTokens)
+            .setOptional("responseType", validated.responseType)
+            .setOptional("topP", validated.topP)
+            .setOptional("presencePenalty", validated.presencePenalty)
+            .setOptional("frequencyPenalty", validated.frequencyPenalty)
+            .setOptional("status", validated.status);
+        const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = updateBuilder.build();
+        const { Attributes } = await this.db.updateItem({
+            PK: buildTenantPK(validated.tenantId),
+            SK: buildAgentSK(validated.agentId),
+        }, UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues, { userCredentials: params.userCredentials });
+        this.logger.info("Agent updated successfully", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        return Attributes;
+    }
+    /**
+     * Delete an agent
+     */
+    async deleteAgent(params) {
+        const validated = deleteAgentSchema.parse({
+            agentId: params.agentId,
+            tenantId: params.tenantId,
+        });
+        this.logger.info("Deleting agent", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        // Check if agent exists (optional, for better UX)
+        const agent = await this.getAgentById({
+            agentId: validated.agentId,
+            tenantId: validated.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        if (!agent) {
+            // Agent doesn't exist, but deletion is idempotent
+            this.logger.warn("Agent not found, nothing to delete", {
+                tenantId: validated.tenantId,
+                agentId: validated.agentId,
+            });
+            return;
+        }
+        await this.db.deleteItem({
+            PK: buildTenantPK(validated.tenantId),
+            SK: buildAgentSK(validated.agentId),
+        }, { userCredentials: params.userCredentials });
+        this.logger.info("Agent deleted successfully", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+    }
+    /**
+     * Stream AI response using agent configuration with ToolLoopAgent
+     */
+    async streamResponse(params) {
+        const identifiers = agentIdentifierSchema.parse({
+            agentId: params.agentId,
+            tenantId: params.tenantId,
+            messages: params.messages,
+        });
+        this.logger.info("Streaming AI response", {
+            tenantId: identifiers.tenantId,
+            agentId: identifiers.agentId,
+            messageCount: params.messages.length,
+        });
+        // Get agent configuration
+        const agent = await this.getAgentById({
+            agentId: identifiers.agentId,
+            tenantId: identifiers.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        if (!agent) {
+            throw new NotFoundError(`Agent with ID ${identifiers.agentId} not found`);
+        }
+        if (agent.status !== "active") {
+            throw new ValidationError(`Agent ${agent.name} is not active. Current status: ${agent.status}`);
+        }
+        // Create ToolLoopAgent with agent configuration
+        const toolLoopAgent = await this.createToolLoopAgent(agent, {
+            tenantId: identifiers.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        this.logger.info("Starting stream with ToolLoopAgent", {
+            agentId: identifiers.agentId,
+            agentName: agent.name,
+            messageCount: params.messages.length,
+            maxSteps: agent.maxSteps,
+            toolChoice: agent.toolChoice,
+        });
+        // Use createAgentUIStreamResponse for streaming
+        return createAgentUIStreamResponse({
+            agent: toolLoopAgent,
+            messages: params.messages,
+        });
+    }
+    /**
+     * Generate AI text (non-streaming) using agent configuration with ToolLoopAgent
+     */
+    async generateText(params) {
+        var _a, _b, _c, _d;
+        const validated = generateTextSchema.parse({
+            agentId: params.agentId,
+            tenantId: params.tenantId,
+            prompt: params.prompt,
+        });
+        this.logger.info("Generating AI text", {
+            tenantId: validated.tenantId,
+            agentId: validated.agentId,
+        });
+        // Get agent configuration
+        const agent = await this.getAgentById({
+            agentId: validated.agentId,
+            tenantId: validated.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        if (!agent) {
+            throw new NotFoundError(`Agent with ID ${validated.agentId} not found`);
+        }
+        if (agent.status !== "active") {
+            throw new ValidationError(`Agent ${agent.name} is not active. Current status: ${agent.status}`);
+        }
+        // Create ToolLoopAgent with agent configuration
+        const toolLoopAgent = await this.createToolLoopAgent(agent, {
+            tenantId: validated.tenantId,
+            userCredentials: params.userCredentials,
+        });
+        this.logger.info("Generating text with ToolLoopAgent", {
+            agentId: validated.agentId,
+            agentName: agent.name,
+            maxSteps: agent.maxSteps,
+            toolChoice: agent.toolChoice,
+        });
+        // Use ToolLoopAgent.generate for text generation
+        const result = await toolLoopAgent.generate({
+            messages: [{ role: "user", content: validated.prompt }],
+        });
+        // Extract tool calls from the result
+        const toolCalls = [];
+        if (result.steps) {
+            for (const step of result.steps) {
+                if ("toolCalls" in step && step.toolCalls) {
+                    for (const toolCall of step.toolCalls) {
+                        let args = {};
+                        let toolResult = undefined;
+                        if (typeof toolCall === "object" && toolCall !== null) {
+                            if ("args" in toolCall && this.isRecord(toolCall.args)) {
+                                args = toolCall.args;
+                            }
+                            if ("toolResult" in toolCall) {
+                                toolResult = toolCall.toolResult;
+                            }
+                        }
+                        toolCalls.push({
+                            toolName: toolCall.toolName,
+                            args,
+                            result: toolResult,
+                        });
+                    }
+                }
+            }
+        }
+        this.logger.info("Text generated successfully", {
+            agentId: validated.agentId,
+            steps: (_b = (_a = result.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+            toolCallCount: toolCalls.length,
+            usage: result.usage,
+        });
+        return {
+            text: result.text,
+            steps: (_d = (_c = result.steps) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: result.usage,
+            finishReason: result.finishReason,
+        };
+    }
+    /**
+     * Generate agent configuration from natural language description.
+     * Uses AI to analyze the description and generate appropriate agent settings.
+     *
+     * @param params - Parameters including tenantId, userId, and description
+     * @returns Promise resolving to generated agent configuration
+     * @throws ValidationError if description is invalid or no default model configured
+     */
+    async generateAgentConfig(params) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        // 1. Validate input using service-level schema
+        const validated = generateAgentConfigSchema.parse(params);
+        this.logger.info("Generating agent configuration", {
+            tenantId: validated.tenantId,
+            userId: validated.userId,
+            descriptionLength: validated.description.length,
+            fileCount: (_b = (_a = params.files) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+        });
+        // 2. Get available providers and models for context
+        const providers = await this.llmService.getAllProviders(validated.tenantId, {
+            userCredentials: params.userCredentials,
+        });
+        const enabledProviders = providers.filter((p) => p.isEnabled);
+        if (enabledProviders.length === 0) {
+            throw new ValidationError("No enabled LLM providers available");
+        }
+        // 3. Get default model for generation
+        const defaultModelResult = await this.llmService.getBasicAssistantDefault(validated.tenantId, {
+            userCredentials: params.userCredentials,
+        });
+        if (!defaultModelResult) {
+            throw new ValidationError("No default model configured for tenant. Please configure a default model in LLM settings.");
+        }
+        const { provider: defaultProvider, model: defaultModel } = defaultModelResult;
+        // 4. Build context about available options for the AI
+        const providerModelsContext = await Promise.all(enabledProviders.map(async (provider) => {
+            const models = await this.llmService.getModelsByProvider(validated.tenantId, provider.id, {
+                userCredentials: params.userCredentials,
+            });
+            const availableModels = models.filter((m) => m.isAvailable);
+            return {
+                providerId: provider.id,
+                providerName: provider.name,
+                models: availableModels.map((m) => ({ id: m.id, name: m.name })),
+            };
+        }));
+        // Build tool descriptions for the AI
+        const toolDescriptions = Object.entries(TOOL_REGISTRY).map(([name, toolDef]) => ({
+            name,
+            description: toolDef.description || `Tool: ${name}`,
+        }));
+        // 5. Build the system prompt for AI generation
+        const systemPrompt = `You are an AI agent configuration generator. Your task is to analyze a user's description of what kind of AI agent they want and generate optimal configuration settings.
+
+Available LLM Providers and Models:
+${JSON.stringify(providerModelsContext, null, 2)}
+
+Available Tools:
+${JSON.stringify(toolDescriptions, null, 2)}
+
+IMPORTANT - Using Attached File Context:
+If the user's description includes "Context from attached files:", you MUST incorporate that content into the agent's instructions. This attached content provides domain knowledge, examples, or reference material that should be embedded in the agent's system prompt. For example:
+- If a document describes a specific process, include those steps in the instructions
+- If it contains terminology or definitions, reference them in the instructions
+- If it's code or technical content, instruct the agent to follow those patterns
+- The agent's instructions should reflect the knowledge from the attached files
+
+Guidelines for Configuration:
+- Name: Create a concise, descriptive name (max 100 chars)
+- Description: Summarize the agent's purpose (max 500 chars)
+- Instructions: Write clear system instructions that define the agent's role and behavior. IMPORTANT: If file context was provided, incorporate relevant content from those files into the instructions.
+- Provider/Model: Select based on the use case:
+  * For coding tasks: prefer models good at code generation
+  * For creative writing: prefer models with higher creativity
+  * For factual Q&A: prefer models with good accuracy
+  * Default to the tenant's default model if unsure
+- Tools: Select relevant tools based on the description:
+  * calculator, arrayOperations: for math/calculations
+  * getCurrentTime: for time-related tasks
+  * stringManipulator: for text processing
+  * jsonValidator: for data validation
+  * urlParser: for URL/web-related tasks
+  * randomNumber: for random generation needs
+- Temperature:
+  * 0.2-0.4 for precise/coding tasks
+  * 0.7 for general tasks (default)
+  * 0.8-1.0 for creative tasks
+- ResponseType:
+  * "text" for general responses
+  * "json" for structured data output
+  * "markdown" for formatted documentation
+- MaxTokens: 4096 is usually appropriate, increase for longer outputs
+- MaxSteps: 20 is default for tool use, increase if complex tool chains needed
+
+Always select valid provider and model IDs from the available options.`;
+        // 6. Get AI SDK provider for generation
+        const aiProvider = this.llmService.getAISDKProvider(defaultProvider, params.userCredentials);
+        const aiModel = aiProvider.languageModel(defaultModel.id);
+        // 8. Build message content with text and optional file attachments
+        const messageContent = [
+            {
+                type: "text",
+                text: `Generate an optimal agent configuration based on this description: "${validated.description}"`,
+            },
+        ];
+        // Add file attachments as file parts for multi-modal processing
+        if (validated.files && validated.files.length > 0) {
+            // Guardrails: limit file count and total size
+            const MAX_FILES = 5;
+            const MAX_TOTAL_SIZE_BYTES = 10 * 1024 * 1024; // 10MB total
+            if (validated.files.length > MAX_FILES) {
+                throw new ValidationError(`Too many files. Maximum ${MAX_FILES} files allowed.`);
+            }
+            // Calculate total size from base64 data URLs
+            let totalSize = 0;
+            for (const file of validated.files) {
+                if ((_c = file.url) === null || _c === void 0 ? void 0 : _c.startsWith("data:")) {
+                    // Base64 size is roughly 4/3 of binary size
+                    const base64Part = file.url.split(",")[1];
+                    if (base64Part) {
+                        totalSize += Math.ceil((base64Part.length * 3) / 4);
+                    }
+                }
+            }
+            if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+                throw new ValidationError(`Total file size exceeds limit. Maximum ${MAX_TOTAL_SIZE_BYTES / 1024 / 1024}MB allowed.`);
+            }
+            this.logger.info("Processing file attachments", {
+                fileCount: validated.files.length,
+                totalSizeBytes: totalSize,
+                files: validated.files.map((f) => {
+                    var _a, _b;
+                    return ({
+                        isDataUrl: (_b = (_a = f.url) === null || _a === void 0 ? void 0 : _a.startsWith("data:")) !== null && _b !== void 0 ? _b : false,
+                        mediaType: f.mediaType,
+                        filename: f.filename,
+                    });
+                }),
+            });
+            for (const file of validated.files) {
+                if (file.url.startsWith("data:")) {
+                    // Extract base64 data from data URL
+                    const matches = file.url.match(/^data:([^;]+);base64,(.+)$/);
+                    if (matches) {
+                        const [, mediaType, base64Data] = matches;
+                        messageContent.push({
+                            type: "file",
+                            data: base64Data,
+                            mediaType: mediaType,
+                        });
+                        this.logger.debug("Added file to message content", {
+                            mediaType,
+                            dataLength: base64Data.length,
+                        });
+                    }
+                    else {
+                        this.logger.warn("Failed to parse data URL", {
+                            filename: file.filename,
+                            mediaType: file.mediaType,
+                        });
+                    }
+                }
+                else {
+                    this.logger.warn("File URL is not a data URL, skipping", {
+                        filename: file.filename,
+                        mediaType: file.mediaType,
+                    });
+                }
+            }
+        }
+        // 9. Call AI with structured output
+        this.logger.info("Calling AI for agent config generation", {
+            tenantId: validated.tenantId,
+            modelId: defaultModel.id,
+            providerId: defaultProvider.id,
+            hasFiles: messageContent.length > 1,
+        });
+        const result = await generateObject({
+            model: aiModel,
+            schema: aiGeneratedConfigSchema,
+            system: systemPrompt,
+            messages: [{ role: "user", content: messageContent }],
+            temperature: 0.4, // Lower temperature for more consistent configs
+        });
+        const generatedConfig = result.object;
+        // 10. Validate and fix provider/model - always ensure valid values
+        let finalProviderId = generatedConfig.providerId;
+        let finalModelId = generatedConfig.modelId;
+        const isProviderValid = enabledProviders.some((p) => p.id === finalProviderId);
+        if (!isProviderValid) {
+            this.logger.warn("AI selected invalid provider, falling back to default", {
+                selectedProvider: finalProviderId,
+                defaultProvider: defaultProvider.id,
+            });
+            finalProviderId = defaultProvider.id;
+            finalModelId = defaultModel.id;
+        }
+        else {
+            // Check if model is valid for the selected provider
+            const providerModels = providerModelsContext.find((p) => p.providerId === finalProviderId);
+            const isModelValid = providerModels === null || providerModels === void 0 ? void 0 : providerModels.models.some((m) => m.id === finalModelId);
+            if (!isModelValid) {
+                this.logger.warn("AI selected invalid model, falling back to default", {
+                    selectedModel: finalModelId,
+                    defaultModel: defaultModel.id,
+                });
+                finalModelId = defaultModel.id;
+                finalProviderId = defaultProvider.id;
+            }
+        }
+        // Final sanity check - ensure we have valid UUIDs
+        if (!finalProviderId || !finalModelId) {
+            this.logger.warn("Provider or model still invalid after fallback, using defaults", {
+                finalProviderId,
+                finalModelId,
+                defaultProviderId: defaultProvider.id,
+                defaultModelId: defaultModel.id,
+            });
+            finalProviderId = defaultProvider.id;
+            finalModelId = defaultModel.id;
+        }
+        // 11. Build the response with defaults applied
+        const config = {
+            name: generatedConfig.name,
+            description: generatedConfig.description,
+            instructions: generatedConfig.instructions,
+            tools: generatedConfig.tools,
+            modelId: finalModelId,
+            providerId: finalProviderId,
+            temperature: (_d = generatedConfig.temperature) !== null && _d !== void 0 ? _d : AGENT_DEFAULTS.TEMPERATURE,
+            maxTokens: (_e = generatedConfig.maxTokens) !== null && _e !== void 0 ? _e : AGENT_DEFAULTS.MAX_TOKENS,
+            responseType: (_f = generatedConfig.responseType) !== null && _f !== void 0 ? _f : AGENT_DEFAULTS.RESPONSE_TYPE,
+            toolChoice: (_g = generatedConfig.toolChoice) !== null && _g !== void 0 ? _g : AGENT_DEFAULTS.TOOL_CHOICE,
+            maxSteps: (_h = generatedConfig.maxSteps) !== null && _h !== void 0 ? _h : AGENT_DEFAULTS.MAX_STEPS,
+            topP: AGENT_DEFAULTS.TOP_P,
+            presencePenalty: AGENT_DEFAULTS.PRESENCE_PENALTY,
+            frequencyPenalty: AGENT_DEFAULTS.FREQUENCY_PENALTY,
+            status: AGENT_DEFAULTS.STATUS,
+        };
+        this.logger.info("Agent configuration generated successfully", {
+            tenantId: validated.tenantId,
+            agentName: config.name,
+            modelId: config.modelId,
+            providerId: config.providerId,
+            toolCount: (_k = (_j = config.tools) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0,
+        });
+        return {
+            config,
+            metadata: {
+                generatedAt: Date.now(),
+                modelUsed: defaultModel.id,
+                providerUsed: defaultProvider.id,
+                promptTokens: (_l = result.usage) === null || _l === void 0 ? void 0 : _l.inputTokens,
+                completionTokens: (_m = result.usage) === null || _m === void 0 ? void 0 : _m.outputTokens,
+            },
+        };
+    }
+    /**
+     * Stream agent configuration generation from natural language description.
+     * Uses AI to analyze the description and stream partial results as they're generated.
+     *
+     * @param params - Parameters including tenantId, userId, and description
+     * @returns StreamObjectResult that can be converted to a Response with toTextStreamResponse()
+     * @throws ValidationError if description is invalid or no default model configured
+     */
+    async streamAgentConfigGeneration(params) {
+        var _a, _b, _c;
+        // 1. Validate input using service-level schema
+        const validated = generateAgentConfigSchema.parse(params);
+        this.logger.info("Starting streaming agent config generation", {
+            tenantId: validated.tenantId,
+            userId: validated.userId,
+            descriptionLength: validated.description.length,
+            fileCount: (_b = (_a = params.files) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+        });
+        // 2. Get available providers and models for context
+        const providers = await this.llmService.getAllProviders(validated.tenantId, {
+            userCredentials: params.userCredentials,
+        });
+        const enabledProviders = providers.filter((p) => p.isEnabled);
+        if (enabledProviders.length === 0) {
+            throw new ValidationError("No enabled LLM providers available");
+        }
+        // 3. Get default model for generation
+        const defaultModelResult = await this.llmService.getBasicAssistantDefault(validated.tenantId, {
+            userCredentials: params.userCredentials,
+        });
+        if (!defaultModelResult) {
+            throw new ValidationError("No default model configured for tenant. Please configure a default model in LLM settings.");
+        }
+        const { provider: defaultProvider, model: defaultModel } = defaultModelResult;
+        // 4. Build context about available options for the AI
+        const providerModelsContext = await Promise.all(enabledProviders.map(async (provider) => {
+            const models = await this.llmService.getModelsByProvider(validated.tenantId, provider.id, {
+                userCredentials: params.userCredentials,
+            });
+            const availableModels = models.filter((m) => m.isAvailable);
+            return {
+                providerId: provider.id,
+                providerName: provider.name,
+                models: availableModels.map((m) => ({
+                    id: m.id,
+                    name: m.name,
+                    contextWindow: m.contextWindow,
+                })),
+            };
+        }));
+        // 5. Build system prompt with context (same as non-streaming version)
+        const availableTools = Object.keys(TOOL_REGISTRY).join(", ");
+        const providerContext = providerModelsContext
+            .filter((p) => p.models.length > 0)
+            .map((p) => `Provider: ${p.providerName} (ID: ${p.providerId})\n` +
+            `Models: ${p.models.map((m) => `${m.name} (ID: ${m.id}, context: ${m.contextWindow})`).join(", ")}`)
+            .join("\n\n");
+        const systemPrompt = `You are an AI assistant that generates optimal agent configurations.
+
+Available LLM Providers and Models:
+${providerContext}
+
+Default Model: ${defaultModel.name} (ID: ${defaultModel.id}) from provider ${defaultProvider.name} (ID: ${defaultProvider.id})
+
+Available Tools: ${availableTools}
+
+Based on the user's description, generate a complete agent configuration with:
+- name: A concise, descriptive name for the agent (2-5 words)
+- description: A brief summary of what the agent does (1-2 sentences)
+- instructions: Detailed system instructions that define the agent's behavior, personality, and capabilities
+- tools: Array of tool names from the available tools list that would be useful for this agent
+- providerId: Choose from available provider IDs (prefer the default if appropriate)
+- modelId: Choose from available model IDs for the selected provider
+- temperature: 0.0-2.0 based on task creativity needs
+- maxTokens: Reasonable limit for expected response lengths
+- responseType: "text", "json", or "markdown" based on expected output format
+- toolChoice: "auto", "required", or "none" based on whether tools should be used
+- maxSteps: Maximum tool use iterations (5-50, default 20)
+
+Guidelines for tool selection:
+- calculator: for mathematical computations
+- getCurrentTime: for time-related tasks
+- stringManipulator: for text processing
+- jsonValidator: for data validation
+- urlParser: for URL/web-related tasks
+- randomNumber: for random generation needs
+- Temperature:
+  * 0.2-0.4 for precise/coding tasks
+  * 0.7 for general tasks (default)
+  * 0.8-1.0 for creative tasks
+- ResponseType:
+  * "text" for general responses
+  * "json" for structured data output
+  * "markdown" for formatted documentation
+- MaxTokens: 4096 is usually appropriate, increase for longer outputs
+- MaxSteps: 20 is default for tool use, increase if complex tool chains needed
+
+Always select valid provider and model IDs from the available options.`;
+        // 6. Get AI SDK provider for generation
+        const aiProvider = this.llmService.getAISDKProvider(defaultProvider, params.userCredentials);
+        const aiModel = aiProvider.languageModel(defaultModel.id);
+        // 7. Build message content with text and optional file attachments
+        const messageContent = [
+            {
+                type: "text",
+                text: `Generate an optimal agent configuration based on this description: "${validated.description}"`,
+            },
+        ];
+        // Add file attachments with guardrails
+        if (validated.files && validated.files.length > 0) {
+            const MAX_FILES = 5;
+            const MAX_TOTAL_SIZE_BYTES = 10 * 1024 * 1024; // 10MB total
+            if (validated.files.length > MAX_FILES) {
+                throw new ValidationError(`Too many files. Maximum ${MAX_FILES} files allowed.`);
+            }
+            let totalSize = 0;
+            for (const file of validated.files) {
+                if ((_c = file.url) === null || _c === void 0 ? void 0 : _c.startsWith("data:")) {
+                    const base64Part = file.url.split(",")[1];
+                    if (base64Part) {
+                        totalSize += Math.ceil((base64Part.length * 3) / 4);
+                    }
+                }
+            }
+            if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+                throw new ValidationError(`Total file size exceeds limit. Maximum ${MAX_TOTAL_SIZE_BYTES / 1024 / 1024}MB allowed.`);
+            }
+            for (const file of validated.files) {
+                if (file.url.startsWith("data:")) {
+                    const matches = file.url.match(/^data:([^;]+);base64,(.+)$/);
+                    if (matches) {
+                        const [, mediaType, base64Data] = matches;
+                        messageContent.push({
+                            type: "file",
+                            data: base64Data,
+                            mediaType: mediaType,
+                        });
+                    }
+                }
+            }
+        }
+        // 8. Create the stream using streamObject and return the result directly
+        // The AI SDK's streamObject returns helpers for creating responses
+        const result = streamObject({
+            model: aiModel,
+            schema: aiGeneratedConfigSchema,
+            system: systemPrompt,
+            messages: [{ role: "user", content: messageContent }],
+            temperature: 0.4,
+        });
+        this.logger.info("Started streaming agent config generation", {
+            tenantId: validated.tenantId,
+        });
+        // Return the streamObject result - caller can use toTextStreamResponse()
+        return result;
+    }
+    /**
+     * Type guard to check if value is a Record<string, unknown>
+     * @private
+     */
+    isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    /**
+     * Get tools from tool names array
+     * @private
+     */
+    getTools(toolNames) {
+        if (!toolNames || toolNames.length === 0)
+            return undefined;
+        return getToolsByNames(toolNames);
+    }
+    /**
+     * Create ToolLoopAgent from agent configuration
+     * @private
+     */
+    async createToolLoopAgent(agent, params) {
+        var _a, _b, _c;
+        // Get provider and model from database
+        const provider = await this.llmService.getProviderById(params.tenantId, agent.providerId, {
+            userCredentials: params.userCredentials,
+        });
+        if (!provider) {
+            throw new NotFoundError(`Provider with ID ${agent.providerId} not found`);
+        }
+        const model = await this.llmService.getModel(params.tenantId, agent.providerId, agent.modelId, {
+            userCredentials: params.userCredentials,
+        });
+        if (!model) {
+            throw new NotFoundError(`Model with ID ${agent.modelId} not found`);
+        }
+        // Get AI SDK provider and model
+        const aiProvider = this.llmService.getAISDKProvider(provider, params.userCredentials);
+        const aiModel = aiProvider.languageModel(model.id);
+        // Get tools from tool names
+        const tools = this.getTools(agent.tools);
+        // Prepare valid toolChoice value
+        const toolChoice = agent.toolChoice === "auto" || agent.toolChoice === "required" || agent.toolChoice === "none"
+            ? agent.toolChoice
+            : undefined;
+        // Prepare instructions based on response type
+        let enhancedInstructions = agent.instructions;
+        if (agent.responseType === "json") {
+            enhancedInstructions = `${agent.instructions}
+
+IMPORTANT: Always respond with valid JSON format. Your response should be parseable JSON.`;
+        }
+        else if (agent.responseType === "markdown") {
+            enhancedInstructions = `${agent.instructions}
+
+IMPORTANT: Format your responses using Markdown syntax for better readability (headings, lists, code blocks, etc.).`;
+        }
+        else if (agent.responseType === "text") {
+            enhancedInstructions = `${agent.instructions}
+
+IMPORTANT: Respond with text only. Do not include any code or other formatting.`;
+        }
+        // Create ToolLoopAgent
+        // Convert null to undefined for AI SDK compatibility
+        return new ToolLoopAgent({
+            model: aiModel,
+            instructions: enhancedInstructions,
+            tools,
+            stopWhen: stepCountIs(agent.maxSteps || 20),
+            toolChoice,
+            temperature: (_a = agent.temperature) !== null && _a !== void 0 ? _a : undefined,
+            maxOutputTokens: (_b = agent.maxTokens) !== null && _b !== void 0 ? _b : undefined,
+            topP: (_c = agent.topP) !== null && _c !== void 0 ? _c : undefined,
+        });
+    }
+}
+/**
+ * Singleton instance of AgentsService
+ */
+let agentsServiceInstance = null;
+/**
+ * Get or create the singleton AgentsService instance
+ */
+export function getAgentsService(deps) {
+    // If a user-specific logger is provided, create a new instance
+    if (deps === null || deps === void 0 ? void 0 : deps.logger) {
+        return new AgentsService(deps);
+    }
+    // Otherwise use singleton with system logger
+    if (!agentsServiceInstance) {
+        agentsServiceInstance = new AgentsService({
+            logger: LoggerFactory.createLogger({
+                serviceName: "AgentsService",
+                userContext: {
+                    userId: "system",
+                    email: "system@captify.com",
+                    name: "System Service Account",
+                    roles: ["service"],
+                    metadata: {
+                        isSystemUser: true,
+                        note: "Service-level logger - user context should be provided by caller",
+                    },
+                },
+            }),
+            db: deps === null || deps === void 0 ? void 0 : deps.db,
+            llmService: deps === null || deps === void 0 ? void 0 : deps.llmService,
+        });
+    }
+    return agentsServiceInstance;
+}
+//# sourceMappingURL=service.js.map