@rnsk/toolkits 0.0.6 → 0.0.8

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

@@ -0,0 +1,72 @@
+export declare const growwCreateGttOrder: import("ai").Tool<{
+    duration: string;
+    trading_symbol: string;
+    quantity: number;
+    trigger_price: string;
+    exchange: string;
+    segment: string;
+    order_type: string;
+    transaction_type: string;
+    reference_id: string;
+    trigger_direction: string;
+    product_type: string;
+    growwAccessToken?: string | undefined;
+    price?: string | undefined;
+}, unknown>;
+export declare const growwCreateOcoOrder: import("ai").Tool<{
+    duration: string;
+    trading_symbol: string;
+    quantity: number;
+    exchange: string;
+    segment: string;
+    transaction_type: string;
+    reference_id: string;
+    product_type: string;
+    net_position_quantity: number;
+    target_trigger_price: string;
+    target_order_type: string;
+    stop_loss_trigger_price: string;
+    stop_loss_order_type: string;
+    growwAccessToken?: string | undefined;
+    target_price?: string | undefined;
+    stop_loss_price?: string | undefined;
+}, unknown>;
+export declare const growwModifySmartOrder: import("ai").Tool<{
+    segment: string;
+    smart_order_id: string;
+    smart_order_type: string;
+    duration?: string | undefined;
+    growwAccessToken?: string | undefined;
+    quantity?: number | undefined;
+    trigger_price?: string | undefined;
+    order_type?: string | undefined;
+    trigger_direction?: string | undefined;
+    product_type?: string | undefined;
+    target_trigger_price?: string | undefined;
+    stop_loss_trigger_price?: string | undefined;
+    order_price?: string | undefined;
+    order_transaction_type?: string | undefined;
+}, unknown>;
+export declare const growwCancelSmartOrder: import("ai").Tool<{
+    segment: string;
+    smart_order_id: string;
+    smart_order_type: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetSmartOrder: import("ai").Tool<{
+    segment: string;
+    smart_order_id: string;
+    smart_order_type: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwListSmartOrders: import("ai").Tool<{
+    status?: string | undefined;
+    page?: number | undefined;
+    page_size?: number | undefined;
+    growwAccessToken?: string | undefined;
+    segment?: string | undefined;
+    smart_order_type?: string | undefined;
+    start_date_time?: string | undefined;
+    end_date_time?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=smart-orders.d.ts.map

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

@@ -0,0 +1,200 @@
+// @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: CASH or FNO');
+export const growwCreateGttOrder = tool({
+    description: 'Create a GTT (Good Till Triggered) smart order that arms a single order when the trigger price is crossed. GTT defaults to one-year validity.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        reference_id: z.string().describe('Unique 8-20 char alphanumeric idempotency key, max two hyphens'),
+        segment: segmentField,
+        trading_symbol: z.string().describe('Trading symbol, e.g. TCS'),
+        quantity: z.number().int().positive().describe('Quantity for the post-trigger order'),
+        trigger_price: z.string().describe('Trigger price as decimal string, e.g. 3985.00'),
+        trigger_direction: z.string().describe('UP or DOWN'),
+        order_type: z.string().describe('Post-trigger order type: LIMIT or SL'),
+        price: z.string().optional().describe('Post-trigger limit price, required for LIMIT/SL'),
+        transaction_type: z.string().describe('BUY or SELL'),
+        product_type: z.string().describe('Product type, e.g. CNC'),
+        exchange: z.string().describe('Exchange: NSE or BSE'),
+        duration: z.string().describe('Validity of post-trigger order, e.g. DAY'),
+    }),
+    execute: async ({ growwAccessToken, order_type, price, transaction_type, ...rest }) => {
+        try {
+            const body = {
+                ...rest,
+                smart_order_type: 'GTT',
+                order: { order_type, ...(price ? { price } : {}), transaction_type },
+            };
+            const result = await growwRequest(growwAccessToken, '/v1/order-advance/create', { method: 'POST', body });
+            return handleGrowwResult(result, 'create GTT order');
+        }
+        catch (error) {
+            return { error: 'Error creating GTT order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwCreateOcoOrder = tool({
+    description: 'Create an OCO (One Cancels Other) smart order with target and stop-loss legs. Quantity must be <= abs(net_position_quantity).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        reference_id: z.string().describe('Unique 8-20 char alphanumeric idempotency key, max two hyphens'),
+        segment: segmentField,
+        trading_symbol: z.string().describe('Trading symbol, e.g. NIFTY25OCT24000CE'),
+        quantity: z.number().int().positive().describe('Total quantity for both legs'),
+        net_position_quantity: z.number().int().describe('Current net position in this symbol'),
+        transaction_type: z.string().describe('Direction of protection/exit: BUY or SELL'),
+        target_trigger_price: z.string().describe('Take-profit trigger price as decimal string'),
+        target_order_type: z.string().describe('Target leg order type: LIMIT or MARKET'),
+        target_price: z.string().optional().describe('Target leg limit price, required if target_order_type is LIMIT'),
+        stop_loss_trigger_price: z.string().describe('Stop-loss trigger price as decimal string'),
+        stop_loss_order_type: z.string().describe('Stop-loss leg order type: SL or SL_M'),
+        stop_loss_price: z.string().optional().describe('Stop-loss leg limit price, required if stop_loss_order_type is SL'),
+        product_type: z.string().describe('Product: MIS for CASH, NRML for FNO'),
+        exchange: z.string().describe('Exchange: NSE or BSE'),
+        duration: z.string().describe('Validity for both legs, e.g. DAY'),
+    }),
+    execute: async ({ growwAccessToken, target_trigger_price, target_order_type, target_price, stop_loss_trigger_price, stop_loss_order_type, stop_loss_price, ...rest }) => {
+        try {
+            const body = {
+                ...rest,
+                smart_order_type: 'OCO',
+                target: {
+                    trigger_price: target_trigger_price,
+                    order_type: target_order_type,
+                    ...(target_price ? { price: target_price } : {}),
+                },
+                stop_loss: {
+                    trigger_price: stop_loss_trigger_price,
+                    order_type: stop_loss_order_type,
+                    ...(stop_loss_price ? { price: stop_loss_price } : {}),
+                },
+            };
+            const result = await growwRequest(growwAccessToken, '/v1/order-advance/create', { method: 'POST', body });
+            return handleGrowwResult(result, 'create OCO order');
+        }
+        catch (error) {
+            return { error: 'Error creating OCO order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwModifySmartOrder = tool({
+    description: 'Modify an active GTT or OCO smart order. GTT allows quantity, trigger_price, trigger_direction, order type/price. OCO allows quantity, duration, product_type and both leg trigger prices. Symbol/exchange/segment/type are immutable (cancel + recreate instead).',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        smart_order_id: z.string().describe('Smart order ID, e.g. gtt_91a7f4'),
+        smart_order_type: z.string().describe('GTT or OCO'),
+        segment: segmentField,
+        quantity: z.number().int().positive().optional().describe('Updated quantity'),
+        trigger_price: z.string().optional().describe('GTT: updated trigger price as decimal string'),
+        trigger_direction: z.string().optional().describe('GTT: UP or DOWN'),
+        order_type: z.string().optional().describe('GTT: updated order type'),
+        order_price: z.string().optional().describe('GTT: updated limit price'),
+        order_transaction_type: z.string().optional().describe('GTT: transaction type (required but not modifiable)'),
+        duration: z.string().optional().describe('OCO: updated validity'),
+        product_type: z.string().optional().describe('OCO: updated product'),
+        target_trigger_price: z.string().optional().describe('OCO: updated target trigger price'),
+        stop_loss_trigger_price: z.string().optional().describe('OCO: updated stop-loss trigger price'),
+    }),
+    execute: async ({ growwAccessToken, smart_order_id, smart_order_type, segment, quantity, trigger_price, trigger_direction, order_type, order_price, order_transaction_type, duration, product_type, target_trigger_price, stop_loss_trigger_price }) => {
+        try {
+            const body = { smart_order_type, segment };
+            if (smart_order_type === 'GTT') {
+                if (quantity !== undefined)
+                    body.quantity = quantity;
+                if (trigger_price)
+                    body.trigger_price = trigger_price;
+                if (trigger_direction)
+                    body.trigger_direction = trigger_direction;
+                if (order_type || order_price || order_transaction_type) {
+                    body.order = {
+                        ...(order_type ? { order_type } : {}),
+                        ...(order_price ? { price: order_price } : {}),
+                        ...(order_transaction_type ? { transaction_type: order_transaction_type } : {}),
+                    };
+                }
+            }
+            else {
+                if (quantity !== undefined)
+                    body.quantity = quantity;
+                if (duration)
+                    body.duration = duration;
+                if (product_type)
+                    body.product_type = product_type;
+                if (target_trigger_price)
+                    body.target = { trigger_price: target_trigger_price };
+                if (stop_loss_trigger_price)
+                    body.stop_loss = { trigger_price: stop_loss_trigger_price };
+            }
+            const result = await growwRequest(growwAccessToken, `/v1/order-advance/modify/${encodeURIComponent(smart_order_id)}`, {
+                method: 'PUT',
+                body,
+            });
+            return handleGrowwResult(result, 'modify smart order');
+        }
+        catch (error) {
+            return { error: 'Error modifying smart order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwCancelSmartOrder = tool({
+    description: 'Cancel an active GTT or OCO smart order.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: segmentField,
+        smart_order_type: z.string().describe('GTT or OCO'),
+        smart_order_id: z.string().describe('Smart order ID'),
+    }),
+    execute: async ({ growwAccessToken, segment, smart_order_type, smart_order_id }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order-advance/cancel/${encodeURIComponent(segment)}/${encodeURIComponent(smart_order_type)}/${encodeURIComponent(smart_order_id)}`, { method: 'POST' });
+            return handleGrowwResult(result, 'cancel smart order');
+        }
+        catch (error) {
+            return { error: 'Error cancelling smart order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetSmartOrder = tool({
+    description: 'Get full details of a GTT or OCO smart order.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: segmentField,
+        smart_order_type: z.string().describe('GTT or OCO'),
+        smart_order_id: z.string().describe('Smart order ID'),
+    }),
+    execute: async ({ growwAccessToken, segment, smart_order_type, smart_order_id }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, `/v1/order-advance/status/${encodeURIComponent(segment)}/${encodeURIComponent(smart_order_type)}/internal/${encodeURIComponent(smart_order_id)}`);
+            return handleGrowwResult(result, 'get smart order');
+        }
+        catch (error) {
+            return { error: 'Error getting smart order', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwListSmartOrders = tool({
+    description: 'List smart orders filtered by segment, type, status and time window with pagination.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        segment: z.string().optional().describe('CASH or FNO'),
+        smart_order_type: z.string().optional().describe('GTT or OCO, default OCO'),
+        status: z.string().optional().describe('ACTIVE, CANCELLED or COMPLETED, default ACTIVE'),
+        page: z.number().int().min(0).max(500).optional().describe('Page number from 0, default 0'),
+        page_size: z.number().int().min(1).max(50).optional().describe('Records per page, default 10, max 50'),
+        start_date_time: z.string().optional().describe('Inclusive start ISO8601 YYYY-MM-DDThh:mm:ss'),
+        end_date_time: z.string().optional().describe('Inclusive end ISO8601, must be >= start, max 1-month span'),
+    }),
+    execute: async ({ growwAccessToken, ...query }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/order-advance/list', { query });
+            return handleGrowwResult(result, 'list smart orders');
+        }
+        catch (error) {
+            return { error: 'Error listing smart orders', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=smart-orders.js.map

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

@@ -0,0 +1,4 @@
+export declare const growwGetUserProfile: import("ai").Tool<{
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=user.d.ts.map

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

@@ -0,0 +1,21 @@
+// @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 growwGetUserProfile = tool({
+    description: 'Get Groww user profile including UCC, enabled exchanges (NSE/BSE), DDPI status and active segments.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+    }),
+    execute: async ({ growwAccessToken }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/user/detail');
+            return handleGrowwResult(result, 'get user profile');
+        }
+        catch (error) {
+            return { error: 'Error getting user profile', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=user.js.map

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

@@ -0,0 +1,18 @@
+export declare const GROWW_BASE = "https://api.groww.in";
+export declare const GROWW_INSTRUMENTS_URL = "https://growwapi-assets.groww.in/instruments/instrument.csv";
+export declare function buildQueryString(params: Record<string, unknown>): string;
+export declare function growwRequest(growwAccessToken: string | undefined, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: unknown;
+}>;
+export declare function handleGrowwResult(result: {
+    ok: boolean;
+    status: number;
+    data: unknown;
+}, action: string): unknown;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,52 @@
+// @ts-nocheck
+export const GROWW_BASE = 'https://api.groww.in';
+export const GROWW_INSTRUMENTS_URL = 'https://growwapi-assets.groww.in/instruments/instrument.csv';
+export function buildQueryString(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== '') {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function growwRequest(growwAccessToken, path, options) {
+    if (!growwAccessToken) {
+        return { ok: false, status: 401, data: { error: 'Missing Groww access token' } };
+    }
+    const qs = options?.query ? buildQueryString(options.query) : '';
+    const url = `${GROWW_BASE}${path.startsWith('/') ? path : `/${path}`}${qs}`;
+    const headers = {
+        Accept: 'application/json',
+        Authorization: `Bearer ${growwAccessToken}`,
+        'X-API-VERSION': '1.0',
+    };
+    if (options?.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const fetchOptions = {
+        method: options?.method ?? 'GET',
+        headers,
+    };
+    if (options?.body !== undefined) {
+        fetchOptions.body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const contentType = response.headers.get('content-type') ?? '';
+    let data = null;
+    if (contentType.includes('application/json')) {
+        data = await response.json().catch(() => null);
+    }
+    else {
+        data = await response.text().catch(() => null);
+    }
+    return { ok: response.ok, status: response.status, data };
+}
+export function handleGrowwResult(result, action) {
+    if (!result.ok) {
+        return { error: `Failed to ${action}`, details: result.data, statusCode: result.status };
+    }
+    return result.data;
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/reddit/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const REDDIT_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/reddit/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg viewBox="0 0 800 800" xmlns="http://www.w3.org/2000/svg" width="2500" height="2500"><circle cx="400" cy="400" fill="#ff4500" r="400"/><path d="M666.8 400c.08 5.48-.6 10.95-2.04 16.24s-3.62 10.36-6.48 15.04c-2.85 4.68-6.35 8.94-10.39 12.65s-8.58 6.83-13.49 9.27c.11 1.46.2 2.93.25 4.4a107.268 107.268 0 0 1 0 8.8c-.05 1.47-.14 2.94-.25 4.4 0 89.6-104.4 162.4-233.2 162.4S168 560.4 168 470.8c-.11-1.46-.2-2.93-.25-4.4a107.268 107.268 0 0 1 0-8.8c.05-1.47.14-2.94.25-4.4a58.438 58.438 0 0 1-31.85-37.28 58.41 58.41 0 0 1 7.8-48.42 58.354 58.354 0 0 1 41.93-25.4 58.4 58.4 0 0 1 46.52 15.5 286.795 286.795 0 0 1 35.89-20.71c12.45-6.02 25.32-11.14 38.51-15.3s26.67-7.35 40.32-9.56 27.45-3.42 41.28-3.63L418 169.6c.33-1.61.98-3.13 1.91-4.49.92-1.35 2.11-2.51 3.48-3.4 1.38-.89 2.92-1.5 4.54-1.8 1.61-.29 3.27-.26 4.87.09l98 19.6c9.89-16.99 30.65-24.27 48.98-17.19s28.81 26.43 24.71 45.65c-4.09 19.22-21.55 32.62-41.17 31.61-19.63-1.01-35.62-16.13-37.72-35.67L440 186l-26 124.8c13.66.29 27.29 1.57 40.77 3.82a284.358 284.358 0 0 1 77.8 24.86A284.412 284.412 0 0 1 568 360a58.345 58.345 0 0 1 29.4-15.21 58.361 58.361 0 0 1 32.95 3.21 58.384 58.384 0 0 1 25.91 20.61A58.384 58.384 0 0 1 666.8 400zm-396.96 55.31c2.02 4.85 4.96 9.26 8.68 12.97 3.71 3.72 8.12 6.66 12.97 8.68A40.049 40.049 0 0 0 306.8 480c16.18 0 30.76-9.75 36.96-24.69 6.19-14.95 2.76-32.15-8.68-43.59s-28.64-14.87-43.59-8.68c-14.94 6.2-24.69 20.78-24.69 36.96 0 5.25 1.03 10.45 3.04 15.31zm229.1 96.02c2.05-2 3.22-4.73 3.26-7.59.04-2.87-1.07-5.63-3.07-7.68s-4.73-3.22-7.59-3.26c-2.87-.04-5.63 1.07-7.94 2.8a131.06 131.06 0 0 1-19.04 11.35 131.53 131.53 0 0 1-20.68 7.99c-7.1 2.07-14.37 3.54-21.72 4.39-7.36.85-14.77 1.07-22.16.67-7.38.33-14.78.03-22.11-.89a129.01 129.01 0 0 1-21.64-4.6c-7.08-2.14-13.95-4.88-20.56-8.18s-12.93-7.16-18.89-11.53c-2.07-1.7-4.7-2.57-7.38-2.44s-5.21 1.26-7.11 3.15c-1.89 1.9-3.02 4.43-3.15 7.11s.74 5.31 2.44 7.38c7.03 5.3 14.5 9.98 22.33 14s16 7.35 24.4 9.97 17.01 4.51 25.74 5.66c8.73 1.14 17.54 1.53 26.33 1.17 8.79.36 17.6-.03 26.33-1.17A153.961 153.961 0 0 0 476.87 564c7.83-4.02 15.3-8.7 22.33-14zm-7.34-68.13c5.42.06 10.8-.99 15.81-3.07 5.01-2.09 9.54-5.17 13.32-9.06s6.72-8.51 8.66-13.58A39.882 39.882 0 0 0 532 441.6c0-16.18-9.75-30.76-24.69-36.96-14.95-6.19-32.15-2.76-43.59 8.68s-14.87 28.64-8.68 43.59c6.2 14.94 20.78 24.69 36.96 24.69z" fill="#fff"/></svg>`;
+export const REDDIT_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/reddit/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/reddit/manifest.js

@@ -0,0 +1,55 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { REDDIT_ICON } from './icon.js';
+import { redditTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'reddit',
+    displayName: 'Reddit',
+    shortDescription: 'Posts, comments, subreddits, users, and search.',
+    category: 'Marketing & Social Media',
+    icon: REDDIT_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'redditToken',
+        provider: {
+            slug: 'reddit',
+            env: { clientId: 'REDDIT_CLIENT_ID', clientSecret: 'REDDIT_CLIENT_SECRET' },
+            authorizeUrl: 'https://www.reddit.com/api/v1/authorize',
+            tokenUrl: 'https://www.reddit.com/api/v1/access_token',
+            scopes: [
+                'identity',
+                'read',
+                'submit',
+                'edit',
+                'flair',
+                'privatemessages',
+                'mysubreddits',
+                'subscribe',
+                'vote',
+                'save',
+                'history',
+            ],
+            scopeSeparator: ' ',
+            exchangeStyle: 'basic',
+            extraAuthParams: { duration: 'permanent' },
+            connectDescription: 'Connect Reddit to read posts and comments, publish content, and manage subreddits.',
+            callbackPath: '/api/auth/reddit/callback',
+            stateCookie: 'reddit_oauth_state',
+        },
+    },
+    allowedHosts: ['oauth.reddit.com', 'www.reddit.com'],
+    tools: redditTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.8',
+        homepage: 'https://www.reddit.com',
+        docsUrl: 'https://www.reddit.com/dev/api/',
+        apiDocsUrl: 'https://www.reddit.com/dev/api/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/reddit/tools/check-username-available.d.ts

@@ -0,0 +1,29 @@
+export declare const redditCheckUsernameAvailable: import("ai").Tool<{
+    username: string;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    username?: undefined;
+    available?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    username: string;
+    available: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    username?: undefined;
+    available?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    username?: undefined;
+    available?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=check-username-available.d.ts.map

package/dist/toolkits/reddit/tools/check-username-available.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditCheckUsernameAvailable = tool({
+    description: 'Check whether a username is available for registration on Reddit. Use before suggesting a new account name.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        username: z.string().describe('Username to check (3-20 characters)'),
+    }),
+    execute: async ({ redditToken, username }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            const available = await redditGet(redditToken, '/api/username_available', { user: username });
+            return { username, available: available === true };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to check username availability', details: error.details };
+            }
+            return {
+                error: 'Error checking username availability',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=check-username-available.js.map

package/dist/toolkits/reddit/tools/client.d.ts

@@ -0,0 +1,10 @@
+export declare class RedditApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+export declare function redditGet(redditToken: string, path: string, query?: Record<string, string | number | boolean | undefined>): Promise<any>;
+export declare function redditPost(redditToken: string, path: string, form: Record<string, string | number | boolean | undefined>): Promise<any>;
+/** Surface Reddit's 200-with-errors convention (`{ json: { errors: [...] } }`). */
+export declare function throwIfJsonErrors(data: any, label: string): void;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/reddit/tools/client.js

@@ -0,0 +1,75 @@
+// @ts-nocheck
+const BASE_URL = 'https://oauth.reddit.com';
+const USER_AGENT = 'web:rnsk-toolkits:0.0.8 (by /u/runstack)';
+export class RedditApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+function authHeaders(redditToken) {
+    return {
+        Authorization: `Bearer ${redditToken}`,
+        'User-Agent': USER_AGENT,
+    };
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+async function parseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+export async function redditGet(redditToken, path, query) {
+    const url = new URL(path, BASE_URL);
+    appendQuery(url, query);
+    const response = await fetch(url.toString(), { headers: authHeaders(redditToken) });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new RedditApiError('Reddit API request failed', response.status, data);
+    }
+    return data;
+}
+export async function redditPost(redditToken, path, form) {
+    const body = new URLSearchParams();
+    body.set('api_type', 'json');
+    for (const [key, value] of Object.entries(form)) {
+        if (value === undefined)
+            continue;
+        body.set(key, String(value));
+    }
+    const response = await fetch(new URL(path, BASE_URL).toString(), {
+        method: 'POST',
+        headers: { ...authHeaders(redditToken), 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new RedditApiError('Reddit API request failed', response.status, data);
+    }
+    return data;
+}
+/** Surface Reddit's 200-with-errors convention (`{ json: { errors: [...] } }`). */
+export function throwIfJsonErrors(data, label) {
+    const errors = data?.json?.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+        throw new RedditApiError(`${label} rejected by Reddit`, 422, { errors });
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/reddit/tools/create-post.d.ts

@@ -0,0 +1,10 @@
+export declare const redditCreatePost: import("ai").Tool<{
+    title: string;
+    subreddit: string;
+    url?: string | undefined;
+    text?: string | undefined;
+    kind?: "link" | "self" | undefined;
+    redditToken?: string | undefined;
+    flairId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-post.d.ts.map