@impart-security/impart-mcp 0.1.2 → 0.2.0

package/dist/index.js

@@ -18,6 +18,46 @@ const server = new mcp_js_1.McpServer({
 function validatePage(page) {
     return Math.max(1, page); // Ensure page is at least 1
 }
+// Helper function to convert date strings to Date objects recursively
+function convertDatesToObjects(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(convertDatesToObjects);
+    }
+    if (typeof obj === "object") {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // Convert RFC3339 date strings to Date objects
+            if (typeof value === "string" && isDateField(key)) {
+                try {
+                    // Check if it looks like an ISO date string
+                    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.exec(value)) {
+                        converted[key] = new Date(value);
+                    }
+                    else {
+                        // For debugging: if it's a date field but doesn't match pattern, keep as null
+                        converted[key] = null;
+                    }
+                }
+                catch {
+                    converted[key] = null; // Set to null if date parsing fails
+                }
+            }
+            else {
+                converted[key] = convertDatesToObjects(value);
+            }
+        }
+        return converted;
+    }
+    return obj;
+}
+// Helper function to identify date fields
+function isDateField(key) {
+    const dateFieldPatterns = ["createdAt", "updatedAt", "lastSeen", "observedAt", "from", "until", "expiration"];
+    return dateFieldPatterns.includes(key) || key.endsWith("At");
+}
 // Helper function for making Impart API requests
 async function makeImpartRequest(endpoint, queryParams, method = "GET", body) {
     const headers = {
@@ -42,56 +82,186 @@ async function makeImpartRequest(endpoint, queryParams, method = "GET", body) {
         });
     }
     try {
-        const response = await fetch(url.toString(), {
+        const requestOptions = {
             method,
             headers,
-            body: body ? JSON.stringify(body) : "",
-        });
+        };
+        if (body && method !== "GET" && method !== "HEAD") {
+            requestOptions.body = JSON.stringify(body);
+        }
+        // Log request details for debugging
+        console.error(`[makeImpartRequest] ${method} ${url.toString()}`);
+        console.error(`[makeImpartRequest] Headers:`, JSON.stringify(headers, null, 2));
+        if (body) {
+            console.error(`[makeImpartRequest] Body:`, JSON.stringify(body, null, 2));
+        }
+        const response = await fetch(url.toString(), requestOptions);
+        console.error(`[makeImpartRequest] Response status: ${response.status} ${response.statusText}`);
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            let errorMessage = `HTTP error! status: ${response.status}`;
+            try {
+                const errorBody = await response.text();
+                if (errorBody)
+                    errorMessage += ` - ${errorBody}`;
+            }
+            catch (e) {
+                // Ignore error reading response body
+            }
+            throw new Error(errorMessage);
         }
-        return (await response.json());
+        const jsonData = await response.json();
+        const converted = convertDatesToObjects(jsonData);
+        return converted;
     }
     catch (error) {
         console.error("Error making Impart request:", error);
+        // Parse API error for better AI-friendly messages
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            const message = error.message;
+            // Extract HTTP status and body for better error messages
+            if (message.includes("status: 400")) {
+                // Extract error details from response body
+                const bodyMatch = message.match(/status: 400 - (.+)/);
+                if (bodyMatch) {
+                    errorMessage = `Bad Request - ${bodyMatch[1]}`;
+                }
+                else {
+                    errorMessage =
+                        "Bad Request - Invalid parameters or format. Check parameter types, ranges, and formats (e.g., time strings should be '-1d', '-24h', or ISO 8601).";
+                }
+            }
+            else if (message.includes("status: 401")) {
+                errorMessage = "Unauthorized - Invalid or expired API token. Please check your IMPART_AUTH_TOKEN.";
+            }
+            else if (message.includes("status: 403")) {
+                const scopeMatch = message.match(/Insufficient scope|permissions/i);
+                if (scopeMatch) {
+                    errorMessage = "Forbidden - Insufficient permissions. Your API token does not have the required scope for this operation.";
+                }
+                else {
+                    errorMessage = "Forbidden - Access denied. Please check your API token has the correct permissions.";
+                }
+            }
+            else if (message.includes("status: 404")) {
+                errorMessage = "Not Found - The requested resource does not exist or may have been deleted.";
+            }
+            else if (message.includes("status: 422")) {
+                const bodyMatch = message.match(/status: 422 - (.+)/);
+                if (bodyMatch) {
+                    errorMessage = `Validation Error - ${bodyMatch[1]}`;
+                }
+                else {
+                    errorMessage = "Validation Error - One or more parameters failed validation.";
+                }
+            }
+            else if (message.includes("status: 429")) {
+                errorMessage = "Rate Limit Exceeded - Too many requests. Please wait before retrying.";
+            }
+            else if (message.includes("status: 500")) {
+                errorMessage = "Server Error - Internal server error. Please try again later.";
+            }
+            else if (message.includes("status: 503")) {
+                errorMessage = "Service Unavailable - API is temporarily unavailable. Please try again later.";
+            }
+            else {
+                errorMessage = message;
+            }
+        }
+        makeImpartRequest.lastError = errorMessage;
         return null;
     }
 }
+// Helper function to generate tool names with orgId
+function getToolName(baseName) {
+    return `${baseName}_${config_js_1.config.orgId.slice(-4)}`;
+}
+// Helper function to validate pagination parameters
+function validatePagination(page, max_results) {
+    if (page !== null && page !== undefined && page < 1) {
+        return {
+            valid: false,
+            error: "Invalid pagination: 'page' must be >= 1. Example: page=1",
+        };
+    }
+    if (max_results !== null && max_results !== undefined) {
+        if (max_results < 1) {
+            return {
+                valid: false,
+                error: "Invalid pagination: 'max_results' must be >= 1. Example: max_results=10",
+            };
+        }
+        if (max_results > 1000) {
+            return {
+                valid: false,
+                error: "Invalid pagination: 'max_results' must be <= 1000. Maximum allowed is 1000.",
+            };
+        }
+    }
+    return { valid: true };
+}
+// Helper function to validate time format
+function validateTimeFormat(time) {
+    // Relative time format: -1d, -24h, -7d, etc.
+    const relativeTimeRegex = /^-\d+[dhms]$/;
+    if (relativeTimeRegex.test(time)) {
+        return { valid: true };
+    }
+    // ISO 8601 timestamp
+    try {
+        const date = new Date(time);
+        if (!isNaN(date.getTime())) {
+            return { valid: true };
+        }
+    }
+    catch {
+        // Fall through to error
+    }
+    return {
+        valid: false,
+        error: `Invalid time format '${time}'. Use relative time (e.g., '-1d', '-24h', '-7d') or ISO 8601 timestamp (e.g., '2025-10-14T12:00:00Z').`,
+    };
+}
 // Register tools with consistent naming patterns
