captify 0.1.18 → 1.1.0

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

@@ -1,15 +1,18 @@
-import { convertToModelMessages, generateObject, streamObject, stepCountIs, ToolLoopAgent, validateUIMessages, } from "ai";
-import { TABLES } from "../../shared/shared.constants";
-import { AGENT_DEFAULTS, buildAgentSK, buildTenantPK } from "../agents.constants";
-import { agentIdentifierSchema, aiGeneratedConfigSchema, createAgentSchema, deleteAgentSchema, generateAgentConfigSchema, generateTextSchema, getAgentSchema, listAgentsSchema, updateAgentSchema, } from "../agents.schemas";
-import { getToolsByNames, TOOL_REGISTRY } from "./agent-tools";
-import { DynamoDbInstances } from "../../shared/services/dynamodb";
-import { UpdateExpressionBuilder } from "../../shared/services/dynamodb";
+import { AGENT_DEFAULTS } from "../agents.constants";
+import { agentIdentifierSchema, aiGeneratedConfigSchema, createAgentSchema, deleteAgentSchema, generateAgentConfigSchema, getAgentSchema, listAgentsSchema, updateAgentSchema, } from "../agents.schemas";
+import { TOOL_DEFINITIONS, getToolsByNames } from "./agent-tools";
+import { agentKeys } from "../../db/schemas";
+import { THINKING_BUDGET } from "../../llm-providers/llm-providers.constants";
 import { getLLMService } from "../../llm-providers/services";
-import { LoggerFactory } from "../../shared/services/logger";
+import { getUsageTrackingService } from "../../model-budget/services";
 import { NotFoundError, ValidationError } from "../../shared/services";
 import { BaseAwsService } from "../../shared/services/base-aws-service";
+import { DynamoDbInstances } from "../../shared/services/dynamodb";
+import { LoggerFactory } from "../../shared/services/logger";
+import { TABLES, USER_CONTEXT_WITH_METADATA } from "../../shared/shared.constants";
 import { sanitizeMessagesForBedrock } from "../../shared/utilities/file";
