@llmindset/hf-mcp 0.2.53 → 0.2.54

package/src/space/utils/gradio-schema.ts

@@ -0,0 +1,74 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export type ParsedSchemaFormat = 'array' | 'object';
+
+export interface ParsedGradioSchema {
+	format: ParsedSchemaFormat;
+	tools: Array<{ name: string; description?: string; inputSchema: unknown }>;
+}
+
+/**
+ * Parse a Gradio MCP schema that may be returned as either:
+ * - Array format: [{ name, description?, inputSchema }, ...]
+ * - Object format: { toolName: { properties, required, description?, ... }, ... }
+ *
+ * Returns a normalized list of tools and the detected format.
+ * Throws if the schema is invalid or empty.
+ */
+export function parseGradioSchemaResponse(schemaResponse: unknown): ParsedGradioSchema {
+	// Array format
+	if (Array.isArray(schemaResponse)) {
+		const tools = (schemaResponse as Array<unknown>).filter((tool): tool is { name: string; description?: string; inputSchema: unknown } => {
+			return (
+				typeof tool === 'object' &&
+				tool !== null &&
+				'name' in tool &&
+				typeof (tool as { name?: unknown }).name === 'string' &&
+				'inputSchema' in tool
+			);
+		});
+
+		if (tools.length === 0) {
+			throw new Error('Invalid schema: no tools found in array schema');
+		}
+
+		return {
+			format: 'array',
+			tools,
+		};
+	}
+
+	// Object format
+	if (typeof schemaResponse === 'object' && schemaResponse !== null) {
+		const entries = Object.entries(schemaResponse as Record<string, unknown>);
+		const tools: ParsedGradioSchema['tools'] = entries.map(([name, toolSchema]) => ({
+			name,
+			description: typeof (toolSchema as { description?: unknown }).description === 'string' ? (toolSchema as { description?: string }).description : undefined,
+			inputSchema: toolSchema,
+		}));
+
+		if (tools.length === 0) {
+			throw new Error('Invalid schema: no tools found in object schema');
+		}
+
+		return {
+			format: 'object',
+			tools,
+		};
+	}
+
+	throw new Error('Invalid schema format: expected array or object');
+}
+
+/**
+ * Convert ParsedGradioSchema.tools into SDK Tool[] shape, filtering out <lambda tools.
+ */
+export function normalizeParsedTools(parsed: ParsedGradioSchema): Tool[] {
+	return parsed.tools
+		.filter((t) => !t.name.toLowerCase().includes('<lambda'))
+		.map((parsedTool) => ({
+			name: parsedTool.name,
+			description: parsedTool.description || `${parsedTool.name} tool`,
+			inputSchema: parsedTool.inputSchema as Tool['inputSchema'],
+		}));
+}

package/test/gradio-caller.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { rewriteReplicaUrlsInResult, extractReplicaId } from '../src/space/utils/gradio-caller.js';
+import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+
+const baseResult: typeof CallToolResultSchema._type = {
+	content: [],
+	isError: false,
+};
+
+describe('extractReplicaId', () => {
+	it('extracts the suffix after hyphen', () => {
+		expect(extractReplicaId('oyerizs4-dspr4')).toBe('dspr4');
+	});
+
+	it('returns null when no hyphen exists', () => {
+		expect(extractReplicaId('singlepart')).toBeNull();
+	});
+
+	it('returns null for empty input', () => {
+		expect(extractReplicaId('')).toBeNull();
+		expect(extractReplicaId(undefined)).toBeNull();
+	});
+});
+
+describe('rewriteReplicaUrlsInResult', () => {
+	const matchUrl = 'https://mcp-tools-qwen-image-fast.hf.space/gradio_api';
+	const rewrittenUrl = 'https://mcp-tools-qwen-image-fast.hf.space/--replicas/dspr4/gradio_api';
+
+	beforeEach(() => {
+		delete process.env.NO_REPLICA_REWRITE;
+	});
+
+	afterEach(() => {
+		delete process.env.NO_REPLICA_REWRITE;
+	});
+
+	it('rewrites URLs in text content when header is present', () => {
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [
+				{ type: 'text', text: `prefix ${matchUrl} suffix` },
+				`plain ${matchUrl}`,
+				{ type: 'image', data: 'noop' },
+			],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, 'oyerizs4-dspr4');
+
+		expect((rewritten.content[0] as { text: string }).text).toContain(rewrittenUrl);
+		expect((rewritten.content[1] as { text: string }).text).toContain(rewrittenUrl);
+		// Non-text blocks untouched
+		expect(rewritten.content[2]).toEqual(result.content[2]);
+	});
+
+	it('does nothing when header is missing', () => {
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [{ type: 'text', text: `prefix ${matchUrl} suffix` }],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, undefined);
+
+		expect(rewritten).toEqual(result);
+	});
+
+	it('respects NO_REPLICA_REWRITE env', () => {
+		process.env.NO_REPLICA_REWRITE = '1';
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [{ type: 'text', text: matchUrl }],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, 'oyerizs4-dspr4');
+
+		expect(rewritten).toEqual(result);
+	});
+});