@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/groww/tools/instruments.js

@@ -0,0 +1,120 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GROWW_INSTRUMENTS_URL } from './utils.js';
+const INSTRUMENT_COLUMNS = [
+    'exchange',
+    'exchange_token',
+    'trading_symbol',
+    'groww_symbol',
+    'name',
+    'instrument_type',
+    'segment',
+    'series',
+    'isin',
+    'underlying_symbol',
+    'underlying_exchange_token',
+    'lot_size',
+    'expiry_date',
+    'strike_price',
+    'tick_size',
+    'freeze_quantity',
+    'is_reserved',
+    'buy_allowed',
+    'sell_allowed',
+];
+function parseCsvLine(line) {
+    const out = [];
+    let cur = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                cur += '"';
+                i++;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if (ch === ',' && !inQuotes) {
+            out.push(cur);
+            cur = '';
+        }
+        else {
+            cur += ch;
+        }
+    }
+    out.push(cur);
+    return out.map((v) => v.trim());
+}
+export const growwSearchInstruments = tool({
+    description: 'Search the Groww instruments master (no auth needed). Downloads the official CSV and filters by exchange, segment, symbol text, underlying or instrument type. Use it to resolve trading_symbol (for orders) and groww_symbol (for backtesting).',
+    inputSchema: z.object({
+        exchange: z.string().optional().describe('Filter by exchange: NSE or BSE'),
+        segment: z.string().optional().describe('Filter by segment: CASH or FNO'),
+        trading_symbol: z.string().optional().describe('Substring match on trading_symbol, e.g. RELIANCE'),
+        groww_symbol: z.string().optional().describe('Substring match on groww_symbol, e.g. NSE-NIFTY'),
+        underlying_symbol: z.string().optional().describe('Exact match on underlying symbol, e.g. NIFTY'),
+        instrument_type: z.string().optional().describe('CE, PE, FUT, EQ, etc.'),
+        limit: z.number().int().min(1).max(200).optional().describe('Max rows to return, default 50, max 200'),
+        offset: z.number().int().min(0).optional().describe('Rows to skip, default 0'),
+    }),
+    execute: async ({ exchange, segment, trading_symbol, groww_symbol, underlying_symbol, instrument_type, limit = 50, offset = 0 }) => {
+        try {
+            const response = await fetch(GROWW_INSTRUMENTS_URL);
+            if (!response.ok) {
+                return { error: 'Failed to download instruments CSV', statusCode: response.status };
+            }
+            const text = await response.text();
+            const lines = text.split('\n').filter((l) => l.trim().length > 0);
+            if (lines.length === 0)
+                return { error: 'Empty instruments CSV' };
+            const header = parseCsvLine(lines[0]).map((h) => h.trim().toLowerCase());
+            const idx = {};
+            header.forEach((h, i) => {
+                idx[h] = i;
+            });
+            const matches = [];
+            let scanned = 0;
+            for (let i = 1; i < lines.length; i++) {
+                const cols = parseCsvLine(lines[i]);
+                const get = (name) => (idx[name] !== undefined ? (cols[idx[name]] ?? '') : '');
+                if (exchange && get('exchange').toUpperCase() !== exchange.toUpperCase())
+                    continue;
+                if (segment && get('segment').toUpperCase() !== segment.toUpperCase())
+                    continue;
+                if (trading_symbol && !get('trading_symbol').toUpperCase().includes(trading_symbol.toUpperCase()))
+                    continue;
+                if (groww_symbol && !get('groww_symbol').toUpperCase().includes(groww_symbol.toUpperCase()))
+                    continue;
+                if (underlying_symbol && get('underlying_symbol').toUpperCase() !== underlying_symbol.toUpperCase())
+                    continue;
+                if (instrument_type && get('instrument_type').toUpperCase() !== instrument_type.toUpperCase())
+                    continue;
+                scanned++;
+                if (scanned <= offset)
+                    continue;
+                const row = {};
+                for (const col of INSTRUMENT_COLUMNS)
+                    row[col] = get(col);
+                matches.push(row);
+                if (matches.length >= limit)
+                    break;
+            }
+            return {
+                source: GROWW_INSTRUMENTS_URL,
+                columns: INSTRUMENT_COLUMNS,
+                returned: matches.length,
+                offset,
+                instruments: matches,
+                note: 'Full CSV is large; results are filtered server-side in this tool. Narrow filters for precise symbol resolution.',
+            };
+        }
+        catch (error) {
+            return { error: 'Error searching instruments', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=instruments.js.map

package/dist/toolkits/groww/tools/live-data.d.ts

@@ -0,0 +1,30 @@
+export declare const growwGetQuote: import("ai").Tool<{
+    trading_symbol: string;
+    exchange: string;
+    segment: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetLtp: import("ai").Tool<{
+    segment: string;
+    exchange_symbols: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetOhlc: import("ai").Tool<{
+    segment: string;
+    exchange_symbols: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetOptionChain: import("ai").Tool<{
+    exchange: string;
+    underlying: string;
+    expiry_date: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetGreeks: import("ai").Tool<{
+    trading_symbol: string;
+    exchange: string;
+    underlying: string;
+    expiry: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=live-data.d.ts.map

package/dist/toolkits/groww/tools/live-data.js

@@ -0,0 +1,101 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { growwRequest, handleGrowwResult } from './utils.js';
+const tokenField = z.string().optional().describe('Groww API access token (injected by system)');
+export const growwGetQuote = tool({
+    description: 'Get full live snapshot for an instrument: last price, market depth, OHLC, volumes, OI, circuits, 52-week high/low.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        segment: z.string().describe('CASH for stocks/indices, FNO for derivatives'),
+        trading_symbol: z.string().describe('Trading symbol, e.g. NIFTY, RELIANCE'),
+    }),
+    execute: async ({ growwAccessToken, exchange, segment, trading_symbol }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/live-data/quote', {
+                query: { exchange, segment, trading_symbol },
+            });
+            return handleGrowwResult(result, 'get quote');
+        }
+        catch (error) {
+            return { error: 'Error getting quote', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetLtp = tool({
+    description: 'Get last traded price for up to 50 instruments. exchange_symbols is a comma-separated list like NSE_RELIANCE,BSE_SENSEX.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().describe('CASH or FNO'),
+        exchange_symbols: z.string().describe('Comma-separated EXCHANGE_SYMBOL list, e.g. NSE_RELIANCE,BSE_SENSEX (max 50)'),
+    }),
+    execute: async ({ growwAccessToken, segment, exchange_symbols }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/live-data/ltp', {
+                query: { segment, exchange_symbols },
+            });
+            return handleGrowwResult(result, 'get LTP');
+        }
+        catch (error) {
+            return { error: 'Error getting LTP', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetOhlc = tool({
+    description: 'Get real-time OHLC snapshot (not interval candles) for up to 50 instruments.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().describe('CASH or FNO'),
+        exchange_symbols: z.string().describe('Comma-separated EXCHANGE_SYMBOL list, e.g. NSE_RELIANCE,BSE_SENSEX (max 50)'),
+    }),
+    execute: async ({ growwAccessToken, segment, exchange_symbols }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/live-data/ohlc', {
+                query: { segment, exchange_symbols },
+            });
+            return handleGrowwResult(result, 'get OHLC');
+        }
+        catch (error) {
+            return { error: 'Error getting OHLC', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetOptionChain = tool({
+    description: 'Get full FNO option chain with Greeks, LTP, OI and volume for an underlying and expiry.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        underlying: z.string().describe('Underlying symbol, e.g. NIFTY, BANKNIFTY'),
+        expiry_date: z.string().describe('Expiry date in YYYY-MM-DD format'),
+    }),
+    execute: async ({ growwAccessToken, exchange, underlying, expiry_date }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/option-chain/exchange/${encodeURIComponent(exchange)}/underlying/${encodeURIComponent(underlying)}`, { query: { expiry_date } });
+            return handleGrowwResult(result, 'get option chain');
+        }
+        catch (error) {
+            return { error: 'Error getting option chain', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetGreeks = tool({
+    description: 'Get Greeks (delta, gamma, theta, vega, rho, IV) for a single FNO contract.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        underlying: z.string().describe('Underlying symbol, e.g. NIFTY'),
+        trading_symbol: z.string().describe('FNO trading symbol, e.g. NIFTY25O1425100CE'),
+        expiry: z.string().describe('Expiry date in YYYY-MM-DD format'),
+    }),
+    execute: async ({ growwAccessToken, exchange, underlying, trading_symbol, expiry }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/live-data/greeks/exchange/${encodeURIComponent(exchange)}/underlying/${encodeURIComponent(underlying)}/trading_symbol/${encodeURIComponent(trading_symbol)}/expiry/${encodeURIComponent(expiry)}`);
+            return handleGrowwResult(result, 'get greeks');
+        }
+        catch (error) {
+            return { error: 'Error getting greeks', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=live-data.js.map

package/dist/toolkits/groww/tools/margin.d.ts

@@ -0,0 +1,18 @@
+export declare const growwGetUserMargin: import("ai").Tool<{
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetRequiredMargin: import("ai").Tool<{
+    segment: string;
+    orders: {
+        product: string;
+        trading_symbol: string;
+        quantity: number;
+        exchange: string;
+        segment: string;
+        order_type: string;
+        transaction_type: string;
+        price?: number | undefined;
+    }[];
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=margin.d.ts.map

package/dist/toolkits/groww/tools/margin.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { growwRequest, handleGrowwResult } from './utils.js';
+const tokenField = z.string().optional().describe('Groww API access token (injected by system)');
+export const growwGetUserMargin = tool({
+    description: 'Get available user margin details (clear cash, margin used, collateral, FNO and equity breakdown). All prices in rupees.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+    }),
+    execute: async ({ growwAccessToken }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/margins/detail/user');
+            return handleGrowwResult(result, 'get user margin');
+        }
+        catch (error) {
+            return { error: 'Error getting user margin', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+const marginOrderSchema = z.object({
+    trading_symbol: z.string().describe('Trading symbol as defined by the exchange'),
+    quantity: z.number().int().positive().describe('Order quantity'),
+    price: z.number().optional().describe('Limit price in rupees (include for limit orders)'),
+    exchange: z.string().describe('NSE or BSE'),
+    segment: z.string().describe('CASH or FNO'),
+    product: z.string().describe('CNC, MIS or NRML'),
+    order_type: z.string().describe('MARKET, LIMIT, SL or SL_M'),
+    transaction_type: z.string().describe('BUY or SELL'),
+});
+export const growwGetRequiredMargin = tool({
+    description: 'Calculate required margin for a single order or a basket of orders (basket supported for FNO). All prices in rupees.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().describe('CASH or FNO (query param; basket orders supported for FNO)'),
+        orders: z.array(marginOrderSchema).min(1).describe('One or more orders to calculate margin for'),
+    }),
+    execute: async ({ growwAccessToken, segment, orders }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/margins/detail/orders', {
+                method: 'POST',
+                query: { segment },
+                body: orders,
+            });
+            return handleGrowwResult(result, 'calculate required margin');
+        }
+        catch (error) {
+            return { error: 'Error calculating margin', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=margin.js.map

package/dist/toolkits/groww/tools/orders.d.ts

@@ -0,0 +1,57 @@
+export declare const growwPlaceOrder: import("ai").Tool<{
+    product: string;
+    validity: string;
+    trading_symbol: string;
+    quantity: number;
+    exchange: string;
+    segment: string;
+    order_type: string;
+    transaction_type: string;
+    order_reference_id: string;
+    growwAccessToken?: string | undefined;
+    price?: number | undefined;
+    trigger_price?: number | undefined;
+}, unknown>;
+export declare const growwModifyOrder: import("ai").Tool<{
+    segment: string;
+    order_type: string;
+    groww_order_id: string;
+    growwAccessToken?: string | undefined;
+    quantity?: number | undefined;
+    price?: number | undefined;
+    trigger_price?: number | undefined;
+}, unknown>;
+export declare const growwCancelOrder: import("ai").Tool<{
+    segment: string;
+    groww_order_id: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetTradesForOrder: import("ai").Tool<{
+    segment: string;
+    groww_order_id: string;
+    page?: number | undefined;
+    page_size?: number | undefined;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetOrderStatus: import("ai").Tool<{
+    segment: string;
+    groww_order_id: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetOrderStatusByReferenceId: import("ai").Tool<{
+    segment: string;
+    order_reference_id: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwListOrders: import("ai").Tool<{
+    page?: number | undefined;
+    page_size?: number | undefined;
+    growwAccessToken?: string | undefined;
+    segment?: string | undefined;
+}, unknown>;
+export declare const growwGetOrderDetail: import("ai").Tool<{
+    segment: string;
+    groww_order_id: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=orders.d.ts.map

package/dist/toolkits/groww/tools/orders.js

@@ -0,0 +1,170 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { growwRequest, handleGrowwResult } from './utils.js';
+const tokenField = z.string().optional().describe('Groww API access token (injected by system)');
+const segmentField = z.string().describe('Segment of the instrument: CASH or FNO');
+export const growwPlaceOrder = tool({
+    description: 'Place a new equity or F&O order on Groww. Requires trading_symbol, quantity, validity, exchange, segment, product, order_type, transaction_type and a unique order_reference_id (8-20 alphanumerics, max 2 hyphens).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        trading_symbol: z.string().describe('Trading symbol as defined by the exchange, e.g. WIPRO, RELIANCE'),
+        quantity: z.number().int().positive().describe('Order quantity'),
+        price: z.number().optional().describe('Limit price in rupees (required for LIMIT/SL orders)'),
+        trigger_price: z.number().optional().describe('Trigger price in rupees (required for SL/SL_M orders)'),
+        validity: z.string().describe('Order validity, e.g. DAY, IOC'),
+        exchange: z.string().describe('Stock exchange: NSE or BSE'),
+        segment: segmentField,
+        product: z.string().describe('Product type: CNC, MIS or NRML'),
+        order_type: z.string().describe('Order type: MARKET, LIMIT, SL or SL_M'),
+        transaction_type: z.string().describe('BUY or SELL'),
+        order_reference_id: z.string().describe('User-provided 8-20 char alphanumeric idempotency key with at most two hyphens'),
+    }),
+    execute: async ({ growwAccessToken, ...body }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/order/create', { method: 'POST', body });
+            return handleGrowwResult(result, 'place order');
+        }
+        catch (error) {
+            return { error: 'Error placing order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwModifyOrder = tool({
+    description: 'Modify a pending/open Groww order (quantity, price, trigger_price, order_type).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        groww_order_id: z.string().describe('Groww order ID to modify'),
+        segment: segmentField,
+        order_type: z.string().describe('Order type: MARKET, LIMIT, SL or SL_M'),
+        quantity: z.number().int().positive().optional().describe('Updated quantity'),
+        price: z.number().optional().describe('Updated limit price in rupees'),
+        trigger_price: z.number().optional().describe('Updated trigger price in rupees'),
+    }),
+    execute: async ({ growwAccessToken, ...body }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/order/modify', { method: 'POST', body });
+            return handleGrowwResult(result, 'modify order');
+        }
+        catch (error) {
+            return { error: 'Error modifying order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwCancelOrder = tool({
+    description: 'Cancel a pending/open Groww order.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        groww_order_id: z.string().describe('Groww order ID to cancel'),
+        segment: segmentField,
+    }),
+    execute: async ({ growwAccessToken, groww_order_id, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/order/cancel', {
+                method: 'POST',
+                body: { groww_order_id, segment },
+            });
+            return handleGrowwResult(result, 'cancel order');
+        }
+        catch (error) {
+            return { error: 'Error cancelling order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetTradesForOrder = tool({
+    description: 'Get all trades (fills) assigned to a Groww order ID. One order may have multiple fills.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        groww_order_id: z.string().describe('Groww order ID'),
+        segment: segmentField,
+        page: z.number().int().min(0).optional().describe('Page number, default 0'),
+        page_size: z.number().int().min(1).max(50).optional().describe('Page size, max 50'),
+    }),
+    execute: async ({ growwAccessToken, groww_order_id, segment, page, page_size }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order/trades/${encodeURIComponent(groww_order_id)}`, {
+                query: { segment, page, page_size },
+            });
+            return handleGrowwResult(result, 'get trades for order');
+        }
+        catch (error) {
+            return { error: 'Error getting trades', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetOrderStatus = tool({
+    description: 'Check status of a Groww order using its groww_order_id.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        groww_order_id: z.string().describe('Groww order ID'),
+        segment: segmentField,
+    }),
+    execute: async ({ growwAccessToken, groww_order_id, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order/status/${encodeURIComponent(groww_order_id)}`, {
+                query: { segment },
+            });
+            return handleGrowwResult(result, 'get order status');
+        }
+        catch (error) {
+            return { error: 'Error getting order status', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetOrderStatusByReferenceId = tool({
+    description: 'Check status of a Groww order using your own order_reference_id.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        order_reference_id: z.string().describe('User-provided order reference ID'),
+        segment: segmentField,
+    }),
+    execute: async ({ growwAccessToken, order_reference_id, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order/status/reference/${encodeURIComponent(order_reference_id)}`, { query: { segment } });
+            return handleGrowwResult(result, 'get order status by reference ID');
+        }
+        catch (error) {
+            return { error: 'Error getting order status', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwListOrders = tool({
+    description: 'List today\u2019s Groww orders (open, pending and executed) with pagination.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().optional().describe('Filter by segment: CASH or FNO'),
+        page: z.number().int().min(0).optional().describe('Page number, default 0'),
+        page_size: z.number().int().min(1).max(100).optional().describe('Page size, max 100'),
+    }),
+    execute: async ({ growwAccessToken, segment, page, page_size }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/order/list', {
+                query: { segment, page, page_size },
+            });
+            return handleGrowwResult(result, 'list orders');
+        }
+        catch (error) {
+            return { error: 'Error listing orders', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetOrderDetail = tool({
+    description: 'Get full details of a Groww order using its groww_order_id.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        groww_order_id: z.string().describe('Groww order ID'),
+        segment: segmentField,
+    }),
+    execute: async ({ growwAccessToken, groww_order_id, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order/detail/${encodeURIComponent(groww_order_id)}`, {
+                query: { segment },
+            });
+            return handleGrowwResult(result, 'get order detail');
+        }
+        catch (error) {
+            return { error: 'Error getting order detail', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=orders.js.map

package/dist/toolkits/groww/tools/portfolio.d.ts

@@ -0,0 +1,13 @@
+export declare const growwGetHoldings: import("ai").Tool<{
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetPositions: import("ai").Tool<{
+    growwAccessToken?: string | undefined;
+    segment?: string | undefined;
+}, unknown>;
+export declare const growwGetPositionForSymbol: import("ai").Tool<{
+    trading_symbol: string;
+    growwAccessToken?: string | undefined;
+    segment?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=portfolio.d.ts.map

package/dist/toolkits/groww/tools/portfolio.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { growwRequest, handleGrowwResult } from './utils.js';
+const tokenField = z.string().optional().describe('Groww API access token (injected by system)');
+export const growwGetHoldings = tool({
+    description: 'Get current DEMAT stock holdings (ISIN, trading symbol, quantity, average price, pledge/locked quantities).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+    }),
+    execute: async ({ growwAccessToken }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/holdings/user');
+            return handleGrowwResult(result, 'get holdings');
+        }
+        catch (error) {
+            return { error: 'Error getting holdings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetPositions = tool({
+    description: 'Get all user positions (credit/debit quantities and prices, carry-forward, net quantity, realised P&L).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().optional().describe('Filter by segment: CASH or FNO'),
+    }),
+    execute: async ({ growwAccessToken, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/positions/user', {
+                query: { segment },
+            });
+            return handleGrowwResult(result, 'get positions');
+        }
+        catch (error) {
+            return { error: 'Error getting positions', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetPositionForSymbol = tool({
+    description: 'Get user position for a particular trading symbol.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        trading_symbol: z.string().describe('Trading symbol, e.g. RELIANCE'),
+        segment: z.string().optional().describe('CASH or FNO'),
+    }),
+    execute: async ({ growwAccessToken, trading_symbol, segment }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/positions/trading-symbol', {
+                query: { trading_symbol, segment },
+            });
+            return handleGrowwResult(result, 'get position for symbol');
+        }
+        catch (error) {
+            return { error: 'Error getting position', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=portfolio.js.map