@immicore/immi-tools 1.0.0

package/dist/common/tool-schema.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+/**
+ * Tool annotations for MCP registerTool API
+ */
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+/**
+ * MCP Tool response content item - matches SDK types
+ */
+export type ToolContentItem = {
+    type: 'text';
+    text: string;
+};
+/**
+ * MCP Tool response structure - matches SDK CallToolResult
+ */
+export interface ToolResponse<T = unknown> {
+    content: ToolContentItem[];
+    structuredContent?: T;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Tool definition interface for MCP servers
+ */
+export interface Tool<TInput extends z.ZodTypeAny = z.ZodTypeAny, TOutput = unknown> {
+    name: string;
+    description: string;
+    inputShape: TInput;
+    outputSchema?: z.ZodTypeAny;
+    annotations?: ToolAnnotations;
+    call: (args: z.infer<TInput>) => Promise<ToolResponse<TOutput>>;
+}
+/**
+ * Configuration for registering tools with McpServer
+ */
+export interface ToolRegistrationConfig {
+    title: string;
+    description: string;
+    inputSchema: z.ZodTypeAny;
+    outputSchema?: z.ZodTypeAny;
+    annotations: ToolAnnotations;
+}
+/**
+ * Helper to create tool registration config from Tool interface
+ */
+export declare function createToolConfig(tool: Tool): ToolRegistrationConfig;
+/**
+ * Get required environment variable or throw
+ */
+export declare function requireEnv(name: string): string;
+/**
+ * Get optional environment variable with default
+ */
+export declare function getEnv(name: string, defaultValue: string): string;

package/dist/common/tool-schema.js

@@ -0,0 +1,33 @@
+/**
+ * Helper to create tool registration config from Tool interface
+ */
+export function createToolConfig(tool) {
+    return {
+        title: tool.annotations?.title || tool.name,
+        description: tool.description,
+        inputSchema: tool.inputShape,
+        outputSchema: tool.outputSchema,
+        annotations: {
+            readOnlyHint: tool.annotations?.readOnlyHint ?? true,
+            destructiveHint: tool.annotations?.destructiveHint ?? false,
+            idempotentHint: tool.annotations?.idempotentHint ?? true,
+            openWorldHint: tool.annotations?.openWorldHint ?? true,
+        },
+    };
+}
+/**
+ * Get required environment variable or throw
+ */
+export function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Required environment variable ${name} is not set`);
+    }
+    return value;
+}
+/**
+ * Get optional environment variable with default
+ */
+export function getEnv(name, defaultValue) {
+    return process.env[name] || defaultValue;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+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';
+const allTools = [
+    CLBConvertMcpTool,
+    NocWagesMcpTool,
+];
+const SERVER_NAME = 'immicore-tools';
+const SERVER_VERSION = '1.0.0';
+const DEFAULT_HTTP_PORT = 3009;
+function createServer() {
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    for (const tool of allTools) {
+        const config = createToolConfig(tool);
+        server.registerTool(tool.name, {
+            title: config.title,
+            description: config.description,
+            inputSchema: config.inputSchema,
+            annotations: config.annotations,
+        }, async (args) => {
+            const result = await tool.call(args);
+            return {
+                content: result.content,
+                structuredContent: result.structuredContent,
+                isError: result.isError,
+            };
+        });
+    }
+    return server;
+}
+async function runStdioMode() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`${SERVER_NAME} running in stdio mode`);
+}
+async function runHttpMode(port) {
+    const app = express();
+    app.use(express.json());
+    app.post('/mcp', async (req, res) => {
+        const server = createServer();
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+            enableJsonResponse: true
+        });
+        res.on('close', () => transport.close());
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    });
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', server: SERVER_NAME, version: SERVER_VERSION });
+    });
+    app.listen(port, () => {
+        console.log(`${SERVER_NAME} running in HTTP mode on http://localhost:${port}/mcp`);
+    });
+}
+async function runSseMode(port) {
+    const app = express();
+    app.use(express.json());
+    const sessions = new Map();
+    app.get('/sse', (req, res) => {
+        const server = createServer();
+        const transport = new SSEServerTransport('/messages', res);
+        const sessionId = transport.sessionId;
+        sessions.set(sessionId, { server, transport });
+        res.on('close', () => {
+            sessions.delete(sessionId);
+        });
+        server.connect(transport);
+    });
+    app.post('/messages', (req, res) => {
+        const sessionId = req.query.sessionId;
+        const session = sessions.get(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        session.transport.handlePostMessage(req, res, req.body);
+    });
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', server: SERVER_NAME, version: SERVER_VERSION, mode: 'sse' });
+    });
+    app.listen(port, () => {
+        console.log(`${SERVER_NAME} running in SSE mode on http://localhost:${port}/sse`);
+    });
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let mode = 'stdio';
+    let port = DEFAULT_HTTP_PORT;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--http') {
+            mode = 'http';
+        }
+        else if (args[i] === '--sse') {
+            mode = 'sse';
+        }
+        else if (args[i] === '--stdio') {
+            mode = 'stdio';
+        }
+        else if (args[i] === '--port' && args[i + 1]) {
+            port = parseInt(args[i + 1], 10);
+            i++;
+        }
+    }
+    return { mode, port };
+}
+async function main() {
+    const { mode, port } = parseArgs();
+    if (mode === 'http') {
+        await runHttpMode(port);
+    }
+    else if (mode === 'sse') {
+        await runSseMode(port);
+    }
+    else {
+        await runStdioMode();
+    }
+}
+main().catch(console.error);

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { CLBConvertInputSchema, CLBConvertOutputSchema } from './clb_convert.tool.js';
+export declare function clbConvertHandler(input: z.infer<typeof CLBConvertInputSchema>): Promise<z.infer<typeof CLBConvertOutputSchema>>;

