@alfe.ai/ctrader-mcp 0.2.1 → 0.3.1

package/dist/server.js

@@ -140,13 +140,30 @@ const PayloadType = {
 	OA_EXECUTION_EVENT: 2126,
 	OA_SUBSCRIBE_SPOTS_REQ: 2127,
 	OA_SUBSCRIBE_SPOTS_RES: 2128,
+	OA_UNSUBSCRIBE_SPOTS_REQ: 2129,
+	OA_UNSUBSCRIBE_SPOTS_RES: 2130,
 	OA_SPOT_EVENT: 2131,
 	OA_ORDER_ERROR_EVENT: 2132,
+	OA_DEAL_LIST_REQ: 2133,
+	OA_DEAL_LIST_RES: 2134,
 	OA_GET_TRENDBARS_REQ: 2137,
 	OA_GET_TRENDBARS_RES: 2138,
+	OA_EXPECTED_MARGIN_REQ: 2139,
+	OA_EXPECTED_MARGIN_RES: 2140,
 	OA_ERROR_RES: 2142,
+	OA_CASH_FLOW_HISTORY_LIST_REQ: 2143,
+	OA_CASH_FLOW_HISTORY_LIST_RES: 2144,
+	OA_GET_TICKDATA_REQ: 2145,
+	OA_GET_TICKDATA_RES: 2146,
 	OA_GET_ACCOUNT_LIST_BY_ACCESS_TOKEN_REQ: 2149,
-	OA_GET_ACCOUNT_LIST_BY_ACCESS_TOKEN_RES: 2150
+	OA_GET_ACCOUNT_LIST_BY_ACCESS_TOKEN_RES: 2150,
+	OA_DEPTH_EVENT: 2155,
+	OA_SUBSCRIBE_DEPTH_QUOTES_REQ: 2156,
+	OA_SUBSCRIBE_DEPTH_QUOTES_RES: 2157,
+	OA_UNSUBSCRIBE_DEPTH_QUOTES_REQ: 2158,
+	OA_UNSUBSCRIBE_DEPTH_QUOTES_RES: 2159,
+	OA_GET_POSITION_UNREALIZED_PNL_REQ: 2187,
+	OA_GET_POSITION_UNREALIZED_PNL_RES: 2188
 };
 /**
 * Map each request payloadType to the fully-qualified proto message name used
@@ -164,6 +181,14 @@ const REQUEST_MESSAGE = {
 	[PayloadType.OA_SYMBOL_BY_ID_REQ]: "ctrader.ProtoOASymbolByIdReq",
 	[PayloadType.OA_GET_TRENDBARS_REQ]: "ctrader.ProtoOAGetTrendbarsReq",
 	[PayloadType.OA_SUBSCRIBE_SPOTS_REQ]: "ctrader.ProtoOASubscribeSpotsReq",
+	[PayloadType.OA_UNSUBSCRIBE_SPOTS_REQ]: "ctrader.ProtoOAUnsubscribeSpotsReq",
+	[PayloadType.OA_SUBSCRIBE_DEPTH_QUOTES_REQ]: "ctrader.ProtoOASubscribeDepthQuotesReq",
+	[PayloadType.OA_UNSUBSCRIBE_DEPTH_QUOTES_REQ]: "ctrader.ProtoOAUnsubscribeDepthQuotesReq",
+	[PayloadType.OA_DEAL_LIST_REQ]: "ctrader.ProtoOADealListReq",
+	[PayloadType.OA_GET_TICKDATA_REQ]: "ctrader.ProtoOAGetTickDataReq",
+	[PayloadType.OA_EXPECTED_MARGIN_REQ]: "ctrader.ProtoOAExpectedMarginReq",
+	[PayloadType.OA_CASH_FLOW_HISTORY_LIST_REQ]: "ctrader.ProtoOACashFlowHistoryListReq",
+	[PayloadType.OA_GET_POSITION_UNREALIZED_PNL_REQ]: "ctrader.ProtoOAGetPositionUnrealizedPnLReq",
 	[PayloadType.OA_NEW_ORDER_REQ]: "ctrader.ProtoOANewOrderReq",
 	[PayloadType.OA_AMEND_ORDER_REQ]: "ctrader.ProtoOAAmendOrderReq",
 	[PayloadType.OA_AMEND_POSITION_SLTP_REQ]: "ctrader.ProtoOAAmendPositionSLTPReq",
@@ -183,7 +208,16 @@ const RESPONSE_MESSAGE = {
 	[PayloadType.OA_SYMBOL_BY_ID_RES]: "ctrader.ProtoOASymbolByIdRes",
 	[PayloadType.OA_GET_TRENDBARS_RES]: "ctrader.ProtoOAGetTrendbarsRes",
 	[PayloadType.OA_SUBSCRIBE_SPOTS_RES]: "ctrader.ProtoOASubscribeSpotsRes",
+	[PayloadType.OA_UNSUBSCRIBE_SPOTS_RES]: "ctrader.ProtoOAUnsubscribeSpotsRes",
 	[PayloadType.OA_SPOT_EVENT]: "ctrader.ProtoOASpotEvent",
+	[PayloadType.OA_SUBSCRIBE_DEPTH_QUOTES_RES]: "ctrader.ProtoOASubscribeDepthQuotesRes",
+	[PayloadType.OA_UNSUBSCRIBE_DEPTH_QUOTES_RES]: "ctrader.ProtoOAUnsubscribeDepthQuotesRes",
+	[PayloadType.OA_DEPTH_EVENT]: "ctrader.ProtoOADepthEvent",
+	[PayloadType.OA_DEAL_LIST_RES]: "ctrader.ProtoOADealListRes",
+	[PayloadType.OA_GET_TICKDATA_RES]: "ctrader.ProtoOAGetTickDataRes",
+	[PayloadType.OA_EXPECTED_MARGIN_RES]: "ctrader.ProtoOAExpectedMarginRes",
+	[PayloadType.OA_CASH_FLOW_HISTORY_LIST_RES]: "ctrader.ProtoOACashFlowHistoryListRes",
+	[PayloadType.OA_GET_POSITION_UNREALIZED_PNL_RES]: "ctrader.ProtoOAGetPositionUnrealizedPnLRes",
 	[PayloadType.OA_EXECUTION_EVENT]: "ctrader.ProtoOAExecutionEvent",
 	[PayloadType.OA_ORDER_ERROR_EVENT]: "ctrader.ProtoOAOrderErrorEvent",
 	[PayloadType.OA_ERROR_RES]: "ctrader.ProtoOAErrorRes"
@@ -352,6 +386,39 @@ function priceToDecimal(raw) {
 	return raw / PRICE_SCALE;
 }
 /**
+* Convert a depth-quote `size` to base-asset units. Depth sizes are in CENTS
+* of a unit on the wire (NOT the centi-unit volume space used by orders):
+* units = size / 100.
+*/
+function depthSizeToUnits(raw) {
+	return raw / 100;
+}
+/**
+* Reconstruct absolute {timestamp, price} ticks from cTrader's delta encoding.
+* Tick data arrives NEWEST-FIRST: the first entry's `timestamp`/`tick` are
+* absolute, every later entry carries the (usually negative) DELTA from the
+* entry before it. Prices come out ÷100000 like every other price.
+*/
+function decodeTickData(ticks) {
+	const out = [];
+	let ts = 0;
+	let price = 0;
+	for (const [i, t] of ticks.entries()) {
+		if (i === 0) {
+			ts = Number(t.timestamp ?? 0);
+			price = Number(t.tick ?? 0);
+		} else {
+			ts += Number(t.timestamp ?? 0);
+			price += Number(t.tick ?? 0);
+		}
+		out.push({
+			timestamp: new Date(ts).toISOString(),
+			price: priceToDecimal(price)
+		});
+	}
+	return out;
+}
+/**
 * Reconstruct a trendbar's OHLC from its delta encoding. cTrader stores the
 * bar `low` absolutely and open/high/close as unsigned deltas above the low.
 */
