@llmindset/hf-mcp 0.2.32 → 0.2.34

package/src/jobs/tool.ts

@@ -0,0 +1,435 @@
+import { z } from 'zod';
+import { JobsApiClient } from './api-client.js';
+import { HfApiError } from '../hf-api-call.js';
+import { runCommand, uvCommand } from './commands/run.js';
+import { psCommand } from './commands/ps.js';
+import { logsCommand } from './commands/logs.js';
+import { inspectCommand, cancelCommand } from './commands/inspect.js';
+import {
+	scheduledRunCommand,
+	scheduledUvCommand,
+	scheduledPsCommand,
+	scheduledInspectCommand,
+	scheduledDeleteCommand,
+	scheduledSuspendCommand,
+	scheduledResumeCommand,
+} from './commands/scheduled.js';
+import type { ToolResult } from '../types/tool-result.js';
+import type {
+	RunArgs,
+	UvArgs,
+	PsArgs,
+	LogsArgs,
+	InspectArgs,
+	CancelArgs,
+	ScheduledRunArgs,
+	ScheduledUvArgs,
+	ScheduledPsArgs,
+	ScheduledJobArgs,
+} from './types.js';
+
+// Re-export types
+export * from './types.js';
+export { JobsApiClient } from './api-client.js';
+
+// Import Zod schemas for validation
+import {
+	runArgsSchema,
+	uvArgsSchema,
+	psArgsSchema,
+	logsArgsSchema,
+	inspectArgsSchema,
+	cancelArgsSchema,
+	scheduledRunArgsSchema,
+	scheduledUvArgsSchema,
+	scheduledPsArgsSchema,
+	scheduledJobArgsSchema,
+} from './types.js';
+
+/**
+ * Map of command names to their validation schemas
+ */
+const COMMAND_SCHEMAS = {
+	run: runArgsSchema,
+	uv: uvArgsSchema,
+	ps: psArgsSchema,
+	logs: logsArgsSchema,
+	inspect: inspectArgsSchema,
+	cancel: cancelArgsSchema,
+	'scheduled run': scheduledRunArgsSchema,
+	'scheduled uv': scheduledUvArgsSchema,
+	'scheduled ps': scheduledPsArgsSchema,
+	'scheduled inspect': scheduledJobArgsSchema,
+	'scheduled delete': scheduledJobArgsSchema,
+	'scheduled suspend': scheduledJobArgsSchema,
+	'scheduled resume': scheduledJobArgsSchema,
+} as const;
+
+/**
+ * Validate command arguments against a Zod schema
+ * Returns a ToolResult with detailed error message if validation fails
+ */
+function validateArgs(
+	schema: z.ZodSchema,
+	args: unknown,
+	commandName: string
+): { success: true } | { success: false; errorResult: ToolResult } {
+	const result = schema.safeParse(args);
+
+	if (result.success) {
+		return { success: true };
+	}
+
+	// Format Zod errors into a helpful message
+	const errors = result.error.errors;
+	const missingFields: string[] = [];
+	const invalidFields: string[] = [];
+
+	for (const err of errors) {
+		const field = err.path.join('.');
+		if (err.code === 'invalid_type' && err.received === 'undefined') {
+			missingFields.push(`  • ${field}: ${err.message}`);
+		} else {
+			invalidFields.push(`  • ${field}: ${err.message}`);
+		}
+	}
+
+	let errorMessage = `Error: Invalid parameters for '${commandName}'\n\n`;
+
+	if (missingFields.length > 0) {
+		errorMessage += `Missing required parameters:\n${missingFields.join('\n')}\n\n`;
+	}
+
+	if (invalidFields.length > 0) {
+		errorMessage += `Invalid parameters:\n${invalidFields.join('\n')}\n\n`;
+	}
+
+	// Show what was provided
+	const providedKeys = args && typeof args === 'object' ? Object.keys(args) : [];
+	if (providedKeys.length > 0) {
+		errorMessage += `You provided: ${JSON.stringify(args, null, 2)}`;
+	} else {
+		errorMessage += `You provided: {} (no parameters)`;
+	}
+
+	return {
+		success: false,
+		errorResult: {
+			formatted: errorMessage,
+			totalResults: 0,
+			resultsShared: 0,
+			isError: true,
+		},
+	};
+}
+
+/**
+ * Usage instructions when tool is called with no arguments
+ */
+const USAGE_INSTRUCTIONS = `# HuggingFace Jobs API
+
+Manage compute jobs on Hugging Face infrastructure.
+
+## Available Commands
+
+### Job Management
+- **run** - Run a job with a Docker image
+- **uv** - Run a Python script with UV (inline dependencies)
+- **ps** - List jobs
+- **logs** - Fetch job logs
+- **inspect** - Get detailed job information
+- **cancel** - Cancel a running job
+
+### Scheduled Jobs
+- **scheduled run** - Create a scheduled job
+- **scheduled uv** - Create a scheduled UV job
+- **scheduled ps** - List scheduled jobs
+- **scheduled inspect** - Get scheduled job details
+- **scheduled delete** - Delete a scheduled job
+- **scheduled suspend** - Pause a scheduled job
+- **scheduled resume** - Resume a suspended job
+
+## Examples
+
+### Run a simple job
+\`\`\`
+# Command as array (recommended, especially for complex commands)
+hf_jobs("run", {
+  "image": "python:3.12",
+  "command": ["python", "-c", "print('Hello from HF Jobs!')"],
+  "flavor": "cpu-basic"
+})
+
+# Command as string (parsed with POSIX shell semantics)
+hf_jobs("run", {
+  "image": "python:3.12",
+  "command": "python -c \\"print('Hello world!')\\"",
+  "flavor": "cpu-basic"
+})
+
+# Use a Hugging Face Space as the image
+hf_jobs("run", {
+  "image": "hf.co/spaces/username/spacename",
+  "command": ["python", "app.py"],
+  "flavor": "cpu-basic"
+})
+\`\`\`
+
+### Run multiline Python scripts
+\`\`\`
+# Use array format with newlines in the -c argument
+hf_jobs("run", {
+  "image": "python:3.12",
+  "command": ["python", "-c", "import sys\\nprint('Line 1')\\nprint('Line 2')"],
+  "flavor": "cpu-basic"
+})
+\`\`\`
+
+### Run bash/shell commands
+\`\`\`
+hf_jobs("run", {
+  "image": "ubuntu:22.04",
+  "command": ["bash", "-c", "apt-get update && apt-get install -y curl"],
+  "flavor": "cpu-basic"
+})
+\`\`\`
+
+### List running jobs
+\`\`\`
+hf_jobs("ps")
+\`\`\`
+
+### Get job logs
+\`\`\`
+hf_jobs("logs", {"job_id": "your-job-id"})
+\`\`\`
+
+### Run with GPU
+\`\`\`
+hf_jobs("run", {
+  "image": "pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel",
+  "command": ["python", "train.py"],
+  "flavor": "a10g-small"
+})
+\`\`\`
+
+### Schedule a job
+\`\`\`
+hf_jobs("scheduled run", {
+  "schedule": "@hourly",
+  "image": "python:3.12",
+  "command": ["python", "backup.py"]
+})
+\`\`\`
+
+## Hardware Flavors
+
+**CPU:** cpu-basic, cpu-upgrade, cpu-performance, cpu-xl
+**GPU:** t4-small, t4-medium, l4x1, a10g-small, a10g-large, a100-large, h100
+**Specialized:** inf2x6 (AWS Inferentia)
+
+## Command Format Guidelines
+
+**Array format (recommended):**
+- Use for complex commands, multiline scripts, or commands with special characters
+- No quoting/escaping needed: \`["python", "-c", "print('hello')"]\`
+- Works with any language: Python, bash, npm, etc.
+
+**String format:**
+- Parsed with POSIX shell semantics (quotes, escaping)
+- Good for simple commands: \`"python script.py"\`
+- Shell operators (|, &&, >, etc.) are NOT supported - use array with \`bash -c\` instead
+- Variable tokens like \`$HF_TOKEN\` are kept literal—the remote container expands them at runtime
+
+**Multiline inline scripts:**
+- Automatically wrapped in \`["/bin/sh", "-lc", "..."]\` for shell execution
+- Paste entire Python/bash snippets—they execute as if typed in a shell
+
+## Tips
+
+- Jobs default to detached mode (return immediately with job ID)
+- Use Hub resources directly: \`load_dataset('squad')\`, \`AutoModel.from_pretrained('bert-base')\`
+- Pass HF_TOKEN via secrets for private resources
+- Logs are time-limited (10s max) - check job page for full logs
+- For shell pipes/operators, use: \`["bash", "-c", "cmd1 | cmd2"]\`
+`;
+
+/**
+ * Jobs tool configuration
+ */
+export const HF_JOBS_TOOL_CONFIG = {
+	name: 'hf_jobs',
+	description:
+		'Manage HuggingFace compute jobs. Run any command in Docker containers (Python, Node.js, bash, etc.), ' +
+		'execute Python scripts with UV package manager, manage scheduled jobs, and monitor job status and logs. ' +
+		'Supports CPU and GPU hardware. Call with no arguments for full usage instructions and examples.',
+	schema: z.object({
+		command: z
+			.string()
+			.optional()
+			.describe(
+				'Command to execute: "run", "uv", "ps", "logs", "inspect", "cancel", ' +
+					'"scheduled run", "scheduled uv", "scheduled ps", "scheduled inspect", ' +
+					'"scheduled delete", "scheduled suspend", "scheduled resume"'
+			),
+		args: z.record(z.any()).optional().describe('Command-specific arguments as a JSON object'),
+	}),
+	annotations: {
+		title: 'HuggingFace Jobs',
+		destructiveHint: false,
+		readOnlyHint: false,
+		openWorldHint: true,
+	},
+} as const;
+
+/**
+ * Jobs tool implementation
+ */
+export class HfJobsTool {
+	private client: JobsApiClient;
+	private hfToken?: string;
+	private isAuthenticated: boolean;
+
+	constructor(hfToken?: string, isAuthenticated?: boolean, namespace?: string) {
+		this.hfToken = hfToken;
+		this.isAuthenticated = isAuthenticated ?? !!hfToken;
+		this.client = new JobsApiClient(hfToken, namespace);
+	}
+
+	/**
+	 * Execute a jobs command
+	 */
+	async execute(params: { command?: string; args?: Record<string, unknown> }): Promise<ToolResult> {
+		// If not authenticated, show upgrade message
+		if (!this.isAuthenticated) {
+			return {
+				formatted:
+					'Jobs are available for Pro, Team and Enterprise users. Go to https://huggingface.co/pricing to get started.',
+				totalResults: 0,
+				resultsShared: 0,
+			};
+		}
+
+		// If no command provided, return usage instructions
+		if (!params.command) {
+			return {
+				formatted: USAGE_INSTRUCTIONS,
+				totalResults: 1,
+				resultsShared: 1,
+			};
+		}
+
+		const command = params.command.toLowerCase();
+		const args = params.args || {};
+
+		// Validate command arguments if schema exists
+		const schema = COMMAND_SCHEMAS[command as keyof typeof COMMAND_SCHEMAS];
+		if (schema) {
+			const validation = validateArgs(schema, args, command);
+			if (!validation.success) {
+				return validation.errorResult;
+			}
+		}
+
+		try {
+			let result: string;
+
+			switch (command) {
+				case 'run':
+					result = await runCommand(args as RunArgs, this.client, this.hfToken);
+					break;
+
+				case 'uv':
+					result = await uvCommand(args as UvArgs, this.client, this.hfToken);
+					break;
+
+				case 'ps':
+					result = await psCommand(args as PsArgs, this.client);
+					break;
+
+				case 'logs':
+					result = await logsCommand(args as LogsArgs, this.client, this.hfToken);
+					break;
+
+				case 'inspect':
+					result = await inspectCommand(args as InspectArgs, this.client);
+					break;
+
+				case 'cancel':
+					result = await cancelCommand(args as CancelArgs, this.client);
+					break;
+
+				case 'scheduled run':
+					result = await scheduledRunCommand(args as ScheduledRunArgs, this.client);
+					break;
+
+				case 'scheduled uv':
+					result = await scheduledUvCommand(args as ScheduledUvArgs, this.client);
+					break;
+
+				case 'scheduled ps':
+					result = await scheduledPsCommand(args as ScheduledPsArgs, this.client);
+					break;
+
+				case 'scheduled inspect':
+					result = await scheduledInspectCommand(args as ScheduledJobArgs, this.client);
+					break;
+
+				case 'scheduled delete':
+					result = await scheduledDeleteCommand(args as ScheduledJobArgs, this.client);
+					break;
+
+				case 'scheduled suspend':
+					result = await scheduledSuspendCommand(args as ScheduledJobArgs, this.client);
+					break;
+
+				case 'scheduled resume':
+					result = await scheduledResumeCommand(args as ScheduledJobArgs, this.client);
+					break;
+
+				default:
+					return {
+						formatted: `Unknown command: "${params.command}"
+
+Available commands:
+- run, uv, ps, logs, inspect, cancel
+- scheduled run, scheduled uv, scheduled ps, scheduled inspect, scheduled delete, scheduled suspend, scheduled resume
+
+Call hf_jobs() with no arguments for full usage instructions.`,
+						totalResults: 0,
+						resultsShared: 0,
+					};
+			}
+
+			return {
+				formatted: result,
+				totalResults: 1,
+				resultsShared: 1,
+			};
+		} catch (error) {
+			let errorMessage = error instanceof Error ? error.message : String(error);
+
+			// If this is an HfApiError with a response body, include it
+			if (error instanceof HfApiError && error.responseBody) {
+				try {
+					// Try to parse and format the response body
+					const parsed: unknown = JSON.parse(error.responseBody);
+					const formattedBody = JSON.stringify(parsed, null, 2);
+					errorMessage += `\n\nServer response:\n${formattedBody}`;
+				} catch {
+					// If not valid JSON, include raw response (if not too long)
+					if (error.responseBody.length < 500) {
+						errorMessage += `\n\nServer response: ${error.responseBody}`;
+					}
+				}
+			}
+
+			return {
+				formatted: `Error executing ${params.command}: ${errorMessage}`,
+				totalResults: 0,
+				resultsShared: 0,
+				isError: true,
+			};
+		}
+	}
+}