+import { normalizeToolParts, sanitizeToolPartsForBedrock, sanitizeUnpairedToolCalls, stripReasoningFromMessages, } from "../../shared/utilities/messages";
+import { ToolLoopAgent, convertToModelMessages, generateObject, stepCountIs, streamObject, validateUIMessages, } from "ai";
 /**
  * Service for managing AI Agents and their configurations.
  * Provides CRUD operations and AI chat capabilities using Vercel AI SDK.
@@ -29,14 +32,12 @@ export class AgentsService extends BaseAwsService {
         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#",
+        const { items: agents } = await this.db.queryTyped({
+            keyCondition: {
+                PK: agentKeys.pk(validated.tenantId),
+                SK: { beginsWith: "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,
@@ -56,8 +57,8 @@ export class AgentsService extends BaseAwsService {
             agentId: validated.agentId,
         });
         const { Item } = await this.db.getItem({
-            PK: buildTenantPK(validated.tenantId),
-            SK: buildAgentSK(validated.agentId),
+            PK: agentKeys.pk(validated.tenantId),
+            SK: agentKeys.sk(validated.agentId),
         }, { userCredentials: params.userCredentials });
         if (!Item) {
             this.logger.warn("Agent not found", {
@@ -103,6 +104,7 @@ export class AgentsService extends BaseAwsService {
         const newAgent = {
             id,
             tenantId: validated.tenantId,
+            createdById: validated.createdById,
             name: validated.name,
             description: validated.description,
             instructions: validated.instructions,
@@ -121,7 +123,7 @@ export class AgentsService extends BaseAwsService {
             createdAt: now,
             updatedAt: now,
         };
-        await this.db.putItem(Object.assign({ PK: buildTenantPK(validated.tenantId), SK: buildAgentSK(id) }, newAgent), { userCredentials: params.userCredentials });
+        await this.db.putItem(Object.assign({ PK: agentKeys.pk(validated.tenantId), SK: agentKeys.sk(id) }, newAgent), { userCredentials: params.userCredentials });
         this.logger.info("Agent created successfully", {
             tenantId: validated.tenantId,
             agentId: id,
@@ -169,11 +171,12 @@ export class AgentsService extends BaseAwsService {
                 throw new ValidationError(`Model ${model.name} is not available`);
             }
         }
-        // Build update expression
-        const updateBuilder = new UpdateExpressionBuilder();
+        // Build update expression (type-safe field names)
+        const updateBuilder = this.db.createUpdateBuilder();
         const now = Date.now();
         updateBuilder
             .set("updatedAt", now)
+            .set("modifiedById", params.modifiedById)
             .setOptional("name", validated.name)
             .setOptional("description", validated.description)
             .setOptional("instructions", validated.instructions)
@@ -191,14 +194,17 @@ export class AgentsService extends BaseAwsService {
             .setOptional("status", validated.status);
         const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = updateBuilder.build();
         const { Attributes } = await this.db.updateItem({
-            PK: buildTenantPK(validated.tenantId),
-            SK: buildAgentSK(validated.agentId),
+            PK: agentKeys.pk(validated.tenantId),
+            SK: agentKeys.sk(validated.agentId),
         }, UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues, { userCredentials: params.userCredentials });
         this.logger.info("Agent updated successfully", {
             tenantId: validated.tenantId,
             agentId: validated.agentId,
         });
-        return Attributes;
+        if (Attributes) {
+            return Attributes;
+        }
+        throw new NotFoundError(`Agent with ID ${validated.agentId} not found`);
     }
     /**
      * Delete an agent
@@ -227,8 +233,8 @@ export class AgentsService extends BaseAwsService {
             return;
         }
         await this.db.deleteItem({
-            PK: buildTenantPK(validated.tenantId),
-            SK: buildAgentSK(validated.agentId),
+            PK: agentKeys.pk(validated.tenantId),
+            SK: agentKeys.sk(validated.agentId),
         }, { userCredentials: params.userCredentials });
         this.logger.info("Agent deleted successfully", {
             tenantId: validated.tenantId,
@@ -264,27 +270,53 @@ export class AgentsService extends BaseAwsService {
         if (agent.status !== "active") {
             throw new ValidationError(`Agent ${agent.name} is not active. Current status: ${agent.status}`);
         }
+        // Check budget and rate limits before proceeding
+        const usageTracker = getUsageTrackingService();
+        const userCredentials = params.userCredentials;
+        const trackingParams = {
+            tenantId: identifiers.tenantId,
+            providerId: agent.providerId,
+            modelId: agent.modelId,
+            userCredentials,
+        };
+        await usageTracker.checkLimitsOrThrow(trackingParams);
         // Create ToolLoopAgent with agent configuration
-        const { toolLoopAgent, providerType } = await this.createToolLoopAgent(agent, {
+        const { toolLoopAgent, providerType, model } = await this.createToolLoopAgent(agent, {
             tenantId: identifiers.tenantId,
+            userId: params.userId,
             userCredentials: params.userCredentials,
         });
         this.logger.info("Starting stream with ToolLoopAgent", {
             agentId: identifiers.agentId,
             agentName: agent.name,
+            userId: params.userId,
             messageCount: params.messages.length,
             maxSteps: agent.maxSteps,
             toolChoice: agent.toolChoice,
         });
-        // Bedrock has strict filename requirements for document attachments
-        // Sanitize filenames before converting to model messages
-        const messagesToConvert = providerType === "bedrock" ? sanitizeMessagesForBedrock(params.messages) : params.messages;
+        // Strip reasoning content from input messages
+        // Reasoning is model output (internal thought process) and should never be sent back as input
+        // Models don't need their previous reasoning, and non-thinking models will reject it
+        let messagesToProcess = stripReasoningFromMessages(params.messages);
+        // Sanitize any incomplete tool calls from history to prevent validation errors
+        messagesToProcess = sanitizeUnpairedToolCalls(messagesToProcess);
+        // Normalize tool parts to standard AI SDK toolInvocations
+        // This ensures that sanitized error states (and other tool parts) are correctly
+        // converted to model messages with proper result blocks
+        messagesToProcess = normalizeToolParts(messagesToProcess);
+        // Bedrock has strict requirements for messages
+        if (providerType === "bedrock") {
+            // Sanitize filenames for document attachments
+            messagesToProcess = sanitizeMessagesForBedrock(messagesToProcess);
+            // Ensure tool inputs are never null (Bedrock validation requirement)
+            messagesToProcess = sanitizeToolPartsForBedrock(messagesToProcess);
+        }
         // Validate and convert messages for the agent
         const validatedMessages = await validateUIMessages({
-            messages: messagesToConvert,
+            messages: messagesToProcess,
             tools: toolLoopAgent.tools,
         });
-        const modelMessages = convertToModelMessages(validatedMessages, {
+        const modelMessages = await convertToModelMessages(validatedMessages, {
             tools: toolLoopAgent.tools,
         });
         // Stream from the agent - this gives us access to totalUsage
@@ -296,104 +328,31 @@ export class AgentsService extends BaseAwsService {
         // Convert to UI message stream response with onFinish that includes usage
         return streamResult.toUIMessageStreamResponse({
             originalMessages: params.messages,
-            onFinish: params.onFinish
-                ? async ({ responseMessage, isAborted }) => {
-                    var _a, _b, _c, _d;
-                    // Await the total usage from the stream result
-                    const totalUsage = await streamResult.totalUsage;
-                    await ((_a = params.onFinish) === null || _a === void 0 ? void 0 : _a.call(params, {
-                        responseMessage,
-                        isAborted,
-                        usage: {
-                            promptTokens: (_b = totalUsage.inputTokens) !== null && _b !== void 0 ? _b : 0,
-                            completionTokens: (_c = totalUsage.outputTokens) !== null && _c !== void 0 ? _c : 0,
-                            totalTokens: (_d = totalUsage.totalTokens) !== null && _d !== void 0 ? _d : 0,
-                        },
-                    }));
-                }
-                : undefined,
-        });
-    }
-    /**
-     * 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
-        // Note: generateText only uses string prompts, no file attachments to sanitize for Bedrock
-        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,
-                        });
-                    }
+            sendReasoning: true,
+            onFinish: async ({ responseMessage, isAborted }) => {
+                var _a, _b, _c, _d;
+                // Await the total usage from the stream result
+                const totalUsage = await streamResult.totalUsage;
+                const inputTokens = (_a = totalUsage.inputTokens) !== null && _a !== void 0 ? _a : 0;
+                const outputTokens = (_b = totalUsage.outputTokens) !== null && _b !== void 0 ? _b : 0;
+                const totalTokens = (_c = totalUsage.totalTokens) !== null && _c !== void 0 ? _c : 0;
+                // Record usage for budget/rate limit tracking
+                // Record even if aborted - input tokens are still charged by providers
+                if (model) {
+                    await usageTracker.recordUsage(trackingParams, model, totalUsage);
                 }
-            }
-        }
-        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,
+                // Call the original onFinish if provided (uses AgentStreamUsage format)
+                await ((_d = params.onFinish) === null || _d === void 0 ? void 0 : _d.call(params, {
+                    responseMessage,
+                    isAborted,
+                    usage: {
+                        promptTokens: inputTokens,
+                        completionTokens: outputTokens,
+                        totalTokens,
+                    },
+                }));
+            },
         });
-        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.
@@ -421,12 +380,12 @@ export class AgentsService extends BaseAwsService {
         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, {
+        // 3. Get default model for generation (uses fallback if no default configured)
+        const defaultModelResult = await this.llmService.getEffectiveBasicAssistantModel(validated.tenantId, {
             userCredentials: params.userCredentials,
         });
         if (!defaultModelResult) {
-            throw new ValidationError("No default model configured for tenant. Please configure a default model in LLM settings.");
+            throw new ValidationError("No available models found. Please configure at least one enabled provider with an available model.");
         }
         const { provider: defaultProvider, model: defaultModel } = defaultModelResult;
         // 4. Build context about available options for the AI
@@ -442,9 +401,9 @@ export class AgentsService extends BaseAwsService {
             };
         }));
         // Build tool descriptions for the AI
-        const toolDescriptions = Object.entries(TOOL_REGISTRY).map(([name, toolDef]) => ({
+        const toolDescriptions = Object.entries(TOOL_DEFINITIONS).map(([name, def]) => ({
             name,
-            description: toolDef.description || `Tool: ${name}`,
+            description: def.description,
         }));
         // 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.
@@ -491,8 +450,9 @@ Guidelines for Configuration:
 
 Always select valid provider and model IDs from the available options.`;
         // 6. Get AI SDK provider for generation
+        // Use model.modelId (actual model identifier) for AI SDK, not model.id (UUID)
         const aiProvider = this.llmService.getAISDKProvider(defaultProvider, params.userCredentials);
-        const aiModel = aiProvider.languageModel(defaultModel.id);
+        const aiModel = aiProvider.languageModel(defaultModel.modelId);
         // 8. Build message content with text and optional file attachments
         const messageContent = [
             {
@@ -565,22 +525,47 @@ Always select valid provider and model IDs from the available options.`;
                 }
             }
         }
-        // 9. Call AI with structured output
+        // 9. Check budget and rate limits before proceeding
+        const usageTracker = getUsageTrackingService();
+        const trackingParams = {
+            tenantId: validated.tenantId,
+            providerId: defaultProvider.id,
+            modelId: defaultModel.id,
+            userCredentials: params.userCredentials,
+        };
+        await usageTracker.checkLimitsOrThrow(trackingParams);
+        // 10. 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
-        });
+        let result;
+        try {
+            result = await generateObject({
+                model: aiModel,
+                schema: aiGeneratedConfigSchema,
+                system: systemPrompt,
+                messages: [{ role: "user", content: messageContent }],
+                temperature: 0.4, // Lower temperature for more consistent configs
+            });
+            // Record usage for budget/rate limit tracking
+            if (result.usage) {
+                await usageTracker.recordUsage(trackingParams, defaultModel, result.usage);
+            }
+        }
+        catch (error) {
+            // Try to extract and record usage from error if available
+            if (error && typeof error === "object" && "usage" in error) {
+                if (error.usage) {
+                    await usageTracker.recordUsage(trackingParams, defaultModel, error.usage);
+                }
+            }
+            throw error;
+        }
         const generatedConfig = result.object;
-        // 10. Validate and fix provider/model - always ensure valid values
+        // 11. 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);
@@ -616,7 +601,7 @@ Always select valid provider and model IDs from the available options.`;
             finalProviderId = defaultProvider.id;
             finalModelId = defaultModel.id;
         }
-        // 11. Build the response with defaults applied
+        // 12. Build the response with defaults applied
         const config = {
             name: generatedConfig.name,
             description: generatedConfig.description,
@@ -678,12 +663,12 @@ Always select valid provider and model IDs from the available options.`;
         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, {
+        // 3. Get default model for generation (uses fallback if no default configured)
+        const defaultModelResult = await this.llmService.getEffectiveBasicAssistantModel(validated.tenantId, {
             userCredentials: params.userCredentials,
         });
         if (!defaultModelResult) {
-            throw new ValidationError("No default model configured for tenant. Please configure a default model in LLM settings.");
+            throw new ValidationError("No available models found. Please configure at least one enabled provider with an available model.");
         }
         const { provider: defaultProvider, model: defaultModel } = defaultModelResult;
         // 4. Build context about available options for the AI
@@ -703,7 +688,7 @@ Always select valid provider and model IDs from the available options.`;
             };
         }));
         // 5. Build system prompt with context (same as non-streaming version)
-        const availableTools = Object.keys(TOOL_REGISTRY).join(", ");
+        const availableTools = Object.keys(TOOL_DEFINITIONS).join(", ");
         const providerContext = providerModelsContext
             .filter((p) => p.models.length > 0)
             .map((p) => `Provider: ${p.providerName} (ID: ${p.providerId})\n` +
@@ -751,8 +736,9 @@ Guidelines for tool selection:
 
 Always select valid provider and model IDs from the available options.`;
         // 6. Get AI SDK provider for generation
+        // Use model.modelId (actual model identifier) for AI SDK, not model.id (UUID)
         const aiProvider = this.llmService.getAISDKProvider(defaultProvider, params.userCredentials);
-        const aiModel = aiProvider.languageModel(defaultModel.id);
+        const aiModel = aiProvider.languageModel(defaultModel.modelId);
         // 7. Build message content with text and optional file attachments
         const messageContent = [
             {
@@ -793,7 +779,16 @@ Always select valid provider and model IDs from the available options.`;
                 }
             }
         }
-        // 8. Create the stream using streamObject and return the result directly
+        // 8. Check budget and rate limits before proceeding
+        const usageTracker = getUsageTrackingService();
+        const trackingParams = {
+            tenantId: validated.tenantId,
+            providerId: defaultProvider.id,
+            modelId: defaultModel.id,
+            userCredentials: params.userCredentials,
+        };
+        await usageTracker.checkLimitsOrThrow(trackingParams);
+        // 9. 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,
@@ -805,6 +800,8 @@ Always select valid provider and model IDs from the available options.`;
         this.logger.info("Started streaming agent config generation", {
             tenantId: validated.tenantId,
         });
+        // Record usage after stream completes (fire-and-forget)
+        usageTracker.recordStreamUsage(trackingParams, defaultModel, result.usage);
         // Return the streamObject result - caller can use toTextStreamResponse()
         return result;
     }
@@ -816,13 +813,13 @@ Always select valid provider and model IDs from the available options.`;
         return typeof value === "object" && value !== null && !Array.isArray(value);
     }
     /**
-     * Get tools from tool names array
+     * Get tools from tool names array with user context
      * @private
      */
