telique-mcp 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "./config.js";
+export declare class TeliqueClient {
+    private baseUrl;
+    private apiToken;
+    private timeoutMs;
+    get isAnonymous(): boolean;
+    constructor(config: Config);
+    get(path: string, params?: Record<string, string | number | undefined>): Promise<unknown>;
+    post(path: string, body: unknown): Promise<unknown>;
+    private buildUrl;
+    private request;
+    private tryParseJson;
+    private describeHttpError;
+}

package/dist/client.js

@@ -0,0 +1,106 @@
+export class TeliqueClient {
+    baseUrl;
+    apiToken;
+    timeoutMs;
+    get isAnonymous() {
+        return this.apiToken === null;
+    }
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+        this.apiToken = config.apiToken;
+        this.timeoutMs = config.requestTimeoutMs;
+    }
+    async get(path, params) {
+        const url = this.buildUrl(path, params);
+        return this.request(url, { method: "GET" });
+    }
+    async post(path, body) {
+        const url = this.buildUrl(path);
+        return this.request(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    buildUrl(path, params) {
+        const url = new URL(path, this.baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    async request(url, init) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                ...init,
+                signal: controller.signal,
+                headers: {
+                    ...(init.headers || {}),
+                    ...(this.apiToken ? { "x-api-token": this.apiToken } : {}),
+                    Accept: "application/json",
+                },
+            });
+            const text = await response.text();
+            if (!response.ok) {
+                return {
+                    _error: true,
+                    status: response.status,
+                    message: this.describeHttpError(response.status),
+                    body: this.tryParseJson(text),
+                };
+            }
+            return this.tryParseJson(text);
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === "AbortError") {
+                return {
+                    _error: true,
+                    status: 0,
+                    message: `Request timed out after ${this.timeoutMs}ms`,
+                };
+            }
+            return {
+                _error: true,
+                status: 0,
+                message: `Network error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    tryParseJson(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    describeHttpError(status) {
+        switch (status) {
+            case 400:
+                return "Bad request — check parameter format";
+            case 401:
+            case 403:
+                return "Authentication failed — check TELIQUE_API_TOKEN";
+            case 404:
+                return "Not found";
+            case 429:
+                return this.apiToken
+                    ? "Rate limit exceeded"
+                    : "Rate limit exceeded (10 ops/min in anonymous mode). Run `npx telique-mcp setup` or visit https://telique.ringer.tel to get an API key for unlimited access.";
+            case 502:
+            case 503:
+                return "Service temporarily unavailable";
+            default:
+                return `HTTP ${status}`;
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export interface Config {
+    baseUrl: string;
+    apiToken: string | null;
+    requestTimeoutMs: number;
+}
+declare const CONFIG_DIR: string;
+declare const CONFIG_FILE: string;
+export { CONFIG_DIR, CONFIG_FILE };
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".telique");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export { CONFIG_DIR, CONFIG_FILE };
+function loadTokenFromConfigFile() {
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        const config = JSON.parse(raw);
+        return typeof config.apiToken === "string" ? config.apiToken : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function loadConfig() {
+    // Token resolution: env var > config file > null (anonymous)
+    const apiToken = process.env.TELIQUE_API_TOKEN || loadTokenFromConfigFile() || null;
+    return {
+        baseUrl: process.env.TELIQUE_API_BASE_URL || "https://api-dev.ringer.tel",
+        apiToken,
+        requestTimeoutMs: parseInt(process.env.TELIQUE_REQUEST_TIMEOUT_MS || "10000", 10),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { loadConfig } from "./config.js";
+const subcommand = process.argv[2];
+if (subcommand === "setup") {
+    const { runSetup } = await import("./setup.js");
+    await runSetup();
+}
+else {
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const { TeliqueClient } = await import("./client.js");
+    const { setAnonymousMode } = await import("./utils/formatting.js");
+    const { registerRoutelinkTools } = await import("./tools/routelink.js");
+    const { registerLrnTools } = await import("./tools/lrn.js");
+    const { registerCnamTools } = await import("./tools/cnam.js");
+    const { registerLergTools } = await import("./tools/lerg.js");
+    const { registerGraphqlTools } = await import("./tools/graphql.js");
+    const { registerCompositeTools } = await import("./tools/composite.js");
+    const config = loadConfig();
+    const client = new TeliqueClient(config);
+    setAnonymousMode(client.isAnonymous);
+    const server = new McpServer({
+        name: "telique",
+        version: "1.0.0",
+    });
+    registerRoutelinkTools(server, client);
+    registerLrnTools(server, client);
+    registerCnamTools(server, client);
+    registerLergTools(server, client);
+    registerGraphqlTools(server, client);
+    registerCompositeTools(server, client);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,131 @@
+import { createInterface } from "node:readline/promises";
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { stdin, stdout } from "node:process";
+import { CONFIG_DIR, CONFIG_FILE } from "./config.js";
+const REGISTER_URL = "https://telique.ringer.tel/register";
+const API_BASE_URL = "https://api-dev.ringer.tel";
+export async function runSetup() {
+    const rl = createInterface({ input: stdin, output: stdout });
+    console.log("\n  Telique MCP — Setup\n");
+    // Check for existing config
+    const existing = loadExistingToken();
+    if (existing) {
+        console.log(`  Found existing API key: ${maskToken(existing)}`);
+        const keep = await rl.question("  Keep this key? (Y/n): ");
+        if (keep.toLowerCase() !== "n") {
+            console.log("\n  ✓ Keeping existing configuration.\n");
+            printMcpConfig(existing);
+            rl.close();
+            return;
+        }
+    }
+    console.log("  Do you have an API key?\n");
+    console.log("  [1] Yes, I have one  → Enter it");
+    console.log("  [2] No, I need one   → Opens telique.ringer.tel in browser");
+    console.log("  [3] Skip for now     → Use anonymous mode (10 ops/min)");
+    console.log();
+    const choice = await rl.question("  > ");
+    switch (choice.trim()) {
+        case "1": {
+            const token = await rl.question("\n  Enter your API key: ");
+            const trimmed = token.trim();
+            if (!trimmed) {
+                console.log("\n  ✗ No key entered. Exiting.\n");
+                rl.close();
+                process.exit(1);
+            }
+            console.log("\n  Validating...");
+            const valid = await validateToken(trimmed);
+            if (!valid) {
+                console.log("  ✗ Token validation failed. The API returned an error.");
+                console.log("  Check your token and try again.\n");
+                rl.close();
+                process.exit(1);
+            }
+            saveToken(trimmed);
+            console.log(`  ✓ Token validated`);
+            console.log(`  ✓ Saved to ${CONFIG_FILE}\n`);
+            printMcpConfig(trimmed);
+            break;
+        }
+        case "2": {
+            console.log(`\n  Opening ${REGISTER_URL} ...\n`);
+            await openBrowser(REGISTER_URL);
+            console.log("  After creating your account, run this command again with your API key.\n");
+            break;
+        }
+        case "3":
+        default: {
+            console.log("\n  ✓ Skipped. Running in anonymous mode (10 ops/min).");
+            console.log(`  Get an API key anytime at ${REGISTER_URL}\n`);
+            printMcpConfig(null);
+            break;
+        }
+    }
+    rl.close();
+}
+function loadExistingToken() {
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        const config = JSON.parse(raw);
+        return typeof config.apiToken === "string" ? config.apiToken : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(token) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    const config = existsSync(CONFIG_FILE)
+        ? JSON.parse(readFileSync(CONFIG_FILE, "utf-8"))
+        : {};
+    config.apiToken = token;
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+async function validateToken(token) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/health`, {
+            headers: { "x-api-token": token },
+            signal: AbortSignal.timeout(10000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function maskToken(token) {
+    if (token.length <= 8)
+        return "****";
+    return token.substring(0, 4) + "..." + token.substring(token.length - 4);
+}
+async function openBrowser(url) {
+    const { exec } = await import("node:child_process");
+    const cmd = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "start"
+            : "xdg-open";
+    exec(`${cmd} ${url}`);
+}
+function printMcpConfig(token) {
+    const env = {};
+    if (token) {
+        env.TELIQUE_API_TOKEN = token;
+    }
+    const config = {
+        mcpServers: {
+            telique: {
+                command: "npx",
+                args: ["-y", "telique-mcp"],
+                ...(token ? { env } : {}),
+            },
+        },
+    };
+    console.log("  Add this to your MCP client configuration:\n");
+    console.log(JSON.stringify(config, null, 2)
+        .split("\n")
+        .map((line) => "  " + line)
+        .join("\n"));
+    console.log();
+}

package/dist/tools/cnam.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerCnamTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/cnam.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { formatResponse } from "../utils/formatting.js";
+export function registerCnamTools(server, client) {
+    server.tool("cnam_lookup", "Look up the Caller Name (CNAM) for a phone number via TransUnion LIDB. Returns the calling_name (up to 15 characters), calling_name_status (available/unavailable), and presentation_indicator (allowed/restricted). Results are cached server-side for 24 hours.", {
+        phone_number: z
+            .string()
+            .regex(/^\d{10,15}$/)
+            .describe("10-15 digit phone number to look up"),
+    }, async ({ phone_number }) => {
+        const result = await client.get(`/v1/telique/cnam/${phone_number}`);
+        return formatResponse(result);
+    });
+}

package/dist/tools/composite.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerCompositeTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/composite.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { formatResponse } from "../utils/formatting.js";
+export function registerCompositeTools(server, client) {
+    server.tool("lookup_tn", "Composite phone number lookup across multiple Telique services. Dips LRN, CNAM, DNO, and LERG (NPA-NXX from lerg_6) in parallel and returns a consolidated view. Use this for a quick, comprehensive profile of any phone number.", {
+        phone_number: z
+            .string()
+            .regex(/^\d{10}$/)
+            .describe("10-digit US phone number"),
+    }, async ({ phone_number }) => {
+        const npa = phone_number.substring(0, 3);
+        const nxx = phone_number.substring(3, 6);
+        const [lrn, cnam, dno, lerg] = await Promise.all([
+            client
+                .get(`/v1/telique/lrn/${phone_number}`, { format: "json" })
+                .catch((err) => ({ _error: true, message: err.message })),
+            client
+                .get(`/v1/telique/cnam/${phone_number}`)
+                .catch((err) => ({ _error: true, message: err.message })),
+            client
+                .get(`/v1/telique/dno/${phone_number}`, { format: "json" })
+                .catch((err) => ({ _error: true, message: err.message })),
+            client
+                .get(`/v1/telique/lerg/lerg_6/npa,nxx,loc_name,loc_state,lata,lata_name,ocn,switch,rc_abbre,rc_type/npa=${npa}%26nxx=${nxx}`, { limit: 5 })
+                .catch((err) => ({ _error: true, message: err.message })),
+        ]);
+        const consolidated = {
+            phone_number,
+            npa,
+            nxx,
+            lrn,
+            cnam,
+            dno,
+            lerg_6: lerg,
+        };
+        return formatResponse(consolidated);
+    });
+}

package/dist/tools/graphql.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerGraphqlTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/graphql.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { formatResponse } from "../utils/formatting.js";
+export function registerGraphqlTools(server, client) {
+    server.tool("graphql_query", `Execute GraphQL queries against LSMS or LERG databases.
+
+LSMS (service='lsms'): Live NPAC porting data. Tables: subscriptionVersions (514M rows — MUST filter by phone_number, lrn, or spid), numberBlocks, serviceProviders, locationRoutingNumbers, npanxx. Safety limits: max 1000 results, depth 5, complexity 200, 10s timeout.
+
+LERG (service='lerg'): Static telecom reference data. All 27 LERG tables with camelCase names (lerg1, lerg6, lerg7Sha, etc.). Supports relationship joins: lerg6→carrier (via OCN→lerg1), lerg6→switchInfo (→lerg7), lerg7Sha→tandemSwitch. Filter operators: EQ, NE, GT, GTE, LT, LTE, LIKE, IN, IS_NULL, IS_NOT_NULL. All field values are nullable strings.`, {
+        service: z
+            .enum(["lsms", "lerg"])
+            .describe("Target service: 'lsms' for live porting data, 'lerg' for static telecom reference"),
+        query: z.string().describe("GraphQL query string"),
+        variables: z
+            .record(z.unknown())
+            .optional()
+            .describe("Optional GraphQL variables"),
+    }, async ({ service, query, variables }) => {
+        const path = service === "lsms"
+            ? "/v1/telique/lsms/gql"
+            : "/v1/telique/lerg/gql";
+        const body = { query };
+        if (variables)
+            body.variables = variables;
+        const result = await client.post(path, body);
+        return formatResponse(result);
+    });
+}

package/dist/tools/lerg.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerLergTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/lerg.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { formatResponse } from "../utils/formatting.js";
+const LERG_TABLES = [
+    "lerg_1",
+    "lerg_1_con",
+    "lerg_2",
+    "lerg_3",
+    "lerg_4",
+    "lerg_5",
+    "lerg_6",
+    "lerg_6_atc",
+    "lerg_6_ins",
+    "lerg_6_odd",
+    "lerg_7",
+    "lerg_7_ins",
+    "lerg_7_sha",
+    "lerg_7_sha_ins",
+    "lerg_8",
+    "lerg_8_lir",
+    "lerg_8_loc",
+    "lerg_8_pst",
+    "lerg_9",
+    "lerg_9_atc",
+    "lerg_10",
+    "lerg_11",
+    "lerg_12",
+    "lerg_12_ins",
+    "lerg_16",
+    "lerg_17",
+    "lergdate",
+];
+export function registerLergTools(server, client) {
+    server.tool("lerg_table_info", "List all 27 LERG tables or get metadata/schema for a specific table. LERG is static telecom reference data. Key tables: lerg_1 (OCN/carrier directory), lerg_6 (NPA-NXX block assignments with switch, LATA, rate center), lerg_7 (switch details), lerg_7_sha (switch homing arrangements/tandems), lerg_12 (LRN registry).", {
+        table_name: z
+            .string()
+            .optional()
+            .describe("Specific table name (e.g. lerg_1, lerg_6, lerg_7_sha). Omit to list all tables."),
+    }, async ({ table_name }) => {
+        if (table_name) {
+            const result = await client.get(`/v1/telique/lerg/tables/${table_name}`);
+            return formatResponse(result);
+        }
+        const result = await client.get("/v1/telique/lerg/tables");
+        return formatResponse(result);
+    });
+    server.tool("lerg_query", "Query any LERG table by field values. Common queries: carrier by OCN (lerg_1, fields: ocn_num,ocn_name,ocn_state), NPA-NXX info (lerg_6, fields: npa,nxx,loc_name,ocn,switch,lata), switch details (lerg_7, fields: switch,ocn,aocn), LRN registry (lerg_12, fields: lrn,lata,switch,ocn). Filter format: field=value, multiple filters joined with & (e.g. npa=303&nxx=629).", {
+        table_name: z.string().describe("Table to query (e.g. lerg_1, lerg_6)"),
+        fields: z
+            .string()
+            .describe("Comma-separated field names to return (e.g. ocn_num,ocn_name,ocn_state)"),
+        query: z
+            .string()
+            .describe("Filter in field=value format, multiple filters joined with & (e.g. ocn_state=CO or npa=303&nxx=629)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(10000)
+            .default(100)
+            .describe("Max results (default 100, max 10000)"),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .default(0)
+            .describe("Pagination offset (default 0)"),
+    }, async ({ table_name, fields, query, limit, offset }) => {
+        // Encode & as %26 so multi-filters stay in the path segment
+        const encodedQuery = query.replace(/&/g, "%26");
+        const result = await client.get(`/v1/telique/lerg/${table_name}/${fields}/${encodedQuery}`, { limit, offset });
+        return formatResponse(result);
+    });
+    server.tool("lerg_complex_query", "Execute a complex LERG query with JOINs across multiple tables. Supports filter operators: eq, ne, gt, gte, lt, lte, like, in, isnull, isnotnull. Use this when you need to combine data from different LERG tables, such as joining NPA-NXX (lerg_6) with carrier info (lerg_1) via OCN.", {
+        table: z.string().describe("Primary table name (e.g. lerg_6)"),
+        fields: z
+            .array(z.string())
+            .optional()
+            .describe("Fields to return from primary table (e.g. ['npa','nxx','ocn','loc_name'])"),
+        filters: z
+            .array(z.object({
+            field: z.string(),
+            operator: z.enum([
+                "eq",
+                "ne",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "like",
+                "in",
+                "isnull",
+                "isnotnull",
+            ]),
+            value: z.union([z.string(), z.number()]),
+        }))
+            .describe("Filter conditions (e.g. [{field:'npa', operator:'eq', value:720}])"),
+        join: z
+            .object({
+            table: z.string().describe("Table to join (e.g. lerg_1)"),
+            on: z
+                .array(z.object({
+                left_field: z.string(),
+                right_field: z.string(),
+            }))
+                .describe("Join conditions (e.g. [{left_field:'ocn', right_field:'ocn_num'}])"),
+            fields: z
+                .array(z.string())
+                .optional()
+                .describe("Fields to return from joined table"),
+            join_type: z
+                .enum(["inner", "left"])
+                .default("inner")
+                .describe("Join type"),
+        })
+            .optional()
+            .describe("Optional JOIN clause"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(10000)
+            .default(100)
+            .describe("Max results (default 100)"),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .default(0)
+            .describe("Pagination offset (default 0)"),
+    }, async ({ table, fields, filters, join, limit, offset }) => {
+        const body = {
+            table,
+            filters,
+            limit,
+            offset,
+        };
+        if (fields)
+            body.fields = fields;
+        if (join)
+            body.join = join;
+        const result = await client.post("/v1/telique/lerg/query", body);
+        return formatResponse(result);
+    });
+    server.tool("lerg_tandem", "Look up tandem routing information for a given NPA-NXX. Returns the tandem switch and routing path for calls to a specific area code and exchange. Uses SQL JOINs across LERG tables (lerg_6, lerg_7, lerg_7_sha) for comprehensive routing data.", {
+        npa: z.string().regex(/^\d{3}$/).describe("3-digit area code (NPA)"),
+        nxx: z.string().regex(/^\d{3}$/).describe("3-digit exchange code (NXX)"),
+    }, async ({ npa, nxx }) => {
+        const result = await client.get("/v1/telique/lerg/tandem", { npa, nxx });
+        return formatResponse(result);
+    });
+}

package/dist/tools/lrn.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerLrnTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/lrn.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { formatResponse, errorResult } from "../utils/formatting.js";
+export function registerLrnTools(server, client) {
+    server.tool("lrn_lookup", "Look up the Local Routing Number (LRN) for a phone number. Returns the LRN, SPID (Service Provider ID), LNP type, and activation timestamp. LRN identifies the switch that serves a ported phone number. This queries live LSMS/NPAC porting data.", {
+        phone_number: z
+            .string()
+            .regex(/^\d{10}$/)
+            .describe("10-digit US phone number"),
+    }, async ({ phone_number }) => {
+        const result = await client.get(`/v1/telique/lrn/${phone_number}`, {
+            format: "json",
+        });
+        return formatResponse(result);
+    });
+    server.tool("lrn_relationship_query", "Query relationships in the LSMS database. Find phone numbers by LRN, SPIDs by LRN or phone number, or LRNs by SPID or phone number. Queries live NPAC porting data (not static LERG reference data).", {
+        query_type: z
+            .enum([
+            "phones_by_lrn",
+            "phones_by_spid",
+            "spid_by_lrn",
+            "spid_by_phone",
+            "lrn_by_spid",
+            "lrn_by_phone",
+        ])
+            .describe("Type of relationship query"),
+        value: z
+            .string()
+            .describe("The LRN, SPID, or phone number to query by (depends on query_type)"),
+    }, async ({ query_type, value }) => {
+        const routeMap = {
+            phones_by_lrn: { resource: "phone_number", param: "lrn" },
+            phones_by_spid: { resource: "phone_number", param: "spid" },
+            spid_by_lrn: { resource: "spid", param: "lrn" },
+            spid_by_phone: { resource: "spid", param: "phone_number" },
+            lrn_by_spid: { resource: "lrn", param: "spid" },
+            lrn_by_phone: { resource: "lrn", param: "phone_number" },
+        };
+        const route = routeMap[query_type];
+        if (!route) {
+            return errorResult(`Unknown query_type: ${query_type}`);
+        }
+        const result = await client.get(`/v1/telique/lsms/list/${route.resource}`, { [route.param]: value });
+        return formatResponse(result);
+    });
+    server.tool("dno_check", "Check if a phone number is on the Do Not Originate (DNO) list. DNO numbers should never appear as a caller ID because they belong to entities that only receive calls (e.g., IRS, major banks). A match indicates potential caller ID spoofing. Supports prefix matching (3, 6, 7, or 10 digit patterns).", {
+        phone_number: z
+            .string()
+            .regex(/^\d{10}$/)
+            .describe("10-digit US phone number to check"),
+    }, async ({ phone_number }) => {
+        const result = await client.get(`/v1/telique/dno/${phone_number}`, {
+            format: "json",
+        });
+        return formatResponse(result);
+    });
+}

package/dist/tools/routelink.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "../client.js";
+export declare function registerRoutelinkTools(server: McpServer, client: TeliqueClient): void;

package/dist/tools/routelink.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { formatResponse, errorResult } from "../utils/formatting.js";
+export function registerRoutelinkTools(server, client) {
+    server.tool("routelink_lookup", "Look up toll-free number routing. Resolves a CRN (toll-free number) to its carrier (CIC), Responsible Organization (ROR), or both. CIC lookup interprets the CPR decision tree using the caller's ANI and LATA to determine which carrier handles the call.", {
+        crn: z
+            .string()
+            .regex(/^\d{10}$/)
+            .describe("10-digit toll-free number (CRN), e.g. 8005551234"),
+        lookup_type: z
+            .enum(["cic", "cicror", "ror"])
+            .describe("Type of lookup: 'cic' = carrier ID, 'ror' = responsible org, 'cicror' = both"),
+        ani: z
+            .string()
+            .regex(/^\d{10}$/)
+            .optional()
+            .describe("10-digit calling party number (required for cic and cicror lookups)"),
+        lata: z
+            .string()
+            .regex(/^\d{3}$/)
+            .optional()
+            .describe("3-digit LATA code (required for cic and cicror lookups)"),
+    }, async ({ crn, lookup_type, ani, lata }) => {
+        if ((lookup_type === "cic" || lookup_type === "cicror") &&
+            (!ani || !lata)) {
+            return errorResult("ani and lata are required for cic and cicror lookups");
+        }
+        let path;
+        if (lookup_type === "ror") {
+            path = `/v1/telique/ror/${crn}`;
+        }
+        else {
+            path = `/v1/telique/${lookup_type}/${crn}/${ani}/${lata}`;
+        }
+        const result = await client.get(path, { format: "json" });
+        return formatResponse(result);
+    });
+    server.tool("routelink_ror_query", "List toll-free numbers (TFNs) or Call Processing Records (CPRs) associated with a Responsible Organization (ROR). Use this to explore which toll-free numbers a specific organization manages.", {
+        ror: z
+            .string()
+            .regex(/^[A-Za-z0-9]{1,5}$/)
+            .describe("1-5 character alphanumeric ROR code (e.g. ATX01, CTJLE)"),
+        resource_type: z
+            .enum(["tfns", "cprs"])
+            .describe("Whether to list TFNs or CPRs for this ROR"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(10000)
+            .default(100)
+            .describe("Max results to return (default 100, max 10000)"),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .default(0)
+            .describe("Pagination offset (default 0)"),
+    }, async ({ ror, resource_type, limit, offset }) => {
+        const result = await client.get(`/v1/telique/ror/${ror}/${resource_type}`, { format: "json", limit, offset });
+        return formatResponse(result);
+    });
+    server.tool("routelink_cpr", "Retrieve the full Call Processing Record (CPR) for a toll-free number. A CPR is a routing decision tree that determines how calls are routed based on LATA, NPA, NXX, ANI, DAY_OF_WEEK, TIME_OF_DAY, PERCENT, STATE, etc. Returns the CPR structure, SHA1 hash, ROR, and optionally expanded template references.", {
+        crn: z
+            .string()
+            .regex(/^\d{1,10}$/)
+            .describe("1-10 digit CRN (toll-free number or template CRN). Shorter values are zero-padded to 10 digits."),
+        expand: z
+            .boolean()
+            .default(true)
+            .describe("Recursively resolve and inline template decision trees (default true)"),
+    }, async ({ crn, expand }) => {
+        // NOTE: /v1/telique/cpr/* path pending frontend URL map addition.
+        // Falls back to /cpr/ which routes to routelink via default backend.
+        const result = await client.get(`/v1/telique/cpr/${crn}`, {
+            format: "json",
+            expand: expand ? "true" : "false",
+        });
+        return formatResponse(result);
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TeliqueClient } from "./client.js";
+export type ToolRegistrar = (server: McpServer, client: TeliqueClient) => void;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/formatting.d.ts

@@ -0,0 +1,15 @@
+export declare function setAnonymousMode(isAnonymous: boolean): void;
+export declare function formatResponse(data: unknown): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare function errorResult(message: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+};

package/dist/utils/formatting.js

@@ -0,0 +1,67 @@
+const MAX_ITEMS = 50;
+const ANONYMOUS_NOTICE = "\n\n---\n⚠ Anonymous mode (10 ops/min). Run `npx telique-mcp setup` or visit https://telique.ringer.tel for unlimited access.";
+let anonymous = false;
+let noticeShown = false;
+export function setAnonymousMode(isAnonymous) {
+    anonymous = isAnonymous;
+}
+function isErrorResponse(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "_error" in value &&
+        value._error === true);
+}
+export function formatResponse(data) {
+    if (isErrorResponse(data)) {
+        const parts = [`Error: ${data.message}`];
+        if (data.body && typeof data.body === "object") {
+            parts.push(JSON.stringify(data.body, null, 2));
+        }
+        else if (data.body) {
+            parts.push(String(data.body));
+        }
+        return {
+            content: [{ type: "text", text: parts.join("\n\n") }],
+            isError: true,
+        };
+    }
+    const truncated = truncateArrays(data);
+    let text = JSON.stringify(truncated, null, 2);
+    if (anonymous && !noticeShown) {
+        text += ANONYMOUS_NOTICE;
+        noticeShown = true;
+    }
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+function truncateArrays(data) {
+    if (Array.isArray(data)) {
+        if (data.length > MAX_ITEMS) {
+            return {
+                _meta: {
+                    total: data.length,
+                    returned: MAX_ITEMS,
+                    has_more: true,
+                    message: `Showing ${MAX_ITEMS} of ${data.length} items. Use limit/offset to paginate.`,
+                },
+                items: data.slice(0, MAX_ITEMS),
+            };
+        }
+        return data.map(truncateArrays);
+    }
+    if (typeof data === "object" && data !== null) {
+        const result = {};
+        for (const [key, value] of Object.entries(data)) {
+            result[key] = truncateArrays(value);
+        }
+        return result;
+    }
+    return data;
+}
+export function errorResult(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,6 @@
+export declare function isValidPhoneNumber(value: string): boolean;
+export declare function isValidCrn(value: string): boolean;
+export declare function isValidNpa(value: string): boolean;
+export declare function isValidNxx(value: string): boolean;
+export declare function isValidLata(value: string): boolean;
+export declare function isValidRor(value: string): boolean;

package/dist/utils/validation.js

@@ -0,0 +1,18 @@
+export function isValidPhoneNumber(value) {
+    return /^\d{10,15}$/.test(value);
+}
+export function isValidCrn(value) {
+    return /^\d{1,10}$/.test(value);
+}
+export function isValidNpa(value) {
+    return /^\d{3}$/.test(value);
+}
+export function isValidNxx(value) {
+    return /^\d{3}$/.test(value);
+}
+export function isValidLata(value) {
+    return /^\d{3}$/.test(value);
+}
+export function isValidRor(value) {
+    return /^[A-Za-z0-9]{1,5}$/.test(value);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "telique-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Telique telecom APIs (RouteLink, LRN, CNAM, LERG)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "telique-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "telique",
+    "telecom",
+    "lrn",
+    "cnam",
+    "lerg",
+    "routelink"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ringer/telique-mcp.git"
+  },
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}