@mambalabsdev/mcp-ai-tooling-detector 1.1.1 → 1.3.0

package/README.md

@@ -76,11 +76,16 @@ Calls consume Apify credits, billed per domain analyzed. Free Apify plans get 15
 |---|---|---|---|
 | `domain` | string | one of these | A single company domain, e.g. `intercom.com`. |
 | `domains` | string[] | one of these | Batch mode. Takes precedence over `domain`. |
+| `vendors` | array | no | Report only these AI vendors, one or more of the 52 fingerprinted tools (`sierra`, `decagon`, `intercom_fin`, `openai_api`, `anthropic_api`, `pinecone`, `langchain` and the rest). The site wide AI maturity read is never narrowed by this. Omit for every vendor. |
 | `check_pricing` | boolean | no | Fetch and score the pricing page. Default true. Setting it false is faster but caps the result at `deployed`, because `commercialized` can only be proven on a pricing page. |
 | `skipCache` | boolean | no | Force a fresh analysis and ignore the 7 day result cache. |
+| `request_timeout_ms` | integer | no | Per-request timeout in milliseconds, 3000 to 20000. Default 9000. |
+| `batchSize` | integer | no | Batch mode only: how many domains the actor analyzes at once, 1 to 10. Default 5. |
 
 The tool is read-only and idempotent. It never writes anything.
 
+The tool starts the actor run and polls it to a finished status, so a long run is not cut off at 300 seconds. The run is allowed 1,800 seconds. If it is still going two minutes after that, the call stops waiting and returns the run ID with a link to it in the Apify Console, where the results land when it finishes. A run that does not succeed comes back as an error with its run ID and status.
+
 ## Full actor documentation
 
 Input reference, the complete output field list, pricing tiers, error handling, and the measured limitations are on the actor's Apify Store page:

package/build/index.js

@@ -19,31 +19,41 @@ function compact(obj) {
     }
     return out;
 }
+// How long the actor run itself is allowed to take, in seconds. One value for
+// every Mamba Labs wrapper, set 2026-10-05: start and poll exists so a long run
+// survives, and a shorter limit would end the long runs it was built for. Past
+// this limit the run ends TIMED-OUT and the caller is told so, with the run id.
+const ACTOR_RUN_TIMEOUT_SECS = 1800;
+// How long this wrapper waits for that run, in milliseconds. The actor's own
+// timeout plus two minutes, so the run's own TIMED-OUT status is what the
+// caller sees rather than the wrapper giving up first and reporting nothing.
+const WRAPPER_WAIT_MS = (ACTOR_RUN_TIMEOUT_SECS + 120) * 1000;
+const POLL_INTERVAL_MS = Number(process.env.MAMBA_POLL_INTERVAL_MS) || 3000;
+const TERMINAL = new Set(["SUCCEEDED", "FAILED", "TIMED-OUT", "ABORTED", "ABORTING"]);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 // Shared caller. actorPath is the actor's immutable Apify actor ID (a stable key
 // that survives Store renames). The /v2/acts/{id} endpoint accepts it directly,
 // so a Store rename never breaks these calls.
