@immicore/immi-tools 1.0.1 → 1.0.3

package/dist/index.js

@@ -5,10 +5,10 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import express from 'express';
 import { createToolConfig } from './common/tool-schema.js';
-import { CLBConvertMcpTool, NocWagesMcpTool } from './tools/index.js';
+import { CLBConvertMcpTool, UnemploymentRateMcpTool } from './tools/index.js';
 const allTools = [
     CLBConvertMcpTool,
-    NocWagesMcpTool,
+    UnemploymentRateMcpTool,
 ];
 const SERVER_NAME = 'immicore-tools';
 const SERVER_VERSION = '1.0.0';

package/dist/tools/index.d.ts

@@ -1,2 +1,2 @@
 export { CLBConvertMcpTool } from './clb_convert.tool.js';
-export { NocWagesMcpTool } from './noc_wages.tool.js';
+export { UnemploymentRateMcpTool } from './unemployment_rate.tool.js';

package/dist/tools/index.js

@@ -1,2 +1,2 @@
 export { CLBConvertMcpTool } from './clb_convert.tool.js';
-export { NocWagesMcpTool } from './noc_wages.tool.js';
+export { UnemploymentRateMcpTool } from './unemployment_rate.tool.js';

package/dist/tools/noc_outlook.handler.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { NocOutlookOutputSchema, OutlookInfoSchema } from './noc_outlook.tool.js';
+export declare function nocOutlookHandler(nocCode: string): Promise<z.infer<typeof NocOutlookOutputSchema>>;
+export declare function nocOutlookByProvinceHandler(nocCode: string, province: string): Promise<z.infer<typeof OutlookInfoSchema> | null>;

package/dist/tools/noc_outlook.handler.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+// Cache for outlook data
+let outlookDataCache = null;
+function getOutlookDataPath() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'data', 'noc_outlooks_2021.json'),
+        path.join(process.cwd(), 'noc_outlooks_2021.json'),
+        path.join(process.env.HOME || '', 'Desktop', 'noc_outlooks_2021.json'),
+    ];
+    for (const dataPath of possiblePaths) {
+        if (fs.existsSync(dataPath)) {
+            return dataPath;
+        }
+    }
+    return path.join(process.cwd(), 'data', 'noc_outlooks_2021.json');
+}
+function loadOutlookData() {
+    if (outlookDataCache) {
+        return outlookDataCache;
+    }
+    const dataPath = getOutlookDataPath();
+    if (!fs.existsSync(dataPath)) {
+        throw new Error(`Outlook data file not found at ${dataPath}`);
+    }
+    try {
+        const rawData = fs.readFileSync(dataPath, 'utf8');
+        outlookDataCache = JSON.parse(rawData);
+        return outlookDataCache || [];
+    }
+    catch (error) {
+        console.error('Error loading outlook data:', error);
+        throw new Error('Failed to load outlook data file');
+    }
+}
+export async function nocOutlookHandler(nocCode) {
+    try {
+        const data = loadOutlookData();
+        const nocEntry = data.find(entry => entry.noc === nocCode);
+        if (!nocEntry) {
+            return [];
+        }
+        return nocEntry.data.map(item => ({
+            noc_code: nocCode,
+            province: item.province,
+            outlook: item.outlook,
+        }));
+    }
+    catch (error) {
+        console.error('Error retrieving outlook data:', error);
+        throw error;
+    }
+}
+export async function nocOutlookByProvinceHandler(nocCode, province) {
+    try {
+        const data = loadOutlookData();
+        const nocEntry = data.find(entry => entry.noc === nocCode);
+        if (!nocEntry) {
+            return null;
+        }
+        // Case-insensitive partial match for province name
+        const provinceMatch = nocEntry.data.find(item => item.province.toLowerCase().includes(province.toLowerCase()) ||
+            province.toLowerCase().includes(item.province.toLowerCase()));
+        if (!provinceMatch) {
+            return null;
+        }
+        return {
+            noc_code: nocCode,
+            province: provinceMatch.province,
+            outlook: provinceMatch.outlook,
+        };
+    }
+    catch (error) {
+        console.error('Error retrieving outlook by province:', error);
+        throw error;
+    }
+}

