clodds 1.1.0

package/dist/agents/handlers/manifold.js

@@ -0,0 +1,1001 @@
+"use strict";
+/**
+ * Manifold Handlers
+ *
+ * Platform handlers for Manifold prediction market.
+ * Migrated from inline switch cases in agents/index.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifoldHandlers = void 0;
+const risk_1 = require("../../trading/risk");
+// =============================================================================
+// HELPERS
+// =============================================================================
+const MANIFOLD_API = 'https://api.manifold.markets';
+/**
+ * Get Manifold API key from context credentials
+ */
+function getManifoldApiKey(context) {
+    const manifoldCreds = context.tradingContext?.credentials.get('manifold');
+    if (!manifoldCreds || manifoldCreds.platform !== 'manifold')
+        return null;
+    return manifoldCreds.data.apiKey;
+}
+/**
+ * Auth headers for Manifold API
+ */
+function authHeaders(apiKey) {
+    return {
+        'Content-Type': 'application/json',
+        'Authorization': `Key ${apiKey}`,
+    };
+}
+/**
+ * Read-only auth headers (no Content-Type)
+ */
+function readAuthHeaders(apiKey) {
+    return {
+        'Authorization': `Key ${apiKey}`,
+    };
+}
+/**
+ * Standard credential error message
+ */
+const CRED_ERROR = JSON.stringify({
+    error: 'No Manifold credentials set up. Use setup_manifold_credentials first.',
+});
+// =============================================================================
+// TRADING HANDLERS (require auth + risk checks)
+// =============================================================================
+// 1. manifold_bet
+async function betHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const userId = context.userId || '';
+    const marketId = toolInput.market_id;
+    const amount = toolInput.amount;
+    const outcome = toolInput.outcome;
+    const limitProb = toolInput.limit_prob;
+    const maxError = (0, risk_1.enforceMaxOrderSize)(context, amount, 'manifold_bet');
+    if (maxError)
+        return maxError;
+    const exposureError = (0, risk_1.enforceExposureLimits)(context, userId, {
+        platform: 'manifold',
+        marketId,
+        outcomeId: outcome,
+        notional: amount,
+        label: 'manifold_bet',
+    });
+    if (exposureError)
+        return exposureError;
+    const body = {
+        contractId: marketId,
+        amount,
+        outcome,
+    };
+    if (limitProb !== undefined) {
+        body.limitProb = limitProb;
+    }
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/bet`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 401 || response.status === 403) {
+                await context.credentials?.markFailure(userId, 'manifold');
+            }
+            return JSON.stringify({ error: 'Bet failed', details: errorText });
+        }
+        await context.credentials?.markSuccess(userId, 'manifold');
+        const result = await response.json();
+        return JSON.stringify({ result: 'Bet placed', betId: result.betId, shares: result.shares });
+    }
+    catch (err) {
+        const error = err;
+        return JSON.stringify({ error: 'Bet failed', details: error.message });
+    }
+}
+// 2. manifold_sell
+async function sellHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const userId = context.userId || '';
+    const marketId = toolInput.market_id;
+    const outcome = toolInput.outcome;
+    const shares = toolInput.shares;
+    const body = {
+        contractId: marketId,
+        outcome,
+    };
+    if (shares !== undefined) {
+        body.shares = shares;
+    }
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/sell`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 401 || response.status === 403) {
+                await context.credentials?.markFailure(userId, 'manifold');
+            }
+            return JSON.stringify({ error: 'Sell failed', details: errorText });
+        }
+        await context.credentials?.markSuccess(userId, 'manifold');
+        const result = await response.json();
+        return JSON.stringify({ result: 'Shares sold', ...(result || {}) });
+    }
+    catch (err) {
+        const error = err;
+        return JSON.stringify({ error: 'Sell failed', details: error.message });
+    }
+}
+// 3. manifold_multiple_choice
+async function multipleChoiceHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const userId = context.userId || '';
+    const marketId = toolInput.market_id;
+    const answerId = toolInput.answer_id;
+    const amount = toolInput.amount;
+    const maxError = (0, risk_1.enforceMaxOrderSize)(context, amount, 'manifold_multiple_choice');
+    if (maxError)
+        return maxError;
+    const exposureError = (0, risk_1.enforceExposureLimits)(context, userId, {
+        platform: 'manifold',
+        marketId,
+        outcomeId: answerId,
+        notional: amount,
+        label: 'manifold_multiple_choice',
+    });
+    if (exposureError)
+        return exposureError;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/bet`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ contractId: marketId, amount, answerId }),
+        });
+        if (!response.ok) {
+            return JSON.stringify({ error: `Bet failed: ${response.status}` });
+        }
+        const result = await response.json();
+        return JSON.stringify({ result: 'Bet placed', ...(result || {}) });
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 4. manifold_multi_bet
+async function multiBetHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const userId = context.userId || '';
+    const marketId = toolInput.market_id;
+    const answerIds = toolInput.answer_ids;
+    const amount = toolInput.amount;
+    const maxError = (0, risk_1.enforceMaxOrderSize)(context, amount, 'manifold_multi_bet');
+    if (maxError)
+        return maxError;
+    const exposureError = (0, risk_1.enforceExposureLimits)(context, userId, {
+        platform: 'manifold',
+        marketId,
+        notional: amount,
+        label: 'manifold_multi_bet',
+    });
+    if (exposureError)
+        return exposureError;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/multi-bet`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ contractId: marketId, answerIds, amount }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Multi-bet failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// =============================================================================
+// READ HANDLERS (require auth)
+// =============================================================================
+// 5. manifold_search
+async function searchHandler(toolInput, _context) {
+    const apiKey = getManifoldApiKey(_context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const query = toolInput.query;
+    const limit = toolInput.limit || 10;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/search-markets?term=${encodeURIComponent(query)}&limit=${limit}&filter=open&sort=liquidity`);
+        const markets = await response.json();
+        return JSON.stringify(markets.slice(0, limit).map((m) => ({
+            id: m.id,
+            question: m.question,
+            probability: m.probability,
+            volume: m.volume,
+            url: m.url,
+        })));
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 6. manifold_market
+async function marketHandler(toolInput, _context) {
+    const apiKey = getManifoldApiKey(_context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const idOrSlug = toolInput.id_or_slug;
+    try {
+        let response = await fetch(`${MANIFOLD_API}/v0/market/${idOrSlug}`);
+        if (!response.ok) {
+            response = await fetch(`${MANIFOLD_API}/v0/slug/${idOrSlug}`);
+        }
+        const market = await response.json();
+        return JSON.stringify(market);
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 7. manifold_balance
+async function balanceHandler(_toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/me`, {
+            headers: readAuthHeaders(apiKey),
+        });
+        const user = await response.json();
+        return JSON.stringify({ balance: user.balance, username: user.username });
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 8. manifold_positions
+async function positionsHandler(_toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/bets?limit=1000`, {
+            headers: readAuthHeaders(apiKey),
+        });
+        const bets = await response.json();
+        // Aggregate by market
+        const positions = {};
+        for (const bet of bets) {
+            if (!positions[bet.contractId]) {
+                positions[bet.contractId] = { yes: 0, no: 0, invested: 0 };
+            }
+            if (bet.outcome === 'YES') {
+                positions[bet.contractId].yes += bet.shares || 0;
+            }
+            else {
+                positions[bet.contractId].no += bet.shares || 0;
+            }
+            if (!bet.isSold) {
+                positions[bet.contractId].invested += bet.amount;
+            }
+        }
+        return JSON.stringify(positions);
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 9. manifold_bets
+async function betsHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    try {
+        const url = marketId
+            ? `${MANIFOLD_API}/v0/bets?contractId=${marketId}`
+            : `${MANIFOLD_API}/v0/bets`;
+        const response = await fetch(url, {
+            headers: readAuthHeaders(apiKey),
+        });
+        const bets = await response.json();
+        return JSON.stringify(bets.slice(0, 50));
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 10. manifold_cancel
+async function cancelHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const betId = toolInput.bet_id;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/bet/cancel/${betId}`, {
+            method: 'POST',
+            headers: readAuthHeaders(apiKey),
+        });
+        if (!response.ok) {
+            return JSON.stringify({ error: `Cancel failed: ${response.status}` });
+        }
+        return JSON.stringify({ result: 'Cancelled', bet_id: betId });
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 11. manifold_get_me
+async function getMeHandler(_toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/me`, {
+            headers: readAuthHeaders(apiKey),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Auth failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 12. manifold_get_user_portfolio
+async function getUserPortfolioHandler(toolInput, context) {
+    const inputUserId = toolInput.user_id;
+    let targetUserId = inputUserId;
+    if (!targetUserId) {
+        const apiKey = getManifoldApiKey(context);
+        if (!apiKey) {
+            return JSON.stringify({ error: 'No user_id provided and no Manifold credentials set up.' });
+        }
+        // Get own user ID first
+        const meResponse = await fetch(`${MANIFOLD_API}/v0/me`, {
+            headers: readAuthHeaders(apiKey),
+        });
+        if (!meResponse.ok)
+            return JSON.stringify({ error: 'Could not get user info' });
+        const me = await meResponse.json();
+        targetUserId = me.id;
+    }
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/get-user-portfolio?userId=${targetUserId}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Portfolio fetch failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 13. manifold_create_market
+async function createMarketHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const body = {
+        outcomeType: toolInput.outcome_type,
+        question: toolInput.question,
+    };
+    if (toolInput.description)
+        body.descriptionMarkdown = toolInput.description;
+    if (toolInput.close_time)
+        body.closeTime = toolInput.close_time;
+    if (toolInput.initial_prob)
+        body.initialProb = toolInput.initial_prob;
+    if (toolInput.min !== undefined)
+        body.min = toolInput.min;
+    if (toolInput.max !== undefined)
+        body.max = toolInput.max;
+    if (toolInput.answers)
+        body.answers = toolInput.answers;
+    if (toolInput.group_ids)
+        body.groupIds = toolInput.group_ids;
+    if (toolInput.visibility)
+        body.visibility = toolInput.visibility;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text();
+            return JSON.stringify({ error: `Create failed: ${response.status}`, details: errText });
+        }
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 14. manifold_add_answer
+async function addAnswerHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const text = toolInput.text;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/answer`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ text }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Add answer failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 15. manifold_add_liquidity
+async function addLiquidityHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const amount = toolInput.amount;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/add-liquidity`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ amount }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Add liquidity failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 16. manifold_add_bounty
+async function addBountyHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const amount = toolInput.amount;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/add-bounty`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ amount }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Add bounty failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 17. manifold_award_bounty
+async function awardBountyHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const commentId = toolInput.comment_id;
+    const amount = toolInput.amount;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/award-bounty`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ amount, commentId }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Award bounty failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 18. manifold_close_market
+async function closeMarketHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const closeTime = toolInput.close_time;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/close`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ closeTime }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Close market failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 19. manifold_manage_topic
+async function manageTopicHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const groupId = toolInput.group_id;
+    const remove = toolInput.remove || false;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/group`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ groupId, remove }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Manage topic failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 20. manifold_resolve_market
+async function resolveMarketHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const outcome = toolInput.outcome;
+    const probabilityInt = toolInput.probability_int;
+    const body = { outcome };
+    if (probabilityInt !== undefined)
+        body.probabilityInt = probabilityInt;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/resolve`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Resolve failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 21. manifold_create_comment
+async function createCommentHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const marketId = toolInput.market_id;
+    const content = toolInput.content;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/comment`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ contractId: marketId, markdown: content }),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Create comment failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 22. manifold_send_mana
+async function sendManaHandler(toolInput, context) {
+    const apiKey = getManifoldApiKey(context);
+    if (!apiKey)
+        return CRED_ERROR;
+    const toIds = toolInput.to_ids;
+    const amount = toolInput.amount;
+    const message = toolInput.message;
+    const body = { toIds, amount };
+    if (message)
+        body.message = message;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/managram`, {
+            method: 'POST',
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            return JSON.stringify({ error: `Send mana failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// =============================================================================
+// PUBLIC HANDLERS (no auth needed)
+// =============================================================================
+// 23. manifold_get_user
+async function getUserHandler(toolInput, _context) {
+    const username = toolInput.username;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/user/${encodeURIComponent(username)}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `User not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 24. manifold_get_user_lite
+async function getUserLiteHandler(toolInput, _context) {
+    const username = toolInput.username;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/user/${encodeURIComponent(username)}/lite`);
+        if (!response.ok)
+            return JSON.stringify({ error: `User not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 25. manifold_get_user_by_id
+async function getUserByIdHandler(toolInput, _context) {
+    const targetUserId = toolInput.user_id;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/user/by-id/${targetUserId}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `User not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 26. manifold_get_user_by_id_lite
+async function getUserByIdLiteHandler(toolInput, _context) {
+    const targetUserId = toolInput.user_id;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/user/by-id/${targetUserId}/lite`);
+        if (!response.ok)
+            return JSON.stringify({ error: `User not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 27. manifold_get_user_portfolio_history
+async function getUserPortfolioHistoryHandler(toolInput, _context) {
+    const targetUserId = toolInput.user_id;
+    const period = toolInput.period;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/get-user-portfolio-history?userId=${targetUserId}&period=${period}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Portfolio history fetch failed: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 28. manifold_list_users
+async function listUsersHandler(toolInput, _context) {
+    const limit = toolInput.limit || 1000;
+    const before = toolInput.before;
+    try {
+        let url = `${MANIFOLD_API}/v0/users?limit=${limit}`;
+        if (before)
+            url += `&before=${before}`;
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 29. manifold_get_groups
+async function getGroupsHandler(toolInput, _context) {
+    const beforeTime = toolInput.before_time;
+    const availableToUserId = toolInput.available_to_user_id;
+    try {
+        let url = `${MANIFOLD_API}/v0/groups`;
+        const params = [];
+        if (beforeTime)
+            params.push(`beforeTime=${beforeTime}`);
+        if (availableToUserId)
+            params.push(`availableToUserId=${availableToUserId}`);
+        if (params.length)
+            url += '?' + params.join('&');
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 30. manifold_get_group
+async function getGroupHandler(toolInput, _context) {
+    const slug = toolInput.slug;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/group/${encodeURIComponent(slug)}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Group not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 31. manifold_get_group_by_id
+async function getGroupByIdHandler(toolInput, _context) {
+    const groupId = toolInput.group_id;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/group/by-id/${groupId}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Group not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 32. manifold_list_markets
+async function listMarketsHandler(toolInput, _context) {
+    const limit = toolInput.limit || 500;
+    const sort = toolInput.sort;
+    const order = toolInput.order;
+    const before = toolInput.before;
+    const userId = toolInput.user_id;
+    const groupId = toolInput.group_id;
+    try {
+        let url = `${MANIFOLD_API}/v0/markets?limit=${limit}`;
+        if (sort)
+            url += `&sort=${sort}`;
+        if (order)
+            url += `&order=${order}`;
+        if (before)
+            url += `&before=${before}`;
+        if (userId)
+            url += `&userId=${userId}`;
+        if (groupId)
+            url += `&groupId=${groupId}`;
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 33. manifold_get_market_by_slug
+async function getMarketBySlugHandler(toolInput, _context) {
+    const slug = toolInput.slug;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/slug/${encodeURIComponent(slug)}`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Market not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 34. manifold_get_probability
+async function getProbabilityHandler(toolInput, _context) {
+    const marketId = toolInput.market_id;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market/${marketId}/prob`);
+        if (!response.ok)
+            return JSON.stringify({ error: `Market not found: ${response.status}` });
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 35. manifold_get_probabilities
+async function getProbabilitiesHandler(toolInput, _context) {
+    const marketIds = toolInput.market_ids;
+    try {
+        const response = await fetch(`${MANIFOLD_API}/v0/market-probs?ids=${marketIds.join(',')}`);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 36. manifold_get_market_positions
+async function getMarketPositionsHandler(toolInput, _context) {
+    const marketId = toolInput.market_id;
+    const order = toolInput.order;
+    const top = toolInput.top;
+    const bottom = toolInput.bottom;
+    const userId = toolInput.user_id;
+    try {
+        let url = `${MANIFOLD_API}/v0/market/${marketId}/positions`;
+        const params = [];
+        if (order)
+            params.push(`order=${order}`);
+        if (top)
+            params.push(`top=${top}`);
+        if (bottom)
+            params.push(`bottom=${bottom}`);
+        if (userId)
+            params.push(`userId=${userId}`);
+        if (params.length)
+            url += '?' + params.join('&');
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 37. manifold_get_user_metrics
+async function getUserMetricsHandler(toolInput, _context) {
+    const targetUserId = toolInput.user_id;
+    const limit = toolInput.limit;
+    const offset = toolInput.offset;
+    const order = toolInput.order;
+    try {
+        let url = `${MANIFOLD_API}/v0/get-user-contract-metrics-with-contracts?userId=${targetUserId}`;
+        if (limit)
+            url += `&limit=${limit}`;
+        if (offset)
+            url += `&offset=${offset}`;
+        if (order)
+            url += `&order=${order}`;
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 38. manifold_get_comments
+async function getCommentsHandler(toolInput, _context) {
+    const marketId = toolInput.market_id;
+    const marketSlug = toolInput.market_slug;
+    const userId = toolInput.user_id;
+    const limit = toolInput.limit || 1000;
+    const page = toolInput.page;
+    try {
+        let url = `${MANIFOLD_API}/v0/comments`;
+        const params = [];
+        if (marketId)
+            params.push(`contractId=${marketId}`);
+        if (marketSlug)
+            params.push(`contractSlug=${marketSlug}`);
+        if (userId)
+            params.push(`userId=${userId}`);
+        params.push(`limit=${limit}`);
+        if (page)
+            params.push(`page=${page}`);
+        if (params.length)
+            url += '?' + params.join('&');
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 39. manifold_get_transactions
+async function getTransactionsHandler(toolInput, _context) {
+    const limit = toolInput.limit || 100;
+    const offset = toolInput.offset;
+    const before = toolInput.before;
+    const after = toolInput.after;
+    const toId = toolInput.to_id;
+    const fromId = toolInput.from_id;
+    const category = toolInput.category;
+    try {
+        let url = `${MANIFOLD_API}/v0/txns`;
+        const params = [`limit=${limit}`];
+        if (offset)
+            params.push(`offset=${offset}`);
+        if (before)
+            params.push(`before=${before}`);
+        if (after)
+            params.push(`after=${after}`);
+        if (toId)
+            params.push(`toId=${toId}`);
+        if (fromId)
+            params.push(`fromId=${fromId}`);
+        if (category)
+            params.push(`category=${category}`);
+        url += '?' + params.join('&');
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// 40. manifold_get_leagues
+async function getLeaguesHandler(toolInput, _context) {
+    const userId = toolInput.user_id;
+    const season = toolInput.season;
+    const cohort = toolInput.cohort;
+    try {
+        let url = `${MANIFOLD_API}/v0/leagues`;
+        const params = [];
+        if (userId)
+            params.push(`userId=${userId}`);
+        if (season)
+            params.push(`season=${season}`);
+        if (cohort)
+            params.push(`cohort=${cohort}`);
+        if (params.length)
+            url += '?' + params.join('&');
+        const response = await fetch(url);
+        return JSON.stringify(await response.json());
+    }
+    catch (err) {
+        return JSON.stringify({ error: err.message });
+    }
+}
+// =============================================================================
+// EXPORT HANDLERS MAP
+// =============================================================================
+exports.manifoldHandlers = {
+    // Trading (require auth + risk checks)
+    manifold_bet: betHandler,
+    manifold_sell: sellHandler,
+    manifold_multiple_choice: multipleChoiceHandler,
+    manifold_multi_bet: multiBetHandler,
+    // Read (require auth)
+    manifold_search: searchHandler,
+    manifold_market: marketHandler,
+    manifold_balance: balanceHandler,
+    manifold_positions: positionsHandler,
+    manifold_bets: betsHandler,
+    manifold_cancel: cancelHandler,
+    manifold_get_me: getMeHandler,
+    manifold_get_user_portfolio: getUserPortfolioHandler,
+    manifold_create_market: createMarketHandler,
+    manifold_add_answer: addAnswerHandler,
+    manifold_add_liquidity: addLiquidityHandler,
+    manifold_add_bounty: addBountyHandler,
+    manifold_award_bounty: awardBountyHandler,
+    manifold_close_market: closeMarketHandler,
+    manifold_manage_topic: manageTopicHandler,
+    manifold_resolve_market: resolveMarketHandler,
+    manifold_create_comment: createCommentHandler,
+    manifold_send_mana: sendManaHandler,
+    // Public (no auth needed)
+    manifold_get_user: getUserHandler,
+    manifold_get_user_lite: getUserLiteHandler,
+    manifold_get_user_by_id: getUserByIdHandler,
+    manifold_get_user_by_id_lite: getUserByIdLiteHandler,
+    manifold_get_user_portfolio_history: getUserPortfolioHistoryHandler,
+    manifold_list_users: listUsersHandler,
+    manifold_get_groups: getGroupsHandler,
+    manifold_get_group: getGroupHandler,
+    manifold_get_group_by_id: getGroupByIdHandler,
+    manifold_list_markets: listMarketsHandler,
+    manifold_get_market_by_slug: getMarketBySlugHandler,
+    manifold_get_probability: getProbabilityHandler,
+    manifold_get_probabilities: getProbabilitiesHandler,
+    manifold_get_market_positions: getMarketPositionsHandler,
+    manifold_get_user_metrics: getUserMetricsHandler,
+    manifold_get_comments: getCommentsHandler,
+    manifold_get_transactions: getTransactionsHandler,
+    manifold_get_leagues: getLeaguesHandler,
+};
+exports.default = exports.manifoldHandlers;
+//# sourceMappingURL=manifold.js.map