+//
+// START AND POLL, NOT RUN-SYNC. Apify's synchronous endpoints carry a platform
+// ceiling of 300 seconds on the HTTP wait itself and answer 408 past it while
+// the run goes on and keeps billing. Starting the run, polling it to a terminal
+// status and then reading the dataset waits as long as the actor needs.
+//
+// The token is read here rather than at module load, so the tool registers
+// unconditionally and a server started without APIFY_TOKEN still advertises its
+// capabilities instead of reporting none.
 async function runActor(actorPath, actorLabel, input) {
+    const APIFY_TOKEN = process.env.APIFY_TOKEN;
     if (!APIFY_TOKEN) {
         return { isError: true, content: [{ type: "text", text: "APIFY_TOKEN is not set. Create a token at https://console.apify.com/account/integrations and set it as the APIFY_TOKEN environment variable." }] };
     }
-    const url = `https://api.apify.com/v2/acts/${actorPath}/run-sync-get-dataset-items?timeout=300`;
-    let response;
-    try {
-        response = await fetch(url, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${APIFY_TOKEN}`,
-                "Content-Type": "application/json",
-                "User-Agent": USER_AGENT,
-            },
-            body: JSON.stringify(input),
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { isError: true, content: [{ type: "text", text: `Could not reach the Apify API: ${message}` }] };
-    }
-    if (!response.ok) {
+    const headers = {
+        Authorization: `Bearer ${APIFY_TOKEN}`,
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+    };
+    const httpError = async (response) => {
         let detail = "";
         try {
             const body = (await response.json());
@@ -53,24 +63,106 @@ async function runActor(actorPath, actorLabel, input) {
         catch {
             detail = "";
         }
-        let message;
         switch (response.status) {
+            case 400:
+                return `The ${actorLabel} run was rejected as invalid input.${detail}`;
             case 401:
-                message = "Invalid Apify token. Check your APIFY_TOKEN environment variable.";
-                break;
+                return "Invalid Apify token. Check your APIFY_TOKEN environment variable.";
             case 402:
-                message =
-                    "Insufficient Apify credits. Check your account balance at https://console.apify.com/billing";
-                break;
-            case 408:
-                message = `The ${actorLabel} run timed out after 300 seconds. Try again, or run the actor on Apify directly for longer jobs.`;
-                break;
+                return "Insufficient Apify credits. Check your account balance at https://console.apify.com/billing";
             default:
-                message = `Apify request to ${actorLabel} failed with status ${response.status}.${detail}`;
+                return `Apify request to ${actorLabel} failed with status ${response.status}.${detail}`;
         }
-        return { isError: true, content: [{ type: "text", text: message }] };
+    };
+    // 1. Start the run.
+    let started;
+    try {
+        started = await fetch(`https://api.apify.com/v2/acts/${actorPath}/runs?timeout=${ACTOR_RUN_TIMEOUT_SECS}`, { method: "POST", headers, body: JSON.stringify(input) });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Could not reach the Apify API: ${message}` }] };
+    }
+    if (!started.ok) {
+        return { isError: true, content: [{ type: "text", text: await httpError(started) }] };
+    }
+    let run;
+    try {
+        run = (await started.json()).data ?? {};
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `The ${actorLabel} run start returned a response that could not be parsed: ${message}` }] };
+    }
+    const runId = run.id;
+    if (!runId) {
+        return { isError: true, content: [{ type: "text", text: `The ${actorLabel} run start returned no run id, so there is nothing to wait for.` }] };
+    }
+    // 2. Poll to a terminal status.
+    const deadline = Date.now() + WRAPPER_WAIT_MS;
+    let status = run.status ?? "READY";
+    let datasetId = run.defaultDatasetId;
+    while (!TERMINAL.has(status)) {
+        if (Date.now() >= deadline) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `The ${actorLabel} run ${runId} was still ${status} after ${Math.round(WRAPPER_WAIT_MS / 1000)} seconds and this call stopped waiting. The run itself is still on Apify: read it at https://console.apify.com/actors/runs/${runId}` }],
+            };
+        }
+        await sleep(POLL_INTERVAL_MS);
+        let poll;
+        try {
+            poll = await fetch(`https://api.apify.com/v2/actor-runs/${runId}`, { headers });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { isError: true, content: [{ type: "text", text: `Lost contact with the Apify API while waiting for ${actorLabel} run ${runId}: ${message}` }] };
+        }
+        if (!poll.ok) {
+            return { isError: true, content: [{ type: "text", text: await httpError(poll) }] };
+        }
+        const body = (await poll.json());
+        status = body.data?.status ?? status;
+        datasetId = body.data?.defaultDatasetId ?? datasetId;
+    }
+    // 3. A run that did not succeed is a failure the caller must see, never an
+    // empty success, so a crashed run never reads as "no results found".
+    if (status !== "SUCCEEDED") {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `The ${actorLabel} run did not succeed (run ID: ${runId}, status: ${status}).` }],
+        };
+    }
+    if (!datasetId) {
+        return { isError: true, content: [{ type: "text", text: `The ${actorLabel} run ${runId} succeeded but reported no dataset, so there is nothing to return.` }] };
+    }
+    // 4. Read the dataset.
+    let ds;
+    try {
+        ds = await fetch(`https://api.apify.com/v2/datasets/${datasetId}/items?format=json`, { headers });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Could not read the ${actorLabel} dataset: ${message}` }] };
+    }
+    if (!ds.ok) {
+        return { isError: true, content: [{ type: "text", text: await httpError(ds) }] };
+    }
+    let items;
+    try {
+        items = await ds.json();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `The ${actorLabel} run returned a response that could not be parsed: ${message}` }] };
+    }
+    if (!Array.isArray(items)) {
+        const asObj = items;
+        const detail = asObj?.error?.message
+            ? `${asObj.error.message}`
+            : JSON.stringify(items);
+        return { isError: true, content: [{ type: "text", text: `The ${actorLabel} run did not return a dataset. ${detail}` }] };
     }
-    const items = await response.json();
     return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
 }
 const server = new McpServer({
@@ -97,6 +189,10 @@ server.registerTool("detect_ai_tooling", {
             .array(z.string())
             .optional()
             .describe("Batch mode: several company domains analyzed in one call. Takes precedence over domain."),
+        vendors: z
+            .array(z.enum(["sierra", "decagon", "ada", "forethought", "intercom_fin", "ultimate_ai", "netomi", "yellow_ai", "cognigy", "kore_ai", "chatbase", "voiceflow", "sendbird_ai", "intercom", "zendesk", "drift", "gorgias", "freshworks", "tidio", "crisp", "kustomer", "qualified", "hubspot_breeze", "algolia", "glean", "inkeep", "kapa_ai", "mendable", "mutiny", "dynamic_yield", "openai_api", "anthropic_api", "azure_openai", "aws_bedrock", "google_gemini", "cohere", "mistral", "groq", "together_ai", "fireworks_ai", "replicate", "perplexity_api", "huggingface", "openrouter", "cloudflare_ai_gateway", "pinecone", "weaviate", "qdrant", "vercel_ai_sdk", "langchain", "llamaindex", "assistant_ui"]))
+            .optional()
+            .describe("Report only these AI vendors, which turns the actor into competitive intelligence for any one of the 52 fingerprinted tools. Detection is unchanged either way, so a filtered call costs the same. The site wide AI maturity read (ai_maturity, confidence, uses_ai, the llms.txt and robots.txt checks, the pricing score) is never narrowed by this. Omit for every vendor."),
         check_pricing: z
             .boolean()
             .optional()
@@ -108,10 +204,19 @@ server.registerTool("detect_ai_tooling", {
         request_timeout_ms: z
             .number()
             .int()
+            .min(3000)
+            .max(20000)
             .optional()
             .describe("Per-request timeout in milliseconds. 3000 to 20000. Default: 9000."),
+        batchSize: z
+            .number()
+            .int()
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("Batch mode only: how many domains the actor analyzes at once. 1 to 10. Default: 5."),
     },
-}, async ({ domain, domains, check_pricing, skipCache, request_timeout_ms }) => {
+}, async ({ domain, domains, vendors, check_pricing, skipCache, request_timeout_ms, batchSize }) => {
     const hasSingle = domain !== undefined && domain !== "";
     const hasBatch = Array.isArray(domains) && domains.length > 0;
     if (!hasSingle && !hasBatch) {
@@ -123,9 +228,11 @@ server.registerTool("detect_ai_tooling", {
     return runActor("EwkHhmqiuJgRoVEbE", "AI Tooling Detector", compact({
         domain: hasBatch ? undefined : domain,
         domains: hasBatch ? domains : undefined,
+        vendors,
         check_pricing,
         skipCache,
         request_timeout_ms,
+        batchSize,
     }));
 });
 const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mambalabsdev/mcp-ai-tooling-detector",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "MCP server for the Mamba Labs AI Tooling Detector actor on Apify. Give it a company domain and it returns whether the company only talks about AI, actually deploys AI tooling on its site, or charges for AI, with the evidence, as Clay-ready JSON.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "tsc && chmod +x build/index.js",
+    "test": "npm run build && node --test test/*.test.js",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -40,11 +41,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "zod": "^3.23.8"
+    "zod": "^4.5.4"
   },
   "devDependencies": {
-    "@types/node": "^20.14.0",
-    "typescript": "^5.6.0"
+    "@types/node": "^26.4.0",
+    "typescript": "5.9.3"
   },
   "mcpName": "com.mambabuilt/mcp-ai-tooling-detector"
 }