@@ -417,10 +484,28 @@ var CTraderError = class extends Error {
 		if (refs?.positionId != null) this.positionId = refs.positionId;
 	}
 };
+/**
+* The unsolicited payload types fanned out to `onEvent` listeners. Everything
+* else without a clientMsgId waiter is still silently dropped (heartbeats,
+* execution events for other sessions, …).
+*/
+const LISTENABLE_EVENTS = new Set([PayloadType.OA_DEPTH_EVENT, PayloadType.OA_SPOT_EVENT]);
 const HEARTBEAT_INTERVAL_MS = 1e4;
 const REQUEST_TIMEOUT_MS = 2e4;
 const RECONNECT_BASE_MS = 1e3;
 const RECONNECT_MAX_MS = 3e4;
+/**
+* Read-idle watchdog: cTrader echoes our 10s heartbeats and pushes its own
+* traffic, so a *healthy* socket is never silent for long. If NO inbound byte
+* arrives for this long we treat the socket as silently half-dead (a TCP
+* half-open with no FIN — the OS never fires `close`, so `handleDrop` never
+* runs and every request would otherwise time out at 20s indefinitely) and
+* force a reconnect. Set to 3× the heartbeat interval so a single dropped
+* heartbeat echo doesn't false-positive.
+*/
+const READ_IDLE_TIMEOUT_MS = 3 * HEARTBEAT_INTERVAL_MS;
+/** How often the watchdog checks the read-idle clock. */
+const WATCHDOG_INTERVAL_MS = HEARTBEAT_INTERVAL_MS;
 function log$1(msg) {
 	process.stderr.write(`[ctrader-mcp] ${msg}\n`);
 }
