@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/core/index.d.ts

@@ -1,5 +1,6 @@
 export { CONNECTOR_CATEGORIES, type ConnectorCategory } from './categories.js';
 export { defineToolkit, defineTool, toolkitCamelId } from './define.js';
+export { inferToolScope } from './scope.js';
 export { validateManifests, getAuthType, } from './validate.js';
 export type { ToolkitManifest, ToolDefinition, ToolkitIcon, ToolkitAuthSpec, ToolkitAuthType, ToolScope, OAuthProviderSpec, EnvVarSpec, ToolkitAvailability, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,4 +1,5 @@
 export { CONNECTOR_CATEGORIES } from './categories.js';
 export { defineToolkit, defineTool, toolkitCamelId } from './define.js';
+export { inferToolScope } from './scope.js';
 export { validateManifests, getAuthType, } from './validate.js';
 //# sourceMappingURL=index.js.map

package/dist/core/scope.d.ts

@@ -0,0 +1,4 @@
+import type { ToolScope } from './types.js';
+/** Heuristic scope inference for migrated tools; explicit scope in manifests is preferred. */
+export declare function inferToolScope(name: string): ToolScope;
+//# sourceMappingURL=scope.d.ts.map

package/dist/core/scope.js

@@ -0,0 +1,12 @@
+/** Heuristic scope inference for migrated tools; explicit scope in manifests is preferred. */
+export function inferToolScope(name) {
+    const normalized = name.toLowerCase();
+    if (/^(delete|remove|unfollow|unstar|destroy|revoke|cancel)/.test(normalized)) {
+        return 'delete';
+    }
+    if (/^(create|add|update|send|post|put|patch|trigger|generate|follow|star|merge|approve|dispatch|set|invite|assign|upload|publish|enable|disable|lock|unlock|rerun|reopen|close|append|fork|watch)/.test(normalized)) {
+        return 'write';
+    }
+    return 'read';
+}
+//# sourceMappingURL=scope.js.map

package/dist/index.d.ts

@@ -2,9 +2,13 @@ import mathematics from './toolkits/mathematics/manifest.js';
 import linear from './toolkits/linear/manifest.js';
 import gmail from './toolkits/gmail/manifest.js';
 import webSearch from './toolkits/web-search/manifest.js';
+import github from './toolkits/github/manifest.js';
+import notion from './toolkits/notion/manifest.js';
+import googleCalendar from './toolkits/google-calendar/manifest.js';
+import googleSheets from './toolkits/google-sheets/manifest.js';
 import type { ToolkitManifest } from './core/types.js';
 export declare const toolkits: ToolkitManifest[];
-export { mathematics, linear, gmail, webSearch };
+export { mathematics, linear, gmail, webSearch, github, notion, googleCalendar, googleSheets, };
 export * from './core/index.js';
 export * from './runtime/index.js';
 export declare function getAllTools(): {

package/dist/index.js

@@ -2,8 +2,21 @@ import mathematics from './toolkits/mathematics/manifest.js';
 import linear from './toolkits/linear/manifest.js';
 import gmail from './toolkits/gmail/manifest.js';
 import webSearch from './toolkits/web-search/manifest.js';
-export const toolkits = [mathematics, linear, gmail, webSearch];
-export { mathematics, linear, gmail, webSearch };
+import github from './toolkits/github/manifest.js';
+import notion from './toolkits/notion/manifest.js';
+import googleCalendar from './toolkits/google-calendar/manifest.js';
+import googleSheets from './toolkits/google-sheets/manifest.js';
+export const toolkits = [
+    mathematics,
+    linear,
+    gmail,
+    webSearch,
+    github,
+    notion,
+    googleCalendar,
+    googleSheets,
+];
+export { mathematics, linear, gmail, webSearch, github, notion, googleCalendar, googleSheets, };
 export * from './core/index.js';
 export * from './runtime/index.js';
 export function getAllTools() {

package/dist/runtime/meta-tools.js

@@ -199,6 +199,7 @@ export function createMetaTools({ registry, credentials, hooks = {} }) {
                         const result = await toolInstance.execute(argsWithToken);
                         return sanitizeToolPayload({
                             toolName,
+                            toolkitId: toolMetadata.toolkitId,
                             success: true,
                             result: sanitizeToolResult(result),
                         });
@@ -225,6 +226,7 @@ export function createMetaTools({ registry, credentials, hooks = {} }) {
                 const result = await toolInstance.execute(argsWithToken);
                 return sanitizeToolPayload({
                     toolName,
+                    toolkitId: toolMetadata.toolkitId,
                     success: true,
                     result: sanitizeToolResult(result),
                 });

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

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

package/dist/toolkits/github/icon.js

@@ -0,0 +1,15 @@
+const SVG = `<svg width="98" height="96" viewBox="0 0 98 96" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clipPath="url(#clip0_730_27126)">
+<path d="M41.4395 69.3848C28.8066 67.8535 19.9062 58.7617 19.9062 46.9902C19.9062 42.2051 21.6289 37.0371 24.5 33.5918C23.2559 30.4336 23.4473 23.7344 24.8828 20.959C28.7109 20.4805 33.8789 22.4902 36.9414 25.2656C40.5781 24.1172 44.4062 23.543 49.0957 23.543C53.7852 23.543 57.6133 24.1172 61.0586 25.1699C64.0254 22.4902 69.2891 20.4805 73.1172 20.959C74.457 23.543 74.6484 30.2422 73.4043 33.4961C76.4668 37.1328 78.0937 42.0137 78.0937 46.9902C78.0937 58.7617 69.1934 67.6621 56.3691 69.2891C59.623 71.3945 61.8242 75.9883 61.8242 81.252L61.8242 91.2051C61.8242 94.0762 64.2168 95.7031 67.0879 94.5547C84.4102 87.9512 98 70.6289 98 49.1914C98 22.1074 75.9883 6.69539e-07 48.9043 4.309e-07C21.8203 1.92261e-07 -1.9479e-07 22.1074 -4.3343e-07 49.1914C-6.20631e-07 70.4375 13.4941 88.0469 31.6777 94.6504C34.2617 95.6074 36.75 93.8848 36.75 91.3008L36.75 83.6445C35.4102 84.2188 33.6875 84.6016 32.1562 84.6016C25.8398 84.6016 22.1074 81.1563 19.4277 74.7441C18.375 72.1602 17.2266 70.6289 15.0254 70.3418C13.877 70.2461 13.4941 69.7676 13.4941 69.1934C13.4941 68.0449 15.4082 67.1836 17.3223 67.1836C20.0977 67.1836 22.4902 68.9063 24.9785 72.4473C26.8926 75.2227 28.9023 76.4668 31.2949 76.4668C33.6875 76.4668 35.2187 75.6055 37.4199 73.4043C39.0469 71.7773 40.291 70.3418 41.4395 69.3848Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_730_27126">
+<rect width="98" height="96" fill="white"/>
+</clipPath>
+</defs>
+</svg>`;
+export const GITHUB_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GITHUB_ICON } from './icon.js';
+import { githubTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'github',
+    displayName: 'GitHub',
+    shortDescription: 'Repositories, issues, pull requests, actions, and more.',
+    category: 'Developer Tools & DevOps',
+    icon: GITHUB_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'githubToken',
+        provider: {
+            slug: 'github',
+            env: { clientId: 'GITHUB_CLIENT_ID', clientSecret: 'GITHUB_CLIENT_SECRET' },
+            authorizeUrl: 'https://github.com/login/oauth/authorize',
+            tokenUrl: 'https://github.com/login/oauth/access_token',
+            scopes: ['repo', 'read:user'],
+            exchangeStyle: 'json',
+            connectDescription: 'Connect GitHub to access repositories, issues, pull requests, and actions.',
+            callbackPath: '/api/auth/github/callback',
+            stateCookie: 'github_oauth_state',
+        },
+    },
+    allowedHosts: ['api.github.com'],
+    tools: githubTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: inferToolScope(entry.name),
+    })),
+    meta: { since: '0.0.2' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/github/tools/Actions/delete-artifact.d.ts

@@ -0,0 +1,13 @@
+export declare const deleteArtifact: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    artifact_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=delete-artifact.d.ts.map

package/dist/toolkits/github/tools/Actions/delete-artifact.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteArtifact = tool({
+    description: 'Delete an artifact from a GitHub repository.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        artifact_id: z.number().describe('The unique identifier of the artifact to delete'),
+    }),
+    execute: async ({ githubToken, owner, repo, artifact_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.actions.deleteArtifact({
+                owner,
+                repo,
+                artifact_id,
+            });
+            return { message: `Successfully deleted artifact ${artifact_id}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete artifact: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-artifact.js.map

package/dist/toolkits/github/tools/Actions/get-artifact.d.ts

@@ -0,0 +1,31 @@
+export declare const getArtifact: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    artifact_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    size_in_bytes?: undefined;
+    created_at?: undefined;
+    expired?: undefined;
+    expires_at?: undefined;
+    workflow_run?: undefined;
+} | {
+    id: number;
+    name: string;
+    size_in_bytes: number;
+    created_at: string | null;
+    expired: boolean;
+    expires_at: string | null;
+    workflow_run: {
+        id?: number;
+        repository_id?: number;
+        head_repository_id?: number;
+        head_branch?: string;
+        head_sha?: string;
+    } | null | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-artifact.d.ts.map

package/dist/toolkits/github/tools/Actions/get-artifact.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getArtifact = tool({
+    description: 'Get a specific artifact from a GitHub repository by its ID.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        artifact_id: z.number().describe('The unique identifier of the artifact'),
+    }),
+    execute: async ({ githubToken, owner, repo, artifact_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.getArtifact({
+                owner,
+                repo,
+                artifact_id,
+            });
+            return {
+                id: data.id,
+                name: data.name,
+                size_in_bytes: data.size_in_bytes,
+                created_at: data.created_at,
+                expired: data.expired,
+                expires_at: data.expires_at,
+                workflow_run: data.workflow_run,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get artifact: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-artifact.js.map

package/dist/toolkits/github/tools/Actions/get-workflow-job.d.ts

@@ -0,0 +1,36 @@
+export declare const getWorkflowJob: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    job_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    run_id?: undefined;
+    name?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    started_at?: undefined;
+    completed_at?: undefined;
+    html_url?: undefined;
+    steps?: undefined;
+} | {
+    id: number;
+    run_id: number;
+    name: string;
+    status: "queued" | "in_progress" | "completed" | "waiting" | "requested" | "pending";
+    conclusion: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | null;
+    started_at: string;
+    completed_at: string | null;
+    html_url: string | null;
+    steps: {
+        name: string;
+        status: "queued" | "in_progress" | "completed";
+        conclusion: string | null;
+        number: number;
+        started_at: string | null | undefined;
+        completed_at: string | null | undefined;
+    }[] | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-workflow-job.d.ts.map

package/dist/toolkits/github/tools/Actions/get-workflow-job.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getWorkflowJob = tool({
+    description: 'Get a specific job for a workflow run. Returns detailed job information including steps.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        job_id: z.number().describe('The unique identifier of the job'),
+    }),
+    execute: async ({ githubToken, owner, repo, job_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.getJobForWorkflowRun({
+                owner,
+                repo,
+                job_id,
+            });
+            return {
+                id: data.id,
+                run_id: data.run_id,
+                name: data.name,
+                status: data.status,
+                conclusion: data.conclusion,
+                started_at: data.started_at,
+                completed_at: data.completed_at,
+                html_url: data.html_url,
+                steps: data.steps?.map(step => ({
+                    name: step.name,
+                    status: step.status,
+                    conclusion: step.conclusion,
+                    number: step.number,
+                    started_at: step.started_at,
+                    completed_at: step.completed_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get workflow job: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-workflow-job.js.map

package/dist/toolkits/github/tools/Actions/list-artifacts.d.ts

@@ -0,0 +1,23 @@
+export declare const listArtifacts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    artifacts?: undefined;
+} | {
+    total_count: number;
+    artifacts: {
+        id: number;
+        name: string;
+        size_in_bytes: number;
+        created_at: string | null;
+        expired: boolean;
+        expires_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-artifacts.d.ts.map

package/dist/toolkits/github/tools/Actions/list-artifacts.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listArtifacts = tool({
+    description: 'List artifacts for a GitHub repository. Returns workflow run artifacts with their names, sizes, and download URLs.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, owner, repo, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.listArtifactsForRepo({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                artifacts: data.artifacts.map(artifact => ({
+                    id: artifact.id,
+                    name: artifact.name,
+                    size_in_bytes: artifact.size_in_bytes,
+                    created_at: artifact.created_at,
+                    expired: artifact.expired,
+                    expires_at: artifact.expires_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list artifacts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-artifacts.js.map

package/dist/toolkits/github/tools/Actions/list-workflow-jobs.d.ts

@@ -0,0 +1,27 @@
+export declare const listWorkflowJobs: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    run_id: number;
+    filter?: "latest" | "all" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    jobs?: undefined;
+} | {
+    total_count: number;
+    jobs: {
+        id: number;
+        run_id: number;
+        name: string;
+        status: "queued" | "in_progress" | "completed" | "waiting" | "requested" | "pending";
+        conclusion: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | null;
+        started_at: string;
+        completed_at: string | null;
+        html_url: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-jobs.d.ts.map

package/dist/toolkits/github/tools/Actions/list-workflow-jobs.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflowJobs = tool({
+    description: 'List jobs for a workflow run. Returns job details including status, conclusion, and steps.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        run_id: z.number().describe('The unique identifier of the workflow run'),
+        filter: z.enum(['latest', 'all']).optional().describe('Filter jobs by latest or all attempts'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, owner, repo, run_id, filter, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.listJobsForWorkflowRun({
+                owner,
+                repo,
+                run_id,
+                filter: filter ?? 'latest',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                jobs: data.jobs.map(job => ({
+                    id: job.id,
+                    run_id: job.run_id,
+                    name: job.name,
+                    status: job.status,
+                    conclusion: job.conclusion,
+                    started_at: job.started_at,
+                    completed_at: job.completed_at,
+                    html_url: job.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflow jobs: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflow-jobs.js.map

package/dist/toolkits/github/tools/Actions/list-workflow-run-artifacts.d.ts

@@ -0,0 +1,24 @@
+export declare const listWorkflowRunArtifacts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    run_id: number;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    artifacts?: undefined;
+} | {
+    total_count: number;
+    artifacts: {
+        id: number;
+        name: string;
+        size_in_bytes: number;
+        created_at: string | null;
+        expired: boolean;
+        expires_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-run-artifacts.d.ts.map

package/dist/toolkits/github/tools/Actions/list-workflow-run-artifacts.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflowRunArtifacts = tool({
+    description: 'List artifacts for a specific workflow run.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        run_id: z.number().describe('The unique identifier of the workflow run'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, owner, repo, run_id, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.listWorkflowRunArtifacts({
+                owner,
+                repo,
+                run_id,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                artifacts: data.artifacts.map(artifact => ({
+                    id: artifact.id,
+                    name: artifact.name,
+                    size_in_bytes: artifact.size_in_bytes,
+                    created_at: artifact.created_at,
+                    expired: artifact.expired,
+                    expires_at: artifact.expires_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflow run artifacts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflow-run-artifacts.js.map

package/dist/toolkits/github/tools/Activity/list-notifications.d.ts

@@ -0,0 +1,24 @@
+export declare const listNotifications: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    all?: boolean | undefined;
+    participating?: boolean | undefined;
+}, {
+    error: string;
+    notifications?: undefined;
+} | {
+    notifications: {
+        id: string;
+        repository: string;
+        subject: {
+            title: string;
+            type: string;
+        };
+        reason: string;
+        unread: boolean;
+        updated_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-notifications.d.ts.map

package/dist/toolkits/github/tools/Activity/list-notifications.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listNotifications = tool({
+    description: 'List notifications for the authenticated user. Returns unread notifications by default.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        all: z.boolean().optional().describe('If true, show notifications marked as read'),
+        participating: z.boolean().optional().describe('If true, only show notifications in which the user is directly participating'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, all, participating, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.activity.listNotificationsForAuthenticatedUser({
+                all: all ?? false,
+                participating: participating ?? false,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                notifications: data.map(notification => ({
+                    id: notification.id,
+                    repository: notification.repository?.full_name,
+                    subject: {
+                        title: notification.subject?.title,
+                        type: notification.subject?.type,
+                    },
+                    reason: notification.reason,
+                    unread: notification.unread,
+                    updated_at: notification.updated_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list notifications: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-notifications.js.map