@llmindset/hf-mcp 0.2.32 → 0.2.34

package/src/types/tool-result.ts

@@ -21,4 +21,10 @@ export interface ToolResult {
 	 * For prompts: 1 if generated successfully
 	 */
 	resultsShared: number;
+
+	/**
+	 * Indicates whether this result represents an error condition
+	 * When true, formatted contains an error message
+	 */
+	isError?: boolean;
 }

package/src/use-space.ts

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { HfApiCall } from './hf-api-call.js';
 import { spaceInfo, type SpaceEntry } from '@huggingface/hub';
 import type { ToolResult } from './types/tool-result.js';
-import './types/mcp-ui-server-shim.js';
 import { createUIResource } from '@mcp-ui/server';
 // Define the return type that matches MCP server expectations
 interface UseSpaceResult {

package/test/jobs/command-translation.spec.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect } from 'vitest';
+import { parseTimeout, parseImageSource, parseCommand, createJobSpec } from '../../src/jobs/commands/utils.js';
+
+describe('Jobs Command Translation', () => {
+	describe('parseTimeout', () => {
+		it('should parse timeout with seconds', () => {
+			expect(parseTimeout('30s')).toBe(30);
+			expect(parseTimeout('45s')).toBe(45);
+		});
+
+		it('should parse timeout with minutes', () => {
+			expect(parseTimeout('5m')).toBe(300);
+			expect(parseTimeout('10m')).toBe(600);
+		});
+
+		it('should parse timeout with hours', () => {
+			expect(parseTimeout('2h')).toBe(7200);
+			expect(parseTimeout('1h')).toBe(3600);
+		});
+
+		it('should parse timeout with days', () => {
+			expect(parseTimeout('1d')).toBe(86400);
+		});
+
+		it('should parse plain number as seconds', () => {
+			expect(parseTimeout('300')).toBe(300);
+			expect(parseTimeout('60')).toBe(60);
+		});
+
+		it('should handle decimal values', () => {
+			expect(parseTimeout('1.5h')).toBe(5400);
+			expect(parseTimeout('2.5m')).toBe(150);
+		});
+
+		it('should throw error for invalid format', () => {
+			expect(() => parseTimeout('invalid')).toThrow(/Invalid timeout format/);
+			expect(() => parseTimeout('xyz')).toThrow(/Invalid timeout format/);
+		});
+
+		it('should parse partial numbers (parseInt behavior)', () => {
+			// parseInt stops at first non-numeric, so '5x' becomes 5
+			expect(parseTimeout('5x')).toBe(5);
+			expect(parseTimeout('10abc')).toBe(10);
+		});
+	});
+
+	describe('parseImageSource', () => {
+		it('should detect Docker Hub images', () => {
+			const result = parseImageSource('python:3.12');
+			expect(result.dockerImage).toBe('python:3.12');
+			expect(result.spaceId).toBeUndefined();
+		});
+
+		it('should detect HuggingFace Space URLs with https://huggingface.co/', () => {
+			const result = parseImageSource('https://huggingface.co/spaces/user/app');
+			expect(result.spaceId).toBe('user/app');
+			expect(result.dockerImage).toBeUndefined();
+		});
+
+		it('should detect HuggingFace Space URLs with https://hf.co/', () => {
+			const result = parseImageSource('https://hf.co/spaces/user/app');
+			expect(result.spaceId).toBe('user/app');
+			expect(result.dockerImage).toBeUndefined();
+		});
+
+		it('should detect HuggingFace Space URLs without https prefix', () => {
+			const result = parseImageSource('huggingface.co/spaces/user/app');
+			expect(result.spaceId).toBe('user/app');
+			expect(result.dockerImage).toBeUndefined();
+		});
+
+		it('should detect HuggingFace Space URLs with hf.co shorthand', () => {
+			const result = parseImageSource('hf.co/spaces/user/app');
+			expect(result.spaceId).toBe('user/app');
+			expect(result.dockerImage).toBeUndefined();
+		});
+
+		it('should treat complex docker images as docker images', () => {
+			const result = parseImageSource('ghcr.io/owner/repo:tag');
+			expect(result.dockerImage).toBe('ghcr.io/owner/repo:tag');
+			expect(result.spaceId).toBeUndefined();
+		});
+	});
+
+	describe('parseCommand', () => {
+		it('should return array commands as-is', () => {
+			const result = parseCommand(['python', '-c', 'print("hello")']);
+			expect(result.command).toEqual(['python', '-c', 'print("hello")']);
+		});
+
+		it('should split simple string commands', () => {
+			const result = parseCommand('python script.py');
+			expect(result.command).toEqual(['python', 'script.py']);
+		});
+
+		it('should handle single word commands', () => {
+			const result = parseCommand('ls');
+			expect(result.command).toEqual(['ls']);
+		});
+
+		it('should handle double-quoted strings', () => {
+			const result = parseCommand('python -c "print(\'Hello world!\')"');
+			expect(result.command).toEqual(['python', '-c', "print('Hello world!')"]);
+		});
+
+		it('should handle single-quoted strings', () => {
+			const result = parseCommand("python -c 'print(\"Hello world!\")'");
+			expect(result.command).toEqual(['python', '-c', 'print("Hello world!")']);
+		});
+
+		it('should handle escaped quotes', () => {
+			const result = parseCommand('echo "He said \\"hello\\""');
+			expect(result.command).toEqual(['echo', 'He said "hello"']);
+		});
+
+		it('should handle mixed quotes and spaces', () => {
+			const result = parseCommand('python -c "print(\'hello world\')"');
+			expect(result.command).toEqual(['python', '-c', "print('hello world')"]);
+		});
+
+		it('should handle multiple quoted arguments', () => {
+			const result = parseCommand('cmd "arg one" "arg two" "arg three"');
+			expect(result.command).toEqual(['cmd', 'arg one', 'arg two', 'arg three']);
+		});
+
+		it('should handle quoted strings with no spaces', () => {
+			const result = parseCommand('echo "hello"');
+			expect(result.command).toEqual(['echo', 'hello']);
+		});
+
+		it('should handle empty quotes', () => {
+			const result = parseCommand('echo "" test');
+			expect(result.command).toEqual(['echo', '', 'test']);
+		});
+
+		it('should handle real-world example from docs', () => {
+			const result = parseCommand('python -c "print(\'Hello world!\')"');
+			expect(result.command).toEqual(['python', '-c', "print('Hello world!')"]);
+		});
+
+		it('should handle commands with multiple spaces', () => {
+			const result = parseCommand('python    script.py    --arg');
+			expect(result.command).toEqual(['python', 'script.py', '--arg']);
+		});
+
+		it('should handle commands with tabs', () => {
+			const result = parseCommand('python\tscript.py\t--arg');
+			expect(result.command).toEqual(['python', 'script.py', '--arg']);
+		});
+
+		it('should handle mixed whitespace', () => {
+			const result = parseCommand('cmd  \t arg1\t\t  arg2');
+			expect(result.command).toEqual(['cmd', 'arg1', 'arg2']);
+		});
+
+		it('should handle backslash escaping (POSIX shell semantics)', () => {
+			// In POSIX shells, \n in double quotes is literal, not a newline
+			const result = parseCommand('echo "hello\\nworld"');
+			expect(result.command).toEqual(['echo', 'hello\\nworld']);
+		});
+
+		it('should handle backslash literally in single quotes', () => {
+			const result = parseCommand("echo 'hello\\nworld'");
+			expect(result.command).toEqual(['echo', 'hello\\nworld']);
+		});
+
+		it('should throw error for shell operators', () => {
+			expect(() => parseCommand('echo hello | grep world')).toThrow(/Unsupported shell syntax/);
+			expect(() => parseCommand('ls && pwd')).toThrow(/Unsupported shell syntax/);
+			expect(() => parseCommand('cat file > output.txt')).toThrow(/Unsupported shell syntax/);
+		});
+
+		it('should throw error for empty command', () => {
+			expect(() => parseCommand('')).toThrow(/Command cannot be empty/);
+			expect(() => parseCommand('   ')).toThrow(/Command cannot be empty/);
+		});
+
+		it('should handle environment variables as literal references', () => {
+			// shell-quote parses $HOME as an env token, which we format as literal string
+			// This preserves the variable reference for the job runtime to handle
+			const result = parseCommand('echo $HOME');
+			expect(result.command).toEqual(['echo', '$HOME']);
+		});
+
+		it('should preserve complex environment variable syntax', () => {
+			const result = parseCommand('echo ${FOO:-bar} ${BAR?missing}');
+			expect(result.command).toEqual(['echo', '${FOO:-bar}', '${BAR?missing}']);
+		});
+
+		it('should retain special parameter references', () => {
+			const result = parseCommand('echo $$ $1 $@ $* $- $! $_');
+			expect(result.command).toEqual(['echo', '$$', '$1', '$@', '$*', '$-', '$!', '$_']);
+		});
+
+		it('should treat escaped dollars as literal variables', () => {
+			const result = parseCommand('echo \\$FOO "$BAR"');
+			expect(result.command).toEqual(['echo', '$FOO', '$BAR']);
+		});
+
+		it('should handle multiline Python in array format', () => {
+			const result = parseCommand(['python', '-c', 'import sys\nprint("hello")\nprint("world")']);
+			expect(result.command).toEqual(['python', '-c', 'import sys\nprint("hello")\nprint("world")']);
+		});
+	});
+
+	describe('createJobSpec', () => {
+		it('should create a basic job spec', () => {
+			const spec = createJobSpec({
+				image: 'python:3.12',
+				command: 'python -c "print(123)"',
+			});
+
+			expect(spec.dockerImage).toBe('python:3.12');
+			expect(spec.command).toEqual(['python', '-c', 'print(123)']);
+			expect(spec.flavor).toBe('cpu-basic');
+		});
+
+		it('should handle Space URLs', () => {
+			const spec = createJobSpec({
+				image: 'hf.co/spaces/user/app',
+				command: 'python run.py',
+			});
+
+			expect(spec.spaceId).toBe('user/app');
+			expect(spec.dockerImage).toBeUndefined();
+		});
+
+		it('should include environment variables', () => {
+			const spec = createJobSpec({
+				image: 'python:3.12',
+				command: 'python script.py',
+				env: { FOO: 'bar', BAZ: 'qux' },
+			});
+
+			expect(spec.environment).toEqual({ FOO: 'bar', BAZ: 'qux' });
+		});
+
+		it('should include secrets', () => {
+			const spec = createJobSpec({
+				image: 'python:3.12',
+				command: 'python script.py',
+				secrets: { API_KEY: 'secret123' },
+			});
+
+			expect(spec.secrets).toEqual({ API_KEY: 'secret123' });
+		});
+
+		it('should parse and include timeout', () => {
+			const spec = createJobSpec({
+				image: 'python:3.12',
+				command: 'python script.py',
+				timeout: '5m',
+			});
+
+			expect(spec.timeoutSeconds).toBe(300);
+		});
+
+		it('should use specified flavor', () => {
+			const spec = createJobSpec({
+				image: 'python:3.12',
+				command: 'python script.py',
+				flavor: 'a10g-small',
+			});
+
+			expect(spec.flavor).toBe('a10g-small');
+		});
+
+		it('should handle array commands', () => {
+			const spec = createJobSpec({
+				image: 'ubuntu',
+				command: ['bash', '-c', 'echo hello'],
+			});
+
+			expect(spec.command).toEqual(['bash', '-c', 'echo hello']);
+		});
+	});
+});