@@ -455,13 +540,20 @@ var HostSocket = class {
 	parser = new FrameParser();
 	pending = /* @__PURE__ */ new Map();
 	heartbeatTimer = null;
+	watchdogTimer = null;
+	/** Timestamp (ms) of the last inbound byte — drives the read-idle watchdog. */
+	lastInboundAt = 0;
 	reconnectAttempts = 0;
+	/** True from the moment a drop is handled until the reconnect succeeds. */
+	reconnectScheduled = false;
 	closing = false;
 	connectPromise = null;
 	/** ctidTraderAccountId → accessToken used to account-auth it on this socket. */
 	authedAccounts = /* @__PURE__ */ new Map();
 	/** Serializes account-auth so concurrent tool calls don't double-auth. */
 	accountAuthPromises = /* @__PURE__ */ new Map();
+	/** Listeners for unsolicited events (depth / spot ticks). */
+	eventListeners = /* @__PURE__ */ new Set();
 	constructor(host, clientId, clientSecret, connectFn = tlsConnect, root = loadRoot()) {
 		this.host = host;
 		this.clientId = clientId;
@@ -476,9 +568,11 @@ var HostSocket = class {
 	}
 	async doStart() {
 		this.conn = await this.connectFn(this.host, CTRADER_PORT);
+		this.lastInboundAt = Date.now();
 		this.wireConnection(this.conn);
 		await this.appAuth();
 		this.startHeartbeat();
+		this.startWatchdog();
 		log$1(`Connected + app-authenticated to ${this.host}`);
 	}
 	/**
@@ -503,8 +597,22 @@ var HostSocket = class {
 		}
 		await inFlight;
 	}
+	/**
+	* Register a listener for unsolicited events (depth / spot ticks) on this
+	* socket. Returns an unregister function — callers MUST unregister when
+	* their collection window ends or the listener leaks for the socket's
+	* lifetime. Listeners receive every listenable event on the socket;
+	* account/symbol filtering is the caller's job.
+	*/
+	onEvent(listener) {
+		this.eventListeners.add(listener);
+		return () => {
+			this.eventListeners.delete(listener);
+		};
+	}
 	wireConnection(conn) {
 		conn.on("data", (chunk) => {
+			this.lastInboundAt = Date.now();
 			for (const frame of this.parser.push(chunk)) this.dispatch(frame);
 		});
 		conn.on("error", (err) => {
@@ -539,9 +647,51 @@ var HostSocket = class {
 			this.heartbeatTimer = null;
 		}
 	}
+	/**
+	* Start the read-idle watchdog. On a *silent* socket (no inbound byte for
+	* `READ_IDLE_TIMEOUT_MS`) the OS may never fire `close` (a TCP half-open with
+	* no FIN), so `handleDrop` never runs and every request just times out at 20s
+	* forever. The watchdog detects that silence and forces a teardown +
+	* reconnect, converting a wedged socket into a fast recovery.
+	*/
+	startWatchdog() {
+		this.stopWatchdog();
+		this.watchdogTimer = setInterval(() => {
+			if (!this.conn || this.closing) return;
+			const idleFor = Date.now() - this.lastInboundAt;
+			if (idleFor >= READ_IDLE_TIMEOUT_MS) {
+				log$1(`No inbound data from ${this.host} for ${String(idleFor)}ms — forcing reconnect`);
+				this.forceReconnect();
+			}
+		}, WATCHDOG_INTERVAL_MS);
+		this.watchdogTimer.unref();
+	}
+	stopWatchdog() {
+		if (this.watchdogTimer) {
+			clearInterval(this.watchdogTimer);
+			this.watchdogTimer = null;
+		}
+	}
+	/**
+	* Tear down a silently-wedged socket and reconnect. Destroying the socket
+	* normally fires `close`, but we don't rely on it — we drive `handleDrop`
+	* directly (which fails in-flight waiters and schedules the reconnect) and
+	* suppress the redundant `close` callback via the same `closing`-free path.
+	*/
+	forceReconnect() {
+		const dead = this.conn;
+		this.conn = null;
+		try {
+			dead?.destroy();
+		} catch {}
+		this.handleDrop();
+	}
 	handleDrop() {
+		if (!this.conn && this.heartbeatTimer === null && this.reconnectScheduled) return;
 		log$1(`Socket dropped (${this.host}) — attempting reconnect`);
 		this.stopHeartbeat();
+		this.stopWatchdog();
+		this.reconnectScheduled = true;
 		this.conn = null;
 		this.parser = new FrameParser();
 		this.authedAccounts.clear();
@@ -560,10 +710,13 @@ var HostSocket = class {
 		if (this.closing) return;
 		try {
 			this.conn = await this.connectFn(this.host, CTRADER_PORT);
+			this.lastInboundAt = Date.now();
 			this.wireConnection(this.conn);
 			await this.appAuth();
 			this.startHeartbeat();
+			this.startWatchdog();
 			this.reconnectAttempts = 0;
+			this.reconnectScheduled = false;
 			log$1(`Reconnected + re-app-authenticated (${this.host})`);
 		} catch (err) {
 			log$1(`Reconnect failed (${this.host}): ${err instanceof Error ? err.message : String(err)}`);
@@ -579,6 +732,17 @@ var HostSocket = class {
 			return;
 		}
 		if (decoded.payloadType === PayloadType.HEARTBEAT_EVENT) return;
+		if (LISTENABLE_EVENTS.has(decoded.payloadType)) {
+			for (const listener of this.eventListeners) try {
+				listener({
+					payloadType: decoded.payloadType,
+					message: decoded.message
+				});
+			} catch (err) {
+				log$1(`Event listener threw (${this.host}): ${err instanceof Error ? err.message : String(err)}`);
+			}
+			return;
+		}
 		const id = decoded.clientMsgId;
 		if (!id) return;
 		const waiter = this.pending.get(id);
@@ -639,6 +803,7 @@ var HostSocket = class {
 	close() {
 		this.closing = true;
 		this.stopHeartbeat();
+		this.stopWatchdog();
 		for (const [id, req] of this.pending) {
 			clearTimeout(req.timer);
 			req.reject(new CTraderError("CLIENT_CLOSED", "Client is shutting down"));
@@ -647,6 +812,7 @@ var HostSocket = class {
 		this.conn?.destroy();
 		this.conn = null;
 		this.authedAccounts.clear();
+		this.eventListeners.clear();
 	}
 };
 /**
@@ -713,6 +879,20 @@ var CTraderPool = class {
 		await socket.authenticateAccount(config.accountId, config.accessToken);
 		return socket.request(payloadType, payload);
 	}
+	/**
+	* Register an unsolicited-event listener on the socket that serves
+	* `accountId`'s host. Returns the unregister function. The listener sees
+	* every listenable event on that socket — filter by
+	* `message.ctidTraderAccountId` / `message.symbolId` in the caller.
+	*
+	* Throws `CTraderError("UNKNOWN_ACCOUNT")` for an unregistered account
+	* (fail closed, same as request()).
+	*/
+	onAccountEvent(accountId, listener) {
+		const config = this.resolve(accountId);
+		if (!config) throw new CTraderError("UNKNOWN_ACCOUNT", `Account ${accountId} is not connected`);
+		return this.socketFor(config).onEvent(listener);
+	}
 	/** Close every host socket. */
 	close() {
 		for (const socket of this.sockets.values()) socket.close();
@@ -725,9 +905,19 @@ var CTraderPool = class {
 * MCP tool registration for the cTrader MCP server.
 *
 * Read tools:  get_accounts, get_account_details, get_positions, get_orders,
-*              get_symbols, get_market_data
+*              get_symbols, get_symbol_details, get_market_data, get_quote,
+*              get_depth, get_tick_data, get_trade_history, get_position_pnl,
+*              get_expected_margin, get_cash_flow_history
 * Write tools: place_order, modify_order, close_position, cancel_order
 *
+* ── Live-data tools (get_quote / get_depth) ──
+* MCP tools are request/response, so live subscriptions are snapshotted:
+* subscribe → collect events for a short window → ALWAYS unsubscribe
+* (finally) → return the assembled snapshot. Calls are serialized per
+* (account, symbol, kind): cTrader only sends the initial full book / first
+* tick on a FRESH subscribe, and double-subscribing errors — so overlapping
+* calls take turns instead of sharing a subscription.
+*
 * ── Account routing (money-safety) ──
 * Every tool that acts on an account takes an OPTIONAL `accountId`
 * (= ctidTraderAccountId):
@@ -748,12 +938,38 @@ var CTraderPool = class {
 const ORDER_TYPE = {
 	MARKET: 1,
 	LIMIT: 2,
-	STOP: 3
+	STOP: 3,
+	STOP_LIMIT: 6
 };
 const TRADE_SIDE = {
 	BUY: 1,
 	SELL: 2
 };
+const QUOTE_TYPE = {
+	BID: 1,
+	ASK: 2
+};
+/** ProtoOATimeInForce (OpenApiModelMessages.proto), transcribed verbatim. */
+const TIME_IN_FORCE = {
+	GOOD_TILL_DATE: 1,
+	GOOD_TILL_CANCEL: 2,
+	IMMEDIATE_OR_CANCEL: 3,
+	FILL_OR_KILL: 4
+};
+/** ProtoOADealStatus (OpenApiModelMessages.proto), transcribed verbatim. */
+const DEAL_STATUS_NAME = {
+	2: "FILLED",
+	3: "PARTIALLY_FILLED",
+	4: "REJECTED",
+	5: "INTERNALLY_REJECTED",
+	6: "ERROR",
+	7: "MISSED"
+};
+/** ProtoOAChangeBalanceType — only the two operations agents care about. */
+const CHANGE_BALANCE_TYPE_NAME = {
+	0: "DEPOSIT",
+	1: "WITHDRAW"
+};
 /**
 * ProtoOAExecutionType (OpenApiModelMessages.proto). The number the broker
 * returns on a ProtoOAExecutionEvent tells us the real outcome — a bare
@@ -886,6 +1102,85 @@ async function getSymbolDetail(pool, accountId, numericAccountId, symbolId) {
 	if (symbols.length === 0) throw new CTraderError("SYMBOL_NOT_FOUND", `No symbol with id ${String(symbolId)} on this account`);
 	return symbols[0];
 }
+/** Unref'd sleep so a pending collection window never keeps the process alive. */
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref();
+	});
+}
+/** Round a decoded price to the symbol's quoted digits. */
+function roundToDigits(price, digits) {
+	return Number(price.toFixed(Math.min(Math.max(digits, 0), 10)));
+}
+/** Parse an ISO 8601 input into epoch ms, failing closed on garbage. */
+function parseTimestamp(value, field) {
+	const ms = Date.parse(value);
+	if (Number.isNaN(ms)) throw new CTraderError("INVALID_TIMESTAMP", `${field} is not a valid ISO 8601 datetime: ${value}`);
+	return ms;
+}
+/**
+* Serializes live-data snapshots per (account, symbol, kind). cTrader only
+* sends the initial full depth book / current spot on a FRESH subscribe and
+* rejects a second subscribe on an already-subscribed symbol — so overlapping
+* tool calls must take turns rather than share one subscription.
+*/
+const liveDataLocks = /* @__PURE__ */ new Map();
+function withLiveDataLock(key, fn) {
+	const run = (liveDataLocks.get(key) ?? Promise.resolve()).then(fn, fn);
+	const tail = run.then(() => void 0, () => void 0);
+	liveDataLocks.set(key, tail);
+	tail.then(() => {
+		if (liveDataLocks.get(key) === tail) liveDataLocks.delete(key);
+	});
+	return run;
+}
+const LIVE_SUBSCRIPTION = {
+	depth: {
+		subscribe: PayloadType.OA_SUBSCRIBE_DEPTH_QUOTES_REQ,
+		unsubscribe: PayloadType.OA_UNSUBSCRIBE_DEPTH_QUOTES_REQ,
+		event: PayloadType.OA_DEPTH_EVENT
+	},
+	spot: {
+		subscribe: PayloadType.OA_SUBSCRIBE_SPOTS_REQ,
+		unsubscribe: PayloadType.OA_UNSUBSCRIBE_SPOTS_REQ,
+		event: PayloadType.OA_SPOT_EVENT
+	}
+};
+/**
+* Subscribe → run `collect` while `handler` receives this symbol's events →
+* ALWAYS unsubscribe + unregister (finally). The unsubscribe is best-effort:
+* its failure is logged, never masks the result, and a truly leaked
+* subscription dies with the socket.
+*/
+async function withLiveSubscription(pool, numericAccountId, symbolId, kind, handler, collect) {
+	const accountId = String(numericAccountId);
+	const sub = LIVE_SUBSCRIPTION[kind];
+	return withLiveDataLock(`${accountId}:${String(symbolId)}:${kind}`, async () => {
+		const unregister = pool.onAccountEvent(accountId, (event) => {
+			if (event.payloadType !== sub.event) return;
+			if (str(event.message.ctidTraderAccountId) !== accountId) return;
+			if (str(event.message.symbolId) !== String(symbolId)) return;
+			handler(event.message);
+		});
+		try {
+			await pool.request(accountId, sub.subscribe, {
+				ctidTraderAccountId: numericAccountId,
+				symbolId: [symbolId]
+			});
+			return await collect();
+		} finally {
+			unregister();
+			try {
+				await pool.request(accountId, sub.unsubscribe, {
+					ctidTraderAccountId: numericAccountId,
+					symbolId: [symbolId]
+				});
+			} catch (err) {
+				process.stderr.write(`[ctrader-mcp] Best-effort ${kind} unsubscribe failed for symbol ${String(symbolId)}: ${err instanceof Error ? err.message : String(err)}\n`);
+			}
+		}
+	});
+}
 /**
 * The shared `accountId` selector for account-scoped tools. Optional at the
 * schema level (single-account convenience); `resolveAccount` enforces the
@@ -970,7 +1265,7 @@ function registerTools(server, pool) {
 				ctidTraderAccountId: resolved.accountId,
 				returnProtectionOrders: true
 			})).message.order ?? [];
-			const typeName = (v) => v === ORDER_TYPE.LIMIT ? "LIMIT" : v === ORDER_TYPE.STOP ? "STOP" : v === ORDER_TYPE.MARKET ? "MARKET" : String(v);
+			const typeName = (v) => v === ORDER_TYPE.LIMIT ? "LIMIT" : v === ORDER_TYPE.STOP ? "STOP" : v === ORDER_TYPE.STOP_LIMIT ? "STOP_LIMIT" : v === ORDER_TYPE.MARKET ? "MARKET" : String(v);
 			return ok({
 				accountId: String(resolved.accountId),
 				orders: orders.map((o) => {
@@ -1053,17 +1348,374 @@ function registerTools(server, pool) {
 			return fail(err);
 		}
 	});
+	register("get_symbol_details", {
+		description: "Get full trading details for one symbol on a connected cTrader account: price digits, pip position, lot size, min/max/step volume (in lots), swap rates, and short-selling availability. Pass `accountId` when several accounts are connected.",
+		inputSchema: {
+			accountId: accountIdField,
+			symbolId: z.number().int().positive().describe("Symbol id from get_symbols")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const symbol = await getSymbolDetail(pool, accountId, resolved.accountId, args.symbolId);
+			const lotSize = num(symbol.lotSize);
+			const toLots = (v) => lotSize > 0 ? volumeToLots(num(v), lotSize) : null;
+			return ok({
+				accountId,
+				symbolId: str(symbol.symbolId) || String(args.symbolId),
+				digits: num(symbol.digits),
+				pipPosition: num(symbol.pipPosition),
+				lotSize,
+				minVolumeLots: toLots(symbol.minVolume),
+				maxVolumeLots: toLots(symbol.maxVolume),
+				stepVolumeLots: toLots(symbol.stepVolume),
+				swapLong: symbol.swapLong ?? null,
+				swapShort: symbol.swapShort ?? null,
+				swapRollover3Days: symbol.swapRollover3Days ?? null,
+				enableShortSelling: symbol.enableShortSelling != null ? Boolean(symbol.enableShortSelling) : null,
+				guaranteedStopLossAvailable: symbol.guaranteedStopLoss != null ? Boolean(symbol.guaranteedStopLoss) : null
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_quote", {
+		description: "Get the LIVE bid/ask for a symbol on a connected cTrader account via a brief spot subscription (ticks merge until both sides are seen, up to waitMs). Returns bid, ask, and spread as real decimal prices. Pass `accountId` when several accounts are connected.",
+		inputSchema: {
+			accountId: accountIdField,
+			symbolId: z.number().int().positive().describe("Symbol id from get_symbols"),
+			waitMs: z.number().int().min(200).max(1e4).default(3e3).describe("Max milliseconds to wait for both bid and ask ticks (returns early once both are seen)")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const digits = num((await getSymbolDetail(pool, accountId, resolved.accountId, args.symbolId)).digits);
+			const quote = {
+				bid: null,
+				ask: null,
+				ticks: 0
+			};
+			let signalBothSeen = () => void 0;
+			const bothSeen = new Promise((resolve) => {
+				signalBothSeen = resolve;
+			});
+			await withLiveSubscription(pool, resolved.accountId, args.symbolId, "spot", (message) => {
+				quote.ticks += 1;
+				if (message.bid != null) quote.bid = roundToDigits(priceToDecimal(num(message.bid)), digits);
+				if (message.ask != null) quote.ask = roundToDigits(priceToDecimal(num(message.ask)), digits);
+				if (quote.bid != null && quote.ask != null) signalBothSeen();
+			}, () => Promise.race([bothSeen, sleep(args.waitMs)]));
+			if (quote.bid == null && quote.ask == null) return fail(new CTraderError("NO_QUOTE_DATA", `No live ticks for symbol ${String(args.symbolId)} within ${String(args.waitMs)}ms — the market may be closed or the symbol not quoted on this account`));
+			return ok({
+				accountId,
+				symbolId: String(args.symbolId),
+				digits,
+				bid: quote.bid,
+				ask: quote.ask,
+				spread: quote.bid != null && quote.ask != null ? roundToDigits(quote.ask - quote.bid, digits) : null,
+				ticksReceived: quote.ticks,
+				...quote.bid == null || quote.ask == null ? { note: "Only one side ticked within the window; the missing side is null." } : {}
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_depth", {
+		description: "Get the LIVE Level 2 order book (depth of market) for a symbol on a connected cTrader account. Subscribes briefly, assembles the bid/ask ladder (sizes aggregated per price level), then unsubscribes. Returns bids (descending) and asks (ascending) with sizes in base-asset units and lots, plus best bid/ask and spread. Not every broker/symbol publishes depth — a NO_DEPTH_DATA error means none arrived. Pass `accountId` when several accounts are connected.",
+		inputSchema: {
+			accountId: accountIdField,
+			symbolId: z.number().int().positive().describe("Symbol id from get_symbols"),
+			levels: z.number().int().min(1).max(50).default(10).describe("Max price levels per side to return"),
+			collectMs: z.number().int().min(200).max(5e3).default(1e3).describe("How long to collect depth events before snapshotting (the full book arrives on subscribe; longer windows fold in more updates)")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const symbol = await getSymbolDetail(pool, accountId, resolved.accountId, args.symbolId);
+			const digits = num(symbol.digits);
+			const lotSize = num(symbol.lotSize);
+			const book = /* @__PURE__ */ new Map();
+			let eventsReceived = 0;
+			await withLiveSubscription(pool, resolved.accountId, args.symbolId, "depth", (message) => {
+				eventsReceived += 1;
+				const newQuotes = message.newQuotes ?? [];
+				for (const quote of newQuotes) {
+					const id = str(quote.id);
+					const sizeUnits = depthSizeToUnits(num(quote.size));
+					if (quote.bid != null) book.set(id, {
+						side: "bid",
+						price: priceToDecimal(num(quote.bid)),
+						sizeUnits
+					});
+					else if (quote.ask != null) book.set(id, {
+						side: "ask",
+						price: priceToDecimal(num(quote.ask)),
+						sizeUnits
+					});
+				}
+				for (const deleted of message.deletedQuotes ?? []) book.delete(str(deleted));
+			}, () => sleep(args.collectMs));
+			if (eventsReceived === 0) return fail(new CTraderError("NO_DEPTH_DATA", `No depth events for symbol ${String(args.symbolId)} within ${String(args.collectMs)}ms — this broker/symbol may not publish Level 2 via the Open API, or the market is closed`));
+			const ladder = (side) => {
+				const byPrice = /* @__PURE__ */ new Map();
+				for (const quote of book.values()) {
+					if (quote.side !== side) continue;
+					byPrice.set(quote.price, (byPrice.get(quote.price) ?? 0) + quote.sizeUnits);
+				}
+				const rows = [...byPrice.entries()].map(([price, sizeUnits]) => ({
+					price: roundToDigits(price, digits),
+					sizeUnits,
+					sizeLots: lotSize > 0 ? volumeToLots(sizeUnits * 100, lotSize) : null
+				}));
+				rows.sort((a, b) => side === "bid" ? b.price - a.price : a.price - b.price);
+				return rows;
+			};
+			const bids = ladder("bid");
+			const asks = ladder("ask");
+			const bestBid = bids.at(0)?.price ?? null;
+			const bestAsk = asks.at(0)?.price ?? null;
+			return ok({
+				accountId,
+				symbolId: String(args.symbolId),
+				digits,
+				bestBid,
+				bestAsk,
+				spread: bestBid != null && bestAsk != null ? roundToDigits(bestAsk - bestBid, digits) : null,
+				bids: bids.slice(0, args.levels),
+				asks: asks.slice(0, args.levels),
+				levelsAvailable: {
+					bid: bids.length,
+					ask: asks.length
+				},
+				eventsReceived
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_tick_data", {
+		description: "Get historical tick-by-tick prices (BID or ASK side) for a symbol on a connected cTrader account. Defaults to the last 5 minutes — keep ranges short, tick volumes are large; `hasMore` signals truncation. Ticks are returned newest-first with real decimal prices.",
+		inputSchema: {
+			accountId: accountIdField,
+			symbolId: z.number().int().positive().describe("Symbol id from get_symbols"),
+			type: z.enum(["BID", "ASK"]).default("BID").describe("Which side's ticks to fetch"),
+			from: z.string().optional().describe("ISO 8601 range start (default: 5 minutes before `to`)"),
+			to: z.string().optional().describe("ISO 8601 range end (default: now)")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const toMs = args.to != null ? parseTimestamp(args.to, "to") : Date.now();
+			const fromMs = args.from != null ? parseTimestamp(args.from, "from") : toMs - 5 * 6e4;
+			if (fromMs >= toMs) return fail(new CTraderError("INVALID_RANGE", "`from` must be before `to`"));
+			const res = await pool.request(accountId, PayloadType.OA_GET_TICKDATA_REQ, {
+				ctidTraderAccountId: resolved.accountId,
+				symbolId: args.symbolId,
+				type: QUOTE_TYPE[args.type],
+				fromTimestamp: fromMs,
+				toTimestamp: toMs
+			});
+			const raw = res.message.tickData ?? [];
+			return ok({
+				accountId,
+				symbolId: String(args.symbolId),
+				type: args.type,
+				count: raw.length,
+				hasMore: Boolean(res.message.hasMore),
+				ticks: decodeTickData(raw)
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_trade_history", {
+		description: "Get executed deal (fill) history for a connected cTrader account: entry/exit fills with price, volume, commission, and — for closing deals — realized PnL. Defaults to the last 7 days; cTrader caps the from/to span (about a week per request).",
+		inputSchema: {
+			accountId: accountIdField,
+			from: z.string().optional().describe("ISO 8601 range start (default: 7 days before `to`)"),
+			to: z.string().optional().describe("ISO 8601 range end (default: now)"),
+			maxRows: z.number().int().min(1).max(1e3).default(100).describe("Max deals to return")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const toMs = args.to != null ? parseTimestamp(args.to, "to") : Date.now();
+			const fromMs = args.from != null ? parseTimestamp(args.from, "from") : toMs - 7 * 864e5;
+			if (fromMs >= toMs) return fail(new CTraderError("INVALID_RANGE", "`from` must be before `to`"));
+			const res = await pool.request(accountId, PayloadType.OA_DEAL_LIST_REQ, {
+				ctidTraderAccountId: resolved.accountId,
+				fromTimestamp: fromMs,
+				toTimestamp: toMs,
+				maxRows: args.maxRows
+			});
+			const deals = res.message.deal ?? [];
+			return ok({
+				accountId,
+				count: deals.length,
+				hasMore: Boolean(res.message.hasMore),
+				deals: deals.map((d) => {
+					const moneyDigits = d.moneyDigits != null ? num(d.moneyDigits) : 2;
+					const close = d.closePositionDetail;
+					const closeMoneyDigits = close?.moneyDigits != null ? num(close.moneyDigits) : moneyDigits;
+					return {
+						dealId: str(d.dealId),
+						orderId: str(d.orderId),
+						positionId: str(d.positionId),
+						symbolId: str(d.symbolId),
+						side: num(d.tradeSide) === TRADE_SIDE.SELL ? "SELL" : "BUY",
+						status: DEAL_STATUS_NAME[num(d.dealStatus)] ?? str(d.dealStatus),
+						volume: str(d.volume) || "0",
+						filledVolume: str(d.filledVolume) || "0",
+						executionPrice: d.executionPrice ?? null,
+						commission: d.commission != null ? moneyToDecimal(num(d.commission), moneyDigits) : null,
+						executedAt: new Date(num(d.executionTimestamp)).toISOString(),
+						closedPosition: close ? {
+							entryPrice: close.entryPrice ?? null,
+							grossProfit: moneyToDecimal(num(close.grossProfit), closeMoneyDigits),
+							swap: moneyToDecimal(num(close.swap), closeMoneyDigits),
+							commission: moneyToDecimal(num(close.commission), closeMoneyDigits),
+							balanceAfter: moneyToDecimal(num(close.balance), closeMoneyDigits)
+						} : null
+					};
+				})
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_position_pnl", {
+		description: "Get the current UNREALIZED profit/loss (gross and net) for every open position on a connected cTrader account, in the account's deposit currency. Pass `accountId` when several accounts are connected.",
+		inputSchema: { accountId: accountIdField }
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const res = await pool.request(accountId, PayloadType.OA_GET_POSITION_UNREALIZED_PNL_REQ, { ctidTraderAccountId: resolved.accountId });
+			const moneyDigits = res.message.moneyDigits != null ? num(res.message.moneyDigits) : 2;
+			return ok({
+				accountId,
+				moneyDigits,
+				positions: (res.message.positionUnrealizedPnL ?? []).map((r) => ({
+					positionId: str(r.positionId),
+					grossUnrealizedPnL: moneyToDecimal(num(r.grossUnrealizedPnL), moneyDigits),
+					netUnrealizedPnL: moneyToDecimal(num(r.netUnrealizedPnL), moneyDigits)
+				}))
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_expected_margin", {
+		description: "Get the margin that would be required to open BUY/SELL positions of given sizes (in lots) on a symbol, in the account's deposit currency. Useful before place_order to check affordability. Pass `accountId` when several accounts are connected.",
+		inputSchema: {
+			accountId: accountIdField,
+			symbolId: z.number().int().positive().describe("Symbol id from get_symbols"),
+			volumesLots: z.array(z.number().positive()).min(1).max(10).describe("Position sizes in lots to quote margin for, e.g. [0.1, 0.5, 1]")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const lotSize = num((await getSymbolDetail(pool, accountId, resolved.accountId, args.symbolId)).lotSize);
+			if (lotSize <= 0) return fail(new CTraderError("SYMBOL_NO_LOTSIZE", `Symbol ${String(args.symbolId)} has no lotSize; cannot size the margin quote`));
+			const res = await pool.request(accountId, PayloadType.OA_EXPECTED_MARGIN_REQ, {
+				ctidTraderAccountId: resolved.accountId,
+				symbolId: args.symbolId,
+				volume: args.volumesLots.map((lots) => lotsToVolume(lots, lotSize))
+			});
+			const moneyDigits = res.message.moneyDigits != null ? num(res.message.moneyDigits) : 2;
+			const margins = res.message.margin ?? [];
+			return ok({
+				accountId,
+				symbolId: String(args.symbolId),
+				margins: margins.map((m) => ({
+					volumeLots: volumeToLots(num(m.volume), lotSize),
+					buyMargin: moneyToDecimal(num(m.buyMargin), moneyDigits),
+					sellMargin: moneyToDecimal(num(m.sellMargin), moneyDigits)
+				}))
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
+	register("get_cash_flow_history", {
+		description: "Get deposit/withdrawal history for a connected cTrader account over a date range (default: last 30 days). Amounts are real currency figures; positive delta = deposit, negative = withdrawal.",
+		inputSchema: {
+			accountId: accountIdField,
+			from: z.string().optional().describe("ISO 8601 range start (default: 30 days before `to`)"),
+			to: z.string().optional().describe("ISO 8601 range end (default: now)")
+		}
+	}, async (args) => {
+		const resolved = resolveAccount(pool, args.accountId);
+		if (isToolError(resolved)) return resolved;
+		const accountId = String(resolved.accountId);
+		try {
+			const toMs = args.to != null ? parseTimestamp(args.to, "to") : Date.now();
+			const fromMs = args.from != null ? parseTimestamp(args.from, "from") : toMs - 30 * 864e5;
+			if (fromMs >= toMs) return fail(new CTraderError("INVALID_RANGE", "`from` must be before `to`"));
+			const entries = (await pool.request(accountId, PayloadType.OA_CASH_FLOW_HISTORY_LIST_REQ, {
+				ctidTraderAccountId: resolved.accountId,
+				fromTimestamp: fromMs,
+				toTimestamp: toMs
+			})).message.depositWithdraw ?? [];
+			return ok({
+				accountId,
+				count: entries.length,
+				entries: entries.map((e) => {
+					const moneyDigits = e.moneyDigits != null ? num(e.moneyDigits) : 2;
+					return {
+						type: CHANGE_BALANCE_TYPE_NAME[num(e.operationType)] ?? str(e.operationType),
+						amount: moneyToDecimal(num(e.delta), moneyDigits),
+						balanceAfter: moneyToDecimal(num(e.balance), moneyDigits),
+						at: new Date(num(e.changeBalanceTimestamp)).toISOString(),
+						note: e.externalNote ?? null
+					};
+				})
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	});
 	register("place_order", {
-		description: "Place a MARKET or LIMIT order on a connected cTrader account. Volume is in LOTS and is converted to the symbol's protocol volume (validated against min/max/step). For LIMIT you must pass limitPrice. SL/TP are absolute prices. Pass `accountId` when several accounts are connected. WARNING: on a live account this moves real money.",
+		description: "Place a MARKET, LIMIT, STOP, or STOP_LIMIT order on a connected cTrader account. Volume is in LOTS and is converted to the symbol's protocol volume (validated against min/max/step). LIMIT requires limitPrice; STOP requires stopPrice; STOP_LIMIT requires stopPrice + slippageInPoints. SL/TP: pass ABSOLUTE prices via stopLoss/takeProfit, or price DISTANCES via stopLossDistance/takeProfitDistance (required for a trailing stop). timeInForce defaults to GOOD_TILL_CANCEL; GOOD_TILL_DATE requires expiresAt. Pass `accountId` when several accounts are connected. WARNING: on a live account this moves real money.",
 		inputSchema: {
 			accountId: accountIdField,
 			symbolId: z.number().int().positive().describe("Symbol id from get_symbols"),
 			side: z.enum(["BUY", "SELL"]).describe("Trade side"),
-			orderType: z.enum(["MARKET", "LIMIT"]).default("MARKET").describe("MARKET fills now; LIMIT rests at limitPrice"),
+			orderType: z.enum([
+				"MARKET",
+				"LIMIT",
+				"STOP",
+				"STOP_LIMIT"
+			]).default("MARKET").describe("MARKET fills now; LIMIT rests at limitPrice; STOP triggers at stopPrice; STOP_LIMIT triggers at stopPrice with a max slippage of slippageInPoints"),
 			volumeLots: z.number().positive().describe("Order size in lots (e.g. 0.1). Converted to protocol volume via the symbol lotSize."),
 			limitPrice: z.number().positive().optional().describe("Required for LIMIT orders — the price to rest the order at"),
-			stopLoss: z.number().positive().optional().describe("Absolute stop-loss price"),
-			takeProfit: z.number().positive().optional().describe("Absolute take-profit price"),
+			stopPrice: z.number().positive().optional().describe("Required for STOP and STOP_LIMIT orders — the trigger price"),
+			slippageInPoints: z.number().int().min(0).optional().describe("Required for STOP_LIMIT — max slippage from stopPrice, in points"),
+			stopLoss: z.number().positive().optional().describe("Absolute stop-loss price (mutually exclusive with stopLossDistance)"),
+			takeProfit: z.number().positive().optional().describe("Absolute take-profit price (mutually exclusive with takeProfitDistance)"),
+			stopLossDistance: z.number().positive().optional().describe("Stop-loss as a price DISTANCE from entry (e.g. 0.0010 = 10 pips on a 5-digit FX pair). Required when trailingStopLoss is true."),
+			takeProfitDistance: z.number().positive().optional().describe("Take-profit as a price DISTANCE from entry"),
+			trailingStopLoss: z.boolean().optional().describe("Trail the stop-loss as price moves in your favour. Requires stopLossDistance (not an absolute stopLoss)."),
+			timeInForce: z.enum([
+				"GOOD_TILL_CANCEL",
+				"GOOD_TILL_DATE",
+				"IMMEDIATE_OR_CANCEL",
+				"FILL_OR_KILL"
+			]).optional().describe("Order lifetime (default GOOD_TILL_CANCEL). GOOD_TILL_DATE requires expiresAt."),
+			expiresAt: z.string().optional().describe("ISO 8601 expiry — required with (and only valid with) timeInForce GOOD_TILL_DATE"),
 			label: z.string().optional().describe("Optional client label for the order")
 		}
 	}, async (args) => {
@@ -1072,6 +1724,19 @@ function registerTools(server, pool) {
 		const accountId = String(resolved.accountId);
 		try {
 			if (args.orderType === "LIMIT" && args.limitPrice == null) return fail(new CTraderError("LIMIT_PRICE_REQUIRED", "LIMIT orders require limitPrice"));
+			if ((args.orderType === "STOP" || args.orderType === "STOP_LIMIT") && args.stopPrice == null) return fail(new CTraderError("STOP_PRICE_REQUIRED", `${args.orderType} orders require stopPrice`));
+			if (args.orderType === "STOP_LIMIT" && args.slippageInPoints == null) return fail(new CTraderError("SLIPPAGE_REQUIRED", "STOP_LIMIT orders require slippageInPoints"));
+			if (args.orderType === "MARKET" && (args.limitPrice != null || args.stopPrice != null)) return fail(new CTraderError("PRICE_NOT_ALLOWED", "MARKET orders take no limitPrice/stopPrice — use LIMIT or STOP"));
+			if (args.orderType === "LIMIT" && args.stopPrice != null) return fail(new CTraderError("PRICE_NOT_ALLOWED", "LIMIT orders take no stopPrice"));
+			if (args.orderType === "STOP" && args.limitPrice != null) return fail(new CTraderError("PRICE_NOT_ALLOWED", "STOP orders take no limitPrice"));
+			if (args.stopLoss != null && args.stopLossDistance != null) return fail(new CTraderError("CONFLICTING_STOP_LOSS", "Pass stopLoss (absolute) OR stopLossDistance, not both"));
+			if (args.takeProfit != null && args.takeProfitDistance != null) return fail(new CTraderError("CONFLICTING_TAKE_PROFIT", "Pass takeProfit (absolute) OR takeProfitDistance, not both"));
+			if (args.trailingStopLoss) {
+				if (args.stopLoss != null) return fail(new CTraderError("TRAILING_NEEDS_DISTANCE", "A trailing stop uses stopLossDistance, not an absolute stopLoss"));
+				if (args.stopLossDistance == null) return fail(new CTraderError("TRAILING_NEEDS_DISTANCE", "trailingStopLoss requires stopLossDistance"));
+			}
+			if (args.timeInForce === "GOOD_TILL_DATE" && args.expiresAt == null) return fail(new CTraderError("EXPIRATION_REQUIRED", "timeInForce GOOD_TILL_DATE requires expiresAt"));
+			if (args.expiresAt != null && args.timeInForce !== "GOOD_TILL_DATE") return fail(new CTraderError("EXPIRATION_NOT_ALLOWED", "expiresAt is only valid with timeInForce GOOD_TILL_DATE"));
 			const symbol = await getSymbolDetail(pool, accountId, resolved.accountId, args.symbolId);
 			const lotSize = num(symbol.lotSize);
 			if (lotSize <= 0) return fail(new CTraderError("SYMBOL_NO_LOTSIZE", `Symbol ${String(args.symbolId)} has no lotSize; cannot size the order`));
@@ -1086,8 +1751,15 @@ function registerTools(server, pool) {
 				volume
 			};
 			if (args.limitPrice != null) payload.limitPrice = args.limitPrice;
+			if (args.stopPrice != null) payload.stopPrice = args.stopPrice;
+			if (args.slippageInPoints != null) payload.slippageInPoints = args.slippageInPoints;
 			if (args.stopLoss != null) payload.stopLoss = args.stopLoss;
 			if (args.takeProfit != null) payload.takeProfit = args.takeProfit;
+			if (args.stopLossDistance != null) payload.relativeStopLoss = Math.round(args.stopLossDistance * PRICE_SCALE);
+			if (args.takeProfitDistance != null) payload.relativeTakeProfit = Math.round(args.takeProfitDistance * PRICE_SCALE);
+			if (args.trailingStopLoss != null) payload.trailingStopLoss = args.trailingStopLoss;
+			if (args.timeInForce != null) payload.timeInForce = TIME_IN_FORCE[args.timeInForce];
+			if (args.expiresAt != null) payload.expirationTimestamp = parseTimestamp(args.expiresAt, "expiresAt");
 			if (args.label != null) payload.label = args.label;
 			const { executionType, summary } = assertExecution(await pool.request(accountId, PayloadType.OA_NEW_ORDER_REQ, payload));
 			return ok({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alfe.ai/ctrader-mcp",
-  "version": "0.2.1",
-  "description": "cTrader MCP server — full trading (place/modify/close orders + read) over the cTrader Open API (protobuf/TLS)",
+  "version": "0.3.1",
+  "description": "cTrader MCP server — full trading (market/limit/stop/stop-limit orders, trailing stops), Level 2 depth, live quotes, trade history, PnL & margin over the cTrader Open API (protobuf/TLS)",
   "type": "module",
   "main": "./dist/server.js",
   "bin": {
@@ -21,7 +21,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "protobufjs": "^8.7.0",
     "zod": "^4.0.5",
-    "@alfe.ai/agent-api-client": "0.11.0",
+    "@alfe.ai/agent-api-client": "0.11.1",
     "@alfe.ai/config": "0.3.0"
   },
   "license": "UNLICENSED",

package/proto/ctrader.proto

@@ -53,6 +53,11 @@ enum ProtoOATradeSide {
   SELL = 2;
 }
 
+enum ProtoOAQuoteType {
+  BID = 1;
+  ASK = 2;
+}
+
 enum ProtoOATrendbarPeriod {
   M1 = 1;
   M2 = 2;
@@ -280,8 +285,11 @@ message ProtoOASymbol {
   optional bool   enableShortSelling = 4;
   optional bool   guaranteedStopLoss = 5;
   optional uint32 swapRollover3Days  = 6;
-  optional bool   swapLong           = 7;
-  optional bool   swapShort          = 8;
+  // swapLong/swapShort are canonical DOUBLE (fixed64 on the wire) — declaring
+  // them bool (varint) mis-consumes bytes and corrupts every field decoded
+  // after them whenever the broker sets swap rates.
+  optional double swapLong           = 7;
+  optional double swapShort          = 8;
   optional int64  maxVolume          = 9;
   optional int64  minVolume          = 10;
   optional int64  stepVolume         = 11;
@@ -361,6 +369,213 @@ message ProtoOASpotEvent {
   optional int64  timestamp           = 8;
 }
 
+message ProtoOAUnsubscribeSpotsReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  repeated int64  symbolId            = 3;
+}
+
+message ProtoOAUnsubscribeSpotsRes {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+}
+
+// ── Depth of market (Level 2) subscription ──────────────────────────────
+//
+// The first ProtoOADepthEvent after a subscribe carries the FULL current book
+// as `newQuotes`; later events are deltas — upsert `newQuotes` by quote `id`,
+// then remove `deletedQuotes` ids. A quote is one side only: `bid` OR `ask`
+// is set, never both. Prices are ×100000 like spot/trendbar prices; `size`
+// is in CENTS of a unit (÷100 = base-asset units).
+
+message ProtoOADepthQuote {
+  required uint64 id   = 1;
+  required uint64 size = 3;
+  optional uint64 bid  = 4;
+  optional uint64 ask  = 5;
+}
+
+message ProtoOASubscribeDepthQuotesReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  repeated int64  symbolId            = 3;
+}
+
+message ProtoOASubscribeDepthQuotesRes {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+}
+
+message ProtoOAUnsubscribeDepthQuotesReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  repeated int64  symbolId            = 3;
+}
+
+message ProtoOAUnsubscribeDepthQuotesRes {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+}
+
+message ProtoOADepthEvent {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  required uint64 symbolId            = 3;
+  repeated ProtoOADepthQuote newQuotes = 4;
+  repeated uint64 deletedQuotes       = 5 [packed = true];
+}
+
+// ── Historical tick data ────────────────────────────────────────────────
+//
+// Tick data comes back NEWEST-FIRST and delta-encoded: the first entry's
+// `timestamp`/`tick` are absolute, every subsequent entry carries the DELTA
+// from the previous entry (negative for time going backwards). Decode by
+// running sums. Tick prices are ×100000 like all other prices.
+
+message ProtoOATickData {
+  required int64 timestamp = 1;
+  required int64 tick      = 2;
+}
+
+message ProtoOAGetTickDataReq {
+  optional uint32           payloadType         = 1;
+  required int64            ctidTraderAccountId = 2;
+  required int64            symbolId            = 3;
+  required ProtoOAQuoteType type                = 4;
+  optional int64            fromTimestamp       = 5;
+  optional int64            toTimestamp         = 6;
+}
+
+message ProtoOAGetTickDataRes {
+  optional uint32          payloadType         = 1;
+  required int64           ctidTraderAccountId = 2;
+  repeated ProtoOATickData tickData            = 3;
+  required bool            hasMore             = 4;
+}
+
+// ── Deal (trade) history ────────────────────────────────────────────────
+// dealStatus is upstream enum ProtoOADealStatus (FILLED=2, PARTIALLY_FILLED=3,
+// REJECTED=4, INTERNALLY_REJECTED=5, ERROR=6, MISSED=7); kept as a scalar like
+// orderStatus. operationType on deposits is ProtoOAChangeBalanceType
+// (BALANCE_DEPOSIT=0, BALANCE_WITHDRAW=1, …), also scalar.
+
+message ProtoOAClosePositionDetail {
+  required double entryPrice   = 1;
+  required int64  grossProfit  = 2;
+  required int64  swap         = 3;
+  required int64  commission   = 4;
+  required int64  balance      = 5;
+  optional double quoteToDepositConversionRate = 6;
+  optional int64  closedVolume = 7;
+  optional int64  balanceVersion = 8;
+  optional uint32 moneyDigits  = 9;
+  optional int64  pnlConversionFee = 10;
+}
+
+message ProtoOADeal {
+  required int64            dealId              = 1;
+  required int64            orderId             = 2;
+  required int64            positionId          = 3;
+  required int64            volume              = 4;
+  required int64            filledVolume        = 5;
+  required int64            symbolId            = 6;
+  required int64            createTimestamp     = 7;
+  required int64            executionTimestamp  = 8;
+  optional int64            utcLastUpdateTimestamp = 9;
+  optional double           executionPrice      = 10;
+  required ProtoOATradeSide tradeSide           = 11;
+  required uint32           dealStatus          = 12;
+  optional double           marginRate          = 13;
+  optional int64            commission          = 14;
+  optional double           baseToUsdConversionRate = 15;
+  optional ProtoOAClosePositionDetail closePositionDetail = 16;
+  optional uint32           moneyDigits         = 17;
+}
+
+message ProtoOADealListReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  optional int64  fromTimestamp       = 3;
+  optional int64  toTimestamp         = 4;
+  optional int32  maxRows             = 5;
+}
+
+message ProtoOADealListRes {
+  optional uint32     payloadType         = 1;
+  required int64      ctidTraderAccountId = 2;
+  repeated ProtoOADeal deal               = 3;
+  required bool       hasMore             = 4;
+}
+
+// ── Expected margin ─────────────────────────────────────────────────────
+
+message ProtoOAExpectedMargin {
+  required int64 volume     = 1;
+  required int64 buyMargin  = 2;
+  required int64 sellMargin = 3;
+}
+
+message ProtoOAExpectedMarginReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  required int64  symbolId            = 3;
+  repeated int64  volume              = 4;
+}
+
+message ProtoOAExpectedMarginRes {
+  optional uint32               payloadType         = 1;
+  required int64                ctidTraderAccountId = 2;
+  repeated ProtoOAExpectedMargin margin             = 3;
+  optional uint32               moneyDigits         = 4;
+}
+
+// ── Cash flow (deposit / withdrawal) history ────────────────────────────
+
+message ProtoOADepositWithdraw {
+  required uint32 operationType          = 1;
+  required int64  balanceHistoryId       = 2;
+  required int64  balance                = 3;
+  required int64  delta                  = 4;
+  required int64  changeBalanceTimestamp = 5;
+  optional string externalNote           = 6;
+  optional int64  balanceVersion         = 7;
+  optional int64  equity                 = 8;
+  optional uint32 moneyDigits            = 9;
+}
+
+message ProtoOACashFlowHistoryListReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  required int64  fromTimestamp       = 3;
+  required int64  toTimestamp         = 4;
+}
+
+message ProtoOACashFlowHistoryListRes {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  repeated ProtoOADepositWithdraw depositWithdraw = 3;
+}
+
+// ── Unrealized PnL per open position ────────────────────────────────────
+
+message ProtoOAPositionUnrealizedPnL {
+  required int64 positionId         = 1;
+  required int64 grossUnrealizedPnL = 2;
+  required int64 netUnrealizedPnL   = 3;
+}
+
+message ProtoOAGetPositionUnrealizedPnLReq {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+}
+
+message ProtoOAGetPositionUnrealizedPnLRes {
+  optional uint32 payloadType         = 1;
+  required int64  ctidTraderAccountId = 2;
+  repeated ProtoOAPositionUnrealizedPnL positionUnrealizedPnL = 3;
+  required uint32 moneyDigits         = 4;
+}
+
 // ── Order mutations (all respond via ProtoOAExecutionEvent, 2126) ───────
 
 message ProtoOANewOrderReq {