@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/inject-json-instruction.test.ts

@@ -1,404 +0,0 @@
-import { JSONSchema7, LanguageModelV3Prompt } from '@ai-sdk/provider';
-import { expect, it, describe } from 'vitest';
-import {
-  injectJsonInstruction,
-  injectJsonInstructionIntoMessages,
-} from './inject-json-instruction';
-
-const basicSchema: JSONSchema7 = {
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    age: { type: 'number' },
-  },
-  required: ['name', 'age'],
-};
-
-describe('injectJsonInstruction', () => {
-  it('should handle basic case with prompt and schema', () => {
-    const result = injectJsonInstruction({
-      prompt: 'Generate a person',
-      schema: basicSchema,
-    });
-    expect(result).toBe(
-      'Generate a person\n\n' +
-        'JSON schema:\n' +
-        '{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle only prompt, no schema', () => {
-    const result = injectJsonInstruction({
-      prompt: 'Generate a person',
-    });
-    expect(result).toBe('Generate a person\n\nYou MUST answer with JSON.');
-  });
-
-  it('should handle only schema, no prompt', () => {
-    const result = injectJsonInstruction({
-      schema: basicSchema,
-    });
-    expect(result).toBe(
-      'JSON schema:\n' +
-        '{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle no prompt, no schema', () => {
-    const result = injectJsonInstruction({});
-    expect(result).toBe('You MUST answer with JSON.');
-  });
-
-  it('should handle custom schemaPrefix and schemaSuffix', () => {
-    const result = injectJsonInstruction({
-      prompt: 'Generate a person',
-      schema: basicSchema,
-      schemaPrefix: 'Custom prefix:',
-      schemaSuffix: 'Custom suffix',
-    });
-    expect(result).toBe(
-      'Generate a person\n\n' +
-        'Custom prefix:\n' +
-        '{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}\n' +
-        'Custom suffix',
-    );
-  });
-
-  it('should handle empty string prompt', () => {
-    const result = injectJsonInstruction({
-      prompt: '',
-      schema: basicSchema,
-    });
-    expect(result).toBe(
-      'JSON schema:\n' +
-        '{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle empty object schema', () => {
-    const result = injectJsonInstruction({
-      prompt: 'Generate something',
-      schema: {},
-    });
-    expect(result).toBe(
-      'Generate something\n\n' +
-        'JSON schema:\n' +
-        '{}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle complex nested schema', () => {
-    const complexSchema: JSONSchema7 = {
-      type: 'object',
-      properties: {
-        person: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            age: { type: 'number' },
-            address: {
-              type: 'object',
-              properties: {
-                street: { type: 'string' },
-                city: { type: 'string' },
-              },
-            },
-          },
-        },
-      },
-    };
-    const result = injectJsonInstruction({
-      prompt: 'Generate a complex person',
-      schema: complexSchema,
-    });
-    expect(result).toBe(
-      'Generate a complex person\n\n' +
-        'JSON schema:\n' +
-        '{"type":"object","properties":{"person":{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"},"address":{"type":"object","properties":{"street":{"type":"string"},"city":{"type":"string"}}}}}}}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle schema with special characters', () => {
-    const specialSchema: JSONSchema7 = {
-      type: 'object',
-      properties: {
-        'special@property': { type: 'string' },
-        'emoji😊': { type: 'string' },
-      },
-    };
-    const result = injectJsonInstruction({
-      schema: specialSchema,
-    });
-    expect(result).toBe(
-      'JSON schema:\n' +
-        '{"type":"object","properties":{"special@property":{"type":"string"},"emoji😊":{"type":"string"}}}\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle very long prompt and schema', () => {
-    const longPrompt = 'A'.repeat(1000);
-    const longSchema: JSONSchema7 = {
-      type: 'object',
-      properties: {},
-    };
-    for (let i = 0; i < 100; i++) {
-      longSchema.properties![`prop${i}`] = { type: 'string' };
-    }
-    const result = injectJsonInstruction({
-      prompt: longPrompt,
-      schema: longSchema,
-    });
-    expect(result).toBe(
-      longPrompt +
-        '\n\n' +
-        'JSON schema:\n' +
-        JSON.stringify(longSchema) +
-        '\n' +
-        'You MUST answer with a JSON object that matches the JSON schema above.',
-    );
-  });
-
-  it('should handle null values for optional parameters', () => {
-    const result = injectJsonInstruction({
-      prompt: null as any,
-      schema: null as any,
-      schemaPrefix: null as any,
-      schemaSuffix: null as any,
-    });
-    expect(result).toBe('');
-  });
-
-  it('should handle undefined values for optional parameters', () => {
-    const result = injectJsonInstruction({
-      prompt: undefined,
-      schema: undefined,
-      schemaPrefix: undefined,
-      schemaSuffix: undefined,
-    });
-    expect(result).toBe('You MUST answer with JSON.');
-  });
-});
-
-describe('injectJsonInstructionIntoMessages', () => {
-  it('should handle basic case with prompt and schema', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [{ role: 'system', content: 'Generate a person' }],
-      schema: basicSchema,
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "Generate a person
-
-      JSON schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      You MUST answer with a JSON object that matches the JSON schema above.",
-          "role": "system",
-        },
-      ]
-    `);
-  });
-
-  it('should not mutate the input messages array', () => {
-    const originalMessages: LanguageModelV3Prompt = [
-      { role: 'system', content: 'Generate a person' },
-    ];
-
-    injectJsonInstructionIntoMessages({
-      messages: originalMessages,
-      schema: basicSchema,
-    });
-
-    expect(originalMessages).toEqual([
-      { role: 'system', content: 'Generate a person' },
-    ]);
-  });
-
-  it('should handle empty messages array', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [],
-      schema: basicSchema,
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "JSON schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      You MUST answer with a JSON object that matches the JSON schema above.",
-          "role": "system",
-        },
-      ]
-    `);
-  });
-
-  it('should handle messages without initial system message', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [
-        { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-        {
-          role: 'assistant',
-          content: [{ type: 'text', text: 'Hi there' }],
-        },
-      ],
-      schema: basicSchema,
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "JSON schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      You MUST answer with a JSON object that matches the JSON schema above.",
-          "role": "system",
-        },
-        {
-          "content": [
-            {
-              "text": "Hello",
-              "type": "text",
-            },
-          ],
-          "role": "user",
-        },
-        {
-          "content": [
-            {
-              "text": "Hi there",
-              "type": "text",
-            },
-          ],
-          "role": "assistant",
-        },
-      ]
-    `);
-  });
-
-  it('should handle system message with empty content', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [
-        { role: 'system', content: '' },
-        { role: 'user', content: [{ type: 'text', text: 'Generate data' }] },
-      ],
-      schema: basicSchema,
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "JSON schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      You MUST answer with a JSON object that matches the JSON schema above.",
-          "role": "system",
-        },
-        {
-          "content": [
-            {
-              "text": "Generate data",
-              "type": "text",
-            },
-          ],
-          "role": "user",
-        },
-      ]
-    `);
-  });
-
-  it('should preserve all non-system messages', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [
-        { role: 'system', content: 'You are helpful' },
-        { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-        { role: 'assistant', content: [{ type: 'text', text: 'Hi' }] },
-        { role: 'user', content: [{ type: 'text', text: 'Generate person' }] },
-      ],
-      schema: basicSchema,
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "You are helpful
-
-      JSON schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      You MUST answer with a JSON object that matches the JSON schema above.",
-          "role": "system",
-        },
-        {
-          "content": [
-            {
-              "text": "Hello",
-              "type": "text",
-            },
-          ],
-          "role": "user",
-        },
-        {
-          "content": [
-            {
-              "text": "Hi",
-              "type": "text",
-            },
-          ],
-          "role": "assistant",
-        },
-        {
-          "content": [
-            {
-              "text": "Generate person",
-              "type": "text",
-            },
-          ],
-          "role": "user",
-        },
-      ]
-    `);
-  });
-
-  it('should handle case with no schema', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [{ role: 'system', content: 'Generate data' }],
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "Generate data
-
-      You MUST answer with JSON.",
-          "role": "system",
-        },
-      ]
-    `);
-  });
-
-  it('should handle custom schema prefix and suffix', () => {
-    const result = injectJsonInstructionIntoMessages({
-      messages: [{ role: 'system', content: 'Generate data' }],
-      schema: basicSchema,
-      schemaPrefix: 'Custom schema:',
-      schemaSuffix: 'Follow this format exactly.',
-    });
-
-    expect(result).toMatchInlineSnapshot(`
-      [
-        {
-          "content": "Generate data
-
-      Custom schema:
-      {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name","age"]}
-      Follow this format exactly.",
-          "role": "system",
-        },
-      ]
-    `);
-  });
-});

