captify 0.1.15 → 0.1.18

package/dist/services/agents/services/agents.service.js

@@ -1,700 +0,0 @@
-import { createAgentUIStreamResponse, generateObject, stepCountIs, ToolLoopAgent } from "ai";
-import { z } from "zod";
-import { TABLES } from "../../../constants/tables";
-import { AGENT_DEFAULTS, buildAgentSK, buildTenantPK } from "../constants";
-import { agentIdentifierSchema, createAgentSchema, deleteAgentSchema, generateAgentConfigSchema, generateTextSchema, getAgentSchema, listAgentsSchema, updateAgentSchema, } from "../schemas";
-import { getToolsByNames, TOOL_REGISTRY } from "../tools";
-import { DynamoDbInstances } from "../../dynamodb/services/dynamodb.singleton";
-import { UpdateExpressionBuilder } from "../../dynamodb/utilities";
-import { getLLMService } from "../../llm";
-import { LoggerFactory } from "../../logger";
-import { NotFoundError, ValidationError } from "../../shared/errors";
-import { BaseAwsService } from "../../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;
-        // 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}`,
-        }));
-        const validToolNames = Object.keys(TOOL_REGISTRY);
-        // 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. Define the output schema for structured generation
-        const agentConfigSchema = z.object({
-            name: z.string().min(1).max(100).describe("Agent display name"),
-            description: z.string().max(500).optional().describe("Brief description of agent purpose"),
-            instructions: z.string().min(1).max(10000).describe("System prompt defining agent behavior"),
-            tools: z
-                .array(z.enum(validToolNames))
-                .optional()
-                .describe("Selected tools for the agent"),
-            modelId: z.string().min(1).describe("Selected model ID from available models - MUST be a valid ID from the list"),
-            providerId: z.string().min(1).describe("Selected provider ID from available providers - MUST be a valid UUID from the list"),
-            temperature: z.number().min(0).max(2).optional().describe("Temperature setting 0-2"),
-            maxTokens: z.number().int().min(1).max(100000).optional().describe("Max output tokens"),
-            responseType: z
-                .enum(["text", "json", "markdown"])
-                .optional()
-                .describe("Response format type"),
-            toolChoice: z
-                .enum(["auto", "required", "none"])
-                .optional()
-                .describe("Tool usage strategy"),
-            maxSteps: z.number().int().min(1).max(50).optional().describe("Max tool loop steps"),
-        });
-        // 7. 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 (params.files && params.files.length > 0) {
-            for (const file of params.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,
-                        });
-                    }
-                }
-            }
-        }
-        // 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: agentConfigSchema,
-            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: (_c = generatedConfig.temperature) !== null && _c !== void 0 ? _c : AGENT_DEFAULTS.TEMPERATURE,
-            maxTokens: (_d = generatedConfig.maxTokens) !== null && _d !== void 0 ? _d : AGENT_DEFAULTS.MAX_TOKENS,
-            responseType: (_e = generatedConfig.responseType) !== null && _e !== void 0 ? _e : AGENT_DEFAULTS.RESPONSE_TYPE,
-            toolChoice: (_f = generatedConfig.toolChoice) !== null && _f !== void 0 ? _f : AGENT_DEFAULTS.TOOL_CHOICE,
-            maxSteps: (_g = generatedConfig.maxSteps) !== null && _g !== void 0 ? _g : 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: (_j = (_h = config.tools) === null || _h === void 0 ? void 0 : _h.length) !== null && _j !== void 0 ? _j : 0,
-        });
-        return {
-            config,
-            metadata: {
-                generatedAt: Date.now(),
-                modelUsed: defaultModel.id,
-                providerUsed: defaultProvider.id,
-                promptTokens: (_k = result.usage) === null || _k === void 0 ? void 0 : _k.inputTokens,
-                completionTokens: (_l = result.usage) === null || _l === void 0 ? void 0 : _l.outputTokens,
-            },
-        };
-    }
-    /**
-     * 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) {
-        // 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
-        return new ToolLoopAgent({
-            model: aiModel,
-            instructions: enhancedInstructions,
-            tools,
-            stopWhen: stepCountIs(agent.maxSteps || 20),
-            toolChoice,
-            temperature: agent.temperature,
-            maxOutputTokens: agent.maxTokens,
-            topP: agent.topP,
-        });
-    }
-}
-/**
- * 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=agents.service.js.map