@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,99 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { paginationFields, razorpayCredentialsField, razorpayRequest, timeRangeFields, toSnakeCase } from './client.js';
+const notesField = z.record(z.string()).optional().describe('Custom metadata (max 15 pairs)');
+export const createOrder = tool({
+    description: 'Creates an order before collecting payment (amount in subunits: paise for INR, so ₹500 = 50000). Optional receipt for tracking and partial-payment flag.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        amount: z.number().int().min(100).describe('Amount in currency subunits (min 100)'),
+        currency: z.string().regex(/^[A-Z]{3}$/).describe("ISO code uppercase, e.g. 'INR'"),
+        receipt: z.string().max(40).optional().describe('Internal receipt reference (max 40 chars)'),
+        notes: notesField,
+        partialPayment: z.boolean().optional().describe('Allow partial payments (default false)'),
+    }),
+    execute: async ({ razorpayCredentials, ...body }) => razorpayRequest(razorpayCredentials, '/orders', { method: 'POST', body: toSnakeCase(body) }, 'create order'),
+});
+export const fetchOrders = tool({
+    description: 'Lists orders (newest first) with receipt/authorization/time filters and skip/count pagination.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        receipt: z.string().optional().describe('Filter by receipt reference'),
+        authorized: z.number().int().optional().describe('1 = authorized, 0 = unauthorized'),
+        fromTimestamp: z.number().int().min(0).optional().describe('Orders created after this Unix time'),
+        toTimestamp: z.number().int().min(0).optional().describe('Orders created before this Unix time'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, fromTimestamp, toTimestamp, ...rest }) => razorpayRequest(razorpayCredentials, '/orders', { query: { from: fromTimestamp, to: toTimestamp, ...rest } }, 'fetch orders'),
+});
+export const fetchOrderById = tool({
+    description: 'Reads one order (status, amounts, attempts). Use to verify payment state before fulfillment.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        orderId: z.string().describe("Order ID, e.g. 'order_SMoQNyHKUeQomP'"),
+    }),
+    execute: async ({ razorpayCredentials, orderId }) => razorpayRequest(razorpayCredentials, `/orders/${orderId}`, undefined, 'fetch order'),
+});
+export const updateOrder = tool({
+    description: 'Updates order metadata notes. Only the notes field is mutable on orders.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        orderId: z.string().describe('Order ID to update'),
+        notes: z.record(z.string()).optional().describe('Replacement metadata notes'),
+    }),
+    execute: async ({ razorpayCredentials, orderId, notes }) => razorpayRequest(razorpayCredentials, `/orders/${orderId}`, { method: 'PATCH', body: { notes } }, 'update order'),
+});
+export const fetchPaymentsByOrder = tool({
+    description: 'Lists all payment attempts for one order (methods, statuses, errors). Use to reconcile order payments.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        orderId: z.string().describe('Order ID to list payments for'),
+    }),
+    execute: async ({ razorpayCredentials, orderId }) => razorpayRequest(razorpayCredentials, `/orders/${orderId}/payments`, undefined, 'fetch payments by order'),
+});
+export const fetchAllPayments = tool({
+    description: 'Lists payments (newest first) with time filters and pagination. Use for audits and payment-history analysis.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        ...timeRangeFields,
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, ...query }) => razorpayRequest(razorpayCredentials, '/payments', { query }, 'fetch payments'),
+});
+export const fetchAllRefundsForPayment = tool({
+    description: 'Lists refunds for one payment (status, history). Use to check refund state for a payment.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        paymentId: z.string().describe("Payment ID, e.g. 'pay_29QQoUBi66xm2f'"),
+        fromTimestamp: z.number().int().optional().describe('Refunds created on/after this Unix time'),
+        toTimestamp: z.number().int().optional().describe('Refunds created on/before this Unix time'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, paymentId, fromTimestamp, toTimestamp, ...rest }) => razorpayRequest(razorpayCredentials, `/payments/${paymentId}/refunds`, { query: { from: fromTimestamp, to: toTimestamp, ...rest } }, 'fetch refunds for payment'),
+});
+export const fetchRefunds = tool({
+    description: 'Lists all refunds with time filters and pagination. Use for refund tracking and history analysis.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        fromTimestamp: z.number().int().optional().describe('Refunds created on/after this Unix time'),
+        toTimestamp: z.number().int().optional().describe('Refunds created on/before this Unix time'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, fromTimestamp, toTimestamp, ...rest }) => razorpayRequest(razorpayCredentials, '/refunds', { query: { from: fromTimestamp, to: toTimestamp, ...rest } }, 'fetch refunds'),
+});
+export const listDisputes = tool({
+    description: 'Lists chargebacks/fraud disputes (open, under_review, won, lost, closed) with date filters and pagination.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        ...timeRangeFields,
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, ...query }) => razorpayRequest(razorpayCredentials, '/disputes', { query }, 'list disputes'),
+});
+export const listPaymentDowntimes = tool({
+    description: 'Lists active payment-method downtimes (method, severity, window, instrument). Use to check gateway health before debugging failures.',
+    inputSchema: z.object({ razorpayCredentials: razorpayCredentialsField }),
+    execute: async ({ razorpayCredentials }) => razorpayRequest(razorpayCredentials, '/payments/downtimes', undefined, 'list payment downtimes'),
+});
+//# sourceMappingURL=orders.js.map