package/dist/tools/noc_outlook.tool.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { Tool } from '../common/tool-schema.js';
+export declare const NocOutlookInputSchema: z.ZodObject<{
+    noc_code: z.ZodString;
+    province: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    province?: string | undefined;
+}, {
+    noc_code: string;
+    province?: string | undefined;
+}>;
+export declare const OutlookInfoSchema: z.ZodObject<{
+    noc_code: z.ZodString;
+    province: z.ZodString;
+    outlook: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    province: string;
+    outlook: string;
+}, {
+    noc_code: string;
+    province: string;
+    outlook: string;
+}>;
+export declare const NocOutlookOutputSchema: z.ZodArray<z.ZodObject<{
+    noc_code: z.ZodString;
+    province: z.ZodString;
+    outlook: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    province: string;
+    outlook: string;
+}, {
+    noc_code: string;
+    province: string;
+    outlook: string;
+}>, "many">;
+export declare const NOC_OUTLOOK_DESCRIPTION = "Query job outlook (employment prospects) for National Occupational Classification (NOC) codes.\n\nReturns employment prospect ratings from the Government of Canada Job Bank data for each province and territory.\n\nOutlook Ratings:\n- **Good**: Strong employment prospects (3 stars)\n- **Moderate**: Fair employment prospects (2 stars)\n- **Limited**: Weak employment prospects (1 star)\n- **Undetermined**: Outlook cannot be determined\n\nParameters:\n- noc_code (required): NOC 2021 code (5 digits)\n- province (optional): Province/territory name. If omitted, returns data for all 13 provinces/territories.\n\nExample usage - all provinces:\n{\n  \"noc_code\": \"21232\"\n}\n\nExample usage - specific province:\n{\n  \"noc_code\": \"21232\",\n  \"province\": \"Ontario\"\n}\n\nUse this tool when:\n- Assessing job market prospects for an occupation\n- Advising clients on employment opportunities by region\n- Comparing career prospects across different provinces\n- Supporting immigration planning with labour market information";
+export declare const NocOutlookMcpTool: Tool;

