@sodiumhq/mcp-pm 0.1.0-beta.2588

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2026 Sodium Software Ltd. All rights reserved.
+
+This software is proprietary to Sodium Software Ltd. Use of this software
+requires an active Sodium Practice Management subscription at the Pro tier
+or higher. Redistribution, modification, or commercial use of this package
+outside the terms of a valid Sodium subscription is prohibited without
+prior written consent from Sodium Software Ltd.
+
+This license applies only to the `@sodiumhq/mcp-pm` npm package. It does
+not grant access to the Sodium Practice Management service itself, which
+is governed by separate terms of service available at https://sodiumhq.com.
+
+For questions about licensing, contact hello@sodiumhq.com.

package/README.md

@@ -0,0 +1,68 @@
+# @sodiumhq/mcp-pm
+
+Model Context Protocol (MCP) server for [Sodium Practice Management](https://sodiumhq.com). Lets AI assistants like Claude Desktop, Claude Code, Cursor, and ChatGPT Desktop interact with your Sodium tenant.
+
+## Status
+
+**Beta.** Iterating toward a stable 1.0. Install explicitly with `@beta` to opt in.
+
+## Quick start
+
+### 1. Generate an API key
+
+In Sodium, go to **Settings → API Keys** and create a new key. Copy it along with your tenant code.
+
+### 2. Configure your MCP client
+
+**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "sodium-pm": {
+      "command": "npx",
+      "args": ["-y", "@sodiumhq/mcp-pm@beta"],
+      "env": {
+        "SODIUM_API_KEY": "your-api-key",
+        "SODIUM_TENANT": "your-tenant-code"
+      }
+    }
+  }
+}
+```
+
+Claude Code, Cursor, VS Code, and other MCP clients use the same config shape in their own config files.
+
+### 3. Restart your client
+
+Then ask: *"give me a summary of my practice"*.
+
+## Environment variables
+
+| Variable | Required | Default | Description |
+|---|---|---|---|
+| `SODIUM_API_KEY` | yes | — | Your Sodium API key |
+| `SODIUM_TENANT` | yes | — | Your tenant code |
+| `SODIUM_API_URL` | no | `https://api.sodiumhq.com` | Override for staging/dev |
+
+## What it can do today
+
+- **`get_practice_details`** — consolidated practice overview (counts, connections, settings)
+- **`list_clients`** — list and filter clients by search, status, type, assignee, services, saved filters
+- **`get_client_summary`** — one-call composite: client identity + contacts + active services + overdue + upcoming tasks
+
+More tools land iteratively as the beta progresses.
+
+## Requirements
+
+- Node.js 20 or later
+- An active Sodium Practice Management subscription at the Pro tier
+- API key and tenant code from your Sodium account
+
+## Licence
+
+Proprietary — see [LICENSE](./LICENSE).
+
+## Support
+
+[hello@sodiumhq.com](mailto:hello@sodiumhq.com) · [sodiumhq.com](https://sodiumhq.com)

package/dist/index.js

@@ -0,0 +1,1241 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region ../mcp-core/src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+//#endregion
+//#region ../mcp-core/src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region ../mcp-core/src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region ../mcp-core/src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region ../mcp-core/src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region ../mcp-core/src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+const setAuthParams = async ({ security, ...options }) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region ../mcp-core/src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts)
+		};
+		let request = new Request(url, requestInit);
+		for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+		const _fetch = opts.fetch;
+		let response;
+		try {
+			response = await _fetch(request);
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, void 0, request, opts);
+			finalError = finalError || {};
+			if (opts.throwOnError) throw finalError;
+			return opts.responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response: void 0
+			};
+		}
+		for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+		const result = {
+			request,
+			response
+		};
+		if (response.ok) {
+			const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+			if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+				let emptyData;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "text":
+						emptyData = await response[parseAs]();
+						break;
+					case "formData":
+						emptyData = new FormData();
+						break;
+					case "stream":
+						emptyData = response.body;
+						break;
+					default:
+						emptyData = {};
+						break;
+				}
+				return opts.responseStyle === "data" ? emptyData : {
+					data: emptyData,
+					...result
+				};
+			}
+			let data;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "json": {
+					const text = await response.text();
+					data = text ? JSON.parse(text) : {};
+					break;
+				}
+				case "stream": return opts.responseStyle === "data" ? response.body : {
+					data: response.body,
+					...result
+				};
+			}
+			if (parseAs === "json") {
+				if (opts.responseValidator) await opts.responseValidator(data);
+				if (opts.responseTransformer) data = await opts.responseTransformer(data);
+			}
+			return opts.responseStyle === "data" ? data : {
+				data,
+				...result
+			};
+		}
+		const textError = await response.text();
+		let jsonError;
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request, opts);
+		finalError = finalError || {};
+		if (opts.throwOnError) throw finalError;
+		return opts.responseStyle === "data" ? void 0 : {
+			error: finalError,
+			...result
+		};
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			headers: opts.headers,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region ../mcp-core/src/generated/client.gen.ts
+const client = createClient(createConfig());
+//#endregion
+//#region ../mcp-core/src/generated/sdk.gen.ts
+/**
+* List Contacts for Client
+*
+* Lists all Contacts for the specified client.
+*/
+const listClientContactsForClient = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/clients/{client}/clientcontact",
+	...options
+});
+/**
+* List Client Services for Client
+*
+* Lists all Client Services for the specified client.
+*/
+const listClientBillableServicesForClient = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/clients/{client}/services/clientbillableservice",
+	...options
+});
+/**
+* List Clients
+*
+* Lists Clients for the given tenant.
+*
+* Supports filtering by manager, partner, associate, status, type, service, and search term.
+* Optionally apply a saved filter by code — saved filter values are used unless explicitly overridden by query parameters.
+*/
+const listClients = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/clients",
+	...options
+});
+/**
+* Get Client
+*
+* Gets a Client for the specified tenant.
+*/
+const getClient = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/clients/{code}",
+	...options
+});
+/**
+* Get Practice Details
+*
+* Returns the practice details for the specified tenant
+*/
+const getPracticeDetails = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/practice",
+	...options
+});
+/**
+* List TaskItems
+*
+* Lists TaskItems for the given tenant.
+*
+* **Date Range Options:**
+* - Use dateRange for preset ranges (ThisWeek, ThisMonth, Today, etc.)
+* - Use startDate/endDate for custom ranges
+* - Date range is required when querying NotStarted tasks (or no status filter)
+* - Date range is NOT required when filtering by non-NotStarted statuses only (e.g., InProgress, Completed)
+* - Date range is NOT required when using isOverdue=true
+*
+* **Overdue Mode (isOverdue=true):**
+* - Returns only tasks where DueDate < today
+* - Automatically excludes Completed and Skipped statuses unless you specify a status filter
+* - No date range required
+*
+* **Standard Mode (includeWorkflowSteps=false, default):**
+* - Returns only tasks (materialised and optionally projected)
+* - Use dateBasis to specify which date field to use for filtering: StartDate (default) or DueDate
+*
+* **Agenda Mode (includeWorkflowSteps=true):**
+* - Returns both tasks AND workflow steps as TaskItemDto objects
+* - Tasks: Returned with all standard TaskItem properties, WorkflowStepDetails = null
+* - Workflow Steps: Returned with parent task properties populated, WorkflowStepDetails contains step-specific information
+*
+* Supports filtering by user(s), client(s), recurring task(s), category, date range, status, and isOverdue.
+*/
+const listTaskItems = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{tenant}/tasks",
+	...options
+});
+/**
+* Get Tenant
+*
+* Retrieves the details of a tenant using its Code identifier.
+*/
+const getTenantByCode = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/tenants/{code}",
+	...options
+});
+/**
+* Get current authenticated user
+*
+* Returns the profile information of the currently authenticated user
+*/
+const getCurrentUser = (options) => (options?.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/users/me",
+	...options
+});
+//#endregion
+//#region ../mcp-core/src/http/client.ts
+var SodiumApiError = class extends Error {
+	constructor(message, statusCode, correlationId) {
+		super(message);
+		this.statusCode = statusCode;
+		this.correlationId = correlationId;
+		this.name = "SodiumApiError";
+	}
+};
+var SodiumApiClient = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+		client.setConfig({
+			baseUrl: ctx.baseUrl,
+			headers: { "x-api-key": ctx.apiKey }
+		});
+	}
+	async getPracticeDetails() {
+		const correlationId = randomUUID();
+		const { data, error, response } = await getPracticeDetails({
+			path: { tenant: this.ctx.tenant },
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, "get practice details");
+		return data;
+	}
+	async getTenantDetails() {
+		const correlationId = randomUUID();
+		const { data, error, response } = await getTenantByCode({
+			path: { code: this.ctx.tenant },
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, "get tenant details");
+		return data;
+	}
+	async getCurrentUser() {
+		const correlationId = randomUUID();
+		const { data, error, response } = await getCurrentUser({ headers: { "X-Correlation-Id": correlationId } });
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, "get current user");
+		return data;
+	}
+	async listClients(query = {}) {
+		const correlationId = randomUUID();
+		const { data, error, response } = await listClients({
+			path: { tenant: this.ctx.tenant },
+			query: {
+				...query,
+				limit: query.limit ?? 10,
+				offset: query.offset ?? 0
+			},
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, "list clients");
+		return data;
+	}
+	async getClient(code) {
+		const correlationId = randomUUID();
+		const { data, error, response } = await getClient({
+			path: {
+				tenant: this.ctx.tenant,
+				code
+			},
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, `get client ${code}`);
+		return data;
+	}
+	async listClientContacts(clientCode, options) {
+		const correlationId = randomUUID();
+		const { data, error, response } = await listClientContactsForClient({
+			path: {
+				tenant: this.ctx.tenant,
+				client: clientCode
+			},
+			query: {
+				limit: options?.limit ?? 50,
+				offset: options?.offset ?? 0
+			},
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, `list contacts for client ${clientCode}`);
+		return data;
+	}
+	async listClientServices(clientCode, options) {
+		const correlationId = randomUUID();
+		const { data, error, response } = await listClientBillableServicesForClient({
+			path: {
+				tenant: this.ctx.tenant,
+				client: clientCode
+			},
+			query: {
+				limit: options?.limit ?? 50,
+				offset: options?.offset ?? 0
+			},
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, `list services for client ${clientCode}`);
+		return data;
+	}
+	async listTasks(query = {}) {
+		const correlationId = randomUUID();
+		const { data, error, response } = await listTaskItems({
+			path: { tenant: this.ctx.tenant },
+			query: {
+				...query,
+				limit: query.limit ?? 10,
+				offset: query.offset ?? 0
+			},
+			headers: { "X-Correlation-Id": correlationId }
+		});
+		if (error !== void 0 || !data) throw this.toError(response, error, correlationId, "list tasks");
+		return data;
+	}
+	toError(response, error, correlationId, operation) {
+		const status = response.status;
+		let message = `Failed to ${operation} (HTTP ${status})`;
+		if (error && typeof error === "object" && "message" in error) message = String(error.message);
+		else if (typeof error === "string") message = error;
+		return new SodiumApiError(message, status, correlationId);
+	}
+};
+//#endregion
+//#region ../mcp-core/src/context/instructions.ts
+async function buildInstructions(api) {
+	const [user, tenant, practice] = await Promise.allSettled([
+		api.getCurrentUser(),
+		api.getTenantDetails(),
+		api.getPracticeDetails()
+	]);
+	const now = /* @__PURE__ */ new Date();
+	const lines = [
+		"You are assisting a user of Sodium Practice Management.",
+		"",
+		`Today: ${now.toISOString().slice(0, 10)} (${now.toLocaleDateString("en-GB", { weekday: "long" })})`,
+		`Current UTC time: ${now.toISOString()}`
+	];
+	if (user.status === "fulfilled") {
+		const name = user.value.fullName ?? user.value.email ?? user.value.code ?? "unknown";
+		lines.push(`Current user: ${name}${user.value.code ? ` (${user.value.code})` : ""}`);
+	}
+	if (tenant.status === "fulfilled") lines.push(`Tenant: ${tenant.value.name} (${tenant.value.code})`);
+	if (practice.status === "fulfilled") lines.push(`Practice: ${practice.value.name}`);
+	lines.push("", "When interpreting relative dates (today, this week, next month), use the date above.", "All codes (client, task, engagement) are string identifiers, not numeric IDs.");
+	return lines.join("\n");
+}
+//#endregion
+//#region ../mcp-core/src/tools/get-practice-details.ts
+function format$1(tenant, practice) {
+	const lines = [];
+	lines.push(`Practice: ${practice.name}`);
+	lines.push(`Tenant: ${tenant.name} (${tenant.code})`);
+	if (practice.address) lines.push(`Address: ${practice.address}`);
+	if (practice.email) lines.push(`Email: ${practice.email}`);
+	if (practice.telephone) lines.push(`Telephone: ${practice.telephone}`);
+	if (practice.mobile) lines.push(`Mobile: ${practice.mobile}`);
+	if (practice.website) lines.push(`Website: ${practice.website}`);
+	if (practice.professionalBody) lines.push(`Professional Body: ${practice.professionalBody}`);
+	if (practice.companyNumber) lines.push(`Company Number: ${practice.companyNumber}`);
+	lines.push(`VAT Registered: ${practice.isVatRegistered ? "Yes" : "No"}`);
+	lines.push("", "--- Counts ---");
+	if (tenant.activeClientCount !== void 0) lines.push(`Active Clients: ${tenant.activeClientCount}`);
+	if (tenant.prospectClientCount !== void 0) lines.push(`Prospect Clients: ${tenant.prospectClientCount}`);
+	if (tenant.inactiveClientCount !== void 0) lines.push(`Inactive Clients: ${tenant.inactiveClientCount}`);
+	if (tenant.lostProspectClientCount !== void 0) lines.push(`Lost Prospects: ${tenant.lostProspectClientCount}`);
+	if (tenant.servicesCount !== void 0) lines.push(`Services: ${tenant.servicesCount}`);
+	if (tenant.workFlowsCount !== void 0) lines.push(`Workflows: ${tenant.workFlowsCount}`);
+	if (tenant.usersCount !== void 0) lines.push(`Users: ${tenant.usersCount}`);
+	if (tenant.proposalsSentThisMonth !== void 0) lines.push(`Proposals Sent This Month: ${tenant.proposalsSentThisMonth}`);
+	const connections = [];
+	if (tenant.accountingConnection) connections.push(`Accounting: ${tenant.accountingConnection.name}`);
+	if (tenant.directDebitConnection) connections.push(`Direct Debit: ${tenant.directDebitConnection.name}`);
+	if (tenant.amlConnection) connections.push(`AML: ${tenant.amlConnection.name}`);
+	if (tenant.documentStorageConnection) connections.push(`Document Storage: ${tenant.documentStorageConnection.name}`);
+	if (connections.length > 0) lines.push("", "--- Connections ---", ...connections);
+	return lines.join("\n");
+}
+async function handleGetPracticeDetails(api) {
+	try {
+		const [tenant, practice] = await Promise.all([api.getTenantDetails(), api.getPracticeDetails()]);
+		return { content: [{
+			type: "text",
+			text: format$1(tenant, practice)
+		}] };
+	} catch (error) {
+		return {
+			content: [{
+				type: "text",
+				text: error instanceof SodiumApiError ? `Error getting practice details: ${error.message} (correlation: ${error.correlationId})` : `Error getting practice details: ${error instanceof Error ? error.message : String(error)}`
+			}],
+			isError: true
+		};
+	}
+}
+//#endregion
+//#region ../mcp-core/src/tools/list-clients.ts
+const statusEnum = z.enum([
+	"Active",
+	"Inactive",
+	"Prospect",
+	"LostProspect"
+]);
+const typeEnum = z.enum([
+	"PrivateLimitedCompany",
+	"PublicLimitedCompany",
+	"LimitedLiabilityPartnership",
+	"Partnership",
+	"Individual",
+	"Trust",
+	"Charity",
+	"SoleTrader"
+]);
+const sortByEnum = z.enum(["Name", "InternalReference"]);
+const ListClientsInputSchema = {
+	search: z.string().min(3, "Search must be at least 3 characters when provided").optional().describe("Free-text search across client code, name, and internal reference. Minimum 3 characters. Omit to browse by filter only."),
+	status: z.array(statusEnum).optional().describe("Filter by client status. Defaults to all statuses if omitted. Example: ['Active'] for active clients only."),
+	type: z.array(typeEnum).optional().describe("Filter by organisation type. Use ['PrivateLimitedCompany', 'PublicLimitedCompany'] for 'limited companies'. Use ['LimitedLiabilityPartnership'] for LLPs. Defaults to all types if omitted."),
+	managerCode: z.array(z.string()).optional().describe("Filter by assigned manager user codes."),
+	partnerCode: z.array(z.string()).optional().describe("Filter by assigned partner user codes."),
+	associateCode: z.array(z.string()).optional().describe("Filter by assigned associate user codes."),
+	serviceCode: z.array(z.string()).optional().describe("Filter by billable service codes that clients have assigned."),
+	savedFilter: z.string().optional().describe("Code of a user-saved filter to apply. Other filter parameters override fields from the saved filter."),
+	sortBy: sortByEnum.optional().describe("Field to sort by. Defaults to Name."),
+	sortDesc: z.boolean().optional().describe("Sort in descending order. Defaults to ascending."),
+	limit: z.number().int().min(1).max(50).optional().describe("Maximum number of clients to return per page. Default 10, max 50."),
+	offset: z.number().int().min(0).optional().describe("Number of records to skip for pagination. Default 0.")
+};
+function formatClient(c) {
+	const code = c.code ?? "(no code)";
+	const name = c.name ?? "(no name)";
+	const meta = [c.status, c.type].filter(Boolean).join(", ");
+	return meta ? `- ${name} (${code}) — ${meta}` : `- ${name} (${code})`;
+}
+async function handleListClients(api, args) {
+	try {
+		const query = args;
+		const result = await api.listClients(query);
+		const items = result.data ?? [];
+		if (items.length === 0) {
+			const desc = describeFilters(args);
+			return { content: [{
+				type: "text",
+				text: desc ? `No clients match ${desc}.` : "No clients found."
+			}] };
+		}
+		const total = result.totalCount ?? items.length;
+		const desc = describeFilters(args);
+		const lines = [
+			desc ? total > items.length ? `Found ${total} clients matching ${desc} (showing ${items.length}):` : `Found ${items.length} client${items.length === 1 ? "" : "s"} matching ${desc}:` : total > items.length ? `Showing ${items.length} of ${total} clients:` : `${items.length} client${items.length === 1 ? "" : "s"}:`,
+			"",
+			...items.map(formatClient)
+		];
+		if (result.hasMore) {
+			const nextOffset = (args.offset ?? 0) + items.length;
+			lines.push("", `More results available — call again with offset: ${nextOffset} to see the next page.`);
+		}
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	} catch (error) {
+		return {
+			content: [{
+				type: "text",
+				text: error instanceof SodiumApiError ? `Error listing clients: ${error.message} (correlation: ${error.correlationId})` : `Error listing clients: ${error instanceof Error ? error.message : String(error)}`
+			}],
+			isError: true
+		};
+	}
+}
+function describeFilters(args) {
+	const parts = [];
+	if (args.search) parts.push(`search "${args.search}"`);
+	if (args.status?.length) parts.push(`status ${args.status.join("/")}`);
+	if (args.type?.length) parts.push(`type ${args.type.join("/")}`);
+	if (args.managerCode?.length) parts.push(`manager ${args.managerCode.join(",")}`);
+	if (args.partnerCode?.length) parts.push(`partner ${args.partnerCode.join(",")}`);
+	if (args.associateCode?.length) parts.push(`associate ${args.associateCode.join(",")}`);
+	if (args.serviceCode?.length) parts.push(`service ${args.serviceCode.join(",")}`);
+	if (args.savedFilter) parts.push(`saved filter "${args.savedFilter}"`);
+	return parts.join(", ");
+}
+//#endregion
+//#region ../mcp-core/src/tools/get-client-summary.ts
+const GetClientSummaryInputSchema = { code: z.string().min(1, "Client code is required").describe("The client code (identifier). Usually discovered via list_clients first.") };
+async function handleGetClientSummary(api, { code }) {
+	const [clientResult, contactsResult, servicesResult, overdueResult, upcomingResult] = await Promise.allSettled([
+		api.getClient(code),
+		api.listClientContacts(code),
+		api.listClientServices(code),
+		api.listTasks({
+			client: [code],
+			isOverdue: true,
+			limit: 50
+		}),
+		api.listTasks({
+			client: [code],
+			dateRange: "Next7Days",
+			dateBasis: "DueDate",
+			limit: 50
+		})
+	]);
+	if (clientResult.status === "rejected") {
+		const err = clientResult.reason;
+		return {
+			content: [{
+				type: "text",
+				text: err instanceof SodiumApiError ? `Error getting client: ${err.message} (correlation: ${err.correlationId})` : `Error getting client: ${err instanceof Error ? err.message : String(err)}`
+			}],
+			isError: true
+		};
+	}
+	return { content: [{
+		type: "text",
+		text: format({
+			client: clientResult.value,
+			contacts: extract(contactsResult),
+			services: extract(servicesResult),
+			overdueTasks: extract(overdueResult),
+			upcomingTasks: extract(upcomingResult),
+			gaps: [
+				contactsResult.status === "rejected" ? "contacts" : null,
+				servicesResult.status === "rejected" ? "services" : null,
+				overdueResult.status === "rejected" ? "overdue tasks" : null,
+				upcomingResult.status === "rejected" ? "upcoming tasks" : null
+			].filter((v) => v !== null)
+		})
+	}] };
+}
+function extract(result) {
+	if (result.status !== "fulfilled") return [];
+	return result.value.data ?? [];
+}
+function format(input) {
+	const { client, contacts, services, overdueTasks, upcomingTasks, gaps } = input;
+	const lines = [];
+	const name = client.name ?? "(no name)";
+	const code = client.code ?? "(no code)";
+	lines.push(`Client: ${name} (${code})`);
+	const statusType = [client.status, client.type].filter(Boolean).join(" · ");
+	if (statusType) lines.push(`Status / Type: ${statusType}`);
+	if (client.email) lines.push(`Email: ${client.email}`);
+	if (client.telephone) lines.push(`Telephone: ${client.telephone}`);
+	if (client.internalReference) lines.push(`Internal Reference: ${client.internalReference}`);
+	if (client.manager) lines.push(`Manager: ${client.manager.name} (${client.manager.code})`);
+	if (client.partner) lines.push(`Partner: ${client.partner.name} (${client.partner.code})`);
+	if (client.associate) lines.push(`Associate: ${client.associate.name} (${client.associate.code})`);
+	lines.push("", `--- Contacts (${contacts.length}) ---`);
+	if (contacts.length === 0) lines.push("No contacts.");
+	else for (const c of contacts) {
+		const contact = c.contact;
+		if (!contact) continue;
+		const fullName = [contact.firstName, contact.lastName].filter(Boolean).join(" ") || "(no name)";
+		const types = c.types?.length ? c.types.join(", ") : c.role ?? "";
+		const email = contact.email ? ` <${contact.email}>` : "";
+		const suffix = types ? ` — ${types}` : "";
+		lines.push(`- ${fullName}${suffix}${email}`);
+	}
+	const activeServices = services.filter((s) => s.status !== "Inactive" && !s.endDate);
+	lines.push("", `--- Active Services (${activeServices.length} of ${services.length} total) ---`);
+	if (activeServices.length === 0) lines.push("No active services.");
+	else for (const s of activeServices) {
+		const svcName = s.billableService?.name ?? "(unnamed)";
+		const freq = s.billingFrequency ? ` ${s.billingFrequency}` : "";
+		const price = s.effectivePrice !== void 0 ? ` — £${s.effectivePrice.toFixed(2)}${freq}` : freq ? ` —${freq}` : "";
+		lines.push(`- ${svcName}${price}`);
+	}
+	lines.push("", "--- Tasks ---");
+	lines.push(`Overdue: ${overdueTasks.length}`);
+	if (overdueTasks.length > 0) {
+		for (const t of overdueTasks.slice(0, 5)) lines.push(`  - ${formatTask(t)}`);
+		if (overdueTasks.length > 5) lines.push(`  ... and ${overdueTasks.length - 5} more`);
+	}
+	lines.push(`Due in next 7 days: ${upcomingTasks.length}`);
+	if (upcomingTasks.length > 0) {
+		for (const t of upcomingTasks.slice(0, 5)) lines.push(`  - ${formatTask(t)}`);
+		if (upcomingTasks.length > 5) lines.push(`  ... and ${upcomingTasks.length - 5} more`);
+	}
+	if (gaps.length > 0) lines.push("", `Note: could not load ${gaps.join(", ")} (partial failure). Retry for a complete picture.`);
+	return lines.join("\n");
+}
+function formatTask(t) {
+	const taskCode = t.code ?? "(no code)";
+	return `${t.name ?? "(unnamed)"} (${taskCode})${t.dueDate ? ` — due ${t.dueDate}` : ""}${t.assignedUser?.name ? ` — ${t.assignedUser.name}` : ""}`;
+}
+//#endregion
+//#region ../mcp-core/src/server.ts
+async function buildServer(config) {
+	const api = new SodiumApiClient(config.context);
+	const instructions = await buildInstructions(api);
+	const server = new McpServer({
+		name: config.serverName,
+		version: config.serverVersion
+	}, {
+		instructions,
+		capabilities: { tools: {} }
+	});
+	server.registerTool("get_practice_details", {
+		title: "Get practice details",
+		description: "Get a consolidated overview of the practice including name, contact details, client/service/user counts, connections, and settings. Use this when the user asks about their practice, tenant, or wants a summary of their account.",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, () => handleGetPracticeDetails(api));
+	server.registerTool("list_clients", {
+		title: "List / search / filter clients",
+		description: "List clients with any combination of: search (code/name/internal reference, 3+ chars), status (Active/Inactive/Prospect/LostProspect), type (PrivateLimitedCompany/PublicLimitedCompany/LimitedLiabilityPartnership/Partnership/Individual/Trust/Charity/SoleTrader), manager/partner/associate user codes, service codes, a saved filter code, sort, and pagination. Use search for 'find ACME'-style queries. Use type for 'list limited companies' (pass PrivateLimitedCompany + PublicLimitedCompany). Use status: ['Active'] to exclude prospects/inactive. Returns up to 50 clients per page — paginate via offset for more. Follow up with get_client_summary for full detail on a specific client.",
+		inputSchema: ListClientsInputSchema,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, (args) => handleListClients(api, args));
+	server.registerTool("get_client_summary", {
+		title: "Get a full summary of one client",
+		description: "Get a consolidated overview of a single client by code: identity (name, status, type, assignments), all contacts, active services with pricing, overdue task count + top 5, and tasks due in the next 7 days. Use this AFTER list_clients identifies the client of interest, or when the user references a specific client by code. Tolerates partial failures — if one section can't be loaded, the rest is still returned with a note about what's missing.",
+		inputSchema: GetClientSummaryInputSchema,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, (args) => handleGetClientSummary(api, args));
+	return server;
+}
+//#endregion
+//#region src/config.ts
+function loadContext() {
+	const apiKey = process.env.SODIUM_API_KEY;
+	const tenant = process.env.SODIUM_TENANT;
+	const baseUrl = process.env.SODIUM_API_URL ?? "https://api.sodiumhq.com";
+	if (!apiKey) throw new Error("SODIUM_API_KEY environment variable is required. Generate one in Sodium → Settings → API Keys.");
+	if (!tenant) throw new Error("SODIUM_TENANT environment variable is required. Find your tenant code in Sodium → Settings → Practice.");
+	return {
+		apiKey,
+		tenant,
+		baseUrl
+	};
+}
+//#endregion
+//#region src/index.ts
+const VERSION = "0.0.1";
+async function main() {
+	const context = loadContext();
+	const server = await buildServer({
+		context,
+		serverName: "Sodium Practice Management",
+		serverVersion: VERSION
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	console.error(`[sodium-pm-mcp] v${VERSION} ready (tenant: ${context.tenant})`);
+}
+main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`[sodium-pm-mcp] fatal: ${message}`);
+	process.exit(1);
+});
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@sodiumhq/mcp-pm",
+  "version": "0.1.0-beta.2588",
+  "description": "Sodium Practice Management MCP server — lets AI assistants interact with your Sodium tenant",
+  "type": "module",
+  "bin": {
+    "mcp-pm": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "sodium",
+    "sodiumhq",
+    "practice-management",
+    "accounting",
+    "ai",
+    "claude"
+  ],
+  "homepage": "https://sodiumhq.com",
+  "repository": {
+    "type": "git",
+    "url": "https://dev.azure.com/sodium-software/sodium/_git/sodium-pm-mcp"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm typecheck && pnpm build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "@sodiumhq/mcp-core": "workspace:*",
+    "@types/node": "^22.15.33",
+    "tsdown": "^0.21.9",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3"
+  }
+}