-server.tool("list_inspectors", "Get a list of inspectors for the organization", {
-    page: zod_1.z
-        .number()
-        .default(1)
-        .describe("The page of results to return (minimum value: 1)"),
+server.tool(getToolName("list_inspectors"), "Get a list of inspectors for the organization", {
+    page: zod_1.z.number().default(1).optional().describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
+        .optional()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
 }, async ({ page, max_results }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-    };
+    // Validate pagination parameters
+    const paginationCheck = validatePagination(page, max_results);
+    if (!paginationCheck.valid) {
+        return {
+            content: [{ type: "text", text: paginationCheck.error }],
+        };
+    }
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = page;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
     const data = await makeImpartRequest("inspectors", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch inspectors: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch inspectors: ${lastError}` }],
         };
     }
     const inspectors = data.items || [];
     if (inspectors.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No inspectors found for this organization." },
-            ],
+            content: [{ type: "text", text: "No inspectors found for this organization." }],
         };
     }
     const formattedInspectors = inspectors.map((inspector) => [
         `ID: ${inspector.id}`,
         `Version: ${inspector.version}`,
-        `Last Seen: ${inspector.last_seen}`,
+        `Last Seen: ${inspector.lastSeen ? inspector.lastSeen.toISOString() : "N/A"}`,
         "---",
     ].join("\n"));
     return {
@@ -99,54 +269,71 @@ server.tool("list_inspectors", "Get a list of inspectors for the organization",
     };
 });
 // Rules Script Tools
-server.tool("list_rules_scripts", "Get a list of rules scripts for your Impart organization", {
+server.tool(getToolName("list_rules_scripts"), "Get a list of rules scripts for your Impart organization", {
     page: zod_1.z
         .number()
+        .optional()
         .default(1)
-        .describe("The page of results to return (minimum value: 1)"),
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
+        .optional()
         .default(100)
-        .describe("The maximum number of results to return"),
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
     type: zod_1.z
-        .string()
+        .enum(["custom", "core", "recipe"])
         .optional()
-        .describe("Filter by type of rule script ('custom' or 'core')"),
-    exclude_src: zod_1.z
-        .boolean()
-        .default(false)
-        .describe("Whether to exclude the rule script source"),
+        .describe("Filter by type of rule script ('custom', 'core' or 'recipe')"),
+    exclude_src: zod_1.z.boolean().optional().default(false).nullable().describe("Whether to exclude the rule script source"),
     exclude_revisions: zod_1.z
         .boolean()
+        .optional()
         .default(false)
+        .nullable()
         .describe("Whether to exclude rule script revisions"),
-    is_disabled: zod_1.z
-        .string()
+    is_disabled: zod_1.z.string().optional().describe("Filter by disabled status ('true' or 'false')"),
+    label: zod_1.z
+        .array(zod_1.z.string())
         .optional()
-        .describe("Filter by disabled status ('true' or 'false')"),
-    label: zod_1.z.array(zod_1.z.string()).optional().describe("Filter by label slugs"),
-}, async ({ page, max_results, type, exclude_src, exclude_revisions, is_disabled, label, }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-        type,
-        exclude_src,
-        exclude_revisions,
-        is_disabled,
-        label,
-    };
+        .nullable()
+        .describe('Filter by label slugs (e.g., ["llm-protection", "waf"])'),
+}, async ({ page, max_results, type, exclude_src, exclude_revisions, is_disabled, label }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (type !== null && type !== undefined) {
+        queryParams["type"] = type;
+    }
+    if (exclude_src !== null && exclude_src !== undefined) {
+        queryParams["exclude_src"] = exclude_src;
+    }
+    if (exclude_revisions !== null && exclude_revisions !== undefined) {
+        queryParams["exclude_revisions"] = exclude_revisions;
+    }
+    if (is_disabled !== null && is_disabled !== undefined) {
+        queryParams["is_disabled"] = is_disabled;
+    }
+    if (label !== null && label !== undefined) {
+        queryParams["label"] = label;
+    }
     const data = await makeImpartRequest("rules_scripts", queryParams);
     if (!data) {
         return {
             content: [
                 {
                     type: "text",
-                    text: "Unable to fetch rules scripts: Unknown error",
+                    text: `Unable to fetch rules scripts: ${makeImpartRequest.lastError || "Unknown error"}`,
                 },
             ],
         };
     }
-    const scripts = data.items || [];
+    const scripts = data.items;
     if (scripts.length === 0) {
         return {
             content: [
@@ -157,46 +344,40 @@ server.tool("list_rules_scripts", "Get a list of rules scripts for your Impart o
             ],
         };
     }
-    const formattedScripts = scripts.map((script) => [
-        `ID: ${script.id}`,
-        `Name: ${script.name}`,
-        `Description: ${script.description ?? "N/A"}`,
-        `Type: ${script.type}`,
-        `Disabled: ${script.disabled}`,
-        `Blocking Effect: ${script.blocking_effect}`,
-        `Language: ${script.lang}`,
-        `Revision: ${script.revision}`,
-        `Labels: ${script.labels.join(", ")}`,
-        `Created By: ${script.created_by}`,
-        `Created At: ${script.created_at}`,
-        `Updated By: ${script.updated_by}`,
-        `Updated At: ${script.updated_at}`,
-        "---",
-    ].join("\n"));
+    // Limit display for performance
+    const maxDisplay = Math.min(scripts.length, 15);
+    const showingLimited = scripts.length > maxDisplay;
+    const result = [
+        `Found ${scripts.length} rules scripts`,
+        showingLimited ? `Showing first ${maxDisplay} for performance. Use filters to narrow results.` : "",
+        "=".repeat(50),
+        "",
+    ];
+    scripts.slice(0, maxDisplay).forEach((script, index) => {
+        result.push(`${index + 1}. ${script.name} (${script.type})`, `   ID: ${script.id} | Rev: ${script.revision} | ${script.disabled ? "DISABLED" : "ENABLED"}`, `   Labels: ${script.labels.length > 0 ? script.labels.join(", ") : "None"}`, `   Created: ${script.createdAt ? script.createdAt.toISOString() : "N/A"}`, "");
+    });
     return {
-        content: [{ type: "text", text: formattedScripts.join("\n") }],
+        content: [{ type: "text", text: result.join("\n") }],
     };
 });
-server.tool("get_rules_script", "Get details of a specific rules script", {
-    rules_script_id: zod_1.z
-        .string()
-        .describe("The unique identifier of the rules script"),
-    revision: zod_1.z.number().optional().describe("The specific revision to fetch"),
+server.tool(getToolName("get_rules_script"), "Get details of a specific rules script", {
+    rules_script_id: zod_1.z.string().describe("The unique identifier of the rules script"),
+    revision: zod_1.z.number().optional().nullable().describe("The specific revision to fetch"),
 }, async ({ rules_script_id, revision }) => {
     if (!rules_script_id) {
         return {
-            content: [
-                { type: "text", text: "Error: rules_script_id is required." },
-            ],
+            content: [{ type: "text", text: "Error: rules_script_id is required." }],
         };
     }
-    const queryParams = revision ? { revision } : undefined;
+    const queryParams = {};
+    if (revision !== null && revision !== undefined) {
+        queryParams["revision"] = revision;
+    }
     const data = await makeImpartRequest(`rules_scripts/${rules_script_id}`, queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch rules script: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch rules script: ${lastError}` }],
         };
     }
     const formattedScript = [
@@ -205,257 +386,316 @@ server.tool("get_rules_script", "Get details of a specific rules script", {
         `Description: ${data.description ?? "N/A"}`,
         `Type: ${data.type}`,
         `Disabled: ${data.disabled}`,
-        `Blocking Effect: ${data.blocking_effect}`,
+        `Blocking Effect: ${data.blockingEffect}`,
         `Language: ${data.lang}`,
         `Source Code: ${data.src ?? "N/A"}`,
-        `Autogenerated Explanation: ${data.autogenerated_explanation ?? "N/A"}`,
+        `Autogenerated Explanation: ${data.autogeneratedExplanation}`,
         `Revision: ${data.revision}`,
         `Dependencies: ${(data.dependencies ?? []).join(", ")}`,
         `Labels: ${data.labels.join(", ")}`,
-        `Created By: ${data.created_by}`,
-        `Created At: ${data.created_at}`,
-        `Updated By: ${data.updated_by}`,
-        `Updated At: ${data.updated_at}`,
+        `Created By: ${data.createdBy}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+        `Updated By: ${data.updatedBy}`,
+        `Updated At: ${data.updatedAt?.toISOString() ?? "N/A"}`,
         "---",
         "Revisions:",
     ];
     data.revisions.forEach((revision) => {
-        formattedScript.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.created_by}`, `  Created At: ${revision.created_at}`, "---");
+        formattedScript.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.createdBy}`, `  Created At: ${revision.createdAt ? revision.createdAt.toISOString() : "N/A"}`, "---");
     });
     return {
         content: [{ type: "text", text: formattedScript.join("\n") }],
     };
 });
-server.tool("create_rules_script", "Creates a new rules script for the organization", {
-    name: zod_1.z.string().describe("The name of the rules script"),
-    src: zod_1.z
-        .string()
-        .describe("The base64-encoded source code of the rules script"),
-    lang: zod_1.z
-        .string()
-        .default("assemblyscript")
-        .describe("The language of the script"),
-    description: zod_1.z
-        .string()
+// Rule Recipe Tools
+// -----------------
+server.tool(getToolName("list_rule_recipes"), "Get a list of rule recipes for your Impart organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
         .optional()
-        .describe("Optional description of the script"),
-    blocking_effect: zod_1.z
-        .string()
-        .default("block")
-        .describe("Effect when rule blocks"),
-    disabled: zod_1.z
-        .boolean()
-        .default(false)
-        .describe("Whether the script is disabled"),
-    labels: zod_1.z
-        .array(zod_1.z.string())
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
         .optional()
-        .describe("Optional list of label slugs"),
-}, async ({ name, src, lang, description, blocking_effect, disabled, labels, }) => {
-    const payload = {
-        name,
-        src,
-        lang,
-        description,
-        blocking_effect,
-        disabled,
-        labels: labels ?? [],
-    };
-    const data = await makeImpartRequest("rules_scripts", undefined, "POST", payload);
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    search: zod_1.z.string().optional().describe("Search string to filter rule recipes"),
+}, async ({ page, max_results, search }) => {
+    // Validate pagination parameters
+    const paginationCheck = validatePagination(page, max_results);
+    if (!paginationCheck.valid) {
+        return { content: [{ type: "text", text: paginationCheck.error }] };
+    }
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = page;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
+    const data = await makeImpartRequest("rule_recipes", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to create rules script" }],
+            content: [{ type: "text", text: `Unable to fetch rule recipes: ${lastError}` }],
         };
     }
-    const formattedScript = [
-        "Rules script created successfully:",
-        `ID: ${data.id}`,
-        `Name: ${data.name}`,
-        `Description: ${data.description ?? "N/A"}`,
-        `Language: ${data.lang}`,
-        `Blocking Effect: ${data.blocking_effect}`,
-        `Disabled: ${data.disabled}`,
-        `Labels: ${data.labels.join(", ")}`,
-        `Created At: ${data.created_at}`,
+    const recipes = data.items ?? [];
+    if (recipes.length === 0) {
+        return {
+            content: [{ type: "text", text: "No rule recipes found." }],
+        };
+    }
+    const formattedRecipes = recipes.map((recipe) => [
+        `ID: ${recipe.id}`,
+        `Name: ${recipe.name}`,
+        `Description: ${recipe.description}`,
+        `Disabled: ${recipe.disabled}`,
+        `Blocking Effect: ${recipe.blockingEffect}`,
+        `Labels: ${recipe.labels.join(", ")}`,
+        `Dependencies: ${recipe.dependencies.join(", ")}`,
+        `Created By: ${recipe.createdBy}`,
+        `Created At: ${recipe.createdAt ? recipe.createdAt.toISOString() : "N/A"}`,
+        `Updated At: ${recipe.updatedAt?.toISOString() ?? "N/A"}`,
         "---",
-    ].join("\n");
+    ].join("\n"));
     return {
-        content: [{ type: "text", text: formattedScript }],
+        content: [{ type: "text", text: formattedRecipes.join("\n") }],
     };
 });
-server.tool("update_rules_script", "Updates an existing rules script", {
-    rules_script_id: zod_1.z
-        .string()
-        .describe("The ID of the rules script to update"),
-    name: zod_1.z.string().describe("The name of the rules script"),
-    src: zod_1.z.string().describe("The source code of the rules script"),
-    lang: zod_1.z
-        .string()
-        .default("assemblyscript")
-        .describe("The language of the script"),
-    description: zod_1.z
-        .string()
-        .optional()
-        .describe("Optional description of the script"),
-    blocking_effect: zod_1.z
-        .string()
-        .default("block")
-        .describe("Effect when rule blocks"),
-    disabled: zod_1.z
-        .boolean()
-        .default(false)
-        .describe("Whether the script is disabled"),
-    labels: zod_1.z
-        .array(zod_1.z.string())
-        .optional()
-        .describe("Optional list of label slugs"),
-}, async ({ rules_script_id, name, src, lang, description, blocking_effect, disabled, labels, }) => {
-    if (!rules_script_id) {
+server.tool(getToolName("get_rule_recipe"), "Get details of a specific rule recipe", {
+    rule_recipe_id: zod_1.z.string().describe("The unique identifier of the rule recipe"),
+}, async ({ rule_recipe_id }) => {
+    if (!rule_recipe_id) {
         return {
-            content: [
-                { type: "text", text: "Error: rules_script_id is required." },
-            ],
+            content: [{ type: "text", text: "Error: rule_recipe_id is required." }],
         };
     }
-    const payload = {
-        name,
-        src,
-        lang,
-        description,
-        blocking_effect,
-        disabled,
-        labels: labels ?? [],
-    };
-    const data = await makeImpartRequest(`rules_scripts/${rules_script_id}`, undefined, "PUT", payload);
+    const data = await makeImpartRequest(`rule_recipes/${rule_recipe_id}`, undefined);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to update rules script" }],
+            content: [{ type: "text", text: `Unable to fetch rule recipe: ${lastError}` }],
         };
     }
-    const formattedScript = [
-        "Rules script updated successfully:",
+    const formattedRecipe = [
         `ID: ${data.id}`,
         `Name: ${data.name}`,
-        `Description: ${data.description ?? "N/A"}`,
-        `Language: ${data.lang}`,
-        `Blocking Effect: ${data.blocking_effect}`,
+        `Description: ${data.description}`,
         `Disabled: ${data.disabled}`,
+        `Blocking Effect: ${data.blockingEffect}`,
         `Labels: ${data.labels.join(", ")}`,
-        `Updated At: ${data.updated_at}`,
-        "---",
+        `Dependencies: ${data.dependencies.join(", ")}`,
+        `Components:`,
+        `  Rate Limit: ${JSON.stringify(data.components.rate_limit, null, 2)}`,
+        `  Inspect Request: ${JSON.stringify(data.components.inspect_request, null, 2)}`,
+        `  Enforce: ${JSON.stringify(data.components.enforce, null, 2)}`,
+        `  Inspect Response: ${JSON.stringify(data.components.inspect_response, null, 2)}`,
+        `Created By: ${data.createdBy}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+        `Updated By: ${data.updatedBy ?? "N/A"}`,
+        `Updated At: ${data.updatedAt?.toISOString() ?? "N/A"}`,
     ].join("\n");
     return {
-        content: [{ type: "text", text: formattedScript }],
+        content: [{ type: "text", text: formattedRecipe }],
     };
 });