package/dist/toolkits/razorpay/tools/payouts.d.ts

@@ -0,0 +1,58 @@
+export declare const createContact: import("ai").Tool<{
+    type: "vendor" | "customer" | "employee";
+    name: string;
+    email?: string | undefined;
+    notes?: Record<string, string> | undefined;
+    razorpayCredentials?: string | undefined;
+    contact?: string | undefined;
+    referenceId?: string | undefined;
+}, any>;
+export declare const getContact: import("ai").Tool<{
+    contactId: string;
+    razorpayCredentials?: string | undefined;
+}, any>;
+export declare const updateContact: import("ai").Tool<{
+    contactId: string;
+    type?: "vendor" | "customer" | "employee" | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    notes?: Record<string, string> | undefined;
+    razorpayCredentials?: string | undefined;
+    contact?: string | undefined;
+    referenceId?: string | undefined;
+}, any>;
+export declare const getFundAccount: import("ai").Tool<{
+    fundAccountId: string;
+    razorpayCredentials?: string | undefined;
+}, any>;
+export declare const listFundAccounts: import("ai").Tool<{
+    count?: number | undefined;
+    razorpayCredentials?: string | undefined;
+    skip?: number | undefined;
+    contactId?: string | undefined;
+    accountType?: string | undefined;
+}, any>;
+export declare const listFundValidations: import("ai").Tool<{
+    count?: number | undefined;
+    from?: number | undefined;
+    to?: number | undefined;
+    razorpayCredentials?: string | undefined;
+    skip?: number | undefined;
+}, any>;
+export declare const getTransferReversals: import("ai").Tool<{
+    transferId: string;
+    count?: number | undefined;
+    razorpayCredentials?: string | undefined;
+    fromTimestamp?: number | undefined;
+    toTimestamp?: number | undefined;
+    skip?: number | undefined;
+}, any>;
+export declare const getSettlementRecon: import("ai").Tool<{
+    year: number;
+    month: number;
+    count?: number | undefined;
+    razorpayCredentials?: string | undefined;
+    skip?: number | undefined;
+    day?: number | undefined;
+}, any>;
+//# sourceMappingURL=payouts.d.ts.map

package/dist/toolkits/razorpay/tools/payouts.js