package/test/jobs/formatters.spec.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect } from 'vitest';
+import { formatJobsTable, formatScheduledJobsTable, formatJobDetails } from '../../src/jobs/formatters.js';
+import type { JobInfo, ScheduledJobInfo, JobSpec } from '../../src/jobs/types.js';
+
+describe('Jobs Formatters', () => {
+	describe('formatJobsTable', () => {
+		it('should return message for empty job list', () => {
+			const result = formatJobsTable([]);
+			expect(result).toBe('No jobs found.');
+		});
+
+		it('should format a single job as markdown table', () => {
+			const jobs: JobInfo[] = [
+				{
+					id: 'job123',
+					createdAt: '2025-01-20T10:00:00Z',
+					dockerImage: 'python:3.12',
+					command: ['python', 'script.py'],
+					flavor: 'cpu-basic',
+					status: { stage: 'RUNNING' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+			];
+
+			const result = formatJobsTable(jobs);
+
+			// Should be a markdown table
+			expect(result).toContain('| JOB ID');
+			expect(result).toContain('| IMAGE/SPACE');
+			expect(result).toContain('| COMMAND');
+			expect(result).toContain('| CREATED');
+			expect(result).toContain('| STATUS');
+
+			// Should contain separator line
+			expect(result).toContain('|---');
+
+			// Should contain job data
+			expect(result).toContain('job123');
+			expect(result).toContain('python:3.12');
+			expect(result).toContain('python script.py');
+			expect(result).toContain('RUNNING');
+		});
+
+		it('should format multiple jobs', () => {
+			const jobs: JobInfo[] = [
+				{
+					id: 'job123',
+					createdAt: '2025-01-20T10:00:00Z',
+					dockerImage: 'python:3.12',
+					command: ['python', 'script.py'],
+					flavor: 'cpu-basic',
+					status: { stage: 'RUNNING' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+				{
+					id: 'job456',
+					createdAt: '2025-01-20T11:00:00Z',
+					dockerImage: 'ubuntu',
+					command: ['bash', 'test.sh'],
+					flavor: 'a10g-small',
+					status: { stage: 'COMPLETED' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+			];
+
+			const result = formatJobsTable(jobs);
+
+			// Should contain both jobs
+			expect(result).toContain('job123');
+			expect(result).toContain('job456');
+			expect(result).toContain('python:3.12');
+			expect(result).toContain('ubuntu');
+			expect(result).toContain('RUNNING');
+			expect(result).toContain('COMPLETED');
+		});
+
+		it('should handle Space IDs instead of Docker images', () => {
+			const jobs: JobInfo[] = [
+				{
+					id: 'job789',
+					createdAt: '2025-01-20T12:00:00Z',
+					spaceId: 'user/myspace',
+					command: ['python', 'app.py'],
+					flavor: 'cpu-basic',
+					status: { stage: 'RUNNING' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+			];
+
+			const result = formatJobsTable(jobs);
+			expect(result).toContain('user/myspace');
+		});
+
+		it('should truncate long values with ellipsis', () => {
+			const jobs: JobInfo[] = [
+				{
+					id: 'a'.repeat(50),
+					createdAt: '2025-01-20T10:00:00Z',
+					dockerImage: 'very-long-image-name-that-exceeds-column-width',
+					command: ['python', '-c', 'print(' + 'x'.repeat(100) + ')'],
+					flavor: 'cpu-basic',
+					status: { stage: 'RUNNING' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+			];
+
+			const result = formatJobsTable(jobs);
+			expect(result).toContain('...');
+		});
+	});
+
+	describe('formatScheduledJobsTable', () => {
+		it('should return message for empty scheduled job list', () => {
+			const result = formatScheduledJobsTable([]);
+			expect(result).toBe('No scheduled jobs found.');
+		});
+
+		it('should format a scheduled job as markdown table', () => {
+			const jobSpec: JobSpec = {
+				dockerImage: 'python:3.12',
+				command: ['python', 'backup.py'],
+				flavor: 'cpu-basic',
+			};
+
+			const jobs: ScheduledJobInfo[] = [
+				{
+					id: 'sched123',
+					schedule: '@hourly',
+					suspend: false,
+					jobSpec,
+					lastRun: '2025-01-20T10:00:00Z',
+					nextRun: '2025-01-20T11:00:00Z',
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					createdAt: '2025-01-20T09:00:00Z',
+				},
+			];
+
+			const result = formatScheduledJobsTable(jobs);
+
+			// Should be a markdown table
+			expect(result).toContain('| ID');
+			expect(result).toContain('| SCHEDULE');
+			expect(result).toContain('| IMAGE/SPACE');
+			expect(result).toContain('| COMMAND');
+			expect(result).toContain('| LAST RUN');
+			expect(result).toContain('| NEXT RUN');
+			expect(result).toContain('| SUSPENDED');
+
+			// Should contain job data
+			expect(result).toContain('sched123');
+			expect(result).toContain('@hourly');
+			expect(result).toContain('python:3.12');
+			expect(result).toContain('No'); // Not suspended
+		});
+
+		it('should show Yes for suspended jobs', () => {
+			const jobSpec: JobSpec = {
+				dockerImage: 'ubuntu',
+				command: ['bash', 'cleanup.sh'],
+				flavor: 'cpu-basic',
+			};
+
+			const jobs: ScheduledJobInfo[] = [
+				{
+					id: 'sched456',
+					schedule: '@daily',
+					suspend: true,
+					jobSpec,
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					createdAt: '2025-01-20T09:00:00Z',
+				},
+			];
+
+			const result = formatScheduledJobsTable(jobs);
+			expect(result).toContain('Yes'); // Suspended
+		});
+	});
+
+	describe('formatJobDetails', () => {
+		it('should format a single job as JSON in code block', () => {
+			const job: JobInfo = {
+				id: 'job123',
+				createdAt: '2025-01-20T10:00:00Z',
+				dockerImage: 'python:3.12',
+				command: ['python', 'script.py'],
+				flavor: 'cpu-basic',
+				status: { stage: 'RUNNING', message: null },
+				owner: { id: 'u123', name: 'testuser', type: 'user' },
+				environment: {},
+			};
+
+			const result = formatJobDetails(job);
+
+			// Should be wrapped in code block
+			expect(result).toMatch(/^```json\n/);
+			expect(result).toMatch(/\n```$/);
+
+			// Should contain job data as JSON
+			expect(result).toContain('"id": "job123"');
+			expect(result).toContain('"dockerImage": "python:3.12"');
+			expect(result).toContain('"stage": "RUNNING"');
+		});
+
+		it('should format multiple jobs as JSON array', () => {
+			const jobs: JobInfo[] = [
+				{
+					id: 'job123',
+					createdAt: '2025-01-20T10:00:00Z',
+					dockerImage: 'python:3.12',
+					command: ['python', 'script.py'],
+					flavor: 'cpu-basic',
+					status: { stage: 'RUNNING' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+				{
+					id: 'job456',
+					createdAt: '2025-01-20T11:00:00Z',
+					dockerImage: 'ubuntu',
+					command: ['bash', 'test.sh'],
+					flavor: 'cpu-basic',
+					status: { stage: 'COMPLETED' },
+					owner: { id: 'u123', name: 'testuser', type: 'user' },
+					environment: {},
+				},
+			];
+
+			const result = formatJobDetails(jobs);
+
+			// Should be wrapped in code block
+			expect(result).toMatch(/^```json\n/);
+			expect(result).toMatch(/\n```$/);
+
+			// Should be an array
+			expect(result).toContain('[');
+			expect(result).toContain(']');
+
+			// Should contain both jobs
+			expect(result).toContain('"id": "job123"');
+			expect(result).toContain('"id": "job456"');
+		});
+
+		it('should format JSON with proper indentation', () => {
+			const job: JobInfo = {
+				id: 'job123',
+				createdAt: '2025-01-20T10:00:00Z',
+				dockerImage: 'python:3.12',
+				command: ['python', 'script.py'],
+				flavor: 'cpu-basic',
+				status: { stage: 'RUNNING' },
+				owner: { id: 'u123', name: 'testuser', type: 'user' },
+				environment: {},
+			};
+
+			const result = formatJobDetails(job);
+
+			// Should have proper indentation (2 spaces)
+			expect(result).toContain('  "id"');
+			expect(result).toContain('  "createdAt"');
+		});
+	});
+});

package/test/jobs/uv-command.spec.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest';
+import { uvCommand } from '../../src/jobs/commands/run.js';
+import type { JobsApiClient } from '../../src/jobs/api-client.js';
+import type { JobInfo, JobSpec } from '../../src/jobs/types.js';
+
+function setupMockClient() {
+	let capturedSpec: JobSpec | undefined;
+
+	const runJob = vi.fn(async (spec: JobSpec) => {
+		capturedSpec = spec;
+		const job: JobInfo = {
+			id: 'job-123',
+			createdAt: new Date().toISOString(),
+			command: spec.command,
+			arguments: spec.arguments,
+			environment: spec.environment ?? {},
+			secrets: {},
+			flavor: spec.flavor,
+			status: { stage: 'RUNNING' },
+			owner: { id: 'owner-1', name: 'tester', type: 'user' },
+		};
+		return job;
+	});
+
+	const getLogsUrl = vi.fn(() => 'https://example.test/logs');
+
+	const client = {
+		runJob,
+		getLogsUrl,
+	} as unknown as JobsApiClient;
+
+	return {
+		client,
+		runJob,
+		getLogsUrl,
+		get lastSpec() {
+			return capturedSpec;
+		},
+	};
+}
+
+describe('uvCommand', () => {
+	it('wraps inline scripts in a shell pipeline executed via /bin/sh', async () => {
+		const harness = setupMockClient();
+		const script = 'print("hello")\nprint("world")';
+
+		await uvCommand({ script, detach: true }, harness.client);
+
+		expect(harness.runJob).toHaveBeenCalledTimes(1);
+		expect(harness.lastSpec).toBeDefined();
+		expect(harness.lastSpec?.command).toEqual([
+			'/bin/sh',
+			'-lc',
+			expect.stringContaining('uv run'),
+		]);
+
+		const encoded = Buffer.from(script).toString('base64');
+		expect(harness.lastSpec?.command?.[2]).toContain(`echo "${encoded}" | base64 -d | uv run`);
+		expect(harness.lastSpec?.command?.[2]).toContain(' -');
+	});
+
+	it('includes dependency and python flags when provided', async () => {
+		const harness = setupMockClient();
+		const script = 'print("deps")\nprint("python")';
+
+		await uvCommand(
+			{
+				script,
+				with_deps: ['numpy', 'pandas'],
+				python: '3.12',
+				detach: true,
+			},
+			harness.client
+		);
+
+		const shellCommand = harness.lastSpec?.command?.[2];
+		expect(shellCommand).toContain('--with numpy');
+		expect(shellCommand).toContain('--with pandas');
+		expect(shellCommand).toContain('-p 3.12');
+	});
+});

package/dist/types/mcp-ui-server-shim.d.ts

@@ -1,37 +0,0 @@
-declare module '@mcp-ui/server' {
-    interface HTMLTextContent {
-        uri: string;
-        mimeType: string;
-        text: string;
-    }
-    interface Base64BlobContent {
-        uri: string;
-        mimeType: string;
-        blob: string;
-    }
-    interface UIResource {
-        type: 'resource';
-        resource: HTMLTextContent | Base64BlobContent;
-    }
-    interface CreateUIResourceOptions {
-        uri: string;
-        encoding: 'text' | 'blob';
-        content: {
-            type: 'rawHtml';
-            htmlString: string;
-        } | {
-            type: 'externalUrl';
-            iframeUrl: string;
-        } | {
-            type: 'remoteDom';
-            script: string;
-            framework?: string;
-        };
-        uiMetadata?: {
-            'preferred-frame-size'?: [string, string];
-        };
-    }
-    function createUIResource(options: CreateUIResourceOptions): UIResource;
-}
-export {};
-//# sourceMappingURL=mcp-ui-server-shim.d.ts.map

package/dist/types/mcp-ui-server-shim.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-ui-server-shim.d.ts","sourceRoot":"","sources":["../../src/types/mcp-ui-server-shim.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,gBAAgB,CAAC;IAC/B,UAAiB,eAAe;QAC/B,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACb;IAED,UAAiB,iBAAiB;QACjC,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACb;IAED,UAAiB,UAAU;QAC1B,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE,eAAe,GAAG,iBAAiB,CAAC;KAC9C;IAED,UAAiB,uBAAuB;QACvC,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;QAC1B,OAAO,EACJ;YAAE,IAAI,EAAE,SAAS,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,GACvC;YAAE,IAAI,EAAE,aAAa,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,GAC1C;YAAE,IAAI,EAAE,WAAW,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAC7D,UAAU,CAAC,EAAE;YACZ,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;SAC1C,CAAC;KACF;IAED,SAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU,CAAC;CAC/E"}

package/dist/types/mcp-ui-server-shim.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mcp-ui-server-shim.js.map

package/dist/types/mcp-ui-server-shim.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-ui-server-shim.js","sourceRoot":"","sources":["../../src/types/mcp-ui-server-shim.ts"],"names":[],"mappings":""}