package/src/jobs/types.ts

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+
+/**
+ * Hardware flavors available for jobs
+ */
+export const CPU_FLAVORS = ['cpu-basic', 'cpu-upgrade', 'cpu-performance', 'cpu-xl'] as const;
+
+export const GPU_FLAVORS = [
+	'sprx8',
+	'zero-a10g',
+	't4-small',
+	't4-medium',
+	'l4x1',
+	'l4x4',
+	'l40sx1',
+	'l40sx4',
+	'l40sx8',
+	'a10g-small',
+	'a10g-large',
+	'a10g-largex2',
+	'a10g-largex4',
+	'a100-large',
+	'h100',
+	'h100x8',
+] as const;
+
+export const SPECIALIZED_FLAVORS = ['inf2x6'] as const;
+
+export const ALL_FLAVORS = [...CPU_FLAVORS, ...GPU_FLAVORS, ...SPECIALIZED_FLAVORS] as const;
+
+export type JobFlavor = (typeof ALL_FLAVORS)[number];
+
+/**
+ * Job status stages (from OpenAPI spec)
+ */
+export type JobStage = 'RUNNING' | 'COMPLETED' | 'CANCELED' | 'ERROR' | 'DELETED';
+
+/**
+ * Job status object from API
+ */
+export interface JobStatus {
+	stage: JobStage;
+	message?: string | null;
+}
+
+/**
+ * Job owner information
+ */
+export interface JobOwner {
+	id: string;
+	name: string;
+	type: 'user' | 'org';
+}
+
+/**
+ * Job information from API
+ * Based on OpenAPI schema
+ */
+export interface JobInfo {
+	id: string;
+	createdAt: string;
+	dockerImage?: string;
+	spaceId?: string;
+	command?: string[];
+	arguments?: string[];
+	environment: Record<string, string>;
+	secrets?: Record<string, string | null>;
+	flavor: string;
+	status: JobStatus;
+	owner: JobOwner;
+	createdBy?: JobOwner;
+	tags?: string[];
+	timeout?: number;
+	// Additional fields not in OpenAPI but present in responses
+	url?: string;
+	endpoint?: string;
+	finishedAt?: string;
+}
+
+/**
+ * Job specification for creating jobs
+ */
+export interface JobSpec {
+	dockerImage?: string;
+	spaceId?: string;
+	command: string[];
+	arguments?: string[];
+	environment?: Record<string, string>;
+	secrets?: Record<string, string>;
+	flavor: string;
+	timeoutSeconds?: number;
+}
+
+/**
+ * Scheduled job specification
+ */
+export interface ScheduledJobSpec {
+	schedule: string;
+	suspend?: boolean;
+	jobSpec: JobSpec;
+}
+
+/**
+ * Scheduled job information from API
+ */
+export interface ScheduledJobInfo {
+	id: string;
+	schedule: string;
+	suspend: boolean;
+	jobSpec: JobSpec;
+	lastRun?: string;
+	nextRun?: string;
+	owner: JobOwner;
+	createdAt: string;
+}
+
+/**
+ * Log event from SSE stream
+ */
+export interface LogEvent {
+	timestamp: string;
+	data: string;
+}
+
+/**
+ * Zod schemas for command arguments
+ */
+
+// Common args shared across commands
+const commonArgsSchema = z.object({
+	namespace: z.string().optional().describe('Target namespace (username or organization). Defaults to current user.'),
+});
+
+// Run command args
+export const runArgsSchema = commonArgsSchema.extend({
+	image: z.string().describe('Docker image or HF Space URL (e.g., "python:3.12" or "hf.co/spaces/user/space")'),
+	command: z
+		.union([z.string(), z.array(z.string())])
+		.describe(
+			'Command to execute. Array format recommended (e.g., ["python", "script.py"]). ' +
+				'String format is parsed with POSIX shell semantics (quotes, escaping). ' +
+				'For multiline scripts, use array with newlines in arguments.'
+		),
+	flavor: z
+		.enum(ALL_FLAVORS)
+		.optional()
+		.default('cpu-basic')
+		.describe(`Hardware flavor. Options: ${ALL_FLAVORS.join(', ')}`),
+	env: z.record(z.string()).optional().describe('Environment variables as key-value pairs'),
+	secrets: z.record(z.string()).optional().describe('Secret environment variables (encrypted server-side)'),
+	timeout: z
+		.string()
+		.optional()
+		.describe('Max duration (e.g., "5m", "2h", "30s"). Default: 30m')
+		.default('30m'),
+	detach: z
+		.boolean()
+		.optional()
+		.default(true)
+		.describe('Run in background and return immediately (default: true)'),
+});
+
+// UV command args
+export const uvArgsSchema = commonArgsSchema.extend({
+	script: z
+		.string()
+		.describe('Python script: local file path, URL, or inline code. UV will handle dependencies automatically.'),
+	repo: z.string().optional().describe('Persistent repository name for script storage'),
+	with_deps: z.array(z.string()).optional().describe('Additional package dependencies'),
+	script_args: z.array(z.string()).optional().describe('Arguments to pass to the script'),
+	python: z.string().optional().describe('Python interpreter version (e.g., "3.12")'),
+	flavor: z.enum(ALL_FLAVORS).optional().default('cpu-basic').describe('Hardware flavor'),
+	env: z.record(z.string()).optional().describe('Environment variables'),
+	secrets: z.record(z.string()).optional().describe('Secret environment variables'),
+	timeout: z.string().optional().default('30m').describe('Max duration'),
+	detach: z.boolean().optional().default(true).describe('Run in background'),
+});
+
+// PS command args
+export const psArgsSchema = commonArgsSchema.extend({
+	all: z.boolean().optional().default(false).describe('Show all jobs (default: only running)'),
+	status: z.string().optional().describe('Filter by status (e.g., "RUNNING", "COMPLETED")'),
+});
+
+// Logs command args
+export const logsArgsSchema = commonArgsSchema.extend({
+	job_id: z.string().describe('Job ID to fetch logs from'),
+	tail: z.number().optional().default(20).describe('Number of lines to return (default: 20)'),
+});
+
+// Inspect command args
+export const inspectArgsSchema = commonArgsSchema.extend({
+	job_id: z.union([z.string(), z.array(z.string())]).describe('Job ID(s) to inspect'),
+});
+
+// Cancel command args
+export const cancelArgsSchema = commonArgsSchema.extend({
+	job_id: z.string().describe('Job ID to cancel'),
+});
+
+// Scheduled run args
+export const scheduledRunArgsSchema = runArgsSchema.extend({
+	schedule: z
+		.string()
+		.describe('Schedule: cron expression or shorthand (@hourly, @daily, @weekly, @monthly, @yearly)'),
+	suspend: z.boolean().optional().default(false).describe('Create in suspended state'),
+});
+
+// Scheduled UV args
+export const scheduledUvArgsSchema = uvArgsSchema.extend({
+	schedule: z.string().describe('Schedule: cron expression or shorthand'),
+	suspend: z.boolean().optional().default(false).describe('Create in suspended state'),
+});
+
+// Scheduled PS args
+export const scheduledPsArgsSchema = commonArgsSchema.extend({
+	all: z.boolean().optional().default(false).describe('Show all scheduled jobs (default: hide suspended)'),
+});
+
+// Scheduled inspect/delete/suspend/resume args
+export const scheduledJobArgsSchema = commonArgsSchema.extend({
+	scheduled_job_id: z.string().describe('Scheduled job ID'),
+});
+
+/**
+ * Export type aliases for use in commands
+ */
+export type RunArgs = z.infer<typeof runArgsSchema>;
+export type UvArgs = z.infer<typeof uvArgsSchema>;
+export type PsArgs = z.infer<typeof psArgsSchema>;
+export type LogsArgs = z.infer<typeof logsArgsSchema>;
+export type InspectArgs = z.infer<typeof inspectArgsSchema>;
+export type CancelArgs = z.infer<typeof cancelArgsSchema>;
+export type ScheduledRunArgs = z.infer<typeof scheduledRunArgsSchema>;
+export type ScheduledUvArgs = z.infer<typeof scheduledUvArgsSchema>;
+export type ScheduledPsArgs = z.infer<typeof scheduledPsArgsSchema>;
+export type ScheduledJobArgs = z.infer<typeof scheduledJobArgsSchema>;