@@ -0,0 +1,91 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { paginationFields, razorpayCredentialsField, razorpayRequest } from './client.js';
+const contactType = z.enum(['employee', 'vendor', 'customer']);
+export const createContact = tool({
+    description: 'Adds a RazorpayX payout contact (employee, vendor, or customer). Returns cont_... ID for payouts.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        name: z.string().describe("Contact name, e.g. 'Gaurav Kumar'"),
+        type: contactType,
+        email: z.string().optional(),
+        contact: z.string().optional().describe('Phone number'),
+        referenceId: z.string().optional().describe('Your-system reference ID'),
+        notes: z.record(z.string()).optional(),
+    }),
+    execute: async ({ razorpayCredentials, referenceId, ...body }) => razorpayRequest(razorpayCredentials, '/contacts', { method: 'POST', body: { reference_id: referenceId, ...body } }, 'create contact'),
+});
+export const getContact = tool({
+    description: 'Reads one payout contact (details, type, metadata).',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        contactId: z.string().regex(/^cont_[a-zA-Z0-9]+$/).describe("Contact ID, e.g. 'cont_SMoUIhAssfaDoy'"),
+    }),
+    execute: async ({ razorpayCredentials, contactId }) => razorpayRequest(razorpayCredentials, `/contacts/${contactId}`, undefined, 'get contact'),
+});
+export const updateContact = tool({
+    description: 'Updates contact name/email/phone/type/reference/notes. Only provided fields change.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        contactId: z.string().describe('Contact ID to update'),
+        name: z.string().optional(),
+        type: contactType.optional(),
+        email: z.string().optional(),
+        contact: z.string().optional().describe('Phone number'),
+        referenceId: z.string().optional(),
+        notes: z.record(z.string()).optional(),
+    }),
+    execute: async ({ razorpayCredentials, contactId, referenceId, ...body }) => razorpayRequest(razorpayCredentials, `/contacts/${contactId}`, { method: 'PATCH', body: { reference_id: referenceId, ...body } }, 'update contact'),
+});
+export const getFundAccount = tool({
+    description: 'Reads one payout destination (bank_account/vpa/card details + linked contact).',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        fundAccountId: z.string().regex(/^fa_[a-zA-Z0-9]+$/).describe("Fund account ID, e.g. 'fa_SMoVEssDpymuR8'"),
+    }),
+    execute: async ({ razorpayCredentials, fundAccountId }) => razorpayRequest(razorpayCredentials, `/fund_accounts/${fundAccountId}`, undefined, 'get fund account'),
+});
+export const listFundAccounts = tool({
+    description: 'Lists payout destinations with contact/type filters and pagination.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        contactId: z.string().optional().describe('Filter by contact (cont_...)'),
+        accountType: z.string().optional().describe("Filter: 'bank_account', 'vpa', 'card', 'wallet'"),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, contactId, accountType, ...query }) => razorpayRequest(razorpayCredentials, '/fund_accounts', { query: { contact_id: contactId, account_type: accountType, ...query } }, 'list fund accounts'),
+});
+export const listFundValidations = tool({
+    description: 'Lists bank-account validation transactions (status, registered name) with date filters and pagination.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        from: z.number().int().optional().describe('Validations created on/after this Unix time'),
+        to: z.number().int().optional().describe('Validations created on/before this Unix time'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, ...query }) => razorpayRequest(razorpayCredentials, '/fund_accounts/validations', { query }, 'list fund validations'),
+});
+export const getTransferReversals = tool({
+    description: 'Lists Route transfer reversals (status, history) with date filters and pagination.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        transferId: z.string().describe("Transfer ID, e.g. 'trf_Lt048W7cgLdo1u'"),
+        fromTimestamp: z.number().int().optional().describe('Reversals created on/after this Unix time'),
+        toTimestamp: z.number().int().optional().describe('Reversals created on/before this Unix time'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, transferId, fromTimestamp, toTimestamp, ...rest }) => razorpayRequest(razorpayCredentials, `/transfers/${transferId}/reversals`, { query: { from: fromTimestamp, to: toTimestamp, ...rest } }, 'get transfer reversals'),
+});
+export const getSettlementRecon = tool({
+    description: 'Fetches the settlement reconciliation report (transactions, fees, UTRs) for a day or whole month. Use for accounting.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        year: z.number().int().min(2000).max(3000).describe("Year, e.g. 2024"),
+        month: z.number().int().min(1).max(12),
+        day: z.number().int().min(1).max(31).optional().describe('Day 1-31 (omit for the whole month)'),
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, ...query }) => razorpayRequest(razorpayCredentials, '/settlements/recon/combined', { query }, 'get settlement recon'),
+});
+//# sourceMappingURL=payouts.js.map

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

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