-server.tool("write_rule_script", "Generate a rule script using Impart's LLM", {
-    query: zod_1.z.string().describe("Description of the rule you want to generate"),
+server.tool(getToolName("generate_rule_recipe"), "Generate a rule recipe configuration using Impart's AI (Sparkle). Returns a JSON configuration that can be saved as a rule recipe.", {
+    query: zod_1.z
+        .string()
+        .describe('Natural language description of the rule recipe to generate (e.g., "Create a rate limit rule that blocks requests after 100 requests per minute")'),
 }, async ({ query }) => {
+    if (!query) {
+        return {
+            content: [{ type: "text", text: "Error: query is required." }],
+        };
+    }
+    // The Sparkle API expects the query field to be a JSON-encoded string
+    // containing the agent-specific input format: {"prompt": "..."}
+    const agentQuery = JSON.stringify({
+        prompt: query,
+    });
     const payload = {
-        agent: "rule_generator",
-        query,
+        agent: "rule_recipe_generator",
+        query: agentQuery,
     };
+    console.error(`[generate_rule_recipe] Calling Sparkle API with payload:`, JSON.stringify(payload, null, 2));
     const data = await makeImpartRequest("sparkle", undefined, "POST", payload);
+    console.error(`[generate_rule_recipe] Response received:`, data ? "Success" : "Failure");
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Error: Failed to generate rule script" },
-            ],
+            content: [{ type: "text", text: `Unable to generate rule recipe: ${lastError}` }],
         };
     }
     if (!data.output) {
         return {
-            content: [
-                {
-                    type: "text",
-                    text: "Error: No output received from the Sparkle API",
-                },
-            ],
+            content: [{ type: "text", text: "Error: No output received from the Sparkle API" }],
         };
     }
     return {
         content: [
-            { type: "text", text: `Generated Rule Script:\n\n${data.output}` },
+            {
+                type: "text",
+                text: `Generated Rule Recipe Configuration:\n\n${data.output}\n\nYou can save this configuration using the create_rule_recipe tool.`,
+            },
         ],
     };
 });
-server.tool("validate_rules_script", "Validate a rules script", {
-    src: zod_1.z
-        .string()
-        .describe("The base64-encoded source code of the rules script to validate"),
-    lang: zod_1.z
+server.tool(getToolName("create_rule_recipe"), "Create a new rule recipe from a configuration. IMPORTANT: The 'components' field requires a complex nested structure with clauses, thresholds, conditions, and actions. You MUST use the output from generate_rule_recipe (Sparkle AI) or copy from an existing rule recipe - do not manually create the components structure as it has a very specific schema.", {
+    name: zod_1.z.string().min(1).max(64).describe("The name of the rule recipe"),
+    description: zod_1.z.string().min(1).max(1024).optional().describe("Optional description of the rule recipe"),
+    disabled: zod_1.z.boolean().default(false).describe("Whether the rule recipe is disabled"),
+    blocking_effect: zod_1.z
+        .enum(["block", "simulate"])
+        .default("block")
+        .optional()
+        .describe("Effect when rule blocks (block or simulate)"),
+    labels: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of label slugs"),
+    components: zod_1.z
         .string()
-        .default("assemblyscript")
-        .describe("The language of the rules script"),
-}, async ({ src, lang }) => {
-    if (!src) {
+        .describe("JSON string containing the rule recipe components (rate_limit, inspect_request, enforce, inspect_response)"),
+}, async ({ name, description, disabled, blocking_effect, labels, components }) => {
+    if (!name || !components) {
         return {
-            content: [
-                {
-                    type: "text",
-                    text: "Error: The source code (src) is required and must be base64 encoded.",
-                },
-            ],
+            content: [{ type: "text", text: "Error: name and components are required." }],
         };
     }
-    const payload = {
-        src,
-        lang,
-    };
-    const data = await makeImpartRequest("rules_script_validate", undefined, "POST", payload);
-    if (!data) {
+    let parsedComponents;
+    try {
+        parsedComponents = JSON.parse(components);
+    }
+    catch (e) {
         return {
-            content: [{ type: "text", text: "Failed to validate rules script" }],
+            content: [{ type: "text", text: "Error: components must be valid JSON" }],
         };
     }
-    const diagnostics = data.diagnostics || [];
-    if (diagnostics.length === 0) {
+    // Remove blocking_effect from components if present - it should be a top-level field
+    if (parsedComponents.blocking_effect) {
+        delete parsedComponents.blocking_effect;
+    }
+    if (parsedComponents.blockingEffect) {
+        delete parsedComponents.blockingEffect;
+    }
+    const payload = {
+        name,
+        disabled,
+        components: parsedComponents,
+    };
+    if (description !== null && description !== undefined) {
+        payload["description"] = description;
+    }
+    if (blocking_effect !== null && blocking_effect !== undefined) {
+        payload["blocking_effect"] = blocking_effect;
+    }
+    if (labels !== null && labels !== undefined) {
+        payload["labels"] = labels;
+    }
+    console.error(`[create_rule_recipe] Payload:`, JSON.stringify(payload, null, 2));
+    const data = await makeImpartRequest("rule_recipes", undefined, "POST", payload);
+    if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                {
-                    type: "text",
-                    text: "Validation successful! No errors or warnings found.",
-                },
-            ],
+            content: [{ type: "text", text: `Unable to create rule recipe: ${lastError}` }],
         };
     }
-    const formattedDiagnostics = diagnostics.map((diagnostic) => `${diagnostic.severity.toUpperCase()} at line ${diagnostic.line}, column ${diagnostic.column}: ${diagnostic.message}`);
+    const formattedRecipe = [
+        "Rule recipe created successfully:",
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Disabled: ${data.disabled}`,
+        `Blocking Effect: ${data.blockingEffect}`,
+        `Labels: ${data.labels.join(", ")}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+    ].join("\n");
     return {
-        content: [
-            {
-                type: "text",
-                text: "Validation completed with the following issues:\n" +
-                    formattedDiagnostics.join("\n"),
-            },
-        ],
+        content: [{ type: "text", text: formattedRecipe }],
     };
 });
-server.tool("list_endpoints", "Get an inventory of endpoints for the organization", {
+server.tool(getToolName("list_endpoints"), "Get an inventory of endpoints for the organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ max_results }) => {
-    const queryParams = { max_results };
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    is_deprecated: zod_1.z.enum(["true", "false"]).optional().describe("Filter by deprecated status"),
+    is_orphaned: zod_1.z.enum(["true", "false"]).optional().describe("Filter by orphaned status"),
+    source: zod_1.z.enum(["learned", "provided"]).optional().describe("Filter by source"),
+    search: zod_1.z.string().optional().describe("Filter by search string"),
+    spec_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Filter by spec IDs"),
+    collection_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Filter by collection IDs"),
+    tag: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Filter by tags"),
+    method: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Filter by methods"),
+    label: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by label slugs (e.g., ["llm-protection", "waf"])'),
+}, async ({ page, max_results, is_deprecated, is_orphaned, source, search, spec_id, collection_id, tag, method, label, }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = page;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (is_deprecated !== null && is_deprecated !== undefined) {
+        queryParams["is_deprecated"] = is_deprecated;
+    }
+    if (is_orphaned !== null && is_orphaned !== undefined) {
+        queryParams["is_orphaned"] = is_orphaned;
+    }
+    if (source !== null && source !== undefined) {
+        queryParams["source"] = source;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
+    if (spec_id !== null && spec_id !== undefined) {
+        queryParams["spec_id"] = spec_id;
+    }
+    if (collection_id !== null && collection_id !== undefined) {
+        queryParams["collection_id"] = collection_id;
+    }
+    if (tag !== null && tag !== undefined) {
+        queryParams["tag"] = tag;
+    }
+    if (method !== null && method !== undefined) {
+        queryParams["method"] = method;
+    }
+    if (label !== null && label !== undefined) {
+        queryParams["label"] = label;
+    }
     const data = await makeImpartRequest("endpoints", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch endpoints: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch endpoints: ${lastError}` }],
         };
     }
     const endpoints = data.items || [];
     if (endpoints.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No endpoints found for this organization." },
-            ],
+            content: [{ type: "text", text: "No endpoints found for this organization." }],
         };
     }
     const formattedEndpoints = endpoints.map((endpoint) => [
         `ID: ${endpoint.id}`,
-        `Spec ID: ${endpoint.spec_id}`,
+        `Spec ID: ${endpoint.specId}`,
         `Path: ${endpoint.path}`,
         `Method: ${endpoint.method}`,
         `Source: ${endpoint.source}`,
@@ -466,36 +706,55 @@ server.tool("list_endpoints", "Get an inventory of endpoints for the organizatio
         content: [{ type: "text", text: formattedEndpoints.join("\n") }],
     };
 });
-server.tool("list_tags", "Get a list of tags for your Impart organization", {
+server.tool(getToolName("list_tags"), "Get a list of tags for your Impart organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ max_results }) => {
-    const queryParams = { max_results };
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    label: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by label slugs (e.g., ["llm-protection", "waf"])'),
+}, async ({ page, max_results, label }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = page;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (label !== null && label !== undefined) {
+        queryParams["label"] = label;
+    }
     const data = await makeImpartRequest("tags", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch tags: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch tags: ${lastError}` }],
         };
     }
     const tags = data.items || [];
     if (tags.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No tags found for this organization." },
-            ],
+            content: [{ type: "text", text: "No tags found for this organization." }],
         };
     }
     const formattedTags = tags.map((tag) => [
         `Name: ${tag.name}`,
-        `Display Name: ${tag.display_name}`,
+        `Display Name: ${tag.displayName}`,
         `Type: ${tag.type}`,
         `Description: ${tag.description ?? "N/A"}`,
-        `Risk Statement: ${tag.risk_statement ?? "N/A"}`,
-        `External URL: ${tag.external_url ?? "N/A"}`,
+        `Risk Statement: ${tag.riskStatement ?? "N/A"}`,
+        `External URL: ${tag.externalUrl ?? "N/A"}`,
         `Category: ${tag.category}`,
         "---",
     ].join("\n"));
@@ -503,56 +762,98 @@ server.tool("list_tags", "Get a list of tags for your Impart organization", {
         content: [{ type: "text", text: formattedTags.join("\n") }],
     };
 });