-    getTools(toolNames) {
+    getTools(toolNames, context) {
         if (!toolNames || toolNames.length === 0)
             return undefined;
-        return getToolsByNames(toolNames);
+        return getToolsByNames(toolNames, context);
     }
     /**
      * Create ToolLoopAgent from agent configuration
@@ -844,31 +841,83 @@ Always select valid provider and model IDs from the available options.`;
             throw new NotFoundError(`Model with ID ${agent.modelId} not found`);
         }
         // Get AI SDK provider and model
+        // Use model.modelId (actual model identifier like "gpt-4") for the AI SDK, not model.id (UUID)
         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);
+        const aiModel = aiProvider.languageModel(model.modelId);
+        // Get tools from tool names with user context for context-aware tools
+        const toolContext = {
+            tenantId: params.tenantId,
+            userId: params.userId,
+            userCredentials: params.userCredentials,
+        };
+        const tools = this.getTools(agent.tools, toolContext);
         // Prepare valid toolChoice value
         const toolChoice = agent.toolChoice === "auto" || agent.toolChoice === "required" || agent.toolChoice === "none"
             ? agent.toolChoice
             : undefined;
-        // Prepare instructions based on response type
+        // Prepare instructions based on response type and tool availability
         let enhancedInstructions = agent.instructions;
+        // Add tool usage guidance if agent has tools
+        if (tools && Object.keys(tools).length > 0) {
+            enhancedInstructions = `${enhancedInstructions}
+
+TOOL USAGE INSTRUCTIONS:
+- You have access to tools that can help you answer questions.
+- When using tools, call them directly WITHOUT announcing what you're about to do.
+- AFTER receiving tool results, you MUST provide a final response that summarizes and interprets the results for the user.
+- Never leave the user without a final answer after tool calls complete.
+- Present information in a clear, user-friendly way - never show raw tool output.`;
+            // Add chart-specific guidance if chart tool is available
+            if (tools["chart"]) {
+                enhancedInstructions = `${enhancedInstructions}
+
+CHART TOOL INSTRUCTIONS:
+When users provide data (tables, lists, CSV, or ask for visualizations), use the chart tool:
+1. Parse the data into an array of objects with consistent keys
+2. Choose the appropriate chart type:
+   - "line" for time series, trends, continuous data
+   - "bar" for categorical comparisons, rankings
+   - "pie" for proportions, part-to-whole relationships
+3. Call the chart tool with:
+   - chartSpec: { type, title, xKey (category field), yKeys (numeric fields) }
+   - data: array of objects with the parsed data
+Example: For "Month | Revenue" data, use xKey="month", yKeys=["revenue"]`;
+            }
+        }
+        // Add response format guidance
         if (agent.responseType === "json") {
-            enhancedInstructions = `${agent.instructions}
+            enhancedInstructions = `${enhancedInstructions}
 
 IMPORTANT: Always respond with valid JSON format. Your response should be parseable JSON.`;
         }
         else if (agent.responseType === "markdown") {
-            enhancedInstructions = `${agent.instructions}
+            enhancedInstructions = `${enhancedInstructions}
 
 IMPORTANT: Format your responses using Markdown syntax for better readability (headings, lists, code blocks, etc.).`;
         }
         else if (agent.responseType === "text") {
-            enhancedInstructions = `${agent.instructions}
+            enhancedInstructions = `${enhancedInstructions}
 
 IMPORTANT: Respond with text only. Do not include any code or other formatting.`;
         }
+        // Calculate thinking budget for models with thinking capability
+        let thinkingBudgetTokens = 0;
+        if (provider.type === "bedrock" && model.capabilities.includes("thinking")) {
+            thinkingBudgetTokens = (_a = model.thinkingBudgetTokens) !== null && _a !== void 0 ? _a : THINKING_BUDGET.DEFAULT_TOKENS;
+            // Validate thinking budget doesn't exceed max output tokens
+            if (model.maxOutputTokens <= thinkingBudgetTokens) {
+                this.logger.warn("Thinking budget exceeds max output tokens, disabling thinking", {
+                    modelId: model.modelId,
+                    maxOutputTokens: model.maxOutputTokens,
+                    thinkingBudgetTokens,
+                });
+                thinkingBudgetTokens = 0;
+            }
+        }
+        // Adjust max output tokens to account for thinking budget
+        const effectiveMaxTokens = agent.maxTokens
+            ? agent.maxTokens - thinkingBudgetTokens
+            : model.maxOutputTokens - thinkingBudgetTokens;
         // Create ToolLoopAgent
         // Convert null to undefined for AI SDK compatibility
         const toolLoopAgent = new ToolLoopAgent({
@@ -877,11 +926,22 @@ IMPORTANT: Respond with text only. Do not include any code or other formatting.`
             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,
+            temperature: (_b = agent.temperature) !== null && _b !== void 0 ? _b : undefined,
+            maxOutputTokens: effectiveMaxTokens > 0 ? effectiveMaxTokens : undefined,
             topP: (_c = agent.topP) !== null && _c !== void 0 ? _c : undefined,
+            // Enable thinking/reasoning for Bedrock models with thinking capability
+            providerOptions: provider.type === "bedrock" && thinkingBudgetTokens > 0
+                ? {
+                    bedrock: {
+                        reasoningConfig: {
+                            type: "enabled",
+                            budgetTokens: thinkingBudgetTokens,
+                        },
+                    },
+                }
+                : undefined,
         });
-        return { toolLoopAgent, providerType: provider.type };
+        return { toolLoopAgent, providerType: provider.type, model };
     }
 }
 /**
@@ -901,16 +961,7 @@ export function getAgentsService(deps) {
         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",
-                    },
-                },
+                userContext: USER_CONTEXT_WITH_METADATA,
             }),
             db: deps === null || deps === void 0 ? void 0 : deps.db,
             llmService: deps === null || deps === void 0 ? void 0 : deps.llmService,