package/dist/toolkits/servicenow/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="1570" height="1403"><path fill="#62d84e" fill-rule="evenodd" d="M1228.4 138.9c129.2 88.9 228.9 214.3 286.3 360.2 57.5 145.8 70 305.5 36 458.5S1437.8 1250 1324 1357.9c-13.3 12.9-28.8 23.4-45.8 30.8-17 7.5-35.2 11.9-53.7 12.9-18.5 1.1-37.1-1.1-54.8-6.6-17.7-5.4-34.3-13.9-49.1-25.2-48.2-35.9-101.8-63.8-158.8-82.6-57.1-18.9-116.7-28.5-176.8-28.5s-119.8 9.6-176.8 28.5c-57 18.8-110.7 46.7-158.9 82.6-14.6 11.2-31 19.8-48.6 25.3s-36 7.8-54.4 6.8c-18.4-.9-36.5-5.1-53.4-12.4s-32.4-17.5-45.8-30.2C132.5 1251 53 1110.8 19 956.8s-20.9-314.6 37.6-461c58.5-146.5 159.6-272 290.3-360.3S631.8.1 789.6.5c156.8 1.3 309.6 49.6 438.8 138.4m-291.8 1014c48.2-19.2 92-48 128.7-84.6 36.7-36.7 65.5-80.4 84.7-128.6 19.2-48.1 28.4-99.7 27-151.5 0-103.9-41.3-203.5-114.8-277S889 396.4 785 396.4s-203.7 41.3-277.2 114.8S393 684.3 393 788.2c-1.4 51.8 7.8 103.4 27 151.5 19.2 48.2 48 91.9 84.7 128.6 36.7 36.6 80.5 65.4 128.6 84.6 48.2 19.2 99.8 28.4 151.7 27 51.8 1.4 103.4-7.8 151.6-27"/></svg>`;
+export const SERVICENOW_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/servicenow/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/servicenow/manifest.js

@@ -0,0 +1,33 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { SERVICENOW_ICON } from './icon.js';
+import { servicenowTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'servicenow',
+    displayName: 'ServiceNow',
+    shortDescription: 'Incidents, changes, service catalog, CMDB, attachments, imports, and CICD.',
+    category: 'Productivity & Project Management',
+    icon: SERVICENOW_ICON,
+    auth: {
+        type: 'service_account',
+        tokenField: 'servicenowCredentials',
+        provider: {
+            fields: ['baseUrl', 'username', 'password', 'accessToken', 'apiKey'],
+            connectDescription: 'Connect your ServiceNow instance with its base URL (e.g. https://mycompany.service-now.com) and credentials. Provide username/password for Basic auth (a dedicated integration user is recommended), OR an OAuth access token (sent as Authorization: Bearer), OR an API key (sent as x-sn-apikey). Supply exactly the credentials your instance requires.',
+        },
+    },
+    tools: servicenowTools.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.11',
+        homepage: 'https://www.servicenow.com',
+        docsUrl: 'https://www.servicenow.com/docs',
+        apiDocsUrl: 'https://developer.servicenow.com/dev.do#!/reference',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/servicenow/tools/attachments.d.ts

@@ -0,0 +1,35 @@
+export declare const uploadAttachment: import("ai").Tool<{
+    fileName: string;
+    tableName: string;
+    tableSysId: string;
+    content?: string | undefined;
+    contentType?: string | undefined;
+    fileToUpload?: any;
+    servicenowCredentials?: string | undefined;
+    creationTime?: string | undefined;
+    recordSysId?: string | undefined;
+    encryptionContext?: string | undefined;
+}, any>;
+export declare const getAttachmentList: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    sysparmLimit?: string | undefined;
+    sysparmQuery?: string | undefined;
+    sysparmOffset?: string | undefined;
+}, any>;
+export declare const getAttachment: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const downloadAttachment: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const deleteAttachment: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const deleteCsmAttachment: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/toolkits/servicenow/tools/attachments.js

@@ -0,0 +1,120 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { snRequest } from './client.js';
+export const uploadAttachment = tool({
+    description: "Attaches a file to a specified record in a ServiceNow table. This action uploads a file and associates it with a specific record (e.g., incident, problem, change request). The file will be visible in the ServiceNow UI under the record's attachments section. Common use cases: - Attach screenshots to incident reports - Upload documents to change requests - Add log files to problem records - Store evidence files for security incidents The action returns complete attachment metadata including download link, file size, and creation details. Note: This action permanently modifies a live ServiceNow instance — attachments cannot be bulk-removed once added.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        fileName: z.string().describe("Name to give the attachment (e.g., 'report.pdf', 'screenshot.png'). This will be the visible filename in ServiceNow."),
+        tableName: z.string().describe("Name of the ServiceNow table to attach the file to (e.g., 'incident', 'problem', 'change_request')."),
+        creationTime: z.string().optional().describe("Creation date and time of the attachment. Use this parameter to capture attachment creation times when the Now Mobile app is offline and the attachment is uploaded to a record at a later time."),
+        recordSysId: z.string().optional().describe("Sys_id of the specific record in the table to attach the file to. This is the unique identifier of the record (e.g., incident sys_id)."),
+        fileToUpload: z.any().optional().describe("File to upload."),
+        encryptionContext: z.string().optional().describe("Sys_id of an encryption context record. Specify this parameter to allow only users with the specified encryption context to access the attachment. For additional information on encryption context records, see https://www.servicenow.com/docs/csh?topicname=column-level-encryption-landing&version=yokohama&pubname=yokohama-platform-security."),
+        tableSysId: z.string().describe("Sys_id of the record to attach the file to. This is the unique identifier of the record."),
+        content: z.string().optional().describe("Inline file content as a string. Use this OR 'file_content' field, not both. The content will be encoded as UTF-8 bytes for upload."),
+        contentType: z.string().optional().describe("MIME type of the content. Defaults to 'text/plain' if not specified. Only used when 'content' field is provided."),
+    }),
+    execute: async ({ servicenowCredentials, fileName, tableName, creationTime, recordSysId, fileToUpload, encryptionContext, tableSysId, content, contentType }) => {
+        const query = {
+            table_name: tableName,
+            table_sys_id: tableSysId ?? recordSysId,
+            file_name: fileName,
+            creation_time: creationTime,
+            encryption_context: encryptionContext,
+        };
+        let filePart;
+        if (typeof fileToUpload === 'string') {
+            filePart = new Blob([fileToUpload], { type: contentType ?? 'text/plain' });
+        }
+        else if (fileToUpload && typeof fileToUpload === 'object' && typeof fileToUpload.arrayBuffer === 'function') {
+            filePart = fileToUpload;
+        }
+        else if (fileToUpload && typeof fileToUpload === 'object') {
+            const inline = fileToUpload.data ?? fileToUpload.content ?? fileToUpload.fileContent ?? fileToUpload;
+            filePart = new Blob([typeof inline === 'string' ? inline : JSON.stringify(inline)], { type: fileToUpload.mimeType ?? fileToUpload.contentType ?? contentType ?? 'text/plain' });
+        }
+        else if (content !== undefined) {
+            filePart = new Blob([content], { type: contentType ?? 'text/plain' });
+        }
+        const formData = new FormData();
+        if (filePart) {
+            formData.append('file', filePart, fileName);
+        }
+        return snRequest(servicenowCredentials, '/api/now/attachment/file', {
+            method: 'POST',
+            query,
+            ...(filePart ? { formData } : {}),
+        });
+    },
+});
+export const getAttachmentList = tool({
+    description: "Retrieves attachment metadata from ServiceNow's sys_attachment table. This endpoint queries file attachments and returns metadata including file name, size, content type, download links, and associated table information. Use sysparm_query to filter by file name, table name, content type, or other attachment properties. Note: This returns metadata only; use the download_link in the response to retrieve actual file content.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        sysparmLimit: z.string().optional().describe("Limit to be applied on pagination. Note: Unusually large sysparm_limit values can impact system performance."),
+        sysparmQuery: z.string().optional().describe("Encoded query. Queries for the Attachment API are relative to the Attachments [sys_attachment] table. For example: (sysparm_query=file_name=attachment.doc) The encoded query provides support for order by. To sort responses based on certain fields, use the ORDERBY and ORDERBYDESC clauses in sysparm_query. For example, sysparm_query=ORDERBYfile_name^ORDERBYDESCtable_Name orders the results in ascending order by name first, then in descending order by table name."),
+        sysparmOffset: z.string().optional().describe("Number of records to exclude from the query. Use this parameter to get more records than specified in sysparm_limit parameter. For example, if sysparm_limit is set to 500, but there are additional records you want to query, you can specify a sysparm_offset parameter value of 500 to get the second set of records."),
+    }),
+    execute: async ({ servicenowCredentials, sysparmLimit, sysparmQuery, sysparmOffset }) => {
+        return snRequest(servicenowCredentials, '/api/now/attachment', {
+            method: 'GET',
+            query: {
+                sysparm_limit: sysparmLimit,
+                sysparm_query: sysparmQuery,
+                sysparm_offset: sysparmOffset,
+            },
+        });
+    },
+});
+export const getAttachment = tool({
+    description: "Retrieves metadata for a specific attachment by its sys_id from ServiceNow. Use this action when you need to fetch information about a single attachment file, such as its file name, content type, size, and associated record details. This action returns metadata only; to download the actual file content, use the download_link from the FindFile action or access the file directly via the ServiceNow attachment API.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        sysId: z.string().describe("The sys_id of the attachment to retrieve. This is the unique identifier assigned to the attachment when it was created."),
+    }),
+    execute: async ({ servicenowCredentials, sysId }) => {
+        return snRequest(servicenowCredentials, `/api/now/attachment/${encodeURIComponent(sysId)}`, {
+            method: 'GET',
+        });
+    },
+});
+export const downloadAttachment = tool({
+    description: "Downloads the binary file attachment with the specified sys_id from ServiceNow. Use this action when you need to retrieve the actual file content of an attachment that was previously uploaded to a ServiceNow record (e.g., incident, problem, change_request). This action returns the raw binary file data which can then be saved locally or processed further. The attachment sys_id can be obtained from the 'FindFile' action or from the ServiceNow UI.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        sysId: z.string().describe("Sys_id of the attachment to download. This is the unique identifier of the attachment record in ServiceNow."),
+    }),
+    execute: async ({ servicenowCredentials, sysId }) => {
+        return snRequest(servicenowCredentials, `/api/now/attachment/file/${encodeURIComponent(sysId)}`, {
+            method: 'GET',
+            expectBinary: true,
+        });
+    },
+});
+export const deleteAttachment = tool({
+    description: "Permanently deletes a specific attachment from ServiceNow using its sys_id. This is a destructive, irreversible operation — the attachment cannot be recovered once deleted. Requires the user to have delete permissions on the attachment. If the attachment doesn't exist or the user lacks permissions, an error will be returned. This action should be used when you have the specific sys_id of an attachment to remove (obtained from FindFile action). Use when you need to remove a specific file attachment from a record and know its sys_id.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        sysId: z.string().describe("The unique system ID (sys_id) of the attachment to delete. This is a 32-character hexadecimal string that uniquely identifies the attachment record in ServiceNow. Example: '003a3ef24ff1120031577d2ca310c74b'. The attachment must exist, or a 404 error will be returned."),
+    }),
+    execute: async ({ servicenowCredentials, sysId }) => {
+        return snRequest(servicenowCredentials, `/api/now/attachment/${encodeURIComponent(sysId)}`, {
+            method: 'DELETE',
+        });
+    },
+});
+export const deleteCsmAttachment = tool({
+    description: "Permanently deletes a specific CSM (Customer Service Management) attachment from ServiceNow using its sys_id. This is a destructive, irreversible operation — the CSM attachment cannot be recovered once deleted. Requires the user to have delete permissions on the attachment. If the attachment doesn't exist or the user lacks permissions, an error will be returned. This action specifically targets attachments associated with CSM records (cases, etc.). Use when you need to remove a specific file attachment from a CSM record and know its sys_id.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        sysId: z.string().describe("The unique system ID (sys_id) of the CSM attachment to delete. This is a 32-character hexadecimal string that uniquely identifies the attachment record in ServiceNow. Example: '260380fa833bf210dd2dc2dfeeaad3c1'. The attachment must exist, or a 404 error will be returned."),
+    }),
+    execute: async ({ servicenowCredentials, sysId }) => {
+        return snRequest(servicenowCredentials, `/api/now/v1/attachment_csm/${encodeURIComponent(sysId)}`, {
+            method: 'DELETE',
+        });
+    },
+});
+//# sourceMappingURL=attachments.js.map

package/dist/toolkits/servicenow/tools/catalog.d.ts

@@ -0,0 +1,122 @@
+export declare const serviceNowCreateServicCatalogItemsAddToCart: import("ai").Tool<{
+    sysId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+    sysparmQuantity?: number | undefined;
+}, any>;
+export declare const serviceNowCreateServicCatalogItemsSubmitProducer: import("ai").Tool<{
+    sysId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+    sysparmDisplayValue?: string | undefined;
+    sysparmNoValidation?: boolean | undefined;
+}, any>;
+export declare const serviceNowCreateServiceCatalogCartCheckout: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    cartId?: string | undefined;
+}, any>;
+export declare const serviceNowCreateServiceCatalogCartSubmitOrder: import("ai").Tool<{
+    variables?: Record<string, any> | undefined;
+    quantity?: number | undefined;
+    servicenowCredentials?: string | undefined;
+    cartId?: string | undefined;
+    ignorePrice?: boolean | undefined;
+    requestedFor?: string | undefined;
+    noAttachmentFoundWarnings?: boolean | undefined;
+}, any>;
+export declare const serviceNowCreateServicecatalogItemsCheckoutGuide: import("ai").Tool<{
+    sysId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowCreateServicecatalogItemsOrderNow: import("ai").Tool<{
+    sysId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+    sysparmQuantity?: number | undefined;
+    sysparmRequestedFor?: string | undefined;
+}, any>;
+export declare const serviceNowDeleteServicecatalogCart: import("ai").Tool<{
+    cartItemId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowDeleteServiceCatalogCartEmpty: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetCmpCatalogApiServices: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    sysparmView?: "mobile" | "desktop" | "both" | undefined;
+    sysparmLimit?: number | undefined;
+    sysparmQuery?: string | undefined;
+    sysparmFields?: string | undefined;
+    sysparmOffset?: number | undefined;
+    sysparmDisplayValue?: "true" | "all" | "false" | undefined;
+    sysparmExcludeReferenceLink?: boolean | undefined;
+    sysparmNoCount?: boolean | undefined;
+    sysparmQueryCategory?: string | undefined;
+    sysparmSuppressPaginationHeader?: boolean | undefined;
+}, any>;
+export declare const serviceNowGetServicatalogItemsById: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServicCatalogItemVariables: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogCart: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogCartDeliveryAddress: import("ai").Tool<{
+    userId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogCatalogById: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogCatalogCategories: import("ai").Tool<{
+    catalogId: string;
+    servicenowCredentials?: string | undefined;
+    sysparmLimit?: number | undefined;
+    sysparmOffset?: number | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogCategoryById: import("ai").Tool<{
+    sysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogItemDelegation: import("ai").Tool<{
+    itemSysId: string;
+    userSysId: string;
+    servicenowCredentials?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogItemsList: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    sysparmLimit?: number | undefined;
+    sysparmText?: string | undefined;
+    sysparmCatalog?: string | undefined;
+    sysparmCategory?: string | undefined;
+}, any>;
+export declare const serviceNowGetServiceCatalogWishlistList: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    sysparmLimit?: number | undefined;
+    sysparmOffset?: number | undefined;
+}, any>;
+export declare const serviceNowListServiceCatalogCatalogs: import("ai").Tool<{
+    servicenowCredentials?: string | undefined;
+    sysparmLimit?: number | undefined;
+    sysparmText?: string | undefined;
+}, any>;
+export declare const serviceNowUpdateServicecatalogCart: import("ai").Tool<{
+    cartItemId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+    sysparmQuantity?: number | undefined;
+}, any>;
+export declare const serviceNowUpdateServicecatalogItemsSubmitGuide: import("ai").Tool<{
+    sysId: string;
+    variables?: Record<string, any> | undefined;
+    servicenowCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=catalog.d.ts.map