package/src/tool-ids.ts

@@ -21,6 +21,7 @@ import {
 	DOCS_SEMANTIC_SEARCH_CONFIG,
 	DOC_FETCH_CONFIG,
 	USE_SPACE_TOOL_CONFIG,
+	HF_JOBS_TOOL_CONFIG,
 } from './index.js';
 
 // Extract tool IDs from their configs (single source of truth)
@@ -41,6 +42,7 @@ export const USER_SUMMARY_PROMPT_ID = USER_SUMMARY_PROMPT_CONFIG.name;
 export const PAPER_SUMMARY_PROMPT_ID = PAPER_SUMMARY_PROMPT_CONFIG.name;
 export const MODEL_DETAIL_PROMPT_ID = MODEL_DETAIL_PROMPT_CONFIG.name;
 export const DATASET_DETAIL_PROMPT_ID = DATASET_DETAIL_PROMPT_CONFIG.name;
+export const HF_JOBS_TOOL_ID = HF_JOBS_TOOL_CONFIG.name;
 
 // Complete list of all built-in tool IDs
 export const ALL_BUILTIN_TOOL_IDS = [
@@ -57,6 +59,7 @@ export const ALL_BUILTIN_TOOL_IDS = [
 	DOCS_SEMANTIC_SEARCH_TOOL_ID,
 	DOC_FETCH_TOOL_ID,
 	USE_SPACE_TOOL_ID,
+	HF_JOBS_TOOL_ID,
 ] as const;
 // Grouped tool IDs for bouquet configurations
 export const TOOL_ID_GROUPS = {
@@ -67,7 +70,13 @@ export const TOOL_ID_GROUPS = {
 		PAPER_SEARCH_TOOL_ID,
 		DOCS_SEMANTIC_SEARCH_TOOL_ID,
 	] as const,
-	spaces: [SPACE_SEARCH_TOOL_ID, DUPLICATE_SPACE_TOOL_ID, SPACE_INFO_TOOL_ID, SPACE_FILES_TOOL_ID, USE_SPACE_TOOL_ID] as const,
+	spaces: [
+		SPACE_SEARCH_TOOL_ID,
+		DUPLICATE_SPACE_TOOL_ID,
+		SPACE_INFO_TOOL_ID,
+		SPACE_FILES_TOOL_ID,
+		USE_SPACE_TOOL_ID,
+	] as const,
 	detail: [MODEL_DETAIL_TOOL_ID, DATASET_DETAIL_TOOL_ID, HUB_INSPECT_TOOL_ID] as const,
 	docs: [DOCS_SEMANTIC_SEARCH_TOOL_ID, DOC_FETCH_TOOL_ID] as const,
 	hf_api: [
@@ -77,6 +86,7 @@ export const TOOL_ID_GROUPS = {
 		PAPER_SEARCH_TOOL_ID,
 		HUB_INSPECT_TOOL_ID,
 		DOCS_SEMANTIC_SEARCH_TOOL_ID,
+		//		HF_JOBS_TOOL_ID,
 	] as const,
 	all: [...ALL_BUILTIN_TOOL_IDS] as const,
 } as const;