package/dist/tools/clb_convert.handler.js

@@ -0,0 +1,32 @@
+import axios from 'axios';
+import { requireEnv } from '../common/tool-schema.js';
+function getClbConvertApiUrl() {
+    const HOST_URL = requireEnv('HOST_URL');
+    return `${HOST_URL}/tools/clb/convert`;
+}
+function getSystemToken() {
+    return requireEnv('SEARCH_SERVICE_TOKEN');
+}
+export async function clbConvertHandler(input) {
+    try {
+        const response = await axios.post(getClbConvertApiUrl(), input, {
+            timeout: 10000,
+            headers: { Authorization: `Bearer ${getSystemToken()}` },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            console.error('Error calling CLB convert API:', error.message);
+            if (error.response) {
+                console.error('Response data:', error.response.data);
+                console.error('Response status:', error.response.status);
+            }
+            throw new Error(`Failed to convert to CLB: ${error.response?.data?.detail || error.message}`);
+        }
+        else {
+            console.error('Unexpected error:', error);
+            throw new Error('An unexpected error occurred while converting to CLB.');
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { Tool } from '../common/tool-schema.js';
+export declare const CLBConvertInputSchema: z.ZodObject<{
+    test_type: z.ZodEnum<["ielts", "celpip", "tef", "tcf"]>;
+    listening: z.ZodNumber;
+    reading: z.ZodNumber;
+    writing: z.ZodNumber;
+    speaking: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    test_type: "ielts" | "celpip" | "tef" | "tcf";
+    listening: number;
+    reading: number;
+    writing: number;
+    speaking: number;
+}, {
+    test_type: "ielts" | "celpip" | "tef" | "tcf";
+    listening: number;
+    reading: number;
+    writing: number;
+    speaking: number;
+}>;
+export declare const CLBConvertOutputSchema: z.ZodObject<{
+    test_type: z.ZodString;
+    listening: z.ZodNumber;
+    reading: z.ZodNumber;
+    writing: z.ZodNumber;
+    speaking: z.ZodNumber;
+    overall: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    test_type: string;
+    listening: number;
+    reading: number;
+    writing: number;
+    speaking: number;
+    overall: number;
+}, {
+    test_type: string;
+    listening: number;
+    reading: number;
+    writing: number;
+    speaking: number;
+    overall: number;
+}>;
+export declare const CLB_CONVERT_DESCRIPTION = "Convert language test scores to Canadian Language Benchmark (CLB) levels.\n\nSupported test types:\n- IELTS General Training (band scores 0-9)\n- CELPIP General (scores 1-12)  \n- TEF Canada (scores 0-600 for all skills)\n- TCF Canada (scores 0-600 for reading/listening, 0-16 for writing/speaking)\n\nReturns CLB levels (0-12) for each skill:\n- listening, reading, writing, speaking\n- overall: minimum of all four skills\n\nExample usage:\n{\n  \"test_type\": \"ielts\",\n  \"listening\": 7.5,\n  \"reading\": 7.0,\n  \"writing\": 6.5,\n  \"speaking\": 7.0\n}\n\nReturns:\n{\n  \"test_type\": \"ielts\",\n  \"listening\": 9,\n  \"reading\": 8,\n  \"writing\": 7,\n  \"speaking\": 8,\n  \"overall\": 7\n}\n\nUse this tool when:\n- Converting client's language test scores to CLB for immigration eligibility\n- Checking Express Entry CRS score requirements\n- Verifying IRCC language requirements for various programs";
+export declare const CLBConvertMcpTool: Tool;

package/dist/tools/clb_convert.tool.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { clbConvertHandler } from './clb_convert.handler.js';
+export const CLBConvertInputSchema = z.object({
+    test_type: z.enum(['ielts', 'celpip', 'tef', 'tcf']).describe('Language test type. Supported: ielts, celpip, tef (TEF Canada), tcf (TCF Canada)'),
+    listening: z.number().describe('Listening score. IELTS: 0-9 (band), CELPIP: 1-12, TEF/TCF: 0-600'),
+    reading: z.number().describe('Reading score. IELTS: 0-9 (band), CELPIP: 1-12, TEF/TCF: 0-600'),
+    writing: z.number().describe('Writing score. IELTS: 0-9 (band), CELPIP: 1-12, TEF: 0-600, TCF: 0-16'),
+    speaking: z.number().describe('Speaking score. IELTS: 0-9 (band), CELPIP: 1-12, TEF: 0-600, TCF: 0-16'),
+}).describe('Input for converting language test scores to CLB levels.');
+export const CLBConvertOutputSchema = z.object({
+    test_type: z.string().describe('The input test type'),
+    listening: z.number().describe('CLB level for listening (0-12)'),
+    reading: z.number().describe('CLB level for reading (0-12)'),
+    writing: z.number().describe('CLB level for writing (0-12)'),
+    speaking: z.number().describe('CLB level for speaking (0-12)'),
+    overall: z.number().describe('Overall CLB level (minimum of all skills)'),
+}).describe('CLB conversion result with levels for each skill.');
+export const CLB_CONVERT_DESCRIPTION = `Convert language test scores to Canadian Language Benchmark (CLB) levels.
+
+Supported test types:
+- IELTS General Training (band scores 0-9)
+- CELPIP General (scores 1-12)  
+- TEF Canada (scores 0-600 for all skills)
+- TCF Canada (scores 0-600 for reading/listening, 0-16 for writing/speaking)
+
+Returns CLB levels (0-12) for each skill:
+- listening, reading, writing, speaking
+- overall: minimum of all four skills
+
+Example usage:
+{
+  "test_type": "ielts",
+  "listening": 7.5,
+  "reading": 7.0,
+  "writing": 6.5,
+  "speaking": 7.0
+}
+
+Returns:
+{
+  "test_type": "ielts",
+  "listening": 9,
+  "reading": 8,
+  "writing": 7,
+  "speaking": 8,
+  "overall": 7
+}
+
+Use this tool when:
+- Converting client's language test scores to CLB for immigration eligibility
+- Checking Express Entry CRS score requirements
+- Verifying IRCC language requirements for various programs`;
+export const CLBConvertMcpTool = {
+    name: 'clb_convert',
+    description: CLB_CONVERT_DESCRIPTION,
+    inputShape: CLBConvertInputSchema,
+    outputSchema: CLBConvertOutputSchema,
+    annotations: {
+        title: 'CLB Score Converter',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    call: async (input) => {
+        try {
+            const result = await clbConvertHandler(input);
+            const text = [
+                `Test Type: ${result.test_type.toUpperCase()}`,
+                ``,
+                `CLB Levels:`,
+                `  Listening: CLB ${result.listening}`,
+                `  Reading:   CLB ${result.reading}`,
+                `  Writing:   CLB ${result.writing}`,
+                `  Speaking:  CLB ${result.speaking}`,
+                ``,
+                `Overall CLB: ${result.overall}`,
+            ].join('\n');
+            return {
+                content: [{ type: 'text', text }],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to convert scores to CLB.';
+            console.error('Error in clb_convert tool call:', error);
+            return {
+                content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    },
+};

package/dist/tools/index.d.ts

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

package/dist/tools/index.js

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

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { WageInfoSchema, NocWagesOutputSchema } from './noc_wages.tool.js';
+export declare function nocWagesHandler(nocCode: string): Promise<z.infer<typeof NocWagesOutputSchema>>;
+export declare function nocWagesByRegionHandler(nocCode: string, region: string): Promise<z.infer<typeof WageInfoSchema> | null>;

package/dist/tools/noc_wages.handler.js

@@ -0,0 +1,62 @@
+import axios from 'axios';
+import { requireEnv } from '../common/tool-schema.js';
+function getWagesApiUrl(nocCode) {
+    const HOST_URL = requireEnv('HOST_URL');
+    return `${HOST_URL}/tools/noc/${nocCode}/wages`;
+}
+function getWagesByRegionApiUrl(nocCode, region) {
+    const HOST_URL = requireEnv('HOST_URL');
+    return `${HOST_URL}/tools/noc/${nocCode}/wages/${encodeURIComponent(region)}`;
+}
+function getSystemToken() {
+    return requireEnv('SEARCH_SERVICE_TOKEN');
+}
+export async function nocWagesHandler(nocCode) {
+    try {
+        const response = await axios.get(getWagesApiUrl(nocCode), {
+            timeout: 10000,
+            headers: { Authorization: `Bearer ${getSystemToken()}` },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            console.error('Error calling NOC wages API:', error.message);
+            if (error.response) {
+                console.error('Response data:', error.response.data);
+                console.error('Response status:', error.response.status);
+            }
+            throw new Error(`Failed to get wage data: ${error.response?.data?.detail || error.message}`);
+        }
+        else {
+            console.error('Unexpected error:', error);
+            throw new Error('An unexpected error occurred while retrieving wage data.');
+        }
+    }
+}
+export async function nocWagesByRegionHandler(nocCode, region) {
+    try {
+        const response = await axios.get(getWagesByRegionApiUrl(nocCode, region), {
+            timeout: 10000,
+            headers: { Authorization: `Bearer ${getSystemToken()}` },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.response?.status === 404) {
+                return null;
+            }
+            console.error('Error calling NOC wages by region API:', error.message);
+            if (error.response) {
+                console.error('Response data:', error.response.data);
+                console.error('Response status:', error.response.status);
+            }
+            throw new Error(`Failed to get wage data: ${error.response?.data?.detail || error.message}`);
+        }
+        else {
+            console.error('Unexpected error:', error);
+            throw new Error('An unexpected error occurred while retrieving wage data.');
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { Tool } from '../common/tool-schema.js';
+export declare const NocWagesInputSchema: z.ZodObject<{
+    noc_code: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    region?: string | undefined;
+}, {
+    noc_code: string;
+    region?: string | undefined;
+}>;
+export declare const WageInfoSchema: z.ZodObject<{
+    noc_code: z.ZodString;
+    region: z.ZodString;
+    low_wage: z.ZodNumber;
+    median_wage: z.ZodNumber;
+    high_wage: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    region: string;
+    low_wage: number;
+    median_wage: number;
+    high_wage: number;
+}, {
+    noc_code: string;
+    region: string;
+    low_wage: number;
+    median_wage: number;
+    high_wage: number;
+}>;
+export declare const NocWagesOutputSchema: z.ZodArray<z.ZodObject<{
+    noc_code: z.ZodString;
+    region: z.ZodString;
+    low_wage: z.ZodNumber;
+    median_wage: z.ZodNumber;
+    high_wage: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    noc_code: string;
+    region: string;
+    low_wage: number;
+    median_wage: number;
+    high_wage: number;
+}, {
+    noc_code: string;
+    region: string;
+    low_wage: number;
+    median_wage: number;
+    high_wage: number;
+}>, "many">;
+export declare const NOC_WAGES_DESCRIPTION = "Query wage information for National Occupational Classification (NOC) codes.\n\nReturns hourly wages (low, median, high) from the Government of Canada Job Bank data.\n\nParameters:\n- noc_code (required): NOC 2021 code (5 digits)\n- region (optional): Economic region name. If omitted, returns data for all available regions.\n\nExample usage - all regions:\n{\n  \"noc_code\": \"21232\"\n}\n\nExample usage - specific region:\n{\n  \"noc_code\": \"21232\",\n  \"region\": \"Toronto\"\n}\n\nReturns wage data in CAD per hour:\n- low_wage: 10th percentile\n- median_wage: 50th percentile  \n- high_wage: 90th percentile\n\nUse this tool when:\n- Checking LMIA wage requirements\n- Verifying prevailing wages for work permits\n- Comparing regional wage differences\n- Advising clients on salary expectations";
+export declare const NocWagesMcpTool: Tool;

package/dist/tools/noc_wages.tool.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { nocWagesHandler, nocWagesByRegionHandler } from './noc_wages.handler.js';
+export const NocWagesInputSchema = z.object({
+    noc_code: z.string().describe('NOC 2021 code (5 digits). Example: "21232" for Software Developers'),
+    region: z.string().optional().describe('Economic region name (optional). If not provided, returns wages for all regions. Example: "Toronto"'),
+}).describe('Input for querying NOC wage information.');
+export const WageInfoSchema = z.object({
+    noc_code: z.string().describe('NOC code'),
+    region: z.string().describe('Economic region name'),
+    low_wage: z.number().describe('Low wage (hourly, CAD)'),
+    median_wage: z.number().describe('Median wage (hourly, CAD)'),
+    high_wage: z.number().describe('High wage (hourly, CAD)'),
+}).describe('Wage information for a NOC code in a specific region.');
+export const NocWagesOutputSchema = z.array(WageInfoSchema).describe('List of wage information for the NOC code across regions.');
+export const NOC_WAGES_DESCRIPTION = `Query wage information for National Occupational Classification (NOC) codes.
+
+Returns hourly wages (low, median, high) from the Government of Canada Job Bank data.
+
+Parameters:
+- noc_code (required): NOC 2021 code (5 digits)
+- region (optional): Economic region name. If omitted, returns data for all available regions.
+
+Example usage - all regions:
+{
+  "noc_code": "21232"
+}
+
+Example usage - specific region:
+{
+  "noc_code": "21232",
+  "region": "Toronto"
+}
+
+Returns wage data in CAD per hour:
+- low_wage: 10th percentile
+- median_wage: 50th percentile  
+- high_wage: 90th percentile
+
+Use this tool when:
+- Checking LMIA wage requirements
+- Verifying prevailing wages for work permits
+- Comparing regional wage differences
+- Advising clients on salary expectations`;
+export const NocWagesMcpTool = {
+    name: 'noc_wages',
+    description: NOC_WAGES_DESCRIPTION,
+    inputShape: NocWagesInputSchema,
+    outputSchema: NocWagesOutputSchema,
+    annotations: {
+        title: 'NOC Wage Lookup',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    call: async (input) => {
+        try {
+            let results;
+            if (input.region) {
+                const result = await nocWagesByRegionHandler(input.noc_code, input.region);
+                results = result ? [result] : [];
+            }
+            else {
+                results = await nocWagesHandler(input.noc_code);
+            }
+            if (!results || results.length === 0) {
+                const msg = input.region
+                    ? `No wage data found for NOC ${input.noc_code} in ${input.region}`
+                    : `No wage data found for NOC ${input.noc_code}`;
+                return {
+                    content: [{ type: 'text', text: msg }],
+                    structuredContent: { results: [], total: 0 },
+                };
+            }
+            const text = results.map(w => [
+                `Region: ${w.region}`,
+                `  Low:    $${w.low_wage.toFixed(2)}/hr`,
+                `  Median: $${w.median_wage.toFixed(2)}/hr`,
+                `  High:   $${w.high_wage.toFixed(2)}/hr`,
+            ].join('\n')).join('\n\n');
+            const header = `NOC ${input.noc_code} Wage Data (${results.length} region${results.length > 1 ? 's' : ''})\n${'='.repeat(40)}\n\n`;
+            return {
+                content: [{ type: 'text', text: header + text }],
+                structuredContent: { results, total: results.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to retrieve wage data.';
+            console.error('Error in noc_wages tool call:', error);
+            return {
+                content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    },
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@immicore/immi-tools",
+  "version": "1.0.0",
+  "description": "MCP server for immigration tools (CLB conversion, NOC wage lookup)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "immicore-immi-tools": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts --stdio",
+    "dev:http": "tsx src/index.ts --http --port 3009",
+    "dev:sse": "tsx src/index.ts --sse --port 3009",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js --stdio",
+    "start:http": "node dist/index.js --http --port 3009",
+    "start:sse": "node dist/index.js --sse --port 3009"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "axios": "^1.8.4",
+    "dotenv": "^17.2.3",
+    "express": "^4.21.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.15.2",
+    "tsx": "^4.16.2",
+    "typescript": "^5.4.5"
+  }
+}