package/src/is-url-supported.test.ts

@@ -1,282 +0,0 @@
-import { isUrlSupported } from './is-url-supported';
-import { describe, expect, it } from 'vitest';
-
-describe('isUrlSupported', () => {
-  describe('when the model does not support any URLs', () => {
-    it('should return false', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://example.com',
-          supportedUrls: {},
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe('when the model supports specific media types and URLs', () => {
-    it('should return true for exact media type and exact URL match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://example.com',
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return true for exact media type and regex URL match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png',
-          url: 'https://images.example.com/cat.png',
-          supportedUrls: {
-            'image/png': [/https:\/\/images\.example\.com\/.+/],
-          },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return true for exact media type and one of multiple regex URLs match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png',
-          url: 'https://another.com/img.png',
-          supportedUrls: {
-            'image/png': [
-              /https:\/\/images\.example\.com\/.+/,
-              /https:\/\/another\.com\/img\.png/,
-            ],
-          },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return false for exact media type but URL mismatch', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://another.com',
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(false);
-    });
-
-    it('should return false for URL match but media type mismatch', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png', // Different media type
-          url: 'https://example.com',
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe('when the model supports URLs via wildcard media type (*)', () => {
-    it('should return true for wildcard media type and exact URL match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://example.com',
-          supportedUrls: { '*': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return true for wildcard media type and regex URL match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/jpeg',
-          url: 'https://images.example.com/dog.jpg',
-          supportedUrls: { '*': [/https:\/\/images\.example\.com\/.+/] },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return false for wildcard media type but URL mismatch', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'video/mp4',
-          url: 'https://another.com',
-          supportedUrls: { '*': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe('when both specific and wildcard media types are defined', () => {
-    const supportedUrls = {
-      'text/plain': [/https:\/\/text\.com/],
-      '*': [/https:\/\/any\.com/],
-    };
-
-    it('should return true if URL matches under specific media type', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://text.com',
-          supportedUrls,
-        }),
-      ).toBe(true);
-    });
-
-    it('should return true if URL matches under wildcard media type even if specific exists', async () => {
-      // Assumes the logic checks specific first, then falls back to wildcard
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain', // Specific type exists
-          url: 'https://any.com', // Matches wildcard
-          supportedUrls,
-        }),
-      ).toBe(true);
-    });
-
-    it('should return true if URL matches under wildcard for a non-specified media type', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png', // No specific entry for this type
-          url: 'https://any.com', // Matches wildcard
-          supportedUrls,
-        }),
-      ).toBe(true);
-    });
-
-    it('should return false if URL matches neither specific nor wildcard', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://other.com',
-          supportedUrls,
-        }),
-      ).toBe(false);
-    });
-
-    it('should return false if URL does not match wildcard for a non-specified media type', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png',
-          url: 'https://other.com',
-          supportedUrls,
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should return true if an empty URL matches a pattern', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: '',
-          supportedUrls: { 'text/plain': [/.*/] }, // Matches any string, including empty
-        }),
-      ).toBe(true);
-    });
-
-    it('should return false if an empty URL does not match a pattern', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: '',
-          supportedUrls: { 'text/plain': [/https:\/\/.+/] }, // Requires non-empty string
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe('case sensitivity', () => {
-    it('should be case-insensitive for media types', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'TEXT/PLAIN', // Uppercase
-          url: 'https://example.com',
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com/] }, // Lowercase
-        }),
-      ).toBe(true);
-    });
-
-    it('should handle case-insensitive regex for URLs if specified', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://EXAMPLE.com/path', // Uppercase domain
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com\/path/] },
-        }),
-      ).toBe(true);
-    });
-
-    it('should be case-insensitive for URL paths by default regex', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://example.com/PATH', // Uppercase path
-          supportedUrls: { 'text/plain': [/https:\/\/example\.com\/path/] }, // Lowercase path in regex
-        }),
-      ).toBe(true);
-    });
-  });
-
-  describe('wildcard subtypes in media types', () => {
-    it('should return true for wildcard subtype match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png',
-          url: 'https://example.com',
-          supportedUrls: { 'image/*': [/https:\/\/example\.com/] },
-        }),
-      ).toBe(true);
-    });
-
-    it('should use full wildcard "*" if subtype wildcard is not matched or supported', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'image/png',
-          url: 'https://any.com',
-          supportedUrls: {
-            'image/*': [/https:\/\/images\.com/], // Doesn't match URL
-            '*': [/https:\/\/any\.com/], // Matches URL
-          },
-        }),
-      ).toBe(true);
-    });
-  });
-
-  describe('empty URL arrays for a media type', () => {
-    it('should return false if the specific media type has an empty URL array', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://example.com',
-          supportedUrls: { 'text/plain': [] },
-        }),
-      ).toBe(false);
-    });
-
-    it('should fall back to wildcard "*" if specific media type has empty array but wildcard matches', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://any.com',
-          supportedUrls: {
-            'text/plain': [],
-            '*': [/https:\/\/any\.com/],
-          },
-        }),
-      ).toBe(true);
-    });
-
-    it('should return false if specific media type has empty array and wildcard does not match', async () => {
-      expect(
-        isUrlSupported({
-          mediaType: 'text/plain',
-          url: 'https://another.com',
-          supportedUrls: {
-            'text/plain': [],
-            '*': [/https:\/\/any\.com/],
-          },
-        }),
-      ).toBe(false);
-    });
-  });
-});