-server.tool("get_tag_metrics", "Get timeseries metrics for one or more tags", {
+server.tool(getToolName("get_tag_metrics"), "Get timeseries metrics for one or more tags. Returns multiple time series datasets when multiple metrics are requested. Examples: \n\n" +
+    '• Single metric: {"metric": ["http-request.count"]}\n' +
+    '• Multiple metrics: {"metric": ["http-request.count", "attack.count", "blocked.count"]}\n' +
+    '• With time range: {"metric": ["http-request.count"], "from": "-7d", "until": "-0h"}\n' +
+    '• With filtering: {"metric": ["attack.count"], "spec_id": ["spec-123"], "rollup": "1h"}\n' +
+    '• Complex query: {"metric": ["http-request.count", "blocked.count"], "from": "-24h", "rollup": "1h", "unlearned": "exclude"}', {
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
     metric: zod_1.z
         .array(zod_1.z.string())
         .default(["http-request.count"])
-        .describe("List of metric names"),
-    from_time: zod_1.z.string().default("-1d").describe("Start time"),
-    until_time: zod_1.z.string().default("-0h").describe("End time"),
-    spec_id: zod_1.z
-        .array(zod_1.z.string())
-        .optional()
-        .describe("Optional list of spec IDs"),
-    collection_id: zod_1.z
-        .array(zod_1.z.string())
         .optional()
-        .describe("Optional list of collection IDs"),
-    endpoint_id: zod_1.z
-        .array(zod_1.z.string())
+        .nullable()
+        .describe("List of metric names. Common metrics: 'http-request.count', 'attack.count', 'blocked.count', 'allowed.count'"),
+    from: zod_1.z
+        .string()
+        .default("-1d")
         .optional()
-        .describe("Optional list of endpoint IDs"),
-    rollup: zod_1.z
+        .nullable()
+        .describe("Start time (relative like '-1d', '-24h', '-7d' or absolute timestamp)"),
+    until: zod_1.z
         .string()
+        .default("-0h")
         .optional()
-        .describe("Optional time window rollup resolution"),
+        .nullable()
+        .describe("End time (relative like '-0h', '-1h' or absolute timestamp)"),
+    spec_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of spec IDs to filter by"),
+    collection_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of collection IDs to filter by"),
+    endpoint_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of endpoint IDs to filter by"),
+    rollup: zod_1.z.string().optional().describe("Time window rollup resolution (e.g., '1h', '15m', '1d')"),
     unlearned: zod_1.z
-        .string()
+        .enum(["exclude", "include", "only"])
         .default("include")
-        .describe("How to handle unlearned endpoints"),
-    max_results: zod_1.z
-        .number()
-        .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ metric, from_time, until_time, spec_id, collection_id, endpoint_id, rollup, unlearned, max_results, }) => {
-    const queryParams = {
-        metric,
-        from: from_time,
-        until: until_time,
-        spec_id,
-        collection_id,
-        endpoint_id,
-        rollup,
-        unlearned,
-        max_results,
-    };
+        .optional()
+        .describe("How to handle unlearned endpoints: 'exclude' (ignore), 'include' (default), 'only' (only unlearned)"),
+}, async ({ metric, from, until, spec_id, collection_id, endpoint_id, rollup, unlearned, max_results }) => {
+    // Validate time format parameters
+    if (from) {
+        const fromCheck = validateTimeFormat(from);
+        if (!fromCheck.valid) {
+            return {
+                content: [{ type: "text", text: fromCheck.error }],
+            };
+        }
+    }
+    if (until) {
+        const untilCheck = validateTimeFormat(until);
+        if (!untilCheck.valid) {
+            return {
+                content: [{ type: "text", text: untilCheck.error }],
+            };
+        }
+    }
+    const queryParams = {};
+    if (metric !== null && metric !== undefined) {
+        // Convert array to comma-separated string for metrics API
+        queryParams["metric"] = Array.isArray(metric) ? metric.join(",") : metric;
+    }
+    if (from !== null && from !== undefined) {
+        queryParams["from"] = from;
+    }
+    if (until !== null && until !== undefined) {
+        queryParams["until"] = until;
+    }
+    if (spec_id !== null && spec_id !== undefined) {
+        queryParams["spec_id"] = spec_id;
+    }
+    if (collection_id !== null && collection_id !== undefined) {
+        queryParams["collection_id"] = collection_id;
+    }
+    if (endpoint_id !== null && endpoint_id !== undefined) {
+        queryParams["endpoint_id"] = endpoint_id;
+    }
+    if (rollup !== null && rollup !== undefined) {
+        queryParams["rollup"] = rollup;
+    }
+    if (unlearned !== null && unlearned !== undefined) {
+        queryParams["unlearned"] = unlearned;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
     const data = await makeImpartRequest("timeseries/tags", queryParams);
     if (!data) {
         return {
             content: [
                 {
                     type: "text",
-                    text: "Unable to fetch timeseries metrics: Unknown error",
+                    text: `Unable to fetch timeseries metrics: ${makeImpartRequest.lastError || "Unknown error"}`,
                 },
             ],
         };
@@ -570,10 +871,10 @@ server.tool("get_tag_metrics", "Get timeseries metrics for one or more tags", {
     }
     const formattedMetrics = metrics.map((metric) => [
         `Metric: ${metric.metric}`,
-        `From: ${metric.from}`,
-        `Until: ${metric.until}`,
+        `From: ${metric.from ? metric.from.toISOString() : "N/A"}`,
+        `Until: ${metric.until ? metric.until.toISOString() : "N/A"}`,
         `Increment: ${metric.inc} seconds`,
-        `Total Points: ${metric.total_points}`,
+        `Total Points: ${metric.totalPoints}`,
         `Data: ${metric.data.join(", ")}`,
         "---",
     ].join("\n"));
@@ -581,27 +882,34 @@ server.tool("get_tag_metrics", "Get timeseries metrics for one or more tags", {
         content: [{ type: "text", text: formattedMetrics.join("\n") }],
     };
 });
-server.tool("list_observed_hosts", "Get a list of observed hosts for your Impart organization", {
+server.tool(getToolName("list_observed_hosts"), "Get a list of observed hosts for your Impart organization", {
     page: zod_1.z
         .number()
         .default(1)
-        .describe("The page of results to return (minimum value: 1)"),
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
 }, async ({ page, max_results }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-    };
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
     const data = await makeImpartRequest("observed_hosts", queryParams);
     if (!data) {
         return {
             content: [
                 {
                     type: "text",
-                    text: "Unable to fetch observed hosts: Unknown error",
+                    text: `Unable to fetch observed hosts: ${makeImpartRequest.lastError || "Unknown error"}`,
                 },
             ],
         };
@@ -619,25 +927,24 @@ server.tool("list_observed_hosts", "Get a list of observed hosts for your Impart
     }
     const formattedHosts = hosts.map((host) => [
         `ID: ${host.id}`,
-        `Name: ${host.name || "N/A"}`,
-        `IP Address: ${host.ip_address || "N/A"}`,
-        `Last Seen: ${host.last_seen || "N/A"}`,
+        `Hostname: ${host.hostname}`,
+        `Port: ${host.port}`,
+        `Created At: ${host.createdAt ? host.createdAt.toISOString() : "N/A"}`,
+        `Observed At: ${host.observedAt ? host.observedAt.toISOString() : "N/A"}`,
+        `Suspected: ${host.suspected}`,
+        `Env: ${host.env}`,
         "---",
     ].join("\n"));
     return {
         content: [{ type: "text", text: formattedHosts.join("\n") }],
     };
 });
-server.tool("get_observed_host", "Get details of a specific observed host", {
-    observed_host_id: zod_1.z
-        .string()
-        .describe("The unique identifier of the observed host"),
+server.tool(getToolName("get_observed_host"), "Get details of a specific observed host", {
+    observed_host_id: zod_1.z.string().describe("The unique identifier of the observed host"),
 }, async ({ observed_host_id }) => {
     if (!observed_host_id) {
         return {
-            content: [
-                { type: "text", text: "Error: observed_host_id is required." },
-            ],
+            content: [{ type: "text", text: "Error: observed_host_id is required." }],
         };
     }
     const data = await makeImpartRequest(`observed_hosts/${observed_host_id}`);
@@ -646,23 +953,24 @@ server.tool("get_observed_host", "Get details of a specific observed host", {
             content: [
                 {
                     type: "text",
-                    text: "Unable to fetch observed host: Unknown error",
+                    text: `Unable to fetch observed host: ${makeImpartRequest.lastError || "Unknown error"}`,
                 },
             ],
         };
     }
     const formattedHost = [
         `ID: ${data.id}`,
-        `Hostname: ${data.hostname ?? "N/A"}`,
-        `Port: ${data.port ?? "N/A"}`,
-        `Created At: ${data.created_at ?? "N/A"}`,
-        `Observed At: ${data.observed_at ?? "N/A"}`,
-        `Suspected Healthcheck: ${data.suspected_healthcheck ?? false}`,
+        `Hostname: ${data.hostname}`,
+        `Port: ${data.port}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+        `Observed At: ${data.observedAt ? data.observedAt.toISOString() : "N/A"}`,
+        `Suspected: ${data.suspected}`,
+        `Env: ${data.env}`,
         "---",
         "Related IDs:",
     ];
-    if (data.related_ids && data.related_ids.length > 0) {
-        data.related_ids.forEach((id) => formattedHost.push(`  - ${id}`));
+    if (data.relatedIds && data.relatedIds.length > 0) {
+        data.relatedIds.forEach((id) => formattedHost.push(`  - Binding ID: ${id.bindingId}, Spec ID: ${id.specId}`));
     }
     else {
         formattedHost.push("  No related IDs");
@@ -671,34 +979,42 @@ server.tool("get_observed_host", "Get details of a specific observed host", {
         content: [{ type: "text", text: formattedHost.join("\n") }],
     };
 });
-server.tool("list_specs", "Get a list of specs for your Impart organization", {
+server.tool(getToolName("list_specs"), "Get a list of specs for your Impart organization", {
     page: zod_1.z
         .number()
         .default(1)
-        .describe("The page of results to return (minimum value: 1)"),
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ page, max_results }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-    };
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    search: zod_1.z.string().optional().describe("Search string to filter specs"),
+}, async ({ page, max_results, search }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
     const data = await makeImpartRequest("specs", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch specs: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch specs: ${lastError}` }],
         };
     }
     const specs = data.items || [];
     if (specs.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No specs found for this organization." },
-            ],
+            content: [{ type: "text", text: "No specs found for this organization." }],
         };
     }
     const formattedSpecs = specs.map((spec) => [
@@ -706,32 +1022,34 @@ server.tool("list_specs", "Get a list of specs for your Impart organization", {
         `Name: ${spec.name}`,
         `Revision: ${spec.revision}`,
         `Score: ${spec.score}`,
-        `Created By: ${spec.created_by}`,
-        `Created At: ${spec.created_at}`,
-        `Updated By: ${spec.updated_by}`,
-        `Updated At: ${spec.updated_at}`,
+        `Created By: ${spec.createdBy}`,
+        `Created At: ${spec.createdAt ? spec.createdAt.toISOString() : "N/A"}`,
+        `Updated By: ${spec.updatedBy}`,
+        `Updated At: ${spec.updatedAt?.toISOString() ?? "N/A"}`,
         "---",
     ].join("\n"));
     return {
         content: [{ type: "text", text: formattedSpecs.join("\n") }],
     };
 });
-server.tool("get_spec", "Get details of a specific spec", {
+server.tool(getToolName("get_spec"), "Get details of a specific spec", {
     spec_id: zod_1.z.string().describe("The unique identifier of the spec"),
-    revision: zod_1.z.number().optional().describe("The specific revision to fetch"),
+    revision: zod_1.z.number().optional().nullable().describe("The specific revision to fetch"),
 }, async ({ spec_id, revision }) => {
     if (!spec_id) {
         return {
             content: [{ type: "text", text: "Error: spec_id is required." }],
         };
     }
-    const queryParams = revision ? { revision } : undefined;
+    const queryParams = {};
+    if (revision !== null && revision !== undefined) {
+        queryParams["revision"] = revision;
+    }
     const data = await makeImpartRequest(`specs/${spec_id}`, queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch spec: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch spec: ${lastError}` }],
         };
     }
     const formattedSpec = [
@@ -739,16 +1057,16 @@ server.tool("get_spec", "Get details of a specific spec", {
         `Name: ${data.name}`,
         `Revision: ${data.revision}`,
         `Score: ${data.score}`,
-        `Created By: ${data.created_by}`,
-        `Created At: ${data.created_at}`,
-        `Updated By: ${data.updated_by}`,
-        `Updated At: ${data.updated_at}`,
+        `Created By: ${data.createdBy}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+        `Updated By: ${data.updatedBy}`,
+        `Updated At: ${data.updatedAt?.toISOString() ?? "N/A"}`,
         "---",
         "Revisions:",
     ];
     if (data.revisions && data.revisions.length > 0) {
         data.revisions.forEach((revision) => {
-            formattedSpec.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.created_by}`, `  Created At: ${revision.created_at}`, "---");
+            formattedSpec.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.createdBy}`, `  Created At: ${revision.createdAt ? revision.createdAt.toISOString() : "N/A"}`, "---");
         });
     }
     formattedSpec.push(`Specification (Base64 Encoded):\n${data.spec ?? "N/A"}`);
@@ -756,26 +1074,44 @@ server.tool("get_spec", "Get details of a specific spec", {
         content: [{ type: "text", text: formattedSpec.join("\n") }],
     };
 });
-server.tool("list_api_bindings", "Get a list of API bindings for the organization", {
+server.tool(getToolName("list_api_bindings"), "Get a list of API bindings for the organization", {
     page: zod_1.z
         .number()
         .default(1)
-        .describe("The page of results to return (minimum value: 1)"),
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum value: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ page, max_results }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-    };
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    search: zod_1.z.string().optional().describe("The search string to filter API bindings"),
+    spec_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of spec IDs"),
+    collection_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("Optional list of collection IDs"),
+}, async ({ page, max_results, search, spec_id, collection_id }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
+    if (spec_id !== null && spec_id !== undefined) {
+        queryParams["spec_id"] = spec_id;
+    }
+    if (collection_id !== null && collection_id !== undefined) {
+        queryParams["collection_id"] = collection_id;
+    }
     const data = await makeImpartRequest("api_bindings", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch API bindings: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch API bindings: ${lastError}` }],
         };
     }
     const bindings = data.items || [];
@@ -792,104 +1128,156 @@ server.tool("list_api_bindings", "Get a list of API bindings for the organizatio
     const formattedBindings = bindings.map((binding) => [
         `ID: ${binding.id}`,
         `Name: ${binding.name}`,
-        `Type: ${binding.type}`,
-        `Host: ${binding.host}`,
-        `Status: ${binding.status}`,
-        `Created At: ${binding.created_at}`,
+        `Host: ${binding.hostname}`,
+        `Type: ${binding.port}`,
+        `Disabled: ${binding.disabled}`,
+        `Created At: ${binding.createdAt ? binding.createdAt.toISOString() : "N/A"}`,
         "---",
     ].join("\n"));
     return {
         content: [{ type: "text", text: formattedBindings.join("\n") }],
     };
 });
-server.tool("create_api_binding", "Create a new API binding for the organization", {
-    name: zod_1.z.string().describe("The name of the API binding"),
-    binding_type: zod_1.z
-        .string()
-        .describe("The type of binding ('apiKey', 'basic', 'bearer', or 'oauth2')"),
-    host: zod_1.z.string().describe("The host to bind to"),
-    api_binding_source: zod_1.z
-        .string()
-        .describe("Location of the binding ('header', 'query', or 'cookie')"),
-    binding_value: zod_1.z.string().describe("The value of the binding"),
-    description: zod_1.z
-        .string()
-        .optional()
-        .describe("Optional description of the binding"),
-    patch_operations: zod_1.z
-        .array(zod_1.z.record(zod_1.z.any()))
-        .optional()
-        .describe("Optional list of JSON patch operations"),
-    enable_learning: zod_1.z
-        .boolean()
-        .default(true)
-        .describe("Whether to enable learning for this binding"),
-}, async ({ name, binding_type, host, api_binding_source, binding_value, description, patch_operations, enable_learning, }) => {
+server.tool(getToolName("create_api_binding"), "Create a new API binding for the organization", {
+    name: zod_1.z.string().min(1).max(64).describe("The name of the API binding"),
+    hostname: zod_1.z.string().describe("The hostname to bind to"),
+    port: zod_1.z.number().describe("The port to bind to"),
+    base_path: zod_1.z.string().describe("The base path for the API binding"),
+    spec_id: zod_1.z.string().describe("The ID of the spec to bind to"),
+    disabled: zod_1.z.boolean().default(false).optional().nullable().describe("Whether the API binding is disabled"),
+    upstream_origin: zod_1.z.string().optional().describe("The upstream origin URL for the API binding"),
+    hops: zod_1.z.number().min(-1).max(10).optional().nullable().describe("Number of hops for the API binding"),
+    use_forwarded: zod_1.z.boolean().optional().nullable().describe("Whether to use forwarded headers"),
+    forwarded_for: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("List of forwarded 'for' headers"),
+    forwarded_host: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("List of forwarded 'host' headers"),
+    forwarded_proto: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("List of forwarded 'proto' headers"),
+    forwarded_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("List of forwarded IDs"),
+}, async ({ name, hostname, port, base_path, spec_id, disabled, upstream_origin, hops, use_forwarded, forwarded_for, forwarded_host, forwarded_proto, forwarded_id, }) => {
     const payload = {
         name,
-        type: binding_type,
-        host,
-        source: api_binding_source,
-        value: binding_value,
-        description,
-        patch_operations: patch_operations ?? [],
-        enable_learning,
+        hostname,
+        port,
+        base_path,
+        spec_id,
     };
+    if (disabled !== null && disabled !== undefined) {
+        payload["disabled"] = disabled;
+    }
+    if (upstream_origin !== null && upstream_origin !== undefined) {
+        payload["upstream_origin"] = upstream_origin;
+    }
+    if (hops !== null && hops !== undefined) {
+        payload["hops"] = hops;
+    }
+    if (use_forwarded !== null && use_forwarded !== undefined) {
+        payload["use_forwarded"] = use_forwarded;
+    }
+    if (forwarded_for !== null && forwarded_for !== undefined) {
+        payload["forwarded_for"] = forwarded_for;
+    }
+    if (forwarded_host !== null && forwarded_host !== undefined) {
+        payload["forwarded_host"] = forwarded_host;
+    }
+    if (forwarded_proto !== null && forwarded_proto !== undefined) {
+        payload["forwarded_proto"] = forwarded_proto;
+    }
+    if (forwarded_id !== null && forwarded_id !== undefined) {
+        payload["forwarded_id"] = forwarded_id;
+    }
     const data = await makeImpartRequest("api_bindings", undefined, "POST", payload);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to create API binding" }],
+            content: [{ type: "text", text: `Unable to create API binding: ${lastError}` }],
         };
     }
     const formattedBinding = [
         "API Binding created successfully:",
         `ID: ${data.id}`,
         `Name: ${data.name}`,
-        `Type: ${data.type}`,
-        `Host: ${data.host}`,
-        `Source: ${data.source}`,
-        `Status: ${data.status}`,
-        `Description: ${data.description ?? "N/A"}`,
-        `Learning Enabled: ${data.enable_learning}`,
-        `Created At: ${data.created_at}`,
+        `Host: ${data.hostname}`,
+        `Port: ${data.port}`,
+        `Disabled: ${data.disabled}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
         "---",
     ].join("\n");
     return {
         content: [{ type: "text", text: formattedBinding }],
     };
 });
-server.tool("list_lists", "Get a list of lists for the organization", {
-    kind: zod_1.z.string().optional().describe("The list kind to query for"),
-    subkind: zod_1.z.string().optional().describe("The list subkind to query for"),
+server.tool(getToolName("list_lists"), "Get a list of lists for the organization. Lists are collections used for filtering and blocking/allowing specific values. Examples:\n\n" +
+    "• Get all lists: {} (no parameters needed)\n" +
+    '• Filter by kind: {"kind": "ip"} or {"kind": "string"}\n' +
+    '• Search lists: {"search": "blocklist"}\n' +
+    '• With pagination: {"page": 1, "max_results": 25}\n' +
+    '• Filter by labels: {"label": ["security", "waf"]}\n' +
+    '• Combined filters: {"kind": "ip", "search": "suspicious", "max_results": 10}', {
+    kind: zod_1.z
+        .string()
+        .optional()
+        .nullable()
+        .describe("Filter by list kind: 'string', 'uuid', 'ip', 'country', 'path', or 'asn' (e.g., \"ip\", \"string\")"),
+    subkind: zod_1.z
+        .string()
+        .optional()
+        .nullable()
+        .describe("Filter by list subkind: 'spec_uuid' or 'endpoint_uuid' (e.g., \"spec_uuid\")"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .nullable()
+        .describe('Search in list names and descriptions (e.g., "blocklist", "suspicious")'),
     page: zod_1.z
         .number()
         .default(1)
-        .describe("The page of results to return (minimum: 1)"),
+        .optional()
+        .nullable()
+        .describe("Page number for pagination, starting from 1 (e.g., 1, 2, 3). Default: 1"),
     max_results: zod_1.z
         .number()
-        .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ kind, subkind, page, max_results }) => {
-    const queryParams = {
-        kind,
-        subkind,
-        page: validatePage(page),
-        max_results,
-    };
+        .default(25)
+        .optional()
+        .nullable()
+        .describe("Maximum results per page, 1-100 (e.g., 10, 25, 50). Default: 25 for performance"),
+    label: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by label slugs (e.g., ["security", "waf", "blocklist"])'),
+}, async ({ kind, subkind, search, page, max_results, label }) => {
+    const queryParams = {};
+    if (kind !== null && kind !== undefined) {
+        queryParams["kind"] = kind;
+    }
+    if (subkind !== null && subkind !== undefined) {
+        queryParams["subkind"] = subkind;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (label !== null && label !== undefined) {
+        queryParams["label"] = label;
+    }
     const data = await makeImpartRequest("lists", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch lists: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch lists: ${lastError}` }],
         };
     }
     const lists = data.items || [];
     if (lists.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No lists found for this organization." },
-            ],
+            content: [{ type: "text", text: "No lists found for this organization." }],
         };
     }
     const formattedLists = lists.map((list) => [
@@ -898,24 +1286,18 @@ server.tool("list_lists", "Get a list of lists for the organization", {
         `Kind: ${list.kind}`,
         `Subkind: ${list.subkind ?? "N/A"}`,
         `Description: ${list.description ?? "N/A"}`,
-        `Created At: ${list.created_at}`,
-        `Updated At: ${list.updated_at}`,
+        `Created By: ${list.createdBy}`,
+        `Created At: ${list.createdAt ? list.createdAt.toISOString() : "N/A"}`,
         "---",
     ].join("\n"));
     return {
         content: [{ type: "text", text: formattedLists.join("\n") }],
     };
 });
-server.tool("get_list_items", "Get items from a specific list", {
+server.tool(getToolName("get_list_items"), "Get items from a specific list", {
     list_id: zod_1.z.string().describe("The ID of the list"),
-    page: zod_1.z
-        .number()
-        .default(1)
-        .describe("The page of results to return (minimum: 1)"),
-    max_results: zod_1.z
-        .number()
-        .default(100)
-        .describe("The maximum number of results to return"),
+    page: zod_1.z.number().default(1).describe("The page of results to return (minimum: 1, e.g., 1, 2, 3)"),
+    max_results: zod_1.z.number().default(100).describe("The maximum number of results to return (e.g., 10, 50, 100)"),
 }, async ({ list_id, page, max_results }) => {
     if (!list_id) {
         return {
@@ -928,70 +1310,114 @@ server.tool("get_list_items", "Get items from a specific list", {
     };
     const data = await makeImpartRequest(`lists/${list_id}/items`, queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch list items: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch list items: ${lastError}` }],
         };
     }
-    const items = data.items || [];
+    // Handle direct array response from API
+    const items = Array.isArray(data) ? data : [];
     if (items.length === 0) {
         return {
             content: [{ type: "text", text: "No items found in this list." }],
         };
     }
-    const formattedItems = items.map((item) => [`Value: ${item.value}`, `Created At: ${item.created_at}`, "---"].join("\n"));
+    const formattedItems = items.map((item) => [`Value: ${item.value}`, `Expiration: ${item.expiration?.toISOString() ?? "N/A"}`, "---"].join("\n"));
     return {
         content: [{ type: "text", text: formattedItems.join("\n") }],
     };
 });
-server.tool("create_list", "Creates a new list for the organization", {
-    name: zod_1.z.string().describe("Name of the list"),
-    kind: zod_1.z.string().describe("The kind of list"),
-    subkind: zod_1.z.string().optional().describe("Optional subkind of list"),
-    description: zod_1.z.string().optional().describe("Optional description"),
-    functionality: zod_1.z
-        .string()
-        .default("add/remove")
-        .describe("List functionality"),
-    items: zod_1.z
-        .array(zod_1.z.record(zod_1.z.any()))
+// items:
+// description: The items in the list.
+// items:
+//   $ref: "#/components/schemas/list_items_inner"
+// maxItems: 100000
+// type: array
+// required:
+// - kind
+// - name
+server.tool(getToolName("create_list"), "Create a new list", {
+    name: zod_1.z.string().min(1).max(64).describe("The name of the list"),
+    kind: zod_1.z.enum(["string", "uuid", "ip", "country", "path", "asn"]).describe("The kind of list to create"),
+    subkind: zod_1.z.enum(["spec_uuid", "endpoint_uuid"]).optional().describe("The subkind of list to create"),
+    functionality: zod_1.z.enum(["add"]).default("add").optional().describe("The functionality of the list"),
+    description: zod_1.z.string().optional().describe("The description of the list"),
+    items: zod_1.z.array(zod_1.z.string()).optional().nullable().describe("The items to add to the list"),
+    labels: zod_1.z
+        .array(zod_1.z.string())
         .optional()
-        .describe("Optional initial list items"),
-}, async ({ name, kind, subkind, description, functionality, items }) => {
-    const payload = {
-        name,
+        .nullable()
+        .describe('The labels to apply to the list (e.g., ["llm-protection", "waf"])'),
+}, async ({ name, kind, subkind, functionality, description, items, labels }) => {
+    if (!kind || !name) {
+        return {
+            content: [{ type: "text", text: "Error: name and kind are required" }],
+            isError: true,
+        };
+    }
+    const body = {
         kind,
-        subkind,
-        description,
-        functionality,
-        items: items ?? [],
+        name,
     };
-    const data = await makeImpartRequest("lists", undefined, "POST", payload);
+    if (subkind !== null && subkind !== undefined) {
+        body["subkind"] = subkind;
+    }
+    if (functionality !== null && functionality !== undefined) {
+        body["functionality"] = functionality;
+    }
+    if (description !== null && description !== undefined) {
+        body["description"] = description;
+    }
+    if (items !== null && items !== undefined) {
+        body["items"] = items;
+    }
+    if (labels !== null && labels !== undefined) {
+        body["labels"] = labels;
+    }
+    const data = await makeImpartRequest("lists", {}, "POST", body);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to create list" }],
+            content: [{ type: "text", text: `Unable to create list: ${lastError}` }],
+            isError: true,
         };
     }
-    const formattedList = [
-        "List created successfully:",
-        `ID: ${data.id}`,
-        `Name: ${data.name}`,
-        `Kind: ${data.kind}`,
-        `Subkind: ${data.subkind ?? "N/A"}`,
-        `Description: ${data.description ?? "N/A"}`,
-        `Created At: ${data.created_at}`,
-        "---",
-    ].join("\n");
     return {
-        content: [{ type: "text", text: formattedList }],
+        content: [
+            {
+                type: "text",
+                text: [
+                    "List created successfully:",
+                    `ID: ${data.id}`,
+                    `Name: ${name}`,
+                    `Kind: ${kind}`,
+                    `Subkind: ${subkind}`,
+                    `Description: ${description ?? "N/A"}`,
+                    `Created By: ${data.createdBy}`,
+                    `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
+                    "---",
+                ].join("\n"),
+            },
+        ],
     };
 });
-server.tool("update_list_items", "Updates items in a list", {
+// add:
+// description: The items in the list.
+// items:
+//   $ref: "#/components/schemas/list_items_inner"
+// maxItems: 100000
+// type: array
+// remove:
+// description: Items to remove from the list.
+// items:
+//   maxLength: 1000
+//   minLength: 1
+//   type: string
+// maxItems: 100000
+// type: array
+server.tool(getToolName("update_list_items"), "Updates items in a list", {
     list_id: zod_1.z.string().describe("The ID of the list to update"),
-    items: zod_1.z
-        .array(zod_1.z.record(zod_1.z.any()))
-        .describe("The items to update in the list"),
+    items: zod_1.z.array(zod_1.z.record(zod_1.z.string(), zod_1.z.any())).describe("The items to update in the list"),
 }, async ({ list_id, items }) => {
     if (!list_id) {
         return {
@@ -1001,85 +1427,510 @@ server.tool("update_list_items", "Updates items in a list", {
     const payload = { items };
     const data = await makeImpartRequest(`lists/${list_id}/items`, undefined, "PATCH", payload);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to update list items" }],
+            content: [{ type: "text", text: `Unable to update list items: ${lastError}` }],
         };
     }
     return {
         content: [{ type: "text", text: "List items updated successfully" }],
     };
 });
-server.tool("create_label", "Creates a new label for the organization", {
-    name: zod_1.z.string().describe("Name of the label"),
+server.tool(getToolName("create_label"), "Creates a new label for the organization", {
+    slug: zod_1.z.string().min(1).max(64).describe("Name of the label"),
+    display_name: zod_1.z.string().optional().describe("Optional display name"),
     description: zod_1.z.string().optional().describe("Optional description"),
-    color: zod_1.z.string().default("gray").describe("Label color"),
-}, async ({ name, description, color }) => {
+    color: zod_1.z
+        .enum(["gray", "red", "orange", "yellow", "green", "teal", "cyan", "blue", "purple", "pink"])
+        .default("gray")
+        .optional()
+        .nullable()
+        .describe("Label color"),
+}, async ({ slug, display_name, description, color }) => {
     const payload = {
-        name,
-        description,
-        color,
+        slug,
     };
+    if (display_name !== null && display_name !== undefined) {
+        payload["display_name"] = display_name;
+    }
+    if (description !== null && description !== undefined) {
+        payload["description"] = description;
+    }
+    if (color !== null && color !== undefined) {
+        payload["color"] = color;
+    }
     const data = await makeImpartRequest("labels", undefined, "POST", payload);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [{ type: "text", text: "Failed to create label" }],
+            content: [{ type: "text", text: `Unable to create label: ${lastError}` }],
         };
     }
     const formattedLabel = [
         "Label created successfully:",
         `Slug: ${data.slug}`,
-        `Name: ${data.name}`,
-        `Description: ${data.description ?? "N/A"}`,
+        `Name: ${data.displayName}`,
+        `Description: ${data.description}`,
         `Color: ${data.color}`,
-        `Created At: ${data.created_at}`,
+        `Created At: ${data.createdAt ? data.createdAt.toISOString() : "N/A"}`,
         "---",
     ].join("\n");
     return {
         content: [{ type: "text", text: formattedLabel }],
     };
 });
-server.tool("list_labels", "Get a list of labels for the organization", {
+server.tool(getToolName("list_labels"), "Get a list of labels for the organization", {
     page: zod_1.z
         .number()
         .default(1)
-        .describe("The page of results to return (minimum: 1)"),
+        .optional()
+        .nullable()
+        .describe("The page of results to return (minimum: 1, e.g., 1, 2, 3)"),
     max_results: zod_1.z
         .number()
         .default(100)
-        .describe("The maximum number of results to return"),
-}, async ({ page, max_results }) => {
-    const queryParams = {
-        page: validatePage(page),
-        max_results,
-    };
+        .optional()
+        .nullable()
+        .describe("The maximum number of results to return (e.g., 10, 50, 100)"),
+    search: zod_1.z.string().nullable().optional().describe("Search string to filter labels"),
+}, async ({ page, max_results, search }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
     const data = await makeImpartRequest("labels", queryParams);
     if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
         return {
-            content: [
-                { type: "text", text: "Unable to fetch labels: Unknown error" },
-            ],
+            content: [{ type: "text", text: `Unable to fetch labels: ${lastError}` }],
         };
     }
     const labels = data.items || [];
     if (labels.length === 0) {
         return {
-            content: [
-                { type: "text", text: "No labels found for this organization." },
-            ],
+            content: [{ type: "text", text: "No labels found for this organization." }],
         };
     }
     const formattedLabels = labels.map((label) => [
         `Slug: ${label.slug}`,
-        `Name: ${label.name}`,
+        `Name: ${label.displayName}`,
         `Description: ${label.description ?? "N/A"}`,
         `Color: ${label.color}`,
-        `Created At: ${label.created_at}`,
+        `Created At: ${label.createdAt ? label.createdAt.toISOString() : "N/A"}`,
         "---",
     ].join("\n"));
     return {
         content: [{ type: "text", text: formattedLabels.join("\n") }],
     };
 });
+server.tool(getToolName("list_test_cases"), "Get a list of test cases for security rules in your Impart organization. Test cases are predefined request/response scenarios used to validate rule behavior and ensure rules work correctly. Examples:\n\n" +
+    "• All test cases: {} (no parameters needed)\n" +
+    '• Search test cases: {"search": "malicious"}\n' +
+    '• Filter by labels: {"label": ["security", "validation"]}\n' +
+    '• With pagination: {"page": 1, "max_results": 25}', {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .optional()
+        .nullable()
+        .describe("Page number for pagination, starting from 1 (e.g., 1, 2, 3). Default: 1"),
+    max_results: zod_1.z
+        .number()
+        .default(25)
+        .optional()
+        .nullable()
+        .describe("Maximum test cases per page, 1-100 (e.g., 10, 25, 50). Default: 25 for performance"),
+    label: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by label slugs (e.g., ["security", "validation", "attack-simulation"])'),
+    search: zod_1.z
+        .string()
+        .optional()
+        .nullable()
+        .describe('Search in test case names and descriptions (e.g., "malicious", "XSS", "SQL injection")'),
+}, async ({ page, max_results, label, search }) => {
+    const queryParams = {};
+    if (page !== null && page !== undefined) {
+        queryParams["page"] = validatePage(page);
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (label !== null && label !== undefined) {
+        queryParams["label"] = label;
+    }
+    if (search !== null && search !== undefined) {
+        queryParams["search"] = search;
+    }
+    const data = await makeImpartRequest("rules_test_cases", queryParams);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unable to fetch test cases: ${makeImpartRequest.lastError || "Unknown error"}`,
+                },
+            ],
+        };
+    }
+    const testCases = data.items || [];
+    if (testCases.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No test cases found for this organization. Test cases are used to validate security rule behavior.",
+                },
+            ],
+        };
+    }
+    // Limit display for performance
+    const maxDisplay = Math.min(testCases.length, 15);
+    const showingLimited = testCases.length > maxDisplay;
+    const result = [
+        `Found ${testCases.length} test cases`,
+        showingLimited ? `Showing first ${maxDisplay} for performance. Use search/filters to narrow results.` : "",
+        "=".repeat(50),
+        "",
+    ];
+    testCases.slice(0, maxDisplay).forEach((testCase, index) => {
+        result.push(`${index + 1}. ${testCase.name} ${testCase.required ? "(REQUIRED)" : ""}`, `   ID: ${testCase.id}`, `   Messages: ${testCase.messages.length} | Assertions: ${testCase.assertions.length}`, `   Labels: ${testCase.labels.length > 0 ? testCase.labels.join(", ") : "None"}`, `   Created: ${testCase.createdAt ? testCase.createdAt.toISOString() : "N/A"}`, "");
+    });
+    return {
+        content: [{ type: "text", text: result.join("\n") }],
+    };
+});
+server.tool(getToolName("get_test_case"), "Get detailed information about a specific test case for security rules. Test cases contain request/response scenarios and assertions to validate rule behavior. Examples:\n\n" +
+    '• Get test case details: {"test_case_id": "tc-abc123"}\n' +
+    '• View test scenario: {"test_case_id": "tc-def456"}\n\n' +
+    "Note: Use test case IDs from the list_test_cases tool or your Impart dashboard.", {
+    test_case_id: zod_1.z.string().describe("The unique identifier of the test case (e.g., 'tc-abc123', 'tc-def456')"),
+}, async ({ test_case_id }) => {
+    if (!test_case_id) {
+        return {
+            content: [{ type: "text", text: "Error: test_case_id is required." }],
+        };
+    }
+    const data = await makeImpartRequest(`rules_test_cases/${test_case_id}`);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unable to fetch test case: ${makeImpartRequest.lastError || "Unknown error"}`,
+                },
+            ],
+        };
+    }
+    const formattedTestCase = [
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Required: ${data.required}`,
+        `Labels: ${data.labels && data.labels.length > 0 ? data.labels.join(", ") : "None"}`,
+        "Messages:",
+    ];
+    (data.messages || []).forEach((message, index) => {
+        formattedTestCase.push(`Message ${index + 1}:`);
+        if (message.req) {
+            formattedTestCase.push("  Request:", `    Method: ${message.req.method ?? "N/A"}`, `    URL: ${message.req.url ?? "N/A"}`, "    Headers:");
+            if (message.req.headerKeys) {
+                Object.entries(message.req.headerKeys).forEach(([key, values]) => {
+                    formattedTestCase.push(`      ${key}: ${values}`);
+                });
+            }
+            if (message.req.body) {
+                formattedTestCase.push(`    Body: ${message.req.body}`);
+            }
+        }
+        if (message.res) {
+            formattedTestCase.push("  Response:", `    Status Code: ${message.res.statusCode ?? "N/A"}`, "    Headers:");
+            if (message.res.headerKeys) {
+                Object.entries(message.res.headerKeys).forEach(([key, values]) => {
+                    formattedTestCase.push(`      ${key}: ${values}`);
+                });
+            }
+            if (message.res.body) {
+                formattedTestCase.push(`    Body: ${message.res.body}`);
+            }
+        }
+    });
+    formattedTestCase.push("Assertions:", ...(data.assertions || []).map((assertion) => `  Type: ${assertion.assertionType}, Expected: ${assertion.expected.toString()}, Indexes: ${assertion.messageIndexes && assertion.messageIndexes.length > 0 ? assertion.messageIndexes.join(", ") : "None"}`), "---");
+    return {
+        content: [{ type: "text", text: formattedTestCase.join("\n") }],
+    };
+});
+server.tool(getToolName("get_requests"), "Get a list of HTTP requests captured by Impart. Supports extensive filtering and pagination. Examples:\n\n" +
+    "• Recent requests (default): {} (gets last day, 25 results)\n" +
+    '• Last 24 hours: {"from": "-24h", "max_results": 50}\n' +
+    '• Last week: {"from": "-7d", "max_results": 100}\n' +
+    '• Filter by API spec: {"spec_id": ["spec-abc123"], "max_results": 25}\n' +
+    '• Error requests only: {"status_code": ["400", "404", "500"], "from": "-1d"}\n' +
+    '• Security events: {"tag": ["attack", "blocked", "suspicious"], "from": "-24h"}\n' +
+    '• Specific IP activity: {"ip": ["192.168.1.100"], "from": "-24h", "sort_order": "desc"}\n' +
+    '• Multiple filters: {"status_code": ["200"], "tag": ["allowed"], "from": "-1h", "max_results": 10}\n' +
+    '• Time range: {"from": "-7d", "until": "-1d", "sort_order": "desc", "max_results": 50}\n' +
+    '• Next page: {"max_results": 25, "next": "eyJ0aW1lc3RhbXAiOi4uLn0="}', {
+    spec_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe('Filter by spec IDs (e.g., ["spec-123", "spec-456"])'),
+    collection_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by collection IDs (e.g., ["collection-123"])'),
+    endpoint_id: zod_1.z.array(zod_1.z.string()).optional().nullable().describe('Filter by endpoint IDs (e.g., ["endpoint-123"])'),
+    tag: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by tag names (e.g., ["attack", "blocked", "allowed"])'),
+    ip: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by IP addresses (e.g., ["192.168.1.1", "10.0.0.1"])'),
+    external_request_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by external request IDs (e.g., ["req-123"])'),
+    rule_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by rule IDs that processed the request (e.g., ["rule-123"])'),
+    status_code: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe('Filter by HTTP status codes (e.g., ["200", "404", "500"])'),
+    from: zod_1.z
+        .string()
+        .default("-1d")
+        .optional()
+        .nullable()
+        .describe("Start time (relative like '-1d', '-24h', '-7d' or absolute timestamp)"),
+    until: zod_1.z
+        .string()
+        .default("-0h")
+        .optional()
+        .nullable()
+        .describe("End time (relative like '-0h', '-1h' or absolute timestamp)"),
+    max_results: zod_1.z
+        .number()
+        .default(25)
+        .optional()
+        .nullable()
+        .describe("Maximum number of results to return (1-1000, e.g., 10, 25, 50). Default 25 for performance"),
+    sort_order: zod_1.z
+        .enum(["asc", "desc"])
+        .optional()
+        .describe("Sort order for results: 'asc' (oldest first) or 'desc' (newest first)"),
+    next: zod_1.z
+        .string()
+        .optional()
+        .nullable()
+        .describe("Pagination token for next page of results (provided in previous response)"),
+    requests_source: zod_1.z
+        .enum(["pg", "clickhouse"])
+        .default("pg")
+        .optional()
+        .describe("Data source: 'pg' (PostgreSQL, default) or 'clickhouse'"),
+}, async ({ spec_id, collection_id, endpoint_id, tag, ip, external_request_id, rule_id, status_code, from, until, max_results, sort_order, next, requests_source, }) => {
+    // Validate time format parameters
+    if (from) {
+        const fromCheck = validateTimeFormat(from);
+        if (!fromCheck.valid) {
+            return { content: [{ type: "text", text: fromCheck.error }] };
+        }
+    }
+    if (until) {
+        const untilCheck = validateTimeFormat(until);
+        if (!untilCheck.valid) {
+            return { content: [{ type: "text", text: untilCheck.error }] };
+        }
+    }
+    // Validate max_results parameter
+    const paginationCheck = validatePagination(undefined, max_results);
+    if (!paginationCheck.valid) {
+        return { content: [{ type: "text", text: paginationCheck.error }] };
+    }
+    const queryParams = {};
+    // Add array parameters
+    if (spec_id !== null && spec_id !== undefined) {
+        queryParams["spec_id"] = spec_id;
+    }
+    if (collection_id !== null && collection_id !== undefined) {
+        queryParams["collection_id"] = collection_id;
+    }
+    if (endpoint_id !== null && endpoint_id !== undefined) {
+        queryParams["endpoint_id"] = endpoint_id;
+    }
+    if (tag !== null && tag !== undefined) {
+        queryParams["tag"] = tag;
+    }
+    if (ip !== null && ip !== undefined) {
+        queryParams["ip"] = ip;
+    }
+    if (external_request_id !== null && external_request_id !== undefined) {
+        queryParams["external_request_id"] = external_request_id;
+    }
+    if (rule_id !== null && rule_id !== undefined) {
+        queryParams["rule_id"] = rule_id;
+    }
+    if (status_code !== null && status_code !== undefined) {
+        queryParams["status_code"] = status_code;
+    }
+    // Add single value parameters
+    if (from !== null && from !== undefined) {
+        queryParams["from"] = from;
+    }
+    if (until !== null && until !== undefined) {
+        queryParams["until"] = until;
+    }
+    if (max_results !== null && max_results !== undefined) {
+        queryParams["max_results"] = max_results;
+    }
+    if (sort_order !== null && sort_order !== undefined) {
+        queryParams["sort_order"] = sort_order;
+    }
+    if (next !== null && next !== undefined) {
+        queryParams["next"] = next;
+    }
+    if (requests_source !== null && requests_source !== undefined) {
+        queryParams["requests_source"] = requests_source;
+    }
+    const data = await makeImpartRequest("requests", queryParams);
+    if (!data) {
+        const lastError = makeImpartRequest.lastError || "Unknown error";
+        return {
+            content: [{ type: "text", text: `Unable to fetch requests: ${lastError}` }],
+        };
+    }
+    const requests = data.items || [];
+    const meta = data.meta || {};
+    if (requests.length === 0) {
+        return {
+            content: [{ type: "text", text: "No requests found matching the specified criteria." }],
+        };
+    }
+    // Limit output for performance and readability
+    const maxDisplay = Math.min(requests.length, 20);
+    const showingLimited = requests.length > maxDisplay;
+    const result = [
+        `Found ${requests.length} requests (Total available: ${meta.total || "unknown"})`,
+        showingLimited
+            ? `Showing first ${maxDisplay} requests for performance. Use pagination or filters to get specific results.`
+            : "",
+        "=".repeat(60),
+        "",
+    ];
+    // Show condensed format for better readability
+    requests.slice(0, maxDisplay).forEach((request, index) => {
+        const clientIp = request.client_ip?.address || "unknown";
+        const tags = request.tags && request.tags.length > 0
+            ? request.tags.length > 3
+                ? `${request.tags.slice(0, 3).join(", ")} (+${request.tags.length - 3} more)`
+                : request.tags.join(", ")
+            : "None";
+        result.push(`${index + 1}. ${request.method} ${request.path} (${request.status_code})`, `   ID: ${request.id} | IP: ${clientIp} | ${request.timestamp}`, `   Tags: ${tags}`, `   Rule: ${request.rule_id || "None"}`, "");
+    });
+    // Add pagination info
+    if (data.next) {
+        result.push(`Next page token: ${data.next}`);
+        result.push("Use this token in the 'next' parameter to get the next page of results.");
+    }
+    return {
+        content: [{ type: "text", text: result.join("\n") }],
+    };
+});
+server.tool(getToolName("get_request_details"), "Get detailed information about a specific HTTP request captured by Impart. Provides complete request metadata, client information, and processing details. Examples:\n\n" +
+    '• Basic usage: {"request_id": "123e4567-e89b-12d3-a456-426614174000"}\n' +
+    '• With data source: {"request_id": "123e4567-e89b-12d3-a456-426614174000", "requests_source": "clickhouse"}\n' +
+    '• PostgreSQL source: {"request_id": "abc12345-678d-90ef-1234-567890abcdef", "requests_source": "pg"}\n\n' +
+    "Note: Use request IDs from the get_requests tool or your Impart dashboard.", {
+    request_id: zod_1.z
+        .string()
+        .describe("The unique identifier of the request (UUID format, e.g., '123e4567-e89b-12d3-a456-426614174000')"),
+    requests_source: zod_1.z
+        .enum(["pg", "clickhouse"])
+        .default("pg")
+        .optional()
+        .describe("Data source: 'pg' (PostgreSQL, default) or 'clickhouse'"),
+}, async ({ request_id, requests_source }) => {
+    if (!request_id) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: request_id is required. Please provide a valid UUID for the request you want to retrieve details for.",
+                },
+            ],
+        };
+    }
+    const queryParams = {};
+    if (requests_source !== null && requests_source !== undefined) {
+        queryParams["requests_source"] = requests_source;
+    }
+    const data = await makeImpartRequest(`requests/${request_id}`, queryParams);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unable to fetch request details for ID '${request_id}': Request not found or unknown error occurred.`,
+                },
+            ],
+        };
+    }
+    // Format the detailed request information
+    const result = [
+        "Request Details",
+        "=".repeat(50),
+        "",
+        `ID: ${data.id}`,
+        `Method: ${data.method}`,
+        `Path: ${data.path}`,
+        `Status Code: ${data.status_code}`,
+        `Timestamp: ${data.timestamp}`,
+        "",
+        "Client Information:",
+        `  IP Address: ${data.client_ip?.address || "N/A"}`,
+        `  IP Version: ${data.client_ip?.version || "N/A"}`,
+        "",
+        "Request Metadata:",
+        `  Spec ID: ${data.spec_id}`,
+        `  Endpoint ID: ${data.endpoint_id}`,
+        `  External Request ID: ${data.external_request_id}`,
+        `  Rule ID: ${data.rule_id || "N/A (no rule processed this request)"}`,
+        "",
+        "Tags:",
+        data.tags && data.tags.length > 0 ? data.tags.map((tag) => `  • ${tag}`).join("\n") : "  No tags applied",
+        "",
+    ];
+    // Add external links if available
+    if (data.external_links && Object.keys(data.external_links).length > 0) {
+        result.push("External Links:");
+        Object.entries(data.external_links).forEach(([key, value]) => {
+            // Properly serialize objects and arrays
+            const serializedValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+            result.push(`  ${key}: ${serializedValue}`);
+        });
+        result.push("");
+    }
+    // Add data source info
+    result.push(`Data Source: ${requests_source || "pg"} (${requests_source === "clickhouse" ? "ClickHouse" : "PostgreSQL"})`);
+    return {
+        content: [{ type: "text", text: result.join("\n") }],
+    };
+});
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);