langmart-gateway-type3 3.0.45 → 3.0.47

package/dist/marketplace-tools.js

@@ -0,0 +1,3089 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketplaceTools = void 0;
+const debug_utils_1 = require("./debug-utils");
+/**
+ * Marketplace Tools - Built-in MCP Tools for LangMart Self-Hosted Gateway CLI
+ *
+ * Provides AI assistant with tools to manage marketplace connections,
+ * providers, and models through natural language conversation.
+ *
+ * These tools call LangMart Marketplace API endpoints.
+ */
+const axios_1 = __importDefault(require("axios"));
+class MarketplaceTools {
+    constructor(marketplaceUrl, apiKey, managementUrl = 'http://localhost:8083', keyVault) {
+        this.connectionMap = new Map(); // sequence number → UUID mapping
+        this.providerMap = new Map(); // sequence number → UUID mapping
+        this.marketplaceUrl = marketplaceUrl;
+        this.apiKey = apiKey;
+        this.managementUrl = managementUrl;
+        this.keyVault = keyVault;
+        this.client = axios_1.default.create({
+            baseURL: marketplaceUrl,
+            timeout: 30000,
+            maxRedirects: 0, // Don't follow redirects
+            validateStatus: (status) => status < 500, // Accept any non-5xx response
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        (0, debug_utils_1.debugLog)(`[MarketplaceTools] Initialized with baseURL: ${marketplaceUrl}`);
+    }
+    static getInstance(marketplaceUrl, apiKey, managementUrl, keyVault) {
+        if (!MarketplaceTools.instance && marketplaceUrl && apiKey && keyVault) {
+            MarketplaceTools.instance = new MarketplaceTools(marketplaceUrl, apiKey, managementUrl || 'http://localhost:8083', keyVault);
+        }
+        if (!MarketplaceTools.instance) {
+            throw new Error('MarketplaceTools not initialized. Provide marketplaceUrl, apiKey, and keyVault.');
+        }
+        return MarketplaceTools.instance;
+    }
+    /**
+     * Get tool definitions for AI
+     */
+    getTools() {
+        return [
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_list',
+                    description: 'List all user connections from the marketplace. Shows provider, endpoint type, gateway type (Managed/Self-hosted), and status for each connection. Connections are numbered [1], [2], [3], etc. in order of creation. No parameters required - call this tool directly when user asks to list, show, or see connections. You can use the connection numbers in subsequent tool calls (e.g., marketplace_connections_test with connection_id "1").',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_add',
+                    description: 'Add a new connection to the marketplace. Creates a connection to an LLM provider (OpenAI, Anthropic, Groq, Ollama, etc.) with specified API key and gateway type. The endpoint_type (protocol translator) is automatically determined from the provider - do NOT ask the user for it. Ask the user for: display name, provider name (must match a provider from marketplace_providers_list), API key, endpoint URL, and gateway type. Marketplace-Managed Compute (Type 2): marketplace stores encrypted API keys and manages gateway - convenient but requires trust. Provider API must be accessible from marketplace network (cloud). Self-Hosted Compute (Type 3): you run local gateway and store API keys in local vault - full control over credentials. Provider API must be accessible from YOUR network (can access localhost/private IPs). Both types work with ANY provider. IMPORTANT: After adding the connection, show the tool result directly to the user with the connection details and ask what they want to do next (test, discover models, update, or remove). DO NOT automatically call marketplace_providers_list or marketplace_models_discover - let the user decide.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Display name for the connection (e.g., "Claude (Anthropic)", "GPT-4 (OpenAI)")'
+                            },
+                            provider_name: {
+                                type: 'string',
+                                description: 'Provider key from marketplace_providers_list: "anthropic", "openai", "groq", "google", "ollama", etc. IMPORTANT: Use marketplace_providers_list first to see available providers and their keys.'
+                            },
+                            endpoint_url: {
+                                type: 'string',
+                                description: 'Provider API endpoint URL (e.g., "https://api.anthropic.com", "https://api.groq.com/openai/v1"). The endpoint_type will be automatically determined from the selected provider.'
+                            },
+                            api_key: {
+                                type: 'string',
+                                description: 'Provider API key for authentication'
+                            },
+                            gateway_type: {
+                                type: 'number',
+                                description: 'Gateway type: 2 (Marketplace-Managed Compute - marketplace stores API keys, provider must be reachable from marketplace network), 3 (Self-Hosted Compute - you store API keys locally, provider must be reachable from YOUR network, can access localhost). Both work with ANY provider (OpenAI, Anthropic, Groq, Ollama, etc.)'
+                            }
+                        },
+                        required: ['name', 'provider_name', 'endpoint_url', 'api_key', 'gateway_type']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_remove',
+                    description: 'Remove a connection from the marketplace (soft delete). IMPORTANT: You can use EITHER a sequence number (1, 2, 3) OR a UUID. If the user says "remove 1" or "remove connection 1", use connection_id: "1" - the tool will automatically resolve it. If the user does not provide any identifier, ask which connection they want to remove.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            connection_id: {
+                                type: 'string',
+                                description: 'Connection identifier - can be EITHER a sequence number from the connections list (e.g., "1", "2", "3") OR a UUID. The tool automatically resolves sequence numbers to UUIDs. Examples: "1" (sequence number) or "b536a9ab-398c-4c81-9d12-f96a12653f26" (UUID).'
+                            }
+                        },
+                        required: ['connection_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_test',
+                    description: 'Test a connection to verify API key and endpoint are working. Works for BOTH Marketplace-Managed Compute and Self-Hosted Compute connections. For Self-Hosted connections, the test is automatically routed to your local gateway instance. IMPORTANT: You can use EITHER a sequence number (1, 2, 3) OR a UUID. If the user says "test 1" or "test connection 1", use connection_id: "1" - the tool will automatically resolve it. If user provides just "test connection" without any number, ask which connection they want to test.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            connection_id: {
+                                type: 'string',
+                                description: 'Connection identifier - can be EITHER a sequence number from the connections list (e.g., "1", "2", "3") OR a UUID. The tool automatically resolves sequence numbers to UUIDs. Examples: "1" (sequence number) or "0238a0c6-0d78-4f40-a08c-b9b797df35d0" (UUID).'
+                            }
+                        },
+                        required: ['connection_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_update_key',
+                    description: 'Update the API key for an existing connection. IMPORTANT: You can use EITHER a sequence number (1, 2, 3) OR a UUID for the connection. If the user says "update key for connection 1", use connection_id: "1" - the tool will automatically resolve it. Always ask the user for the new API key if not provided.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            connection_id: {
+                                type: 'string',
+                                description: 'Connection identifier - can be EITHER a sequence number from the connections list (e.g., "1", "2", "3") OR a UUID. The tool automatically resolves sequence numbers to UUIDs. Examples: "1" (sequence number) or "0238a0c6-0d78-4f40-a08c-b9b797df35d0" (UUID).'
+                            },
+                            api_key: {
+                                type: 'string',
+                                description: 'New API key (e.g., "sk-..." for OpenAI, "gsk_..." for Groq, etc.). You MUST ask the user for this if not provided.'
+                            }
+                        },
+                        required: ['connection_id', 'api_key']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_providers_list',
+                    description: 'List all available LLM providers in the marketplace. Shows provider names, base URLs, and active status. No parameters required - call this tool directly when user asks to list, show, or see available providers. IMPORTANT: After displaying the provider list, ALWAYS ask the user: "Would you like to add a connection to any of these providers?" Explain that they will need: (1) Provider API key from the provider, (2) Display name for the connection, (3) Gateway type: Marketplace-Managed Compute (provider must be internet-accessible from marketplace) or Self-Hosted Compute (provider can be on your local network, including localhost). Then use marketplace_connections_add to create the connection. Wait for user response.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_discover',
+                    description: 'Discover and store models from a provider. Fetches available models from the provider API and adds them to the marketplace. IMPORTANT: This requires detailed provider information. If the user wants to discover models from an existing connection, first call marketplace_connections_list to get the connection details (provider, endpoint_url, endpoint_type, gateway_type), then ask the user for their API key. If user wants to discover from a new provider, ask them for: provider name, API key, endpoint URL, endpoint type, and gateway type (2 for Marketplace-Managed Compute - provider must be internet-accessible, 3 for Self-Hosted Compute - provider can be on local network).',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                description: 'Provider key (e.g., "groq", "openai", "anthropic"). Use marketplace_providers_list to see available providers.'
+                            },
+                            apiKey: {
+                                type: 'string',
+                                description: 'Provider API key (e.g., "sk-..." for OpenAI, "gsk_..." for Groq). You MUST ask the user for this.'
+                            },
+                            gatewayType: {
+                                type: 'number',
+                                description: 'Gateway type: 2 (Marketplace-Managed Compute - provider must be internet-accessible from marketplace), 3 (Self-Hosted Compute - provider can be on local network, localhost accessible). Both work with ANY provider.'
+                            },
+                            endpointUrl: {
+                                type: 'string',
+                                description: 'Provider endpoint URL (e.g., "https://api.groq.com/openai/v1", "https://api.openai.com/v1")'
+                            },
+                            endpointType: {
+                                type: 'string',
+                                description: 'Endpoint type: "openai-v1" for OpenAI-compatible APIs, "anthropic-messages" for Anthropic, "google-gemini" for Google'
+                            }
+                        },
+                        required: ['provider', 'apiKey', 'gatewayType', 'endpointUrl', 'endpointType']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_list',
+                    description: 'List and filter available models for the user with pagination. Shows model names, providers, context windows, pricing, and capabilities. Supports filtering by publication status (public/private), price range, provider, keyword search, capabilities, and context window.\n\n**Filter behavior (same as UI tab filter):**\n- Space-separated keywords use AND condition (all must match)\n- Matches against model_id and model_name\n- Example: "groq llama" matches models containing BOTH "groq" AND "llama"\n\nUse filters when user asks for specific model types (e.g., "cheap models", "vision models", "Groq models", "published models", "private models", "models with 100k+ context"). Pagination defaults to 10 models per page - use offset to get next pages. HELPFUL TIP: After showing models, explain that they can use these models for chat by selecting them with Tab or /model command.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            limit: {
+                                type: 'number',
+                                description: 'Number of models to return per page (default: 10, max: 100). Example: 20 for 20 models per page'
+                            },
+                            offset: {
+                                type: 'number',
+                                description: 'Number of models to skip for pagination (default: 0). Example: 10 for page 2, 20 for page 3, etc.'
+                            },
+                            keyword: {
+                                type: 'string',
+                                description: 'Filter by keyword(s) - SAME LOGIC AS UI TAB FILTER. Matches against model_id and model_name only. Space-separated keywords use AND matching - ALL keywords must match. Case-insensitive, partial match. Examples: "llama" (single keyword), "groq llama" (must match both "groq" AND "llama" in either model_id or model_name), "google flash lite" (must match all three keywords)'
+                            },
+                            access_level: {
+                                type: 'string',
+                                description: 'Filter by publication status. Options: "public" (published models available to all marketplace users), "private" (unpublished models only visible to owner). Omit to see all models (both public and private). Example: use "public" to list only published models.'
+                            },
+                            provider: {
+                                type: 'string',
+                                description: 'Filter by provider name (case-insensitive). Example: "groq", "openai", "anthropic", "google". Use marketplace_providers_list to see available providers.'
+                            },
+                            max_input_price: {
+                                type: 'number',
+                                description: 'Maximum input price per million tokens (USD). Example: 0.5 for models costing at most $0.50/M input tokens'
+                            },
+                            max_output_price: {
+                                type: 'number',
+                                description: 'Maximum output price per million tokens (USD). Example: 1.5 for models costing at most $1.50/M output tokens'
+                            },
+                            min_context_window: {
+                                type: 'number',
+                                description: 'Minimum context window size in tokens. Example: 100000 for models with at least 100k context'
+                            },
+                            has_vision: {
+                                type: 'boolean',
+                                description: 'Filter for models with vision/image understanding capability'
+                            },
+                            has_reasoning: {
+                                type: 'boolean',
+                                description: 'Filter for models with advanced reasoning capability (e.g., o1, o3 series)'
+                            },
+                            has_tool_use: {
+                                type: 'boolean',
+                                description: 'Filter for models with function/tool calling support'
+                            },
+                            has_image_gen: {
+                                type: 'boolean',
+                                description: 'Filter for models that can generate images (e.g., DALL-E)'
+                            },
+                            has_audio: {
+                                type: 'boolean',
+                                description: 'Filter for models with audio processing capability'
+                            },
+                            has_embedding: {
+                                type: 'boolean',
+                                description: 'Filter for embedding models'
+                            },
+                            order_by: {
+                                type: 'string',
+                                description: 'Sort order for results (default: "model_id_asc"). Options: "model_id_asc", "model_id_desc", "model_name_asc", "model_name_desc", "provider_asc", "provider_desc", "context_window_asc", "context_window_desc", "input_price_asc", "input_price_desc", "output_price_asc", "output_price_desc". Example: "input_price_asc" for cheapest first.'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_update_capabilities',
+                    description: 'Update capability flags for a model. Allows setting vision support, reasoning capability, tool/function calling, image generation, video generation, audio processing, and embedding capabilities. Use when user wants to update or configure what their model can do. Each capability is a boolean flag. IMPORTANT: Only the model owner can update capabilities.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            model_id: {
+                                type: 'string',
+                                description: 'Model ID (e.g., "groq/llama-3.3-70b-versatile"). Use marketplace_models_list to get model IDs.'
+                            },
+                            supports_vision: {
+                                type: 'boolean',
+                                description: 'Can the model process and understand images? (multimodal vision input)'
+                            },
+                            supports_reasoning: {
+                                type: 'boolean',
+                                description: 'Does the model have advanced reasoning capabilities? (e.g., o1, o3 series)'
+                            },
+                            supports_tool_use: {
+                                type: 'boolean',
+                                description: 'Does the model support function/tool calling?'
+                            },
+                            supports_image_gen: {
+                                type: 'boolean',
+                                description: 'Can the model generate images? (e.g., DALL-E, Imagen)'
+                            },
+                            supports_video_gen: {
+                                type: 'boolean',
+                                description: 'Can the model generate videos?'
+                            },
+                            supports_audio: {
+                                type: 'boolean',
+                                description: 'Can the model process or generate audio?'
+                            },
+                            supports_embedding: {
+                                type: 'boolean',
+                                description: 'Is the model designed for text embeddings?'
+                            }
+                        },
+                        required: ['model_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_get',
+                    description: 'Get detailed information about a specific model including pricing and capabilities. Returns model name, display name, provider, context window, input/output pricing per million tokens, and all capability flags (vision, reasoning, tool_use, etc.). Use when user asks for details about a specific model, its price, or what it can do.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            model_id: {
+                                type: 'string',
+                                description: 'Model identifier (e.g., "groq/llama-3.3-70b-versatile", "google/gemini-2.5-flash"). Use marketplace_models_list to find available model IDs.'
+                            }
+                        },
+                        required: ['model_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_request_logs_list',
+                    description: 'Query user\'s request logs with pagination and filtering. Shows recent API requests including method, endpoint, status code, model used, IP address, and timestamp. Use this to debug issues, view usage history, or find specific requests. Each log has an x-request-id for tracking. Supports filtering by status code, endpoint path, and model name. Call when user asks to see logs, requests, history, or wants to debug an issue.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            limit: {
+                                type: 'number',
+                                description: 'Number of logs to return (default: 20, max: 100)'
+                            },
+                            offset: {
+                                type: 'number',
+                                description: 'Pagination offset (default: 0)'
+                            },
+                            status: {
+                                type: 'number',
+                                description: 'Filter by HTTP status code (e.g., 200 for success, 400 for bad request, 500 for server error)'
+                            },
+                            endpoint: {
+                                type: 'string',
+                                description: 'Filter by endpoint path (partial match, e.g., "chat/completions", "models")'
+                            },
+                            model: {
+                                type: 'string',
+                                description: 'Filter by model name (partial match, e.g., "gpt-4", "claude", "gemini")'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_request_logs_get',
+                    description: 'Get detailed log entry by ID including full request/response bodies, headers, status codes, and timing information. Useful for debugging specific failed requests. The log ID can be found from request_logs_list or from the x-request-id response header. Sensitive data (API keys, auth tokens) are automatically redacted. Body content is truncated by default for readability - use show_full_body to see complete content.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            log_id: {
+                                type: 'string',
+                                description: 'Log ID (UUID) from request_logs_list or x-request-id header'
+                            },
+                            show_full_body: {
+                                type: 'boolean',
+                                description: 'Show full request/response bodies without truncation (default: false, truncates to 500 chars)'
+                            }
+                        },
+                        required: ['log_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_request_logs_stats',
+                    description: 'Get aggregated statistics about user\'s API usage. Shows total requests, success rate, top models used, top endpoints, and daily request counts. Use this for usage analytics, monitoring, or understanding request patterns. No parameters required.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            start_date: {
+                                type: 'string',
+                                description: 'Start date in ISO 8601 format (default: 30 days ago)'
+                            },
+                            end_date: {
+                                type: 'string',
+                                description: 'End date in ISO 8601 format (default: now)'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_vault_status',
+                    description: 'Get comprehensive vault status showing LocalVault (persistent encrypted storage) and KeyVault (in-memory protection). Returns pre-formatted text with box-drawing characters. IMPORTANT: Display the output exactly as received - do not summarize or reformat. Use when user asks about vault, credentials, or security.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_vault_localvault',
+                    description: 'List all credentials in LocalVault (persistent encrypted storage at ~/.langmart/keystore.enc). Returns pre-formatted text. IMPORTANT: Display output exactly as received - do not summarize. Use when user asks about stored credentials.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_vault_keyvault',
+                    description: 'Show KeyVault status (in-memory chat protection that redacts API keys from LLM messages). Returns pre-formatted text. IMPORTANT: Display output exactly as received. Use when user asks about key protection or redaction.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_quota_manage',
+                    description: 'Set or update sales quota limits for a connection. Quota applies to ALL models under the connection and tracks total consumption (owner usage + published model sales). Daily quota resets at midnight UTC, monthly resets on 1st. When quota exceeded, all models auto-disable. Can enable/disable enforcement. Use connection_id from marketplace_connections_list.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            connection_id: {
+                                type: 'string',
+                                description: 'Connection identifier - can be sequence number (1, 2, 3) or UUID'
+                            },
+                            max_daily_sales_usd: {
+                                type: 'number',
+                                description: 'Maximum daily sales in USD (e.g., 100 for $100/day). Omit or set to null for no daily limit.'
+                            },
+                            max_monthly_sales_usd: {
+                                type: 'number',
+                                description: 'Maximum monthly sales in USD (e.g., 1000 for $1000/month). Omit or set to null for no monthly limit.'
+                            },
+                            quota_enabled: {
+                                type: 'boolean',
+                                description: 'Enable quota enforcement (true = auto-disable models when exceeded, false = track only without disabling)'
+                            }
+                        },
+                        required: ['connection_id', 'quota_enabled']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_quota_get',
+                    description: 'Get current quota status and usage for a specific connection. Shows daily/monthly limits, current consumption, percentage used, quota exceeded status, affected models count, and usage history (last 30 days). Use connection_id from marketplace_connections_list.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            connection_id: {
+                                type: 'string',
+                                description: 'Connection identifier - can be sequence number (1, 2, 3) or UUID'
+                            }
+                        },
+                        required: ['connection_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_connections_quota_list',
+                    description: 'List quota status for all connections owned by the user. Shows quota settings, current usage, and enforcement status for each connection. Useful for getting an overview of quota usage across all provider connections.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_update_pricing',
+                    description: 'Update pricing for one or multiple models using filter-based selection. Supports both single model updates and bulk operations.\n\n**TWO PRICING METHODS:**\n1. Exact Price: Set specific prices with input_tokens_per_1k and output_tokens_per_1k\n2. Percentage Adjustment: Increase/decrease current prices by percentage\n\n**TWO TARGET MODES:**\n1. Single Model: Provide model_id to update one model\n2. Bulk Mode: Provide filter (space-separated keywords) to update multiple models using AND-condition matching\n\n**PERCENTAGE EXAMPLES:**\n- "increase all groq models by 10%" → filter="groq", increase_percentage=10\n- "decrease all llama models by 15%" → filter="llama", decrease_percentage=15\n- "increase my published models by 20%" → filter="", source_access_level="public", increase_percentage=20\n- "increase all image models by 10%" → filter="image", increase_percentage=10\n\n**BULK UPDATE WORKFLOW:**\n- Default (auto_confirm: false): Shows matched models, asks for confirmation\n- With auto_confirm: true: Immediately updates all matched models\n- Use source_access_level to pre-filter by publication status\n\n**ENHANCED FILTER LOGIC:**\n- Space-separated keywords use AND condition (all must match)\n- Matches against model_id, model_name, provider name, AND capabilities\n- Capability keywords: image, vision, tool, reasoning, audio, video, embedding\n- Example: "groq llama" matches models with BOTH keywords\n- Example: "image" matches all models with vision or image generation capability\n- Example: "google tool" matches Google models with tool use capability\n\nOnly model owners can update pricing. Use marketplace_models_list to find model IDs.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            model_id: {
+                                type: 'string',
+                                description: 'Single model UUID from marketplace_models_list (the id field, NOT model_id field). Mutually exclusive with filter. Use for single model updates.'
+                            },
+                            filter: {
+                                type: 'string',
+                                description: 'Space-separated keywords for bulk operation (e.g., "groq", "llama 70b", "gemini flash", "image", "vision", "tool"). Uses AND condition - all keywords must match. Mutually exclusive with model_id. Matches against model_id, model_name, provider name, and capabilities (vision, image, reasoning, tool, audio, video, embedding).'
+                            },
+                            source_access_level: {
+                                type: 'string',
+                                enum: ['public', 'private', 'disabled'],
+                                description: 'Pre-filter models by current publication status before applying keyword filter. Useful for "update pricing for all my published models".'
+                            },
+                            auto_confirm: {
+                                type: 'boolean',
+                                description: 'For bulk operations: false (default) = show matches and ask confirmation, true = immediately update all matches. Recommended: use false first to preview, then true to confirm.'
+                            },
+                            input_tokens_per_1k: {
+                                type: 'number',
+                                description: 'EXACT PRICE MODE: Price per 1000 input tokens in USD (e.g., 0.0001 for $0.0001/1K tokens). Mutually exclusive with percentage adjustments.'
+                            },
+                            output_tokens_per_1k: {
+                                type: 'number',
+                                description: 'EXACT PRICE MODE: Price per 1000 output tokens in USD (e.g., 0.0003 for $0.0003/1K tokens). Mutually exclusive with percentage adjustments.'
+                            },
+                            cached_input_tokens_per_1k: {
+                                type: 'number',
+                                description: 'EXACT PRICE MODE: Optional - Price per 1000 cached input tokens in USD (for models with caching)'
+                            },
+                            reasoning_tokens_per_1k: {
+                                type: 'number',
+                                description: 'EXACT PRICE MODE: Optional - Price per 1000 reasoning tokens in USD (for reasoning models like o1)'
+                            },
+                            increase_percentage: {
+                                type: 'number',
+                                description: 'PERCENTAGE MODE: Increase current prices by this percentage (e.g., 10 for 10% increase). Mutually exclusive with decrease_percentage and exact prices. Current price × (1 + percentage/100). Example: $1.00 with 10% increase = $1.10'
+                            },
+                            decrease_percentage: {
+                                type: 'number',
+                                description: 'PERCENTAGE MODE: Decrease current prices by this percentage (e.g., 15 for 15% decrease). Mutually exclusive with increase_percentage and exact prices. Current price × (1 - percentage/100). Example: $1.00 with 15% decrease = $0.85'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'marketplace_models_publish',
+                    description: 'Publish or unpublish models by setting access level. Supports BOTH single model (by UUID) and bulk operations (by filter).\n\n**Two modes:**\n1. Single model: Provide `model_id` (UUID from marketplace_models_list)\n2. Bulk operation: Provide `filter` (space-separated keywords, same as UI filter)\n\n**IMPORTANT - Automatic filtering logic:**\n- When unpublishing (`access_level: "private"`): Automatically searches only your PUBLIC models\n- When publishing (`access_level: "public"`): Automatically searches only your PRIVATE models\n- When disabling (`access_level: "disabled"`): Searches all your models\n\n**Filter behavior:**\n- Space-separated keywords use AND condition (all must match)\n- Matches against model_id and model_name\n- Example: "groq llama" matches models containing BOTH "groq" AND "llama"\n\n**Confirmation:**\n- `auto_confirm: false` (default): Shows matched models, asks user to confirm\n- `auto_confirm: true`: Immediately updates all matched models\n\n**Access levels:**\n- "public": Available to all users in marketplace (publish)\n- "private": Only owner can use (delist/unpublish)\n- "disabled": Not available to anyone',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            model_id: {
+                                type: 'string',
+                                description: 'Single model UUID from marketplace_models_list (the "id" field). Use this for single model update. Mutually exclusive with filter. Format: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"'
+                            },
+                            filter: {
+                                type: 'string',
+                                description: 'Filter keywords for bulk operation (space-separated, AND condition). Example: "groq llama" matches models with BOTH keywords. Mutually exclusive with model_id. IMPORTANT: Tool automatically filters by correct source access level (public models when unpublishing, private models when publishing).'
+                            },
+                            access_level: {
+                                type: 'string',
+                                description: 'Target access level: "public" (publish to marketplace), "private" (delist/unpublish), "disabled" (completely unavailable)',
+                                enum: ['public', 'private', 'disabled']
+                            },
+                            auto_confirm: {
+                                type: 'boolean',
+                                description: 'If true, skip confirmation and immediately update all matched models. If false (default), show matched models and ask user to confirm first. Default: false',
+                                default: false
+                            },
+                            source_access_level: {
+                                type: 'string',
+                                description: 'OPTIONAL: Override automatic source filtering. Leave empty to use automatic logic (recommended). Only use if you need to override default behavior.',
+                                enum: ['public', 'private', 'disabled']
+                            }
+                        },
+                        required: ['access_level']
+                    }
+                }
+            },
+            // ========================================================================
+            // WORKFLOW QUERY TOOLS - For agents to query workflow execution state
+            // ========================================================================
+            {
+                type: 'function',
+                function: {
+                    name: 'workflow_get_status',
+                    description: 'Get the overall status of a workflow execution by trace ID. Returns the workflow name, overall status (pending/running/completed/failed), start time, completion time, and progress summary. Use this to check if the workflow is still running or has completed.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            trace_id: {
+                                type: 'string',
+                                description: 'The trace ID of the workflow execution. This is provided in your system prompt as "Trace ID".'
+                            }
+                        },
+                        required: ['trace_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'workflow_list_instances',
+                    description: 'List all agent instances in a workflow execution. Shows each agent\'s name, role (START/AGENT/END), execution order, status, and any error messages. Use this to see what other agents are in your workflow and their current status.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            trace_id: {
+                                type: 'string',
+                                description: 'The trace ID of the workflow execution. This is provided in your system prompt as "Trace ID".'
+                            }
+                        },
+                        required: ['trace_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'workflow_get_instance_output',
+                    description: 'Get the output from a specific agent instance in the workflow. Returns the agent\'s response/output from its most recent session. Use this to retrieve results from agents that have already completed.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            instance_id: {
+                                type: 'string',
+                                description: 'The instance ID of the agent. Get instance IDs from workflow_list_instances.'
+                            }
+                        },
+                        required: ['instance_id']
+                    }
+                }
+            }
+        ];
+    }
+    /**
+     * Format tools for AI system prompt
+     */
+    formatToolsForPrompt() {
+        const tools = this.getTools();
+        const formatTool = (tool) => {
+            const func = tool.function;
+            const params = func.parameters?.properties || {};
+            const required = func.parameters?.required || [];
+            const paramDescriptions = Object.entries(params).map(([key, value]) => {
+                const isRequired = required.includes(key);
+                const desc = value.description || 'No description';
+                return `      ${key}${isRequired ? ' (required)' : ''}: ${desc}`;
+            }).join('\n');
+            return paramDescriptions
+                ? `  - ${func.name}: ${func.description}\n${paramDescriptions}`
+                : `  - ${func.name}: ${func.description}`;
+        };
+        return tools.map(formatTool).join('\n\n');
+    }
+    /**
+     * Execute a marketplace tool
+     */
+    async executeTool(toolName, args) {
+        try {
+            switch (toolName) {
+                case 'marketplace_connections_list':
+                    return await this.listConnections();
+                case 'marketplace_connections_add':
+                    return await this.addConnection(args);
+                case 'marketplace_connections_remove':
+                    return await this.removeConnection(args.connection_id);
+                case 'marketplace_connections_test':
+                    return await this.testConnection(args.connection_id);
+                case 'marketplace_connections_update_key':
+                    return await this.updateConnectionKey(args.connection_id, args.api_key);
+                case 'marketplace_providers_list':
+                    return await this.listProviders();
+                case 'marketplace_models_discover':
+                    return await this.discoverModels(args);
+                case 'marketplace_models_list':
+                    return await this.listModels(args);
+                case 'marketplace_models_update_capabilities':
+                    return await this.updateModelCapabilities(args);
+                case 'marketplace_models_get':
+                    return await this.getModelInfo(args.model_id);
+                case 'marketplace_request_logs_list':
+                    return await this.listRequestLogs(args);
+                case 'marketplace_request_logs_get':
+                    return await this.getRequestLog(args.log_id, args.show_full_body);
+                case 'marketplace_request_logs_stats':
+                    return await this.getRequestLogStats(args);
+                case 'marketplace_vault_status':
+                    return await this.getVaultStatus();
+                case 'marketplace_vault_localvault':
+                    return await this.getLocalVaultList();
+                case 'marketplace_vault_keyvault':
+                    return await this.getKeyVaultStatus();
+                case 'marketplace_connections_quota_manage':
+                    return await this.manageConnectionQuota(args);
+                case 'marketplace_connections_quota_get':
+                    return await this.getConnectionQuota(args.connection_id);
+                case 'marketplace_connections_quota_list':
+                    return await this.listConnectionQuotas();
+                case 'marketplace_models_update_pricing':
+                    return await this.updateModelPricing(args);
+                case 'marketplace_models_publish':
+                    return await this.publishModel(args);
+                // Workflow query tools
+                case 'workflow_get_status':
+                    return await this.getWorkflowStatus(args.trace_id);
+                case 'workflow_list_instances':
+                    return await this.listWorkflowInstances(args.trace_id);
+                case 'workflow_get_instance_output':
+                    return await this.getInstanceOutput(args.instance_id);
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown tool: ${toolName}`
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    // ========================================================================
+    // HELPER METHODS
+    // ========================================================================
+    /**
+     * Resolve connection identifier to UUID
+     * Accepts either:
+     * - Sequence number (1, 2, 3, etc.) - looks up in connectionMap
+     * - UUID string - returns as-is
+     */
+    resolveConnectionId(identifier) {
+        // If it's a number, look up in the map
+        if (typeof identifier === 'number') {
+            const uuid = this.connectionMap.get(identifier);
+            if (!uuid) {
+                throw new Error(`Connection #${identifier} not found. Run 'connections' first to see available connections.`);
+            }
+            return uuid;
+        }
+        // If it's a string that looks like a number, parse and look up
+        const numMatch = identifier.match(/^#?(\d+)$/);
+        if (numMatch) {
+            const seqNum = parseInt(numMatch[1]);
+            const uuid = this.connectionMap.get(seqNum);
+            if (!uuid) {
+                throw new Error(`Connection #${seqNum} not found. Run 'connections' first to see available connections.`);
+            }
+            return uuid;
+        }
+        // Otherwise assume it's a UUID
+        return identifier;
+    }
+    // ========================================================================
+    // TOOL IMPLEMENTATIONS
+    // ========================================================================
+    async listConnections() {
+        try {
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Listing connections from: ${this.marketplaceUrl}/api/connections`);
+            const response = await this.client.get('/api/connections');
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] List response status: ${response.status}`);
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] List response data keys:`, Object.keys(response.data || {}));
+            const connections = response.data.connections || [];
+            if (connections.length === 0) {
+                return {
+                    success: true,
+                    output: 'No connections found. Use marketplace.connections.add to create one.'
+                };
+            }
+            // Sort by created_at to maintain consistent ordering
+            connections.sort((a, b) => {
+                const dateA = new Date(a.created_at || 0).getTime();
+                const dateB = new Date(b.created_at || 0).getTime();
+                return dateA - dateB;
+            });
+            // Clear and rebuild connection map
+            this.connectionMap.clear();
+            connections.forEach((conn, idx) => {
+                this.connectionMap.set(idx + 1, conn.id);
+            });
+            // Build output with sequence IDs and UUID mapping
+            const output = connections.map((conn, idx) => {
+                const seqId = idx + 1;
+                const gatewayLabel = conn.gateway_type === 2 ? 'Managed' : 'Self-hosted';
+                return `[${seqId}] ${conn.provider?.name || 'Unknown'} - ${conn.endpoint_type} (${gatewayLabel})\n` +
+                    `    Status: ${conn.status || 'active'}\n` +
+                    `    Endpoint: ${conn.endpoint_url}\n` +
+                    `    Connection ID: ${conn.id}`;
+            }).join('\n\n');
+            return {
+                success: true,
+                output: `Found ${connections.length} connection(s):\n\n${output}\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `📋 Available Actions:\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    `  ➕ Add a New Connection\n` +
+                    `      Create connection to LLM provider (OpenAI, Groq, etc.)\n\n` +
+                    `  🔍 Discover Models\n` +
+                    `      Fetch available models from provider API and add to marketplace\n\n` +
+                    `  🔑 Update API Key\n` +
+                    `      Change API key for existing connection (Marketplace-Managed only)\n\n` +
+                    `  📊 Manage Quota\n` +
+                    `      Set usage limits for connection (daily/monthly spending caps)\n\n` +
+                    `  📈 View Quota Status\n` +
+                    `      Get detailed quota usage and history for a connection\n\n` +
+                    `  📋 List All Quotas\n` +
+                    `      View quota status for all connections at once\n\n` +
+                    `  🧪 Test Connection\n` +
+                    `      Verify connection works by discovering models\n\n` +
+                    `  🗑️  Delete Connection\n` +
+                    `      Remove connection and all its models from marketplace\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`
+            };
+        }
+        catch (error) {
+            console.error(`[MarketplaceTools] List connections error:`);
+            console.error(`[MarketplaceTools] Error code:`, error.code);
+            console.error(`[MarketplaceTools] Error message:`, error.message);
+            console.error(`[MarketplaceTools] Response status:`, error.response?.status);
+            console.error(`[MarketplaceTools] Response data:`, error.response?.data);
+            // Socket hang up / connection reset errors
+            if (error.code === 'ECONNRESET' || error.code === 'EPIPE' ||
+                error.message?.toLowerCase().includes('socket hang up')) {
+                return {
+                    success: false,
+                    error: `🔌 Connection lost while listing connections\n\n` +
+                        `The marketplace API connection was interrupted.\n` +
+                        `This may happen if:\n` +
+                        `  • The gateway is restarting\n` +
+                        `  • Network is unstable\n` +
+                        `  • Request timed out\n\n` +
+                        `💡 Try again in a few seconds.\n\n` +
+                        `Error details: ${error.message}\n` +
+                        `Error code: ${error.code || 'unknown'}`
+                };
+            }
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async addConnection(args) {
+        try {
+            const response = await this.client.post('/api/connections', args);
+            const conn = response.data.connection;
+            // Build detailed connection info
+            const gatewayTypeLabel = conn.gateway_type === 2 ? 'Marketplace-Managed Compute' : 'Self-Hosted Compute';
+            return {
+                success: true,
+                output: `✅ Connection added successfully!\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `📋 Connection Details:\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `  Name:          ${conn.name || args.name}\n` +
+                    `  Provider:      ${conn.provider?.name || args.provider_name}\n` +
+                    `  Endpoint:      ${conn.endpoint_url}\n` +
+                    `  Endpoint Type: ${conn.endpoint_type}\n` +
+                    `  Gateway Type:  ${gatewayTypeLabel}\n` +
+                    `  Status:        ${conn.status || 'active'}\n` +
+                    `  Connection ID: ${conn.id}\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    `💡 What would you like to do next?\n\n` +
+                    `  1️⃣  Test this connection\n` +
+                    `      Use: marketplace.connections.test\n\n` +
+                    `  2️⃣  Discover available models\n` +
+                    `      Use: marketplace.models.discover\n\n` +
+                    `  3️⃣  Update the API key\n` +
+                    `      Use: marketplace.connections.updateKey\n\n` +
+                    `  4️⃣  Remove this connection\n` +
+                    `      Use: marketplace.connections.remove\n\n` +
+                    `IMPORTANT: Show this output to the user and ask what they'd like to do next. DO NOT automatically call other tools.`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async removeConnection(connectionId) {
+        try {
+            // Resolve sequence number to UUID if needed
+            const resolvedId = this.resolveConnectionId(connectionId);
+            await this.client.delete(`/api/connections/${resolvedId}`);
+            return {
+                success: true,
+                output: `✅ Connection removed successfully (ID: ${resolvedId})`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async testConnection(connectionId) {
+        try {
+            // Resolve sequence number to UUID if needed
+            const resolvedId = this.resolveConnectionId(connectionId);
+            const testUrl = `/api/connections/${resolvedId}/test`;
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Testing connection: ${connectionId} (resolved to: ${resolvedId})`);
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Full URL: ${this.marketplaceUrl}${testUrl}`);
+            const response = await this.client.post(testUrl);
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Response status: ${response.status}`);
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Response data:`, response.data);
+            const data = response.data;
+            // Check for non-2xx responses (axios doesn't throw for < 500)
+            if (response.status >= 400 || data.success === false) {
+                // Handle 404 - Connection not found
+                if (response.status === 404) {
+                    return {
+                        success: false,
+                        error: `❌ Connection not found\n\n` +
+                            `Connection: ${connectionId} (resolved to: ${resolvedId})\n\n` +
+                            `💡 Use marketplace.connections.list to see available connections.`
+                    };
+                }
+                // Handle other 4xx errors using the standardized error format
+                const errorData = data.error || data;
+                if (errorData.code === 'rate_limit_exceeded') {
+                    return {
+                        success: false,
+                        error: `⚠️  ${errorData.error || 'Rate limit exceeded'}\n\n` +
+                            `Provider: ${errorData.provider}\n` +
+                            `Status: ${errorData.status} (Rate Limited)\n` +
+                            (errorData.details ? `Details: ${errorData.details}\n` : '') +
+                            `\n💡 ${errorData.suggestion || 'Please wait a few minutes before trying again.'}\n` +
+                            (errorData.retry_after ? `   Retry after: ${errorData.retry_after}\n` : '')
+                    };
+                }
+                if (errorData.code === 'auth_failed') {
+                    return {
+                        success: false,
+                        error: `🔒 ${errorData.error || 'Authentication failed'}\n\n` +
+                            `Provider: ${errorData.provider}\n` +
+                            `Status: ${errorData.status} (Authentication Failed)\n` +
+                            (errorData.details ? `Details: ${errorData.details}\n` : '') +
+                            `\n💡 Check your API key and update it if needed using:\n` +
+                            `   marketplace.connections.updateKey`
+                    };
+                }
+                if (errorData.code === 'type3_gateway_unavailable') {
+                    return {
+                        success: false,
+                        error: `🔧 ${errorData.error || 'Type 3 gateway not available'}\n\n` +
+                            (errorData.details ? `${errorData.details}\n` : '') +
+                            `\n💡 Start your local Self-Hosted Gateway to test self-hosted connections.`
+                    };
+                }
+                if (errorData.code === 'connection_failed') {
+                    return {
+                        success: false,
+                        error: `🔌 ${errorData.error || 'Connection failed'}\n\n` +
+                            (errorData.details ? `Details: ${errorData.details}\n` : '') +
+                            `\n💡 Verify the endpoint URL is correct and the provider is accessible.`
+                    };
+                }
+                // Generic 4xx error
+                return {
+                    success: false,
+                    error: `❌ Connection test failed\n\n` +
+                        `Status: ${response.status}\n` +
+                        `${errorData.error || errorData.message || 'Unknown error'}\n` +
+                        (errorData.details ? `\nDetails: ${errorData.details}` : '')
+                };
+            }
+            // Success case
+            return {
+                success: true,
+                output: `✅ Connection test successful!\n\n` +
+                    `Provider: ${data.provider}\n` +
+                    `Gateway Type: ${data.gateway_type || 'Unknown'}\n` +
+                    `Status: ${data.status || 'OK'}\n` +
+                    (data.models_available ? `Models Available: ${data.models_available}\n` : '') +
+                    (data.gateway_type === 3 ? `\n(Tested via your local Self-Hosted Gateway instance)` : '')
+            };
+        }
+        catch (error) {
+            console.error(`[MarketplaceTools] Test connection error for ${connectionId}:`);
+            console.error(`[MarketplaceTools] Error code:`, error.code);
+            console.error(`[MarketplaceTools] Error message:`, error.message);
+            console.error(`[MarketplaceTools] Response status:`, error.response?.status);
+            console.error(`[MarketplaceTools] Response data:`, error.response?.data);
+            // Socket hang up / connection reset errors
+            if (error.code === 'ECONNRESET' || error.code === 'EPIPE' ||
+                error.message?.toLowerCase().includes('socket hang up')) {
+                return {
+                    success: false,
+                    error: `🔌 Connection lost during test\n\n` +
+                        `The marketplace API connection was interrupted.\n` +
+                        `This may happen if:\n` +
+                        `  • The gateway is restarting\n` +
+                        `  • Network is unstable\n` +
+                        `  • Request timed out\n\n` +
+                        `💡 Try again in a few seconds.\n\n` +
+                        `Error details: ${error.message}\n` +
+                        `Error code: ${error.code || 'unknown'}`
+                };
+            }
+            // ECONNREFUSED - Gateway not running
+            if (error.code === 'ECONNREFUSED') {
+                return {
+                    success: false,
+                    error: `🔌 Cannot connect to marketplace API\n\n` +
+                        `The marketplace API is not reachable at ${this.marketplaceUrl}\n\n` +
+                        `💡 Ensure the LangMart Marketplace is running on the correct port.`
+                };
+            }
+            // Generic error fallback
+            const errorData = error.response?.data;
+            return {
+                success: false,
+                error: `❌ Connection test failed\n\n` +
+                    (errorData?.error || error.message) +
+                    (errorData?.details ? `\n\nDetails: ${errorData.details}` : '')
+            };
+        }
+    }
+    async updateConnectionKey(connectionId, apiKey) {
+        try {
+            // Resolve sequence number to UUID if needed
+            const resolvedId = this.resolveConnectionId(connectionId);
+            await this.client.post(`/api/connections/${resolvedId}/update-key`, { api_key: apiKey });
+            return {
+                success: true,
+                output: `✅ API key updated successfully for connection ${connectionId} (ID: ${resolvedId})`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async listProviders() {
+        try {
+            const response = await this.client.get('/api/public/providers');
+            const providers = response.data.providers || [];
+            if (providers.length === 0) {
+                return {
+                    success: true,
+                    output: 'No providers found in marketplace.'
+                };
+            }
+            const output = providers.map((p, idx) => `${idx + 1}. ${p.name} (${p.key})\n` +
+                `   Base URL: ${p.base_url}\n` +
+                `   Active: ${p.is_active ? 'Yes' : 'No'}`).join('\n\n');
+            return {
+                success: true,
+                output: `Found ${providers.length} provider(s):\n\n${output}\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `💡 Would you like to add a connection?\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    `To add a connection to any provider, you'll need:\n\n` +
+                    `  📋 Required Information:\n` +
+                    `     • Provider name (e.g., "groq", "openai", "anthropic")\n` +
+                    `     • API key from the provider\n` +
+                    `     • Display name for your connection\n` +
+                    `     • Gateway type:\n` +
+                    `       - Type 2: Cloud providers (OpenAI, Groq, Anthropic, Google)\n` +
+                    `       - Type 3: Self-hosted (Ollama, local LLMs)\n\n` +
+                    `  🔧 Example:\n` +
+                    `     "Add a Groq connection with API key gsk_..."\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    `IMPORTANT: Ask the user if they'd like to add a connection to any of these providers and wait for their response.`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async discoverModels(args) {
+        try {
+            const response = await this.client.post('/api/models/discover', args);
+            const data = response.data;
+            return {
+                success: true,
+                output: `✅ Model discovery complete!\n\n` +
+                    `Provider: ${data.provider}\n` +
+                    `Discovered: ${data.discovered} models\n` +
+                    `Stored: ${data.stored} models\n` +
+                    `Failed: ${data.failed} models\n` +
+                    `Source: ${data.source}\n\n` +
+                    `Use marketplace.models.list to see all available models.`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async listModels(args = {}) {
+        try {
+            // Build query parameters for server-side filtering
+            const params = {};
+            if (args.keyword) {
+                params.keyword = args.keyword;
+            }
+            if (args.access_level) {
+                params.access_level = args.access_level;
+            }
+            const response = await this.client.get('/api/models', { params });
+            let models = response.data.models || [];
+            if (models.length === 0) {
+                return {
+                    success: true,
+                    output: 'No models found. Use marketplace.models.discover to discover models from your connections.'
+                };
+            }
+            // Pagination parameters
+            const limit = Math.min(Math.max(args.limit || 10, 1), 100); // Default 10, max 100
+            const offset = Math.max(args.offset || 0, 0);
+            // Build active filters list for display
+            const activeFilters = [];
+            // Apply filters
+            if (args.keyword) {
+                // Split by spaces and apply AND logic - all keywords must match
+                // IMPORTANT: This matches the EXACT same logic as UI tab filter
+                const keywords = args.keyword.trim().split(/\s+/).filter((k) => k.length > 0).map((k) => k.toLowerCase());
+                models = models.filter((m) => {
+                    const modelId = (m.model_id || '').toLowerCase();
+                    const modelName = (m.model_name || '').toLowerCase();
+                    // ALL keywords must match (AND logic) - same as UI filter
+                    // Matches against: model_id OR model_name only
+                    return keywords.every((keyword) => {
+                        return modelId.includes(keyword) || modelName.includes(keyword);
+                    });
+                });
+                activeFilters.push(`Keywords: "${args.keyword}" (all must match)`);
+            }
+            if (args.access_level) {
+                const accessLabel = args.access_level === 'organization' ? 'Published (Public)' : 'Private (Unpublished)';
+                activeFilters.push(`Access Level: ${accessLabel}`);
+            }
+            if (args.provider) {
+                const provider = args.provider.toLowerCase();
+                models = models.filter((m) => {
+                    const providerName = (m.provider?.name || '').toLowerCase();
+                    const providerKey = (m.provider?.key || '').toLowerCase();
+                    return providerName.includes(provider) || providerKey.includes(provider);
+                });
+                activeFilters.push(`Provider: "${args.provider}"`);
+            }
+            if (typeof args.max_input_price === 'number') {
+                models = models.filter((m) => {
+                    const pricePerMillion = parseFloat(m.pricing?.input_per_1k || 0) * 1000;
+                    return pricePerMillion <= args.max_input_price;
+                });
+                activeFilters.push(`Max Input Price: $${args.max_input_price}/M tokens`);
+            }
+            if (typeof args.max_output_price === 'number') {
+                models = models.filter((m) => {
+                    const pricePerMillion = parseFloat(m.pricing?.output_per_1k || 0) * 1000;
+                    return pricePerMillion <= args.max_output_price;
+                });
+                activeFilters.push(`Max Output Price: $${args.max_output_price}/M tokens`);
+            }
+            if (typeof args.min_context_window === 'number') {
+                models = models.filter((m) => {
+                    const contextWindow = m.context_window || 0;
+                    return contextWindow >= args.min_context_window;
+                });
+                activeFilters.push(`Min Context: ${args.min_context_window.toLocaleString()} tokens`);
+            }
+            // Capability filters
+            if (args.has_vision === true) {
+                models = models.filter((m) => m.capabilities?.vision === true);
+                activeFilters.push(`Has Vision: Yes`);
+            }
+            if (args.has_reasoning === true) {
+                models = models.filter((m) => m.capabilities?.reasoning === true);
+                activeFilters.push(`Has Reasoning: Yes`);
+            }
+            if (args.has_tool_use === true) {
+                models = models.filter((m) => m.capabilities?.tool_use === true);
+                activeFilters.push(`Has Tool Use: Yes`);
+            }
+            if (args.has_image_gen === true) {
+                models = models.filter((m) => m.capabilities?.image_gen === true);
+                activeFilters.push(`Has Image Gen: Yes`);
+            }
+            if (args.has_audio === true) {
+                models = models.filter((m) => m.capabilities?.audio === true);
+                activeFilters.push(`Has Audio: Yes`);
+            }
+            if (args.has_embedding === true) {
+                models = models.filter((m) => m.capabilities?.embedding === true);
+                activeFilters.push(`Has Embedding: Yes`);
+            }
+            // Apply sorting (default: model_id ascending)
+            const orderBy = args.order_by || 'model_id_asc';
+            models.sort((a, b) => {
+                let compareA;
+                let compareB;
+                let ascending = true;
+                switch (orderBy) {
+                    case 'model_id_asc':
+                        compareA = (a.model_id || '').toLowerCase();
+                        compareB = (b.model_id || '').toLowerCase();
+                        ascending = true;
+                        break;
+                    case 'model_id_desc':
+                        compareA = (a.model_id || '').toLowerCase();
+                        compareB = (b.model_id || '').toLowerCase();
+                        ascending = false;
+                        break;
+                    case 'model_name_asc':
+                        compareA = (a.model_name || a.model_id || '').toLowerCase();
+                        compareB = (b.model_name || b.model_id || '').toLowerCase();
+                        ascending = true;
+                        break;
+                    case 'model_name_desc':
+                        compareA = (a.model_name || a.model_id || '').toLowerCase();
+                        compareB = (b.model_name || b.model_id || '').toLowerCase();
+                        ascending = false;
+                        break;
+                    case 'provider_asc':
+                        compareA = (a.provider?.name || '').toLowerCase();
+                        compareB = (b.provider?.name || '').toLowerCase();
+                        ascending = true;
+                        break;
+                    case 'provider_desc':
+                        compareA = (a.provider?.name || '').toLowerCase();
+                        compareB = (b.provider?.name || '').toLowerCase();
+                        ascending = false;
+                        break;
+                    case 'context_window_asc':
+                        compareA = a.context_window || 0;
+                        compareB = b.context_window || 0;
+                        ascending = true;
+                        break;
+                    case 'context_window_desc':
+                        compareA = a.context_window || 0;
+                        compareB = b.context_window || 0;
+                        ascending = false;
+                        break;
+                    case 'input_price_asc':
+                        compareA = parseFloat(a.pricing?.input_per_1k || 0);
+                        compareB = parseFloat(b.pricing?.input_per_1k || 0);
+                        ascending = true;
+                        break;
+                    case 'input_price_desc':
+                        compareA = parseFloat(a.pricing?.input_per_1k || 0);
+                        compareB = parseFloat(b.pricing?.input_per_1k || 0);
+                        ascending = false;
+                        break;
+                    case 'output_price_asc':
+                        compareA = parseFloat(a.pricing?.output_per_1k || 0);
+                        compareB = parseFloat(b.pricing?.output_per_1k || 0);
+                        ascending = true;
+                        break;
+                    case 'output_price_desc':
+                        compareA = parseFloat(a.pricing?.output_per_1k || 0);
+                        compareB = parseFloat(b.pricing?.output_per_1k || 0);
+                        ascending = false;
+                        break;
+                    default:
+                        // Default to model_id_asc
+                        compareA = (a.model_id || '').toLowerCase();
+                        compareB = (b.model_id || '').toLowerCase();
+                        ascending = true;
+                }
+                if (typeof compareA === 'string') {
+                    // String comparison
+                    if (ascending) {
+                        return compareA.localeCompare(compareB);
+                    }
+                    else {
+                        return compareB.localeCompare(compareA);
+                    }
+                }
+                else {
+                    // Numeric comparison
+                    if (ascending) {
+                        return compareA - compareB;
+                    }
+                    else {
+                        return compareB - compareA;
+                    }
+                }
+            });
+            // Store total count before pagination
+            const totalModels = models.length;
+            // Build sort info (define early so it can be used in error messages)
+            const sortLabels = {
+                'model_id_asc': 'Model ID (A→Z)',
+                'model_id_desc': 'Model ID (Z→A)',
+                'model_name_asc': 'Model Name (A→Z)',
+                'model_name_desc': 'Model Name (Z→A)',
+                'provider_asc': 'Provider (A→Z)',
+                'provider_desc': 'Provider (Z→A)',
+                'context_window_asc': 'Context Window (Smallest→Largest)',
+                'context_window_desc': 'Context Window (Largest→Smallest)',
+                'input_price_asc': 'Input Price (Cheapest→Most Expensive)',
+                'input_price_desc': 'Input Price (Most Expensive→Cheapest)',
+                'output_price_asc': 'Output Price (Cheapest→Most Expensive)',
+                'output_price_desc': 'Output Price (Most Expensive→Cheapest)'
+            };
+            const sortLabel = sortLabels[orderBy] || sortLabels['model_id_asc'];
+            // Check if filters removed all models
+            if (totalModels === 0) {
+                return {
+                    success: true,
+                    output: `No models match the specified filters.\n\n` +
+                        `Active Filters:\n  ${activeFilters.join('\n  ')}\n` +
+                        `Sorted By: ${sortLabel}\n\n` +
+                        `Try relaxing the filters or use marketplace.models.discover to add more models.`
+                };
+            }
+            // Apply pagination
+            const paginatedModels = models.slice(offset, offset + limit);
+            const hasMore = offset + limit < totalModels;
+            const nextOffset = offset + limit;
+            // Check if offset is beyond available models
+            if (offset >= totalModels) {
+                return {
+                    success: true,
+                    output: `No models at offset ${offset}. Total models available: ${totalModels}\n\n` +
+                        `💡 Try offset=0 to see the first page, or use a smaller offset value.`
+                };
+            }
+            // Build filter header
+            const filterHeader = activeFilters.length > 0
+                ? `Active Filters:\n  ${activeFilters.join('\n  ')}\n\nSorted By: ${sortLabel}\n\n`
+                : `Sorted By: ${sortLabel}\n\n`;
+            // Format model capabilities as icons
+            const formatCaps = (caps) => {
+                if (!caps)
+                    return '';
+                const icons = [];
+                if (caps.vision)
+                    icons.push('📷');
+                if (caps.reasoning)
+                    icons.push('💭');
+                if (caps.tool_use)
+                    icons.push('🔧');
+                if (caps.image_gen)
+                    icons.push('🎨');
+                if (caps.audio)
+                    icons.push('🔊');
+                if (caps.embedding)
+                    icons.push('📊');
+                return icons.length > 0 ? ` [${icons.join(' ')}]` : '';
+            };
+            const output = paginatedModels.map((m, idx) => {
+                const inputPricePerMillion = parseFloat(m.pricing?.input_per_1k || 0) * 1000;
+                const outputPricePerMillion = parseFloat(m.pricing?.output_per_1k || 0) * 1000;
+                return `${offset + idx + 1}. ${m.model_name || m.model_id || 'Unknown'}${formatCaps(m.capabilities)}\n` +
+                    `   Model ID (for delisting): ${m.id}\n` +
+                    `   Provider: ${m.provider?.name || 'Unknown'}\n` +
+                    (m.context_window ? `   Context Window: ${m.context_window.toLocaleString()} tokens\n` : '') +
+                    (m.pricing?.input_per_1k !== undefined
+                        ? `   Pricing: $${inputPricePerMillion.toFixed(4)}/M input, $${outputPricePerMillion.toFixed(4)}/M output\n`
+                        : '');
+            }).join('\n');
+            // Build pagination info
+            const paginationInfo = [
+                `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                `Showing ${offset + 1}-${offset + paginatedModels.length} of ${totalModels} models`,
+                hasMore ? `\n💡 Next page: Use offset=${nextOffset} to see more models` : '',
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`
+            ].filter(line => line).join('\n');
+            return {
+                success: true,
+                output: `Found ${totalModels} model(s)${activeFilters.length > 0 ? ' matching filters' : ''}:\n\n${filterHeader}${output}${paginationInfo}\n\n` +
+                    `💡 Capability Icons: 📷 Vision | 💭 Reasoning | 🔧 Tools | 🎨 Images | 🔊 Audio | 📊 Embeddings`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Get detailed information about a specific model
+     */
+    async getModelInfo(modelId) {
+        try {
+            const response = await this.client.get(`/api/models/${encodeURIComponent(modelId)}`);
+            const model = response.data.model;
+            // Format capabilities
+            const caps = model.capabilities || {};
+            const capsList = [];
+            if (caps.vision)
+                capsList.push('📷 Vision');
+            if (caps.reasoning)
+                capsList.push('💭 Reasoning');
+            if (caps.tool_use)
+                capsList.push('🔧 Tools/Functions');
+            if (caps.image_gen)
+                capsList.push('🎨 Image Generation');
+            if (caps.video_gen)
+                capsList.push('🎬 Video Generation');
+            if (caps.audio)
+                capsList.push('🔊 Audio');
+            if (caps.embedding)
+                capsList.push('📊 Embeddings');
+            const output = [
+                `Model: ${model.model_name || model.model_key || 'Unknown'}`,
+                `Model ID: ${model.model_id || 'Unknown'}`,
+                `Provider Model ID: ${model.model_name_at_endpoint || 'Unknown'}`,
+                `Provider: ${model.provider?.name || model.provider_name || 'Unknown'}`,
+                '',
+                `Context Window: ${model.context_window ? model.context_window.toLocaleString() + ' tokens' : 'Unknown'}`,
+                '',
+                `Pricing:`,
+                `  Input:  $${model.input_price_per_million || '0'}/M tokens`,
+                `  Output: $${model.output_price_per_million || '0'}/M tokens`,
+                '',
+                `Capabilities:`,
+                capsList.length > 0 ? capsList.map(c => `  ${c}`).join('\n') : '  (No special capabilities)'
+            ].join('\n');
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return {
+                    success: false,
+                    error: `Model "${modelId}" not found. Use marketplace.models.list to see available models.`
+                };
+            }
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Update model capabilities
+     */
+    async updateModelCapabilities(args) {
+        try {
+            const { model_id, ...capabilities } = args;
+            if (!model_id) {
+                return {
+                    success: false,
+                    error: 'Model ID is required'
+                };
+            }
+            // Build request body with only provided capabilities
+            const body = {};
+            if (typeof capabilities.supports_vision === 'boolean')
+                body.supports_vision = capabilities.supports_vision;
+            if (typeof capabilities.supports_reasoning === 'boolean')
+                body.supports_reasoning = capabilities.supports_reasoning;
+            if (typeof capabilities.supports_tool_use === 'boolean')
+                body.supports_tool_use = capabilities.supports_tool_use;
+            if (typeof capabilities.supports_image_gen === 'boolean')
+                body.supports_image_gen = capabilities.supports_image_gen;
+            if (typeof capabilities.supports_video_gen === 'boolean')
+                body.supports_video_gen = capabilities.supports_video_gen;
+            if (typeof capabilities.supports_audio === 'boolean')
+                body.supports_audio = capabilities.supports_audio;
+            if (typeof capabilities.supports_embedding === 'boolean')
+                body.supports_embedding = capabilities.supports_embedding;
+            if (Object.keys(body).length === 0) {
+                return {
+                    success: false,
+                    error: 'At least one capability must be provided'
+                };
+            }
+            const response = await this.client.patch(`/api/models/${encodeURIComponent(model_id)}/capabilities`, body);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error?.message || 'Failed to update model capabilities'
+                };
+            }
+            const model = response.data.model;
+            const caps = model.capabilities;
+            const capabilityLabels = [];
+            if (caps.vision)
+                capabilityLabels.push('📷 Vision');
+            if (caps.reasoning)
+                capabilityLabels.push('💭 Reasoning');
+            if (caps.tool_use)
+                capabilityLabels.push('🔧 Tools');
+            if (caps.image_gen)
+                capabilityLabels.push('🎨 Image Gen');
+            if (caps.video_gen)
+                capabilityLabels.push('🎬 Video Gen');
+            if (caps.audio)
+                capabilityLabels.push('🔊 Audio');
+            if (caps.embedding)
+                capabilityLabels.push('📊 Embedding');
+            return {
+                success: true,
+                output: `✅ Model capabilities updated successfully!\n\n` +
+                    `Model: ${model.model_id}\n` +
+                    `Name: ${model.model_name}\n\n` +
+                    `Capabilities:\n` +
+                    (capabilityLabels.length > 0
+                        ? capabilityLabels.map(c => `  • ${c}`).join('\n')
+                        : '  (No capabilities enabled)') +
+                    `\n\nUpdated: ${new Date(model.updated_at).toLocaleString()}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * List request logs with pagination and filtering
+     */
+    async listRequestLogs(args) {
+        try {
+            const params = {
+                limit: args.limit || 20,
+                offset: args.offset || 0
+            };
+            if (args.status)
+                params.status = args.status;
+            if (args.endpoint)
+                params.endpoint = args.endpoint;
+            if (args.model)
+                params.model = args.model;
+            const response = await this.client.get('/api/account/request-logs', { params });
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error || 'Failed to fetch request logs'
+                };
+            }
+            const { data, pagination } = response.data;
+            if (data.length === 0) {
+                // Show active filters in the "no results" message
+                const activeFilters = [];
+                if (args.status)
+                    activeFilters.push(`Status: ${args.status}`);
+                if (args.endpoint)
+                    activeFilters.push(`Endpoint: ${args.endpoint}`);
+                if (args.model)
+                    activeFilters.push(`Model: ${args.model}`);
+                const filterMsg = activeFilters.length > 0
+                    ? `\n\nActive filters:\n  ${activeFilters.join('\n  ')}`
+                    : '';
+                return {
+                    success: true,
+                    output: `No request logs found.${filterMsg}`
+                };
+            }
+            // Build filter summary
+            const filterSummary = [];
+            if (args.status)
+                filterSummary.push(`Status: ${args.status}`);
+            if (args.endpoint)
+                filterSummary.push(`Endpoint: *${args.endpoint}*`);
+            if (args.model)
+                filterSummary.push(`Model: *${args.model}*`);
+            const filterHeader = filterSummary.length > 0
+                ? `Filters: ${filterSummary.join(' | ')}\n\n`
+                : '';
+            const output = data.map((log, index) => {
+                const statusEmoji = log.response_status >= 200 && log.response_status < 300 ? '✅' :
+                    log.response_status >= 400 && log.response_status < 500 ? '⚠️' : '❌';
+                const lines = [
+                    `[${pagination.offset + index + 1}] ${statusEmoji} ${log.method} ${log.endpoint}`,
+                    `    Status: ${log.response_status}`,
+                    `    Time: ${new Date(log.created_at).toLocaleString()}`,
+                    `    IP: ${log.ip_address}`
+                ];
+                // Add model info if available
+                if (log.model_used) {
+                    lines.push(`    Model: ${log.model_used}`);
+                }
+                lines.push(`    Request ID: ${log.request_id}`);
+                lines.push(`    Log ID: ${log.id}`);
+                return lines.join('\n');
+            }).join('\n\n');
+            const paginationInfo = [
+                `\nShowing ${pagination.offset + 1}-${pagination.offset + pagination.returned} of ${pagination.total} logs`,
+                pagination.has_more ? `\n💡 Next page: offset=${pagination.next_offset}` : ''
+            ].join('');
+            return {
+                success: true,
+                output: `Request Logs:\n\n${filterHeader}${output}${paginationInfo}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Get detailed request log by ID
+     */
+    async getRequestLog(logId, showFullBody = false) {
+        try {
+            const response = await this.client.get(`/api/account/request-logs/${logId}`);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error || 'Failed to fetch log details'
+                };
+            }
+            const log = response.data.data;
+            // Helper function to truncate JSON strings
+            const formatBody = (body, maxLength = 500) => {
+                if (!body)
+                    return '  (empty)';
+                const jsonStr = JSON.stringify(body, null, 2);
+                if (showFullBody || jsonStr.length <= maxLength) {
+                    return `  ${jsonStr.split('\n').join('\n  ')}`;
+                }
+                const truncated = jsonStr.substring(0, maxLength);
+                const lines = truncated.split('\n');
+                const remainingChars = jsonStr.length - maxLength;
+                return `  ${lines.join('\n  ')}\n  ... (truncated, ${remainingChars} more characters)\n  💡 Use show_full_body: true to see complete content`;
+            };
+            // Helper to format headers
+            const formatHeaders = (headers) => {
+                if (!headers || Object.keys(headers).length === 0)
+                    return '  (no headers)';
+                const formatted = Object.entries(headers)
+                    .map(([key, value]) => `    ${key}: ${value}`)
+                    .join('\n');
+                return formatted;
+            };
+            // Status emoji
+            const statusEmoji = log.response_status >= 200 && log.response_status < 300 ? '✅' :
+                log.response_status >= 400 && log.response_status < 500 ? '⚠️' : '❌';
+            const output = [
+                `═══════════════════════════════════════════════════════`,
+                `           ${statusEmoji} REQUEST LOG DETAILS`,
+                `═══════════════════════════════════════════════════════`,
+                ``,
+                `📋 Basic Information:`,
+                `  Log ID:       ${log.id}`,
+                `  Request ID:   ${log.request_id}`,
+                `  User ID:      ${log.user_id}`,
+                `  Timestamp:    ${new Date(log.created_at).toLocaleString()}`,
+                ``,
+                `🌐 Request Information:`,
+                `  Method:       ${log.method}`,
+                `  Endpoint:     ${log.endpoint}`,
+                `  IP Address:   ${log.ip_address}`,
+                `  User Agent:   ${log.user_agent || '(not provided)'}`,
+                log.model_used ? `  Model Used:   ${log.model_used}` : null,
+                ``,
+                `📊 Response Information:`,
+                `  Status Code:  ${log.response_status} ${statusEmoji}`,
+                log.error_message ? `  Error:        ${log.error_message}` : null,
+                ``,
+                `─────────────────────────────────────────────────────────`,
+                ``,
+                `📤 Request Headers:`,
+                formatHeaders(log.request_headers),
+                ``,
+                `📤 Request Body:`,
+                formatBody(log.request_body),
+                ``,
+                `─────────────────────────────────────────────────────────`,
+                ``,
+                `📥 Response Headers:`,
+                formatHeaders(log.response_headers),
+                ``,
+                `📥 Response Body:`,
+                formatBody(log.response_body),
+                ``,
+                `═══════════════════════════════════════════════════════`
+            ].filter(line => line !== null).join('\n');
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Get request log statistics
+     */
+    async getRequestLogStats(args) {
+        try {
+            const params = {
+                display_friendly: 'true' // Always use display-friendly names for MCP tool
+            };
+            if (args.start_date)
+                params.start_date = args.start_date;
+            if (args.end_date)
+                params.end_date = args.end_date;
+            const response = await this.client.get('/api/account/request-logs/stats', { params });
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error || 'Failed to fetch statistics'
+                };
+            }
+            const { period, summary, top_models, top_endpoints, daily_counts } = response.data.data;
+            const output = [
+                `Request Statistics`,
+                ``,
+                `Period: ${new Date(period.start_date).toLocaleDateString()} - ${new Date(period.end_date).toLocaleDateString()}`,
+                ``,
+                `Summary:`,
+                `  Total Requests: ${summary.total_requests}`,
+                `  Success Rate: ${summary.success_rate}`,
+                `  Successful: ${summary.successful_requests}`,
+                `  Client Errors (4xx): ${summary.client_errors}`,
+                `  Server Errors (5xx): ${summary.server_errors}`,
+                `  Days Active: ${summary.days_with_requests}`,
+                `  Unique Models: ${summary.unique_models_used}`,
+                `  Unique Endpoints: ${summary.unique_endpoints}`,
+                ``,
+                `Top Models (by request count):`,
+                ...top_models.slice(0, 5).map((m, i) => {
+                    const modelName = m.model_name || m.category_id;
+                    return `  ${i + 1}. ${modelName}: ${m.request_count} requests`;
+                }),
+                ``,
+                `Top Endpoints (by request count):`,
+                ...top_endpoints.slice(0, 5).map((e, i) => {
+                    const displayEndpoint = e.display_endpoint || e.endpoint;
+                    return `  ${i + 1}. ${displayEndpoint}: ${e.request_count} requests`;
+                }),
+                ``,
+                `Recent Daily Activity (last 7 days):`,
+                ...daily_counts.slice(0, 7).map((d) => `  ${new Date(d.date).toLocaleDateString()}: ${d.request_count} requests (${d.successful_count} success, ${d.error_count} errors)`)
+            ].join('\n');
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Get comprehensive vault status showing both LocalVault and KeyVault
+     */
+    async getVaultStatus() {
+        try {
+            // Get LocalVault credentials from management API
+            const vaultResponse = await axios_1.default.get(`${this.managementUrl}/providers`);
+            const providers = vaultResponse.data.providers || [];
+            // Get KeyVault statistics
+            const keyVaultStats = this.keyVault.getStatistics();
+            const lines = [
+                '═══════════════════════════════════════════════════════',
+                '                    🗝️  VAULT STATUS',
+                '═══════════════════════════════════════════════════════',
+                '',
+                '  Two vault systems protect your API keys:',
+                '',
+                '  💾 LocalVault (Persistent Storage)',
+                '     • Stores connection API keys on disk',
+                '     • Encrypted with AES-256-GCM',
+                '     • Location: ~/.langmart/keystore.enc',
+                '     • Survives gateway restarts',
+                '',
+                '  🧠 KeyVault (In-Memory Protection)',
+                '     • Redacts API keys in chat messages',
+                '     • Prevents keys from being sent to LLMs',
+                '     • Temporary protection (session only)',
+                '     • Cleared on gateway restart',
+                '',
+                '─────────────────────────────────────────────────────────',
+                '',
+                `  💾 LocalVault - Persistent Storage`,
+                `     Status:        ${providers.length > 0 ? '✅ Active' : '⚠️  Empty'}`,
+                `     Credentials:   ${providers.length} stored`,
+                `     Encryption:    AES-256-GCM`,
+                `     File:          ~/.langmart/keystore.enc`,
+                ''
+            ];
+            if (providers.length === 0) {
+                lines.push('     📋 No credentials stored');
+                lines.push('');
+                lines.push('     💡 Add connections via /menu → Connections');
+            }
+            else {
+                lines.push('     📋 Stored Credentials:');
+                lines.push('');
+                for (let i = 0; i < providers.length; i++) {
+                    const provider = providers[i];
+                    if (provider.connection_id === '__gateway_auth__') {
+                        lines.push(`        ${i + 1}. 🔐 Gateway Authentication`);
+                        lines.push(`           Type:   Marketplace API Key`);
+                        lines.push(`           Status: ✅ Encrypted & Stored`);
+                    }
+                    else {
+                        lines.push(`        ${i + 1}. 🔑 ${provider.access_key_name || provider.connection_id}`);
+                        if (provider.provider_name) {
+                            lines.push(`           Provider:   ${provider.provider_name}`);
+                        }
+                        if (provider.endpoint) {
+                            lines.push(`           Endpoint:   ${provider.endpoint}`);
+                        }
+                        if (provider.gateway_type) {
+                            const gatewayName = provider.gateway_type === 2
+                                ? 'Marketplace-Managed Compute'
+                                : 'Self-Hosted Compute';
+                            lines.push(`           Gateway:    ${gatewayName}`);
+                        }
+                        lines.push(`           Status:     ✅ Encrypted & Stored`);
+                    }
+                    if (i < providers.length - 1) {
+                        lines.push('');
+                    }
+                }
+            }
+            lines.push('');
+            lines.push('─────────────────────────────────────────────────────────');
+            lines.push('');
+            lines.push(`  🧠 KeyVault - In-Memory Chat Protection`);
+            lines.push(`     Status:        ${keyVaultStats.totalKeys > 0 ? '✅ Active' : '💤 Idle'}`);
+            lines.push(`     Protected Keys: ${keyVaultStats.totalKeys}`);
+            lines.push(`     Session Only:   RAM (lost on restart)`);
+            lines.push('');
+            if (keyVaultStats.totalKeys === 0) {
+                lines.push('     📋 No keys currently protected in memory');
+                lines.push('');
+                lines.push('     💡 KeyVault automatically detects and redacts API keys');
+                lines.push('        when you type them in chat messages.');
+            }
+            else {
+                lines.push('     📋 Currently Protected Keys:');
+                lines.push('');
+                for (let i = 0; i < keyVaultStats.keys.length; i++) {
+                    const key = keyVaultStats.keys[i];
+                    lines.push(`        ${i + 1}. ${key.provider.toUpperCase()} API Key`);
+                    lines.push(`           Placeholder: ${key.redactedPrefix}`);
+                    lines.push(`           Detected:    ${new Date(key.detectedAt).toLocaleTimeString()}`);
+                    lines.push(`           Age:         ${key.age} minutes`);
+                    lines.push(`           Used:        ${key.useCount} times`);
+                    if (i < keyVaultStats.keys.length - 1) {
+                        lines.push('');
+                    }
+                }
+                lines.push('');
+                lines.push('     ℹ️  Keys older than 15 minutes are auto-removed');
+            }
+            lines.push('');
+            lines.push('─────────────────────────────────────────────────────────');
+            lines.push('');
+            lines.push('  ℹ️  Information');
+            lines.push('');
+            lines.push('  • LocalVault stores connection credentials permanently');
+            lines.push('  • KeyVault protects chat messages from exposing keys');
+            lines.push('  • Both systems work together for complete security');
+            lines.push('  • Keys are never sent to LLMs in plaintext');
+            lines.push('');
+            lines.push('═══════════════════════════════════════════════════════');
+            return {
+                success: true,
+                output: lines.join('\n')
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * List all credentials in LocalVault (persistent storage)
+     */
+    async getLocalVaultList() {
+        try {
+            const vaultResponse = await axios_1.default.get(`${this.managementUrl}/providers`);
+            const providers = vaultResponse.data.providers || [];
+            const lines = [
+                '═══════════════════════════════════════════════════════',
+                '              💾 LocalVault - Stored Credentials',
+                '═══════════════════════════════════════════════════════',
+                '',
+                `  Total Credentials: ${providers.length}`,
+                `  Storage Location:  ~/.langmart/keystore.enc`,
+                `  Encryption:        AES-256-GCM`,
+                ''
+            ];
+            if (providers.length === 0) {
+                lines.push('  📋 No credentials stored');
+                lines.push('');
+                lines.push('  💡 Add connections via /menu → Connections');
+            }
+            else {
+                lines.push('  📋 Stored Credentials:');
+                lines.push('');
+                for (let i = 0; i < providers.length; i++) {
+                    const provider = providers[i];
+                    if (provider.connection_id === '__gateway_auth__') {
+                        lines.push(`  ${i + 1}. 🔐 Gateway Authentication`);
+                        lines.push(`     Type:       Marketplace API Key`);
+                        lines.push(`     Purpose:    Authenticate with marketplace`);
+                        lines.push(`     Status:     ✅ Encrypted & Stored`);
+                    }
+                    else {
+                        lines.push(`  ${i + 1}. 🔑 ${provider.access_key_name || provider.connection_id}`);
+                        if (provider.provider_name) {
+                            lines.push(`     Provider:   ${provider.provider_name}`);
+                        }
+                        if (provider.endpoint) {
+                            lines.push(`     Endpoint:   ${provider.endpoint}`);
+                        }
+                        if (provider.gateway_type) {
+                            const gatewayName = provider.gateway_type === 2
+                                ? 'Marketplace-Managed Compute'
+                                : 'Self-Hosted Compute';
+                            lines.push(`     Gateway:    ${gatewayName}`);
+                        }
+                        lines.push(`     Connection: ${provider.connection_id}`);
+                        lines.push(`     Status:     ✅ Encrypted & Stored`);
+                    }
+                    if (i < providers.length - 1) {
+                        lines.push('');
+                    }
+                }
+            }
+            lines.push('');
+            lines.push('═══════════════════════════════════════════════════════');
+            return {
+                success: true,
+                output: lines.join('\n')
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Show KeyVault status (in-memory chat protection)
+     */
+    async getKeyVaultStatus() {
+        try {
+            const keyVaultStats = this.keyVault.getStatistics();
+            const lines = [
+                '═══════════════════════════════════════════════════════',
+                '        🧠 KeyVault - In-Memory Chat Protection',
+                '═══════════════════════════════════════════════════════',
+                '',
+                `  Status:         ${keyVaultStats.totalKeys > 0 ? '✅ Active' : '💤 Idle'}`,
+                `  Protected Keys: ${keyVaultStats.totalKeys}`,
+                `  Storage:        RAM (temporary, session only)`,
+                `  Persistence:    Lost on gateway restart`,
+                ''
+            ];
+            if (keyVaultStats.totalKeys === 0) {
+                lines.push('  📋 No keys currently protected in memory');
+                lines.push('');
+                lines.push('  💡 How KeyVault Works:');
+                lines.push('');
+                lines.push('  1. Automatically detects API keys in chat messages');
+                lines.push('  2. Replaces them with random placeholders');
+                lines.push('  3. Sends placeholder to LLM (real key never exposed)');
+                lines.push('  4. Restores real key in responses (for tool calls)');
+                lines.push('  5. Auto-removes keys after 15 minutes of inactivity');
+                lines.push('');
+                lines.push('  Supported Providers:');
+                lines.push('  • OpenAI (sk-proj-...)');
+                lines.push('  • Anthropic (sk-ant-api...)');
+                lines.push('  • Google Gemini (AIza...)');
+                lines.push('  • Groq (gsk_...)');
+                lines.push('  • DeepSeek (sk-...)');
+            }
+            else {
+                lines.push('  📋 Currently Protected Keys:');
+                lines.push('');
+                for (let i = 0; i < keyVaultStats.keys.length; i++) {
+                    const key = keyVaultStats.keys[i];
+                    const detectedTime = new Date(key.detectedAt);
+                    lines.push(`  ${i + 1}. ${key.provider.toUpperCase()} API Key`);
+                    lines.push(`     Placeholder:  ${key.redactedPrefix}`);
+                    lines.push(`     Detected At:  ${detectedTime.toLocaleString()}`);
+                    lines.push(`     Age:          ${key.age} minutes ago`);
+                    lines.push(`     Restored:     ${key.useCount} times`);
+                    lines.push(`     Status:       ${key.age < 15 ? '✅ Active' : '⚠️  Expiring soon'}`);
+                    if (i < keyVaultStats.keys.length - 1) {
+                        lines.push('');
+                    }
+                }
+                lines.push('');
+                lines.push('  ⏰ Auto-Cleanup:');
+                lines.push('     Keys older than 15 minutes are automatically removed');
+                lines.push('     from memory to prevent stale key accumulation.');
+            }
+            lines.push('');
+            lines.push('═══════════════════════════════════════════════════════');
+            return {
+                success: true,
+                output: lines.join('\n')
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Manage connection quota (set daily/monthly limits and enable/disable enforcement)
+     */
+    async manageConnectionQuota(args) {
+        try {
+            const { connection_id, max_daily_sales_usd, max_monthly_sales_usd, quota_enabled } = args;
+            if (!connection_id) {
+                return {
+                    success: false,
+                    error: 'Connection ID is required'
+                };
+            }
+            if (typeof quota_enabled !== 'boolean') {
+                return {
+                    success: false,
+                    error: 'quota_enabled must be a boolean (true or false)'
+                };
+            }
+            // Resolve sequence number to UUID if needed
+            const resolvedId = this.resolveConnectionId(connection_id);
+            // Build request body
+            const body = {
+                quota_enabled
+            };
+            // Add quota limits if provided (null is valid for "no limit")
+            // Note: Endpoint expects max_daily_sales_quota_usd, not max_daily_sales_usd
+            if (max_daily_sales_usd !== undefined) {
+                body.max_daily_sales_quota_usd = max_daily_sales_usd;
+            }
+            if (max_monthly_sales_usd !== undefined) {
+                body.max_monthly_sales_quota_usd = max_monthly_sales_usd;
+            }
+            const response = await this.client.patch(`/api/connections/${resolvedId}/quota`, body);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error?.message || 'Failed to update connection quota'
+                };
+            }
+            const data = response.data.data;
+            const quota = data.quota;
+            // Format quota limits
+            const dailyLimit = quota.max_daily_sales_usd
+                ? `$${quota.max_daily_sales_usd}/day`
+                : 'No limit';
+            const monthlyLimit = quota.max_monthly_sales_usd
+                ? `$${quota.max_monthly_sales_usd}/month`
+                : 'No limit';
+            const enforcementStatus = quota.enabled
+                ? '✅ Enabled (models auto-disable when exceeded)'
+                : '⚠️  Disabled (tracking only, no enforcement)';
+            const modelsAffected = quota.models_affected_count || '0';
+            return {
+                success: true,
+                output: `✅ Connection quota updated successfully!\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `📊 Quota Settings:\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `  Connection ID:    ${resolvedId}\n` +
+                    `  Access Key:       ${data.access_key}\n` +
+                    `  Models Affected:  ${modelsAffected}\n\n` +
+                    `  Daily Limit:      ${dailyLimit}\n` +
+                    `  Monthly Limit:    ${monthlyLimit}\n` +
+                    `  Enforcement:      ${enforcementStatus}\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    `ℹ️  Quota applies to:\n` +
+                    `  • ALL models under this connection\n` +
+                    `  • Your own consumption via this connection\n` +
+                    `  • Other users consuming your published models\n\n` +
+                    `⏰ Reset Schedule:\n` +
+                    `  • Daily quota resets at midnight UTC\n` +
+                    `  • Monthly quota resets on 1st of month\n\n` +
+                    `📝 ${data.message}\n\n` +
+                    `Updated: ${new Date(data.updated_at).toLocaleString()}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Get quota status for a specific connection
+     */
+    async getConnectionQuota(connection_id) {
+        try {
+            if (!connection_id) {
+                return {
+                    success: false,
+                    error: 'Connection ID is required'
+                };
+            }
+            // Resolve sequence number to UUID if needed
+            const resolvedId = this.resolveConnectionId(connection_id);
+            const response = await this.client.get(`/api/connections/${resolvedId}/quota`);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error?.message || 'Failed to get connection quota'
+                };
+            }
+            const data = response.data.data;
+            const quota = data.quota;
+            const models = data.models;
+            const history = data.history || [];
+            // Format quota limits
+            const dailyLimit = quota.max_daily_sales_usd
+                ? `$${quota.max_daily_sales_usd}`
+                : 'No limit';
+            const monthlyLimit = quota.max_monthly_sales_usd
+                ? `$${quota.max_monthly_sales_usd}`
+                : 'No limit';
+            const enforcementStatus = quota.enabled
+                ? '✅ Enabled'
+                : '⚠️  Disabled (tracking only)';
+            // Format current usage
+            const dailyUsage = quota.current_daily_sales_usd || 0;
+            const monthlyUsage = quota.current_monthly_sales_usd || 0;
+            const dailyPercentage = quota.daily_quota_percentage || '0.00';
+            const monthlyPercentage = quota.monthly_quota_percentage || '0.00';
+            // Build output
+            let output = `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+            output += `📊 Quota Status for Connection ${connection_id}\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+            output += `🔧 Configuration:\n`;
+            output += `  Connection ID:    ${data.connection_id}\n`;
+            output += `  Access Key:       ${data.access_key}\n`;
+            output += `  Enforcement:      ${enforcementStatus}\n\n`;
+            output += `💰 Quota Limits:\n`;
+            output += `  Daily Limit:      ${dailyLimit}\n`;
+            output += `  Monthly Limit:    ${monthlyLimit}\n\n`;
+            output += `📈 Current Usage:\n`;
+            output += `  Daily:            $${dailyUsage.toFixed(4)} (${dailyPercentage}%)\n`;
+            output += `  Monthly:          $${monthlyUsage.toFixed(4)} (${monthlyPercentage}%)\n\n`;
+            if (quota.quota_exceeded) {
+                output += `❌ QUOTA EXCEEDED\n`;
+                output += `  Exceeded At:      ${new Date(quota.quota_exceeded_at).toLocaleString()}\n\n`;
+            }
+            output += `🎯 Affected Models:\n`;
+            output += `  Total Models:     ${models.total_count}\n`;
+            output += `  Available:        ${models.available_count}\n`;
+            output += `  Disabled:         ${models.disabled_count}\n\n`;
+            // Show recent history if available
+            if (history.length > 0) {
+                output += `📅 Recent Usage History (Last ${Math.min(history.length, 7)} days):\n\n`;
+                const recentHistory = history.slice(0, 7);
+                recentHistory.forEach((day) => {
+                    const date = new Date(day.date).toLocaleDateString();
+                    const dayUsage = parseFloat(day.daily_sales_usd || 0);
+                    const requests = day.daily_requests || 0;
+                    const exceeded = day.daily_quota_exceeded ? '❌' : '✅';
+                    output += `  ${date}:  $${dayUsage.toFixed(4)} (${requests} requests) ${exceeded}\n`;
+                });
+                output += `\n`;
+            }
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`;
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * List quota status for all connections
+     */
+    async listConnectionQuotas() {
+        try {
+            // First get all connections
+            const connectionsResponse = await this.client.get('/api/connections');
+            const connections = connectionsResponse.data.connections || [];
+            if (connections.length === 0) {
+                return {
+                    success: true,
+                    output: 'No connections found. Use marketplace.connections.add to create one.'
+                };
+            }
+            // Sort by created_at to maintain consistent ordering
+            connections.sort((a, b) => {
+                const dateA = new Date(a.created_at || 0).getTime();
+                const dateB = new Date(b.created_at || 0).getTime();
+                return dateA - dateB;
+            });
+            let output = `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+            output += `📊 Quota Status - All Connections\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+            // Fetch and display quota for each connection
+            for (let idx = 0; idx < connections.length; idx++) {
+                const conn = connections[idx];
+                const seqId = idx + 1;
+                try {
+                    const quotaResponse = await this.client.get(`/api/connections/${conn.id}/quota`);
+                    if (quotaResponse.data.success) {
+                        const data = quotaResponse.data.data;
+                        const quota = data.quota;
+                        const dailyLimit = quota.max_daily_sales_usd ? `$${quota.max_daily_sales_usd}` : 'No limit';
+                        const monthlyLimit = quota.max_monthly_sales_usd ? `$${quota.max_monthly_sales_usd}` : 'No limit';
+                        const dailyUsage = quota.current_daily_sales_usd || 0;
+                        const monthlyUsage = quota.current_monthly_sales_usd || 0;
+                        const enforcementIcon = quota.enabled ? '✅' : '⚠️';
+                        const exceededIcon = quota.quota_exceeded ? '❌' : '✅';
+                        output += `[${seqId}] ${conn.provider?.name || 'Unknown'} - ${conn.endpoint_type}\n`;
+                        output += `    ${enforcementIcon} Enforcement: ${quota.enabled ? 'Enabled' : 'Disabled'}\n`;
+                        output += `    Daily:   $${dailyUsage.toFixed(2)} / ${dailyLimit} (${quota.daily_quota_percentage || '0'}%)\n`;
+                        output += `    Monthly: $${monthlyUsage.toFixed(2)} / ${monthlyLimit} (${quota.monthly_quota_percentage || '0'}%)\n`;
+                        output += `    Status:  ${exceededIcon} ${quota.quota_exceeded ? 'EXCEEDED' : 'Within limits'}\n`;
+                        output += `    Models:  ${data.models.available_count}/${data.models.total_count} available\n`;
+                    }
+                    else {
+                        output += `[${seqId}] ${conn.provider?.name || 'Unknown'} - ${conn.endpoint_type}\n`;
+                        output += `    ⚠️  Could not fetch quota status\n`;
+                    }
+                }
+                catch (error) {
+                    output += `[${seqId}] ${conn.provider?.name || 'Unknown'} - ${conn.endpoint_type}\n`;
+                    output += `    ❌ Error fetching quota: ${error.message}\n`;
+                }
+                if (idx < connections.length - 1) {
+                    output += `\n`;
+                }
+            }
+            output += `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+            output += `💡 Use marketplace.connections.quota.get to see detailed history for a specific connection\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`;
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    /**
+     * Update model pricing (input/output/cached/reasoning tokens)
+     * Supports both single model and bulk operations with filter
+     */
+    async updateModelPricing(args) {
+        try {
+            const { model_id, filter, source_access_level, auto_confirm = false, input_tokens_per_1k, output_tokens_per_1k, cached_input_tokens_per_1k, reasoning_tokens_per_1k, increase_percentage, decrease_percentage } = args;
+            // Determine pricing mode: exact or percentage
+            const hasExactPrices = typeof input_tokens_per_1k === 'number' && typeof output_tokens_per_1k === 'number';
+            const hasPercentage = typeof increase_percentage === 'number' || typeof decrease_percentage === 'number';
+            // Validate pricing parameters
+            if (!hasExactPrices && !hasPercentage) {
+                return {
+                    success: false,
+                    error: 'Must provide either exact prices (input_tokens_per_1k + output_tokens_per_1k) OR percentage adjustment (increase_percentage or decrease_percentage)'
+                };
+            }
+            if (hasExactPrices && hasPercentage) {
+                return {
+                    success: false,
+                    error: 'Cannot specify both exact prices and percentage adjustment. Choose one pricing method.'
+                };
+            }
+            if (typeof increase_percentage === 'number' && typeof decrease_percentage === 'number') {
+                return {
+                    success: false,
+                    error: 'Cannot specify both increase_percentage and decrease_percentage. Choose one direction.'
+                };
+            }
+            // Validate percentage range
+            if (typeof increase_percentage === 'number' && (increase_percentage <= 0 || increase_percentage > 1000)) {
+                return {
+                    success: false,
+                    error: 'increase_percentage must be between 0 and 1000'
+                };
+            }
+            if (typeof decrease_percentage === 'number' && (decrease_percentage <= 0 || decrease_percentage >= 100)) {
+                return {
+                    success: false,
+                    error: 'decrease_percentage must be between 0 and 100 (cannot decrease by 100% or more)'
+                };
+            }
+            // Check mutually exclusive parameters
+            if (model_id && filter) {
+                return {
+                    success: false,
+                    error: 'Cannot specify both model_id and filter. Use model_id for single update or filter for bulk update.'
+                };
+            }
+            if (!model_id && !filter) {
+                return {
+                    success: false,
+                    error: 'Either model_id or filter is required. Use model_id for single update or filter for bulk update.'
+                };
+            }
+            // MODE 1: Single model update
+            if (model_id && !filter) {
+                // For percentage mode, fetch current pricing first
+                if (hasPercentage) {
+                    const modelResponse = await this.client.get(`/api/models/${model_id}`);
+                    const model = modelResponse.data;
+                    if (!model) {
+                        return {
+                            success: false,
+                            error: `Model with id ${model_id} not found`
+                        };
+                    }
+                    // Calculate new prices based on percentage
+                    const multiplier = typeof increase_percentage === 'number'
+                        ? (1 + increase_percentage / 100)
+                        : (1 - decrease_percentage / 100);
+                    const currentInput = parseFloat(model.pricing?.input_per_1k || 0);
+                    const currentOutput = parseFloat(model.pricing?.output_per_1k || 0);
+                    const currentCached = parseFloat(model.pricing?.cached_input_per_1k || 0);
+                    const currentReasoning = parseFloat(model.pricing?.reasoning_per_1k || 0);
+                    const newInput = currentInput * multiplier;
+                    const newOutput = currentOutput * multiplier;
+                    const newCached = currentCached > 0 ? currentCached * multiplier : undefined;
+                    const newReasoning = currentReasoning > 0 ? currentReasoning * multiplier : undefined;
+                    return await this.updateSingleModelPricing(model_id, newInput, newOutput, newCached, newReasoning);
+                }
+                // Exact price mode
+                return await this.updateSingleModelPricing(model_id, input_tokens_per_1k, output_tokens_per_1k, cached_input_tokens_per_1k, reasoning_tokens_per_1k);
+            }
+            // MODE 2: Bulk update using filter
+            if (filter !== undefined && !model_id) {
+                // Step 1: Fetch all models with optional access level filter
+                let fetchUrl = '/api/models?limit=1000';
+                if (source_access_level) {
+                    fetchUrl += `&access_level=${source_access_level}`;
+                }
+                const response = await this.client.get(fetchUrl);
+                const allModels = response.data.models || [];
+                if (allModels.length === 0) {
+                    return {
+                        success: false,
+                        error: source_access_level
+                            ? `🔍 No ${source_access_level} models found.`
+                            : '🔍 No models found.'
+                    };
+                }
+                // Step 2: Apply keyword filter (enhanced to include capabilities)
+                const keywords = filter.trim().split(/\s+/).filter((k) => k.length > 0).map((k) => k.toLowerCase());
+                const matchedModels = allModels.filter((m) => {
+                    const modelId = (m.model_id || '').toLowerCase();
+                    const modelName = (m.model_name || '').toLowerCase();
+                    const providerName = (m.provider?.name || '').toLowerCase();
+                    // Build searchable capabilities string
+                    const capabilities = [];
+                    if (m.capabilities?.vision)
+                        capabilities.push('vision', 'image', 'photo');
+                    if (m.capabilities?.reasoning)
+                        capabilities.push('reasoning', 'think', 'o1');
+                    if (m.capabilities?.tool_use)
+                        capabilities.push('tool', 'tools', 'function');
+                    if (m.capabilities?.image_gen)
+                        capabilities.push('image', 'dalle', 'generate', 'imagen');
+                    if (m.capabilities?.video_gen)
+                        capabilities.push('video');
+                    if (m.capabilities?.audio)
+                        capabilities.push('audio', 'sound', 'speech');
+                    if (m.capabilities?.embedding)
+                        capabilities.push('embedding', 'vector');
+                    const capabilitiesText = capabilities.join(' ');
+                    // ALL keywords must match (AND condition) - check model fields AND capabilities
+                    return keywords.every((keyword) => {
+                        return modelId.includes(keyword)
+                            || modelName.includes(keyword)
+                            || providerName.includes(keyword)
+                            || capabilitiesText.includes(keyword);
+                    });
+                });
+                if (matchedModels.length === 0) {
+                    return {
+                        success: false,
+                        error: `🔍 No models matched filter: "${filter}"\n\n` +
+                            `Tip: Use space-separated keywords for AND matching.\n` +
+                            `Example: "groq llama" matches models with BOTH keywords.`
+                    };
+                }
+                // Step 3: Calculate prices for each model (different logic for percentage vs exact)
+                const modelsWithPricing = matchedModels.map((m) => {
+                    if (hasPercentage) {
+                        // Calculate new prices based on percentage
+                        const multiplier = typeof increase_percentage === 'number'
+                            ? (1 + increase_percentage / 100)
+                            : (1 - decrease_percentage / 100);
+                        const currentInput = parseFloat(m.pricing?.input_per_1k || 0);
+                        const currentOutput = parseFloat(m.pricing?.output_per_1k || 0);
+                        const currentCached = parseFloat(m.pricing?.cached_input_per_1k || 0);
+                        const currentReasoning = parseFloat(m.pricing?.reasoning_per_1k || 0);
+                        return {
+                            ...m,
+                            newPricing: {
+                                input: currentInput * multiplier,
+                                output: currentOutput * multiplier,
+                                cached: currentCached > 0 ? currentCached * multiplier : undefined,
+                                reasoning: currentReasoning > 0 ? currentReasoning * multiplier : undefined
+                            }
+                        };
+                    }
+                    else {
+                        // Exact pricing mode
+                        return {
+                            ...m,
+                            newPricing: {
+                                input: input_tokens_per_1k,
+                                output: output_tokens_per_1k,
+                                cached: cached_input_tokens_per_1k,
+                                reasoning: reasoning_tokens_per_1k
+                            }
+                        };
+                    }
+                });
+                // Step 4: Show confirmation if auto_confirm is false
+                if (!auto_confirm) {
+                    let pricingHeader = '';
+                    if (hasPercentage) {
+                        const adjType = typeof increase_percentage === 'number' ? 'Increase' : 'Decrease';
+                        const percentage = typeof increase_percentage === 'number' ? increase_percentage : decrease_percentage;
+                        pricingHeader = `${adjType} all prices by ${percentage}%`;
+                    }
+                    else {
+                        const inputPerMillion = (input_tokens_per_1k * 1000).toFixed(4);
+                        const outputPerMillion = (output_tokens_per_1k * 1000).toFixed(4);
+                        pricingHeader = `Set exact prices:\n  - Input:  $${inputPerMillion}/M ($${input_tokens_per_1k}/1K)\n  - Output: $${outputPerMillion}/M ($${output_tokens_per_1k}/1K)`;
+                    }
+                    const modelList = modelsWithPricing.slice(0, 10).map((m, idx) => {
+                        const currentInput = parseFloat(m.pricing?.input_per_1k || 0) * 1000;
+                        const currentOutput = parseFloat(m.pricing?.output_per_1k || 0) * 1000;
+                        const newInput = m.newPricing.input * 1000;
+                        const newOutput = m.newPricing.output * 1000;
+                        return `${idx + 1}. ${m.model_name || m.model_id}\n` +
+                            `   Current: $${currentInput.toFixed(4)}/M in, $${currentOutput.toFixed(4)}/M out\n` +
+                            `   New:     $${newInput.toFixed(4)}/M in, $${newOutput.toFixed(4)}/M out`;
+                    }).join('\n\n');
+                    const remaining = modelsWithPricing.length > 10 ? `\n\n... and ${modelsWithPricing.length - 10} more models` : '';
+                    return {
+                        success: false,
+                        error: `🔍 Found ${modelsWithPricing.length} model(s) matching filter: "${filter}"\n\n` +
+                            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                            `💰 Pricing Change:\n` +
+                            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                            pricingHeader + '\n\n' +
+                            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                            `📋 Models to Update (showing current → new):\n` +
+                            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                            modelList + remaining + '\n\n' +
+                            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                            `⚠️  To proceed, please confirm by calling this tool again with:\n` +
+                            `   auto_confirm: true\n\n` +
+                            `Or cancel by not making the call.`
+                    };
+                }
+                // Step 5: Update all matched models with rate limiting
+                const results = [];
+                const errors = [];
+                // Helper function to delay between requests to avoid rate limits
+                const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+                for (let i = 0; i < modelsWithPricing.length; i++) {
+                    const model = modelsWithPricing[i];
+                    try {
+                        const result = await this.updateSingleModelPricing(model.id, model.newPricing.input, model.newPricing.output, model.newPricing.cached, model.newPricing.reasoning);
+                        if (result.success) {
+                            results.push({
+                                id: model.id,
+                                name: model.model_name || model.model_id
+                            });
+                        }
+                        else {
+                            errors.push({
+                                id: model.id,
+                                name: model.model_name || model.model_id,
+                                error: result.error
+                            });
+                        }
+                    }
+                    catch (err) {
+                        // Check if it's a rate limit error
+                        if (err.response?.status === 429) {
+                            errors.push({
+                                id: model.id,
+                                name: model.model_name || model.model_id,
+                                error: 'Rate limit exceeded - try again with fewer models or wait a moment'
+                            });
+                            // Stop processing further to avoid more rate limit errors
+                            break;
+                        }
+                        errors.push({
+                            id: model.id,
+                            name: model.model_name || model.model_id,
+                            error: err.response?.data?.error?.message || err.message
+                        });
+                    }
+                    // Add delay between requests to avoid rate limiting (200ms per request)
+                    if (i < modelsWithPricing.length - 1) {
+                        await delay(200);
+                    }
+                }
+                // Step 6: Build response
+                let pricingSummary = '';
+                if (hasPercentage) {
+                    const adjType = typeof increase_percentage === 'number' ? 'increased' : 'decreased';
+                    const percentage = typeof increase_percentage === 'number' ? increase_percentage : decrease_percentage;
+                    pricingSummary = `Pricing ${adjType} by ${percentage}%`;
+                }
+                else {
+                    const inputPerMillion = (input_tokens_per_1k * 1000).toFixed(4);
+                    const outputPerMillion = (output_tokens_per_1k * 1000).toFixed(4);
+                    pricingSummary = `New Pricing: $${inputPerMillion}/M input, $${outputPerMillion}/M output`;
+                }
+                let output = `✅ Bulk pricing update completed!\n\n`;
+                if (results.length > 0) {
+                    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                    output += `✅ Successfully updated (${results.length} models):\n`;
+                    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                    output += `${pricingSummary}\n\n`;
+                    results.forEach((r, idx) => {
+                        output += `${idx + 1}. ${r.name}\n`;
+                    });
+                }
+                if (errors.length > 0) {
+                    output += `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                    output += `❌ Failed (${errors.length} models):\n`;
+                    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                    errors.forEach((e, idx) => {
+                        output += `${idx + 1}. ${e.name}\n   Error: ${e.error}\n\n`;
+                    });
+                }
+                return {
+                    success: results.length > 0,
+                    output
+                };
+            }
+            // Error: Must provide either model_id or filter
+            return {
+                success: false,
+                error: 'Must provide either model_id (for single update) or filter (for bulk update), but not both'
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message
+                || error.response?.data?.message
+                || error.message
+                || 'An unexpected error occurred while updating pricing';
+            console.error('[updateModelPricing] Error:', errorMessage, error);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Helper: Update pricing for a single model
+     */
+    async updateSingleModelPricing(model_id, input_tokens_per_1k, output_tokens_per_1k, cached_input_tokens_per_1k, reasoning_tokens_per_1k) {
+        // Build request body
+        const body = {
+            price_per_1k_input_tokens: input_tokens_per_1k,
+            price_per_1k_output_tokens: output_tokens_per_1k
+        };
+        // Add optional pricing
+        if (typeof cached_input_tokens_per_1k === 'number') {
+            body.price_per_1k_cached_input_tokens = cached_input_tokens_per_1k;
+        }
+        if (typeof reasoning_tokens_per_1k === 'number') {
+            body.price_per_1k_reasoning_tokens = reasoning_tokens_per_1k;
+        }
+        const response = await this.client.patch(`/api/models/${encodeURIComponent(model_id)}/pricing`, body);
+        if (!response.data.success) {
+            return {
+                success: false,
+                error: response.data.error?.message || 'Failed to update model pricing'
+            };
+        }
+        const model = response.data.model;
+        // Calculate per-million prices for display
+        const inputPerMillion = (input_tokens_per_1k * 1000).toFixed(4);
+        const outputPerMillion = (output_tokens_per_1k * 1000).toFixed(4);
+        const pricingLines = [
+            `  Input Tokens:     $${inputPerMillion}/M tokens ($${input_tokens_per_1k}/1K)`,
+            `  Output Tokens:    $${outputPerMillion}/M tokens ($${output_tokens_per_1k}/1K)`
+        ];
+        if (cached_input_tokens_per_1k !== undefined) {
+            const cachedPerMillion = (cached_input_tokens_per_1k * 1000).toFixed(4);
+            pricingLines.push(`  Cached Input:     $${cachedPerMillion}/M tokens ($${cached_input_tokens_per_1k}/1K)`);
+        }
+        if (reasoning_tokens_per_1k !== undefined) {
+            const reasoningPerMillion = (reasoning_tokens_per_1k * 1000).toFixed(4);
+            pricingLines.push(`  Reasoning Tokens: $${reasoningPerMillion}/M tokens ($${reasoning_tokens_per_1k}/1K)`);
+        }
+        return {
+            success: true,
+            output: `✅ Model pricing updated successfully!\n\n` +
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                `💰 Pricing Details:\n` +
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                `  Model:            ${model.model_name || model_id}\n` +
+                `  Model ID:         ${model_id}\n` +
+                `  Provider:         ${model.provider?.name || 'Unknown'}\n\n` +
+                pricingLines.join('\n') + '\n\n' +
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                `Updated: ${new Date(model.updated_at).toLocaleString()}`
+        };
+    }
+    /**
+     * Publish or unpublish a model (set access level)
+     */
+    async publishModel(args) {
+        try {
+            const { model_id, filter, access_level, auto_confirm = false, source_access_level } = args;
+            if (!access_level) {
+                return {
+                    success: false,
+                    error: 'access_level is required (must be "public", "private", or "disabled")'
+                };
+            }
+            // Validate access level
+            const validLevels = ['public', 'private', 'disabled'];
+            if (!validLevels.includes(access_level)) {
+                return {
+                    success: false,
+                    error: `Invalid access_level: "${access_level}". Must be one of: ${validLevels.join(', ')}`
+                };
+            }
+            // Check mutually exclusive parameters
+            if (model_id && filter) {
+                return {
+                    success: false,
+                    error: 'Cannot specify both model_id and filter. Use model_id for single update or filter for bulk update.'
+                };
+            }
+            if (!model_id && !filter) {
+                return {
+                    success: false,
+                    error: 'Either model_id or filter is required. Use model_id for single update or filter for bulk update.'
+                };
+            }
+            // SINGLE MODEL MODE
+            if (model_id) {
+                return await this.updateSingleModelAccess(model_id, access_level);
+            }
+            // BULK MODE - Filter-based operation
+            // Step 1: Determine source access level based on target
+            // When unpublishing -> fetch public models
+            // When publishing -> fetch private models
+            // When disabling -> can fetch any (or use source_access_level if provided)
+            let effectiveSourceLevel = source_access_level;
+            if (!effectiveSourceLevel) {
+                if (access_level === 'private') {
+                    // Unpublishing: fetch currently public models
+                    effectiveSourceLevel = 'public';
+                }
+                else if (access_level === 'organization') {
+                    // Publishing: fetch currently private models
+                    effectiveSourceLevel = 'private';
+                }
+                else if (access_level === 'disabled') {
+                    // Disabling: can disable any active model (public or private)
+                    // Don't set effectiveSourceLevel, fetch all
+                }
+            }
+            // Step 2: Fetch models with correct access level filter
+            const fetchParams = { limit: 1000 }; // High limit for bulk operations
+            if (effectiveSourceLevel) {
+                fetchParams.access_level = effectiveSourceLevel;
+            }
+            const listResponse = await this.client.get('/api/models', { params: fetchParams });
+            if (!listResponse.data.success) {
+                return {
+                    success: false,
+                    error: 'Failed to fetch models for filtering'
+                };
+            }
+            let allModels = listResponse.data.models || [];
+            // Step 3: Apply keyword filter (same logic as UI)
+            const keywords = filter.trim().split(/\s+/).filter((k) => k.length > 0).map((k) => k.toLowerCase());
+            const matchedModels = allModels.filter((m) => {
+                const modelId = (m.model_id || '').toLowerCase();
+                const modelName = (m.model_name || '').toLowerCase();
+                // All keywords must match (AND condition)
+                return keywords.every((keyword) => {
+                    return modelId.includes(keyword) || modelName.includes(keyword);
+                });
+            });
+            if (matchedModels.length === 0) {
+                const actionHint = access_level === 'private'
+                    ? '(only searching in your public models)'
+                    : access_level === 'organization'
+                        ? '(only searching in your private models)'
+                        : '';
+                return {
+                    success: true,
+                    output: `🔍 No models matched filter: "${filter}" ${actionHint}\n\n` +
+                        `Tip: Use space-separated keywords for AND matching.\n` +
+                        `Example: "groq llama" matches models with BOTH keywords.`
+                };
+            }
+            // Step 3: Show matched models and ask for confirmation (unless auto_confirm)
+            const formatAccessLevel = (level) => {
+                switch (level) {
+                    case 'public': return '🌍 Public';
+                    case 'private': return '🔒 Private';
+                    case 'disabled': return '🚫 Disabled';
+                    default: return level;
+                }
+            };
+            const modelList = matchedModels.map((m, idx) => {
+                return `${idx + 1}. ${m.model_name || m.model_id}\n` +
+                    `   ID: ${m.id}\n` +
+                    `   Current: ${formatAccessLevel(m.access_level)} → Target: ${formatAccessLevel(access_level)}`;
+            }).join('\n\n');
+            if (!auto_confirm) {
+                // Return matched models for user confirmation
+                const actionVerb = access_level === 'organization' ? 'publish' : access_level === 'private' ? 'delist/unpublish' : 'disable';
+                return {
+                    success: true,
+                    output: `🔍 Found ${matchedModels.length} model(s) matching filter: "${filter}"\n\n` +
+                        `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                        `📋 Models to ${actionVerb}:\n` +
+                        `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                        modelList + '\n\n' +
+                        `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                        `⚠️  To proceed, please confirm by calling this tool again with:\n` +
+                        `   auto_confirm: true\n\n` +
+                        `Or cancel by not making the call.`
+                };
+            }
+            // Step 4: Update all matched models with rate limiting
+            const results = [];
+            const errors = [];
+            // Helper function to delay between requests to avoid rate limits
+            const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+            for (let i = 0; i < matchedModels.length; i++) {
+                const model = matchedModels[i];
+                try {
+                    const response = await this.client.patch(`/api/models/${encodeURIComponent(model.id)}/access`, {
+                        access_level
+                    });
+                    if (response.data.success) {
+                        results.push({
+                            id: model.id,
+                            name: model.model_name || model.model_id,
+                            success: true
+                        });
+                    }
+                    else {
+                        errors.push({
+                            id: model.id,
+                            name: model.model_name || model.model_id,
+                            error: response.data.error?.message || 'Unknown error'
+                        });
+                    }
+                }
+                catch (err) {
+                    // Check if it's a rate limit error
+                    if (err.response?.status === 429) {
+                        errors.push({
+                            id: model.id,
+                            name: model.model_name || model.model_id,
+                            error: 'Rate limit exceeded - try again with fewer models or wait a moment'
+                        });
+                        // Stop processing further to avoid more rate limit errors
+                        break;
+                    }
+                    else {
+                        errors.push({
+                            id: model.id,
+                            name: model.model_name || model.model_id,
+                            error: err.response?.data?.error?.message || err.message
+                        });
+                    }
+                }
+                // Add delay between requests to avoid rate limiting (200ms per request)
+                // Skip delay for last item
+                if (i < matchedModels.length - 1) {
+                    await delay(200);
+                }
+            }
+            // Step 5: Format results
+            const actionVerb = access_level === 'organization' ? 'published' : access_level === 'private' ? 'delisted' : 'disabled';
+            let output = `✅ Bulk update completed!\n\n`;
+            if (results.length > 0) {
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                output += `✅ Successfully ${actionVerb} (${results.length} model${results.length > 1 ? 's' : ''}):\n`;
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                results.forEach((r, idx) => {
+                    output += `${idx + 1}. ${r.name}\n`;
+                });
+                output += '\n';
+            }
+            if (errors.length > 0) {
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                output += `❌ Failed (${errors.length} model${errors.length > 1 ? 's' : ''}):\n`;
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                errors.forEach((e, idx) => {
+                    output += `${idx + 1}. ${e.name}\n   Error: ${e.error}\n\n`;
+                });
+            }
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    async updateSingleModelAccess(model_id, access_level) {
+        try {
+            const response = await this.client.patch(`/api/models/${encodeURIComponent(model_id)}/access`, {
+                access_level
+            });
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error?.message || 'Failed to update model access level'
+                };
+            }
+            const model = response.data.data;
+            // Format access level description
+            let accessDescription = '';
+            let statusEmoji = '';
+            switch (access_level) {
+                case 'public':
+                    statusEmoji = '🌍';
+                    accessDescription = 'Public - Available to all marketplace users';
+                    break;
+                case 'private':
+                    statusEmoji = '🔒';
+                    accessDescription = 'Private - Only you can use this model';
+                    break;
+                case 'disabled':
+                    statusEmoji = '🚫';
+                    accessDescription = 'Disabled - Not available to anyone';
+                    break;
+            }
+            return {
+                success: true,
+                output: `✅ ${model.message || 'Model access level updated successfully!'}\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `${statusEmoji} Model Access Settings:\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                    `  Model:          ${model.display_name || model.category_key || model_id}\n` +
+                    `  Model ID:       ${model_id}\n\n` +
+                    `  Access Level:   ${access_level.toUpperCase()}\n` +
+                    `  Description:    ${accessDescription}\n\n` +
+                    `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                    (access_level === 'organization'
+                        ? `ℹ️  Your model is now listed in the marketplace and available for\n` +
+                            `   other users to consume. You'll earn revenue when others use it.\n\n`
+                        : access_level === 'private'
+                            ? `ℹ️  Your model is now private and only accessible to you.\n\n`
+                            : `ℹ️  Your model is now disabled and not available for use.\n\n`) +
+                    `Updated: ${new Date(model.updated_at).toLocaleString()}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error?.message || error.message
+            };
+        }
+    }
+    // ========================================================================
+    // WORKFLOW QUERY TOOL IMPLEMENTATIONS
+    // ========================================================================
+    /**
+     * Get overall status of a workflow execution
+     */
+    async getWorkflowStatus(traceId) {
+        try {
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Getting workflow status for trace: ${traceId}`);
+            const response = await this.client.get(`/api/agents/executions/${traceId}/trace`);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error || 'Failed to get workflow status'
+                };
+            }
+            const { workflowName, status, startedAt, completedAt, instances } = response.data;
+            // Calculate progress
+            const total = instances?.length || 0;
+            const completed = instances?.filter((i) => i.status === 'completed').length || 0;
+            const failed = instances?.filter((i) => i.status === 'failed').length || 0;
+            const running = instances?.filter((i) => i.status === 'active' || i.status === 'running').length || 0;
+            let statusEmoji = '⏳';
+            if (status === 'completed')
+                statusEmoji = '✅';
+            else if (status === 'failed')
+                statusEmoji = '❌';
+            else if (status === 'running')
+                statusEmoji = '🔄';
+            let output = `${statusEmoji} Workflow Execution Status\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+            output += `  Workflow:    ${workflowName || 'Unnamed Workflow'}\n`;
+            output += `  Trace ID:    ${traceId}\n`;
+            output += `  Status:      ${status?.toUpperCase() || 'UNKNOWN'}\n\n`;
+            output += `  Progress:    ${completed}/${total} agents completed\n`;
+            if (running > 0)
+                output += `  Running:     ${running} agent(s)\n`;
+            if (failed > 0)
+                output += `  Failed:      ${failed} agent(s)\n`;
+            output += `\n`;
+            if (startedAt)
+                output += `  Started:     ${new Date(startedAt).toLocaleString()}\n`;
+            if (completedAt)
+                output += `  Completed:   ${new Date(completedAt).toLocaleString()}\n`;
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error || error.message
+            };
+        }
+    }
+    /**
+     * List all instances in a workflow execution
+     */
+    async listWorkflowInstances(traceId) {
+        try {
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Listing workflow instances for trace: ${traceId}`);
+            const response = await this.client.get(`/api/agents/executions/${traceId}/trace`);
+            if (!response.data.success) {
+                return {
+                    success: false,
+                    error: response.data.error || 'Failed to list workflow instances'
+                };
+            }
+            const { workflowName, instances } = response.data;
+            if (!instances || instances.length === 0) {
+                return {
+                    success: true,
+                    output: 'No instances found for this workflow execution.'
+                };
+            }
+            let output = `📋 Workflow Instances\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+            output += `  Workflow: ${workflowName || 'Unnamed Workflow'}\n`;
+            output += `  Total Agents: ${instances.length}\n\n`;
+            for (const instance of instances) {
+                let statusEmoji = '⏳';
+                if (instance.status === 'completed')
+                    statusEmoji = '✅';
+                else if (instance.status === 'failed')
+                    statusEmoji = '❌';
+                else if (instance.status === 'active' || instance.status === 'running')
+                    statusEmoji = '🔄';
+                let roleEmoji = '🤖';
+                if (instance.nodeType === 'START')
+                    roleEmoji = '🚀';
+                else if (instance.nodeType === 'END')
+                    roleEmoji = '🏁';
+                output += `${roleEmoji} [${instance.executionOrder}] ${instance.definitionName || instance.name}\n`;
+                output += `   ID: ${instance.id}\n`;
+                output += `   Role: ${instance.nodeType}\n`;
+                output += `   Status: ${statusEmoji} ${instance.status?.toUpperCase() || 'PENDING'}\n`;
+                if (instance.errorMessage) {
+                    output += `   Error: ${instance.errorMessage}\n`;
+                }
+                output += `\n`;
+            }
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error || error.message
+            };
+        }
+    }
+    /**
+     * Get output from a specific agent instance
+     */
+    async getInstanceOutput(instanceId) {
+        try {
+            (0, debug_utils_1.debugLog)(`[MarketplaceTools] Getting instance output for: ${instanceId}`);
+            // Get the instance trace which includes sessions
+            const traceResponse = await this.client.get(`/api/agents/instances/${instanceId}/trace`);
+            if (!traceResponse.data?.success) {
+                return {
+                    success: false,
+                    error: traceResponse.data?.error || 'Instance not found'
+                };
+            }
+            const instance = traceResponse.data.instance;
+            const sessions = traceResponse.data.sessions || [];
+            if (sessions.length === 0) {
+                return {
+                    success: true,
+                    output: `📦 Instance Output\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+                        `  Instance: ${instance.name || instanceId}\n` +
+                        `  Status: No sessions found - agent has not run yet.\n`
+                };
+            }
+            const latestSession = sessions[0];
+            let statusEmoji = '⏳';
+            if (latestSession.status === 'completed')
+                statusEmoji = '✅';
+            else if (latestSession.status === 'failed')
+                statusEmoji = '❌';
+            else if (latestSession.status === 'active')
+                statusEmoji = '🔄';
+            let output = `📦 Instance Output\n`;
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+            output += `  Instance:   ${instance.name || instanceId}\n`;
+            output += `  Definition: ${instance.definition_name || 'Unknown'}\n`;
+            output += `  Status:     ${statusEmoji} ${latestSession.status?.toUpperCase() || 'UNKNOWN'}\n\n`;
+            if (latestSession.error_message) {
+                output += `  ❌ Error: ${latestSession.error_message}\n\n`;
+            }
+            // Try to get the assistant's response from the session
+            if (latestSession.response) {
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                output += `Response:\n`;
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                output += latestSession.response;
+            }
+            else if (latestSession.metadata?.output) {
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+                output += `Output:\n`;
+                output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+                output += JSON.stringify(latestSession.metadata.output, null, 2);
+            }
+            else {
+                output += `  No output available yet.\n`;
+            }
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.response?.data?.error || error.message
+            };
+        }
+    }
+}
+exports.MarketplaceTools = MarketplaceTools;
+MarketplaceTools.instance = null;
+//# sourceMappingURL=marketplace-tools.js.map