kimi-vercel-ai-sdk-provider 0.2.0

package/src/__tests__/core.test.ts

@@ -0,0 +1,172 @@
+import { describe, expect, it } from 'vitest';
+import {
+  KimiAuthenticationError,
+  KimiContentFilterError,
+  KimiContextLengthError,
+  KimiError,
+  KimiModelNotFoundError,
+  KimiRateLimitError,
+  KimiValidationError,
+  kimiErrorSchema
+} from '../core';
+
+describe('KimiError', () => {
+  it('should create a base error', () => {
+    const error = new KimiError('Test error', 'test_code', 500);
+    expect(error.message).toBe('Test error');
+    expect(error.code).toBe('test_code');
+    expect(error.statusCode).toBe(500);
+    expect(error.name).toBe('KimiError');
+  });
+
+  it('should work without status code', () => {
+    const error = new KimiError('Test error', 'test_code');
+    expect(error.statusCode).toBeUndefined();
+  });
+});
+
+describe('KimiAuthenticationError', () => {
+  it('should create authentication error with default message', () => {
+    const error = new KimiAuthenticationError();
+    expect(error.message).toBe('Invalid API key or authentication failed');
+    expect(error.code).toBe('authentication_error');
+    expect(error.statusCode).toBe(401);
+    expect(error.name).toBe('KimiAuthenticationError');
+  });
+
+  it('should create authentication error with custom message', () => {
+    const error = new KimiAuthenticationError('Custom auth error');
+    expect(error.message).toBe('Custom auth error');
+  });
+});
+
+describe('KimiRateLimitError', () => {
+  it('should create rate limit error with default message', () => {
+    const error = new KimiRateLimitError();
+    expect(error.message).toBe('Rate limit exceeded');
+    expect(error.code).toBe('rate_limit_error');
+    expect(error.statusCode).toBe(429);
+    expect(error.name).toBe('KimiRateLimitError');
+  });
+
+  it('should include retry after', () => {
+    const error = new KimiRateLimitError('Too many requests', 30);
+    expect(error.retryAfter).toBe(30);
+  });
+});
+
+describe('KimiValidationError', () => {
+  it('should create validation error', () => {
+    const error = new KimiValidationError('Invalid parameter');
+    expect(error.message).toBe('Invalid parameter');
+    expect(error.code).toBe('validation_error');
+    expect(error.statusCode).toBe(400);
+    expect(error.name).toBe('KimiValidationError');
+  });
+
+  it('should include param in message', () => {
+    const error = new KimiValidationError('Invalid value', 'temperature');
+    expect(error.message).toBe('Invalid value (param: temperature)');
+  });
+});
+
+describe('KimiModelNotFoundError', () => {
+  it('should create model not found error', () => {
+    const error = new KimiModelNotFoundError('kimi-invalid');
+    expect(error.message).toBe("Model 'kimi-invalid' not found");
+    expect(error.code).toBe('model_not_found');
+    expect(error.statusCode).toBe(404);
+    expect(error.modelId).toBe('kimi-invalid');
+    expect(error.name).toBe('KimiModelNotFoundError');
+  });
+});
+
+describe('KimiContentFilterError', () => {
+  it('should create content filter error with default message', () => {
+    const error = new KimiContentFilterError();
+    expect(error.message).toBe('Content was filtered due to policy violation');
+    expect(error.code).toBe('content_filter');
+    expect(error.statusCode).toBe(400);
+    expect(error.name).toBe('KimiContentFilterError');
+  });
+});
+
+describe('KimiContextLengthError', () => {
+  it('should create context length error with default message', () => {
+    const error = new KimiContextLengthError();
+    expect(error.message).toBe('Context length exceeded');
+    expect(error.code).toBe('context_length_exceeded');
+    expect(error.statusCode).toBe(400);
+    expect(error.name).toBe('KimiContextLengthError');
+  });
+
+  it('should create with custom message', () => {
+    const error = new KimiContextLengthError('Max 128k tokens exceeded');
+    expect(error.message).toBe('Max 128k tokens exceeded');
+  });
+});
+
+describe('kimiErrorSchema', () => {
+  it('should parse standard error response', () => {
+    const result = kimiErrorSchema.safeParse({
+      error: {
+        message: 'Invalid API key',
+        type: 'authentication_error',
+        code: 'invalid_api_key'
+      }
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success && 'error' in result.data) {
+      expect(result.data.error.message).toBe('Invalid API key');
+      expect(result.data.error.type).toBe('authentication_error');
+      expect(result.data.error.code).toBe('invalid_api_key');
+    }
+  });
+
+  it('should parse error with minimal fields', () => {
+    const result = kimiErrorSchema.safeParse({
+      error: {
+        message: 'Something went wrong'
+      }
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success && 'error' in result.data) {
+      expect(result.data.error.message).toBe('Something went wrong');
+    }
+  });
+
+  it('should parse simple message error format', () => {
+    const result = kimiErrorSchema.safeParse({
+      message: 'Simple error message'
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success && 'message' in result.data) {
+      expect(result.data.message).toBe('Simple error message');
+    }
+  });
+
+  it('should parse error with numeric code', () => {
+    const result = kimiErrorSchema.safeParse({
+      error: {
+        message: 'Rate limit exceeded',
+        code: 429
+      }
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success && 'error' in result.data) {
+      expect(result.data.error.code).toBe(429);
+    }
+  });
+
+  it('should fail for completely invalid structure', () => {
+    const result = kimiErrorSchema.safeParse({
+      invalid: 'structure'
+    });
+
+    expect(result.success).toBe(false);
+  });
+});

package/src/__tests__/files.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Tests for file handling utilities.
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  SUPPORTED_FILE_EXTENSIONS,
+  SUPPORTED_MIME_TYPES,
+  getMediaTypeFromExtension,
+  getPurposeFromMediaType,
+  isDocumentMediaType,
+  isFileExtractMediaType,
+  isImageMediaType,
+  isVideoMediaType
+} from '../files/file-utils';
+
+describe('file-utils', () => {
+  describe('SUPPORTED_FILE_EXTENSIONS', () => {
+    it('should include common document extensions', () => {
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.pdf');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.doc');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.docx');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.txt');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.md');
+    });
+
+    it('should include common image extensions', () => {
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.png');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.jpg');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.jpeg');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.gif');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.webp');
+    });
+
+    it('should include common code file extensions', () => {
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.py');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.js');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.ts');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.tsx');
+      expect(SUPPORTED_FILE_EXTENSIONS).toContain('.java');
+    });
+  });
+
+  describe('SUPPORTED_MIME_TYPES', () => {
+    it('should map PDF to file-extract', () => {
+      expect(SUPPORTED_MIME_TYPES['application/pdf']).toBe('file-extract');
+    });
+
+    it('should map images to image purpose', () => {
+      expect(SUPPORTED_MIME_TYPES['image/jpeg']).toBe('image');
+      expect(SUPPORTED_MIME_TYPES['image/png']).toBe('image');
+      expect(SUPPORTED_MIME_TYPES['image/gif']).toBe('image');
+    });
+
+    it('should map videos to video purpose', () => {
+      expect(SUPPORTED_MIME_TYPES['video/mp4']).toBe('video');
+      expect(SUPPORTED_MIME_TYPES['video/webm']).toBe('video');
+    });
+  });
+
+  describe('isImageMediaType', () => {
+    it('should return true for image MIME types', () => {
+      expect(isImageMediaType('image/jpeg')).toBe(true);
+      expect(isImageMediaType('image/png')).toBe(true);
+      expect(isImageMediaType('image/gif')).toBe(true);
+      expect(isImageMediaType('image/webp')).toBe(true);
+      expect(isImageMediaType('image/svg+xml')).toBe(true);
+    });
+
+    it('should return false for non-image MIME types', () => {
+      expect(isImageMediaType('application/pdf')).toBe(false);
+      expect(isImageMediaType('video/mp4')).toBe(false);
+      expect(isImageMediaType('text/plain')).toBe(false);
+    });
+  });
+
+  describe('isVideoMediaType', () => {
+    it('should return true for video MIME types', () => {
+      expect(isVideoMediaType('video/mp4')).toBe(true);
+      expect(isVideoMediaType('video/webm')).toBe(true);
+      expect(isVideoMediaType('video/ogg')).toBe(true);
+    });
+
+    it('should return false for non-video MIME types', () => {
+      expect(isVideoMediaType('image/jpeg')).toBe(false);
+      expect(isVideoMediaType('application/pdf')).toBe(false);
+    });
+  });
+
+  describe('isFileExtractMediaType', () => {
+    it('should return true for text MIME types', () => {
+      expect(isFileExtractMediaType('text/plain')).toBe(true);
+      expect(isFileExtractMediaType('text/html')).toBe(true);
+      expect(isFileExtractMediaType('text/markdown')).toBe(true);
+    });
+
+    it('should return true for PDF', () => {
+      expect(isFileExtractMediaType('application/pdf')).toBe(true);
+    });
+
+    it('should return false for images', () => {
+      expect(isFileExtractMediaType('image/jpeg')).toBe(false);
+      expect(isFileExtractMediaType('image/png')).toBe(false);
+    });
+
+    it('should return false for videos', () => {
+      expect(isFileExtractMediaType('video/mp4')).toBe(false);
+    });
+  });
+
+  describe('isDocumentMediaType', () => {
+    it('should return true for document MIME types', () => {
+      expect(isDocumentMediaType('application/pdf')).toBe(true);
+      expect(isDocumentMediaType('application/msword')).toBe(true);
+      expect(isDocumentMediaType('application/vnd.openxmlformats-officedocument.wordprocessingml.document')).toBe(true);
+      expect(isDocumentMediaType('application/vnd.ms-excel')).toBe(true);
+    });
+
+    it('should return false for non-document types', () => {
+      expect(isDocumentMediaType('text/plain')).toBe(false);
+      expect(isDocumentMediaType('image/jpeg')).toBe(false);
+    });
+  });
+
+  describe('getPurposeFromMediaType', () => {
+    it('should return image for image MIME types', () => {
+      expect(getPurposeFromMediaType('image/jpeg')).toBe('image');
+      expect(getPurposeFromMediaType('image/png')).toBe('image');
+    });
+
+    it('should return video for video MIME types', () => {
+      expect(getPurposeFromMediaType('video/mp4')).toBe('video');
+      expect(getPurposeFromMediaType('video/webm')).toBe('video');
+    });
+
+    it('should return file-extract for other types', () => {
+      expect(getPurposeFromMediaType('application/pdf')).toBe('file-extract');
+      expect(getPurposeFromMediaType('text/plain')).toBe('file-extract');
+      expect(getPurposeFromMediaType('application/json')).toBe('file-extract');
+    });
+  });
+
+  describe('getMediaTypeFromExtension', () => {
+    it('should return correct MIME type for document extensions', () => {
+      expect(getMediaTypeFromExtension('.pdf')).toBe('application/pdf');
+      expect(getMediaTypeFromExtension('.txt')).toBe('text/plain');
+      expect(getMediaTypeFromExtension('.md')).toBe('text/markdown');
+      expect(getMediaTypeFromExtension('.json')).toBe('application/json');
+    });
+
+    it('should return correct MIME type for image extensions', () => {
+      expect(getMediaTypeFromExtension('.jpg')).toBe('image/jpeg');
+      expect(getMediaTypeFromExtension('.jpeg')).toBe('image/jpeg');
+      expect(getMediaTypeFromExtension('.png')).toBe('image/png');
+      expect(getMediaTypeFromExtension('.gif')).toBe('image/gif');
+      expect(getMediaTypeFromExtension('.webp')).toBe('image/webp');
+    });
+
+    it('should return correct MIME type for video extensions', () => {
+      expect(getMediaTypeFromExtension('.mp4')).toBe('video/mp4');
+      expect(getMediaTypeFromExtension('.webm')).toBe('video/webm');
+    });
+
+    it('should return correct MIME type for code extensions', () => {
+      expect(getMediaTypeFromExtension('.js')).toBe('text/javascript');
+      expect(getMediaTypeFromExtension('.ts')).toBe('text/typescript');
+      expect(getMediaTypeFromExtension('.py')).toBe('text/x-python');
+    });
+
+    it('should handle extensions without leading dot', () => {
+      expect(getMediaTypeFromExtension('pdf')).toBe('application/pdf');
+      expect(getMediaTypeFromExtension('jpg')).toBe('image/jpeg');
+    });
+
+    it('should handle uppercase extensions', () => {
+      expect(getMediaTypeFromExtension('.PDF')).toBe('application/pdf');
+      expect(getMediaTypeFromExtension('.JPG')).toBe('image/jpeg');
+    });
+
+    it('should return octet-stream for unknown extensions', () => {
+      expect(getMediaTypeFromExtension('.xyz')).toBe('application/octet-stream');
+      expect(getMediaTypeFromExtension('.unknown')).toBe('application/octet-stream');
+    });
+  });
+});