package/dist/tools/noc_outlook.tool.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { nocOutlookHandler, nocOutlookByProvinceHandler } from './noc_outlook.handler.js';
+export const NocOutlookInputSchema = z.object({
+    noc_code: z.string().describe('NOC 2021 code (5 digits). Example: "21232" for Software Developers'),
+    province: z.string().optional().describe('Province or territory name (optional). If not provided, returns outlooks for all provinces. Example: "Ontario"'),
+}).describe('Input for querying NOC job outlook information.');
+export const OutlookInfoSchema = z.object({
+    noc_code: z.string().describe('NOC code'),
+    province: z.string().describe('Province or territory name'),
+    outlook: z.string().describe('Job outlook rating (e.g., "Good", "Moderate", "Limited", "Undetermined")'),
+}).describe('Job outlook information for a NOC code in a specific province.');
+export const NocOutlookOutputSchema = z.array(OutlookInfoSchema).describe('List of job outlook information for the NOC code across provinces.');
+export const NOC_OUTLOOK_DESCRIPTION = `Query job outlook (employment prospects) for National Occupational Classification (NOC) codes.
+
+Returns employment prospect ratings from the Government of Canada Job Bank data for each province and territory.
+
+Outlook Ratings:
+- **Good**: Strong employment prospects (3 stars)
+- **Moderate**: Fair employment prospects (2 stars)
+- **Limited**: Weak employment prospects (1 star)
+- **Undetermined**: Outlook cannot be determined
+
+Parameters:
+- noc_code (required): NOC 2021 code (5 digits)
+- province (optional): Province/territory name. If omitted, returns data for all 13 provinces/territories.
+
+Example usage - all provinces:
+{
+  "noc_code": "21232"
+}
+
+Example usage - specific province:
+{
+  "noc_code": "21232",
+  "province": "Ontario"
+}
+
+Use this tool when:
+- Assessing job market prospects for an occupation
+- Advising clients on employment opportunities by region
+- Comparing career prospects across different provinces
+- Supporting immigration planning with labour market information`;
+export const NocOutlookMcpTool = {
+    name: 'noc_outlook',
+    description: NOC_OUTLOOK_DESCRIPTION,
+    inputShape: NocOutlookInputSchema,
+    outputSchema: NocOutlookOutputSchema,
+    annotations: {
+        title: 'NOC Job Outlook Lookup',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    call: async (input) => {
+        try {
+            let results;
+            if (input.province) {
+                const result = await nocOutlookByProvinceHandler(input.noc_code, input.province);
+                results = result ? [result] : [];
+            }
+            else {
+                results = await nocOutlookHandler(input.noc_code);
+            }
+            if (!results || results.length === 0) {
+                const msg = input.province
+                    ? `No outlook data found for NOC ${input.noc_code} in ${input.province}`
+                    : `No outlook data found for NOC ${input.noc_code}`;
+                return {
+                    content: [{ type: 'text', text: msg }],
+                    structuredContent: { results: [], total: 0 },
+                };
+            }
+            // Group results by outlook rating for better readability
+            const grouped = results.reduce((acc, item) => {
+                const rating = item.outlook;
+                if (!acc[rating])
+                    acc[rating] = [];
+                acc[rating].push(item.province);
+                return acc;
+            }, {});
+            const textLines = [];
+            const outlookOrder = ['Good', 'Moderate', 'Limited', 'Undetermined'];
+            for (const outlook of outlookOrder) {
+                if (grouped[outlook]) {
+                    textLines.push(`\n${outlook}:`);
+                    for (const province of grouped[outlook].sort()) {
+                        textLines.push(`  • ${province}`);
+                    }
+                }
+            }
+            const header = `NOC ${input.noc_code} Job Outlook (${results.length} province${results.length > 1 ? 's' : ''})\n${'='.repeat(50)}\n`;
+            return {
+                content: [{ type: 'text', text: header + textLines.join('\n') }],
+                structuredContent: { results, total: results.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to retrieve outlook data.';
+            console.error('Error in noc_outlook tool call:', error);
+            return {
+                content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    },
+};

package/dist/tools/unemployment_rate.handler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Unemployment rate data for a single period
+ */
+export interface PeriodRate {
+    period: string;
+    startDate: Date;
+    endDate: Date;
+    rate: number;
+}
+/**
+ * CMA (Census Metropolitan Area) unemployment data
+ */
+export interface CMAData {
+    cma: string;
+    city: string;
+    province: string;
+    rates: PeriodRate[];
+}
+/**
+ * Result returned by the unemployment rate handler
+ */
+export interface UnemploymentRateResult {
+    cma: string;
+    province: string;
+    unemployment_rate: number;
+    period: string;
+    data_source: string;
+}
+/**
+ * Main handler function for the unemployment rate tool
+ */
+export declare function unemploymentRateHandler(location: string): Promise<UnemploymentRateResult>;
+/**
+ * Clear the cache (useful for testing)
+ */
+export declare function clearCache(): void;

package/dist/tools/unemployment_rate.handler.js

@@ -0,0 +1,266 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+const DATA_SOURCE_URL = 'https://www.canada.ca/en/employment-social-development/services/foreign-workers/refusal.html';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+let cache = null;
+/**
+ * Parse date string like "July 11, 2025" into Date object
+ */
+function parseDate(dateStr) {
+    const cleaned = dateStr.trim().replace(/,/g, '');
+    const date = new Date(cleaned);
+    if (isNaN(date.getTime())) {
+        throw new Error(`Failed to parse date: ${dateStr}`);
+    }
+    return date;
+}
+/**
+ * Parse period string like "July 11, 2025, to October 9, 2025" into start/end dates
+ */
+function parsePeriod(periodStr) {
+    // Extract dates from header like "Unemployment rate (%) for applications submitted from July 11, 2025, to October 9, 2025"
+    const match = periodStr.match(/from\s+(.+?),?\s+to\s+(.+?)$/i);
+    if (match) {
+        return {
+            startDate: parseDate(match[1]),
+            endDate: parseDate(match[2]),
+            period: `${match[1].trim()} to ${match[2].trim()}`,
+        };
+    }
+    // Fallback: try to find any two dates
+    const datePattern = /([A-Z][a-z]+ \d{1,2},? \d{4})/g;
+    const dates = periodStr.match(datePattern);
+    if (dates && dates.length >= 2) {
+        return {
+            startDate: parseDate(dates[0]),
+            endDate: parseDate(dates[1]),
+            period: `${dates[0]} to ${dates[1]}`,
+        };
+    }
+    throw new Error(`Could not parse period from: ${periodStr}`);
+}
+/**
+ * Extract city and province from CMA name
+ * Examples:
+ *   "Toronto, Ontario" -> { city: "Toronto", province: "Ontario" }
+ *   "Ottawa-Gatineau, Ontario/Quebec" -> { city: "Ottawa-Gatineau", province: "Ontario/Quebec" }
+ *   "St. John's, Newfoundland and Labrador" -> { city: "St. John's", province: "Newfoundland and Labrador" }
+ */
+function parseCMAName(cma) {
+    const parts = cma.split(',').map(p => p.trim());
+    if (parts.length >= 2) {
+        return {
+            city: parts[0],
+            province: parts.slice(1).join(', '),
+        };
+    }
+    // If no comma, treat the whole thing as city with unknown province
+    return { city: cma, province: '' };
+}
+/**
+ * Fetch and parse unemployment data from canada.ca
+ */
+async function fetchUnemploymentData() {
+    const response = await axios.get(DATA_SOURCE_URL, {
+        timeout: 30000,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (compatible; ImmiCore/1.0; +https://immicore.ca)',
+        },
+    });
+    const $ = cheerio.load(response.data);
+    // Find the unemployment rates table
+    const table = $('table').filter((_, el) => {
+        const caption = $(el).find('caption').text();
+        return caption.toLowerCase().includes('unemployment rates by cma');
+    });
+    if (table.length === 0) {
+        // Try finding by table header
+        const altTable = $('table').filter((_, el) => {
+            const firstTh = $(el).find('th').first().text();
+            return firstTh.toLowerCase().includes('census metropolitan area');
+        });
+        if (altTable.length === 0) {
+            throw new Error('Could not find unemployment rates table on the page');
+        }
+        return parseTable($, altTable.first());
+    }
+    return parseTable($, table.first());
+}
+/**
+ * Parse the unemployment rates table
+ */
+function parseTable($, table) {
+    const results = [];
+    // Parse headers to get period information
+    const headers = [];
+    table.find('thead th').each((index, th) => {
+        if (index === 0)
+            return; // Skip first column (CMA name)
+        const headerText = $(th).text().trim();
+        try {
+            headers.push(parsePeriod(headerText));
+        }
+        catch {
+            console.warn(`Could not parse header: ${headerText}`);
+        }
+    });
+    if (headers.length === 0) {
+        throw new Error('Could not parse any period headers from the table');
+    }
+    // Parse each row
+    table.find('tbody tr').each((_, tr) => {
+        const cells = $(tr).find('td');
+        if (cells.length === 0)
+            return;
+        // Get CMA name (might be in an <a> tag or direct text)
+        const firstCell = cells.first();
+        const cmaName = firstCell.find('a').text().trim() || firstCell.text().trim();
+        if (!cmaName)
+            return;
+        const { city, province } = parseCMAName(cmaName);
+        const rates = [];
+        // Parse rate values for each period
+        cells.slice(1).each((i, td) => {
+            if (i >= headers.length)
+                return;
+            // Rate might be wrapped in <strong> for high values
+            const rateText = $(td).text().trim();
+            const rate = parseFloat(rateText);
+            if (!isNaN(rate)) {
+                rates.push({
+                    period: headers[i].period,
+                    startDate: headers[i].startDate,
+                    endDate: headers[i].endDate,
+                    rate,
+                });
+            }
+        });
+        if (rates.length > 0) {
+            results.push({
+                cma: cmaName,
+                city,
+                province,
+                rates,
+            });
+        }
+    });
+    return results;
+}
+/**
+ * Get cached data or fetch fresh if cache expired
+ */
+async function getCMAData() {
+    const now = Date.now();
+    // Check if cache is valid
+    if (cache && (now - cache.fetchedAt) < CACHE_TTL_MS) {
+        return cache.data;
+    }
+    try {
+        const data = await fetchUnemploymentData();
+        cache = { data, fetchedAt: now };
+        return data;
+    }
+    catch (error) {
+        // If fetch fails but we have stale cache, use it
+        if (cache) {
+            console.warn('Failed to refresh unemployment data, using stale cache:', error);
+            return cache.data;
+        }
+        throw error;
+    }
+}
+/**
+ * Determine which period is currently applicable based on today's date
+ */
+function getCurrentPeriodRate(rates) {
+    const now = new Date();
+    // Find the period that contains today's date
+    for (const rate of rates) {
+        if (now >= rate.startDate && now <= rate.endDate) {
+            return rate;
+        }
+    }
+    // If no period contains today, return the latest one
+    // (This handles the case where data hasn't been updated yet)
+    return rates.length > 0 ? rates[rates.length - 1] : null;
+}
+/**
+ * Normalize string by removing accents/diacritics
+ * e.g., "Montréal" → "montreal", "Québec" → "quebec", "Trois-Rivières" → "trois-rivieres"
+ */
+function normalizeString(str) {
+    return str
+        .toLowerCase()
+        .trim()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, ''); // Remove combining diacritical marks
+}
+/**
+ * Find CMA matching the given location string
+ * Supports fuzzy matching and accent-insensitive search
+ */
+function findMatchingCMA(data, location) {
+    const searchLower = location.toLowerCase().trim();
+    const searchNormalized = normalizeString(location);
+    // 1. Exact match on full CMA name (case-insensitive)
+    const exactMatch = data.find(d => d.cma.toLowerCase() === searchLower);
+    if (exactMatch)
+        return exactMatch;
+    // 2. Exact match on city name (case-insensitive)
+    const cityMatch = data.find(d => d.city.toLowerCase() === searchLower);
+    if (cityMatch)
+        return cityMatch;
+    // 3. Normalized match (accent-insensitive) on CMA name
+    const normalizedCmaMatch = data.find(d => normalizeString(d.cma) === searchNormalized);
+    if (normalizedCmaMatch)
+        return normalizedCmaMatch;
+    // 4. Normalized match (accent-insensitive) on city name
+    const normalizedCityMatch = data.find(d => normalizeString(d.city) === searchNormalized);
+    if (normalizedCityMatch)
+        return normalizedCityMatch;
+    // 5. City starts with search term (normalized)
+    const startsWithMatch = data.find(d => normalizeString(d.city).startsWith(searchNormalized) ||
+        normalizeString(d.cma).startsWith(searchNormalized));
+    if (startsWithMatch)
+        return startsWithMatch;
+    // 6. CMA contains search term (normalized)
+    const containsMatch = data.find(d => normalizeString(d.cma).includes(searchNormalized) ||
+        normalizeString(d.city).includes(searchNormalized));
+    if (containsMatch)
+        return containsMatch;
+    return null;
+}
+/**
+ * Get all available CMA names for error messages
+ */
+function getAllCMANames(data) {
+    return data.map(d => d.cma).sort();
+}
+/**
+ * Main handler function for the unemployment rate tool
+ */
+export async function unemploymentRateHandler(location) {
+    const data = await getCMAData();
+    const matched = findMatchingCMA(data, location);
+    if (!matched) {
+        const availableCMAs = getAllCMANames(data);
+        throw new Error(`No CMA found matching "${location}". Available CMAs:\n${availableCMAs.join('\n')}`);
+    }
+    const currentRate = getCurrentPeriodRate(matched.rates);
+    if (!currentRate) {
+        throw new Error(`No unemployment rate data available for ${matched.cma}`);
+    }
+    return {
+        cma: matched.cma,
+        province: matched.province,
+        unemployment_rate: currentRate.rate,
+        period: currentRate.period,
+        data_source: DATA_SOURCE_URL,
+    };
+}
+/**
+ * Clear the cache (useful for testing)
+ */
+export function clearCache() {
+    cache = null;
+}

package/dist/tools/unemployment_rate.tool.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { Tool } from '../common/tool-schema.js';
+export declare const UnemploymentRateInputSchema: z.ZodObject<{
+    location: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    location: string;
+}, {
+    location: string;
+}>;
+export declare const UnemploymentRateOutputSchema: z.ZodObject<{
+    cma: z.ZodString;
+    province: z.ZodString;
+    unemployment_rate: z.ZodNumber;
+    period: z.ZodString;
+    data_source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    cma: string;
+    province: string;
+    unemployment_rate: number;
+    period: string;
+    data_source: string;
+}, {
+    cma: string;
+    province: string;
+    unemployment_rate: number;
+    period: string;
+    data_source: string;
+}>;
+export declare const UNEMPLOYMENT_RATE_DESCRIPTION = "Query unemployment rates for Canadian Census Metropolitan Areas (CMAs).\n\nReturns the current unemployment rate from the Government of Canada Employment and Social Development website.\n\nParameters:\n- location (required): CMA or city name (e.g., \"Toronto\", \"Vancouver\", \"Montreal\")\n\nExample usage:\n{\n  \"location\": \"Toronto\"\n}\n\nReturns:\n- cma: Full CMA name (e.g., \"Toronto, Ontario\")\n- province: Province or territory\n- unemployment_rate: Current unemployment rate (%)\n- period: The applicable period for this rate\n- data_source: Official data source URL\n\nUse this tool when:\n- Checking unemployment rates for LMIA applications\n- Verifying if a CMA qualifies for low-wage LMIA processing (rate < 6%)\n- Understanding regional labour market conditions\n- Advising clients on LMIA application timing\n\nNote: CMAs with unemployment rate >= 6% may have low-wage LMIA applications refused to process.";
+export declare const UnemploymentRateMcpTool: Tool;

package/dist/tools/unemployment_rate.tool.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { unemploymentRateHandler } from './unemployment_rate.handler.js';
+export const UnemploymentRateInputSchema = z.object({
+    location: z.string().describe('CMA (Census Metropolitan Area) name or city name. Examples: "Toronto", "Vancouver", "Ottawa-Gatineau"'),
+}).describe('Input for querying CMA unemployment rate.');
+export const UnemploymentRateOutputSchema = z.object({
+    cma: z.string().describe('Full CMA name'),
+    province: z.string().describe('Province or territory'),
+    unemployment_rate: z.number().describe('Unemployment rate (%)'),
+    period: z.string().describe('Applicable period for this rate'),
+    data_source: z.string().describe('Data source URL'),
+}).describe('Unemployment rate information for a CMA.');
+export const UNEMPLOYMENT_RATE_DESCRIPTION = `Query unemployment rates for Canadian Census Metropolitan Areas (CMAs).
+
+Returns the current unemployment rate from the Government of Canada Employment and Social Development website.
+
+Parameters:
+- location (required): CMA or city name (e.g., "Toronto", "Vancouver", "Montreal")
+
+Example usage:
+{
+  "location": "Toronto"
+}
+
+Returns:
+- cma: Full CMA name (e.g., "Toronto, Ontario")
+- province: Province or territory
+- unemployment_rate: Current unemployment rate (%)
+- period: The applicable period for this rate
+- data_source: Official data source URL
+
+Use this tool when:
+- Checking unemployment rates for LMIA applications
+- Verifying if a CMA qualifies for low-wage LMIA processing (rate < 6%)
+- Understanding regional labour market conditions
+- Advising clients on LMIA application timing
+
+Note: CMAs with unemployment rate >= 6% may have low-wage LMIA applications refused to process.`;
+export const UnemploymentRateMcpTool = {
+    name: 'unemployment_rate',
+    description: UNEMPLOYMENT_RATE_DESCRIPTION,
+    inputShape: UnemploymentRateInputSchema,
+    outputSchema: UnemploymentRateOutputSchema,
+    annotations: {
+        title: 'CMA Unemployment Rate',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    call: async (input) => {
+        try {
+            const result = await unemploymentRateHandler(input.location);
+            const rateStatus = result.unemployment_rate >= 6
+                ? '(>= 6% - Low-wage LMIA may be refused)'
+                : '(< 6% - Eligible for low-wage LMIA)';
+            const text = [
+                `CMA: ${result.cma}`,
+                `Province: ${result.province}`,
+                `Unemployment Rate: ${result.unemployment_rate}% ${rateStatus}`,
+                `Period: ${result.period}`,
+                `Data Source: ${result.data_source}`,
+            ].join('\n');
+            return {
+                content: [{ type: 'text', text }],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to retrieve unemployment rate.';
+            console.error('Error in unemployment_rate tool call:', error);
+            return {
+                content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immicore/immi-tools",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "MCP server for immigration tools (CLB conversion, NOC wage lookup)",
   "type": "module",
   "main": "dist/index.js",
@@ -26,6 +26,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
     "axios": "^1.8.4",
+    "cheerio": "^1.0.0",
     "dotenv": "^17.2.3",
     "express": "^4.21.2",
     "zod": "^3.22.4"
@@ -33,6 +34,7 @@
   "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/node": "^22.15.2",
+    "domhandler": "^5.0.3",
     "tsx": "^4.16.2",
     "typescript": "^5.4.5"
   }