@rnsk/toolkits 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,104 @@
+# @rnsk/toolkits
+
+Manifest-driven toolkit registry for AI agents — connector definitions you publish as npm and wire into [Runstack](https://runstack.engineer).
+
+[![npm version](https://img.shields.io/npm/v/@rnsk/toolkits.svg)](https://www.npmjs.com/package/@rnsk/toolkits)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)
+
+> This is **not** [`@rnsk/tools`](https://www.npmjs.com/package/@rnsk/tools) (the MCP client SDK). `@rnsk/toolkits` ships **connector implementations** — manifests, tools, OAuth specs, and icons.
+
+## What this package contains
+
+| Export | Purpose |
+|--------|---------|
+| `@rnsk/toolkits` | All toolkit manifests, `registerAllTools()`, `getAllTools()` |
+| `@rnsk/toolkits/core` | Types, `defineToolkit`, validation, schema helpers |
+
+## Seed toolkits (v0.0.3)
+
+**223 tools** across **8 toolkits**.
+
+| Toolkit | Tools | Auth |
+|---------|------:|------|
+| mathematics | 9 | none |
+| linear | 3 | OAuth2 |
+| gmail | 15 | OAuth2 |
+| web-search (Firecrawl) | 2 | service env |
+| github | 173 | OAuth2 |
+| notion | 8 | OAuth2 |
+| google-calendar | 6 | OAuth2 |
+| google-sheets | 7 | OAuth2 |
+
+## Install
+
+```bash
+npm install @rnsk/toolkits
+```
+
+Peer dependencies: `ai`, `zod`.
+
+## Usage
+
+Register every toolkit tool into your application's registry:
+
+```ts
+import { toolkits, registerAllTools } from '@rnsk/toolkits';
+
+registerAllTools(myRegistry);
+```
+
+Inspect manifests or build custom registration:
+
+```ts
+import { toolkits } from '@rnsk/toolkits';
+import { defineToolkit, validateManifests } from '@rnsk/toolkits/core';
+
+for (const manifest of toolkits) {
+  console.log(manifest.id, manifest.tools.length);
+}
+```
+
+Runstack loads this package server-side, registers tools, and routes agent requests through its own meta-tool layer. You can publish a **private fork** or scoped package and point Runstack at your version to host connectors outside the public registry.
+
+## Toolkit structure
+
+Each toolkit lives under `src/toolkits/<id>/`:
+
+```
+<id>/
+  manifest.ts    # defineToolkit({ displayName, auth, tools, ... })
+  icon.ts        # SVG/PNG data URI
+  tools/
+    *.ts         # one tool per file (AI SDK tool() + execute)
+    index.ts     # exports array
+```
+
+After adding a toolkit, register it in `src/index.ts`, then run `npm run validate && npm run build`.
+
+## Local testing
+
+The repo includes a **sandbox** (not published to npm) for exercising tools at runtime:
+
+```bash
+cd ../../sandbox
+cp .env.local.example .env.local
+npm run dev
+```
+
+Use `POST /api/tools/execute` to invoke a tool directly with the same credential-injection pattern Runstack uses. See the [repository README](../../README.md) for sandbox endpoints.
+
+## Versioning
+
+Pre-1.0 (`0.0.x`): patch releases add toolkits and tools. Pin an exact version in production (e.g. `"0.0.3"`).
+
+## Contributing
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md) in the repository root.
+
+## Security
+
+Report vulnerabilities privately — [SECURITY.md](../../SECURITY.md). Toolkit `execute` functions run server-side with user credentials; every PR is reviewed for token handling and outbound hosts.
+
+## License
+
+MIT

package/dist/core/index.d.ts

@@ -1,5 +1,7 @@
 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 { TOOL_OUTPUT_JSON_SCHEMA, getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, type ParameterInfo, } from './schema-helpers.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,6 @@
 export { CONNECTOR_CATEGORIES } from './categories.js';
 export { defineToolkit, defineTool, toolkitCamelId } from './define.js';
+export { inferToolScope } from './scope.js';
 export { validateManifests, getAuthType, } from './validate.js';
+export { TOOL_OUTPUT_JSON_SCHEMA, getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, } from './schema-helpers.js';
 //# sourceMappingURL=index.js.map

package/dist/core/schema-helpers.d.ts

@@ -0,0 +1,20 @@
+export declare const TOOL_OUTPUT_JSON_SCHEMA: Record<string, unknown>;
+export declare function getToolInputZodSchema(tool: any): any | null;
+export declare function resolveZodObjectShape(schema: {
+    shape?: Record<string, unknown>;
+    _def?: {
+        shape?: Record<string, unknown> | (() => Record<string, unknown>);
+    };
+} | null | undefined): Record<string, unknown> | null;
+export declare function toolInputToJsonSchema(tool: any, requiredAuth?: string): Record<string, unknown>;
+export interface ParameterInfo {
+    type: string;
+    required: boolean;
+    description?: string;
+    itemType?: string;
+    options?: string[];
+    values?: string[];
+}
+export declare function extractParameterInfo(zodType: any): ParameterInfo | Record<string, unknown>;
+export declare function coerceArguments(args: Record<string, unknown>, schema: any): Record<string, unknown>;
+//# sourceMappingURL=schema-helpers.d.ts.map

package/dist/core/schema-helpers.js

@@ -0,0 +1,157 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+export const TOOL_OUTPUT_JSON_SCHEMA = {
+    type: 'object',
+    description: 'JSON object returned by the tool. May include result data or an error field.',
+    additionalProperties: true,
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getToolInputZodSchema(tool) {
+    if (!tool || typeof tool !== 'object')
+        return null;
+    return tool.inputSchema ?? tool._def?.parameters ?? null;
+}
+export function resolveZodObjectShape(schema) {
+    if (!schema)
+        return null;
+    if (schema.shape)
+        return schema.shape;
+    const defShape = schema._def?.shape;
+    if (typeof defShape === 'function')
+        return defShape();
+    if (defShape && typeof defShape === 'object')
+        return defShape;
+    return null;
+}
+function flattenJsonSchema(schema) {
+    if (schema.$ref && typeof schema.$ref === 'string' && schema.definitions) {
+        const refName = schema.$ref.replace('#/definitions/', '');
+        const definitions = schema.definitions;
+        const resolved = definitions[refName];
+        if (resolved) {
+            return {
+                ...resolved,
+                ...(schema.$schema ? { $schema: schema.$schema } : {}),
+            };
+        }
+    }
+    return schema;
+}
+function stripAuthFromJsonSchema(schema, requiredAuth) {
+    const properties = schema.properties;
+    if (!properties)
+        return schema;
+    const filtered = { ...properties };
+    for (const key of Object.keys(filtered)) {
+        if (key === requiredAuth || key.endsWith('Token')) {
+            delete filtered[key];
+        }
+    }
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((key) => key !== requiredAuth && !key.endsWith('Token'))
+        : undefined;
+    return {
+        ...schema,
+        properties: filtered,
+        ...(required && required.length > 0 ? { required } : {}),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function toolInputToJsonSchema(tool, requiredAuth) {
+    const zodSchema = getToolInputZodSchema(tool);
+    if (!zodSchema) {
+        return { type: 'object', properties: {} };
+    }
+    const jsonSchema = zodToJsonSchema(zodSchema, {
+        $refStrategy: 'none',
+    });
+    return stripAuthFromJsonSchema(flattenJsonSchema(jsonSchema), requiredAuth);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractParameterInfo(zodType) {
+    const typeName = zodType._def?.typeName;
+    const info = {
+        type: typeName?.replace('Zod', '').toLowerCase() || 'unknown',
+        required: !(zodType?.isOptional?.() ?? false),
+        description: zodType.description || undefined,
+    };
+    switch (typeName) {
+        case 'ZodNumber':
+            info.type = 'number';
+            break;
+        case 'ZodString':
+            info.type = 'string';
+            break;
+        case 'ZodBoolean':
+            info.type = 'boolean';
+            break;
+        case 'ZodArray':
+            info.type = 'array';
+            info.itemType = extractParameterInfo(zodType._def.type).type;
+            break;
+        case 'ZodObject':
+            info.type = 'object';
+            break;
+        case 'ZodUnion':
+            info.type = 'union';
+            info.options =
+                zodType._def.options?.map(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (opt) => extractParameterInfo(opt).type) || [];
+            break;
+        case 'ZodEnum':
+            info.type = 'enum';
+            info.values = zodType._def.values || [];
+            break;
+        case 'ZodOptional': {
+            const innerInfo = extractParameterInfo(zodType._def.innerType);
+            return { ...innerInfo, required: false };
+        }
+        default:
+            info.type = typeName?.replace('Zod', '').toLowerCase() || 'any';
+    }
+    return info;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function coerceArguments(args, schema) {
+    const shape = resolveZodObjectShape(schema);
+    if (!shape)
+        return args;
+    const coercedArgs = {};
+    for (const [key, value] of Object.entries(args)) {
+        const fieldSchema = shape[key];
+        if (!fieldSchema) {
+            coercedArgs[key] = value;
+            continue;
+        }
+        let typeName = fieldSchema._def?.typeName;
+        let actualSchema = fieldSchema;
+        if (typeName === 'ZodOptional') {
+            actualSchema = fieldSchema._def?.innerType;
+            typeName = actualSchema?._def?.typeName;
+        }
+        try {
+            switch (typeName) {
+                case 'ZodNumber':
+                    coercedArgs[key] = typeof value === 'string' ? parseFloat(value) : Number(value);
+                    break;
+                case 'ZodString':
+                    coercedArgs[key] = String(value);
+                    break;
+                case 'ZodBoolean':
+                    coercedArgs[key] =
+                        typeof value === 'string' ? value.toLowerCase() === 'true' : Boolean(value);
+                    break;
+                case 'ZodArray':
+                    coercedArgs[key] = Array.isArray(value) ? value : [value];
+                    break;
+                default:
+                    coercedArgs[key] = value;
+            }
+        }
+        catch {
+            coercedArgs[key] = value;
+        }
+    }
+    return coercedArgs;
+}
+//# sourceMappingURL=schema-helpers.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,11 +2,14 @@ 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(): {
     name: string;
     description: string;

package/dist/index.js

@@ -2,10 +2,22 @@ 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() {
     return toolkits.flatMap((t) => t.tools.map((toolDef) => ({
         name: toolDef.name,

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