@ai-sdk/provider-utils 4.0.5 → 4.0.6

package/src/validate-types.test.ts

@@ -0,0 +1,105 @@
+import { TypeValidationError } from '@ai-sdk/provider';
+import { describe, expect, it } from 'vitest';
+import { safeValidateTypes, validateTypes } from './validate-types';
+import { StandardSchema } from './schema';
+
+const customSchema: StandardSchema<{ name: string; age: number }> = {
+  '~standard': {
+    version: 1,
+    vendor: 'custom',
+    validate: async (value: any) => {
+      return typeof value === 'object' &&
+        value !== null &&
+        'name' in value &&
+        typeof value.name === 'string' &&
+        'age' in value &&
+        typeof value.age === 'number'
+        ? { value }
+        : { issues: [new Error('Invalid input')] };
+    },
+    jsonSchema: {
+      input: () => ({
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+      }),
+      output: () => ({
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+      }),
+    },
+  },
+};
+
+describe('validateTypes', () => {
+  it('should return validated object for valid input', async () => {
+    const input = { name: 'John', age: 30 };
+    expect(await validateTypes({ value: input, schema: customSchema })).toEqual(
+      input,
+    );
+  });
+
+  it('should throw TypeValidationError for invalid input', async () => {
+    const input = { name: 'John', age: '30' };
+
+    try {
+      await validateTypes({
+        value: input,
+        schema: customSchema,
+      });
+      expect.fail('Expected TypeValidationError to be thrown');
+    } catch (error) {
+      expect(error).toBeInstanceOf(TypeValidationError);
+
+      const typedError = error as TypeValidationError;
+
+      expect({
+        name: typedError.name,
+        value: typedError.value,
+        cause: typedError.cause,
+        message: typedError.message,
+      }).toStrictEqual({
+        name: 'AI_TypeValidationError',
+        value: input,
+        cause: [expect.any(Error)],
+        message: expect.stringContaining('Type validation failed'),
+      });
+    }
+  });
+});
+
+describe('safeValidateTypes', () => {
+  it('should return validated object for valid input', async () => {
+    const input = { name: 'John', age: 30 };
+    const result = await safeValidateTypes({
+      value: input,
+      schema: customSchema,
+    });
+    expect(result).toEqual({ success: true, value: input, rawValue: input });
+  });
+
+  it('should return error object for invalid input', async () => {
+    const input = { name: 'John', age: '30' };
+    const result = await safeValidateTypes({
+      value: input,
+      schema: customSchema,
+    });
+
+    expect(result).toEqual({
+      success: false,
+      error: expect.any(TypeValidationError),
+      rawValue: input,
+    });
+
+    if (!result.success) {
+      expect(result.error).toBeInstanceOf(TypeValidationError);
+      expect(result.error.value).toEqual(input);
+      expect(result.error.message).toContain('Type validation failed');
+    }
+  });
+});

package/src/validate-types.ts

@@ -0,0 +1,81 @@
+import { TypeValidationError } from '@ai-sdk/provider';
+import { FlexibleSchema, asSchema } from './schema';
+
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @returns {Promise<T>} - The typed object.
+ */
+export async function validateTypes<OBJECT>({
+  value,
+  schema,
+}: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+}): Promise<OBJECT> {
+  const result = await safeValidateTypes({ value, schema });
+
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
+  }
+
+  return result.value;
+}
+
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The JSON object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+export async function safeValidateTypes<OBJECT>({
+  value,
+  schema,
+}: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+}): Promise<
+  | {
+      success: true;
+      value: OBJECT;
+      rawValue: unknown;
+    }
+  | {
+      success: false;
+      error: TypeValidationError;
+      rawValue: unknown;
+    }
+> {
+  const actualSchema = asSchema(schema);
+
+  try {
+    if (actualSchema.validate == null) {
+      return { success: true, value: value as OBJECT, rawValue: value };
+    }
+
+    const result = await actualSchema.validate(value);
+
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value,
+    };
+  }
+}

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';

package/src/with-user-agent-suffix.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+
+import { withUserAgentSuffix } from './with-user-agent-suffix';
+
+describe('withUserAgentSuffix', () => {
+  it('should create a new user-agent header when no existing user-agent exists', () => {
+    const headers = {
+      'content-type': 'application/json',
+      authorization: 'Bearer token123',
+    };
+
+    const result = withUserAgentSuffix(
+      headers,
+      'ai-sdk/0.0.0-test',
+      'provider/test-openai',
+    );
+
+    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test provider/test-openai');
+    expect(result['content-type']).toBe('application/json');
+    expect(result['authorization']).toBe('Bearer token123');
+  });
+
+  it('should append suffix parts to existing user-agent header', () => {
+    const headers = {
+      'user-agent': 'TestApp/0.0.0-test',
+      accept: 'application/json',
+    };
+
+    const result = withUserAgentSuffix(
+      headers,
+      'ai-sdk/0.0.0-test',
+      'provider/test-anthropic',
+    );
+
+    expect(result['user-agent']).toBe(
+      'TestApp/0.0.0-test ai-sdk/0.0.0-test provider/test-anthropic',
+    );
+    expect(result['accept']).toBe('application/json');
+  });
+
+  it('should automatically remove undefined entries from headers', () => {
+    const headers = {
+      'content-type': 'application/json',
+      authorization: undefined,
+      'user-agent': 'TestApp/0.0.0-test',
+      accept: 'application/json',
+      'cache-control': null,
+    };
+
+    const result = withUserAgentSuffix(headers as any, 'ai-sdk/0.0.0-test');
+
+    expect(result['user-agent']).toBe('TestApp/0.0.0-test ai-sdk/0.0.0-test');
+    expect(result['content-type']).toBe('application/json');
+    expect(result['accept']).toBe('application/json');
+    expect(result['authorization']).toBeUndefined();
+    expect(result['cache-control']).toBeUndefined();
+  });
+
+  it('should preserve headers when given a Headers instance', () => {
+    const headers = new Headers({
+      Authorization: 'Bearer token123',
+      'X-Custom': 'value',
+    });
+
+    const result = withUserAgentSuffix(headers, 'ai-sdk/0.0.0-test');
+
+    expect(result['authorization']).toBe('Bearer token123');
+    expect(result['x-custom']).toBe('value');
+    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test');
+  });
+
+  it('should handle array header entries', () => {
+    const headers: HeadersInit = [
+      ['Authorization', 'Bearer token123'],
+      ['X-Feature', 'alpha'],
+    ];
+
+    const result = withUserAgentSuffix(headers, 'ai-sdk/0.0.0-test');
+
+    expect(result['authorization']).toBe('Bearer token123');
+    expect(result['x-feature']).toBe('alpha');
+    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test');
+  });
+});

package/src/with-user-agent-suffix.ts

@@ -0,0 +1,27 @@
+import { normalizeHeaders } from './normalize-headers';
+
+/**
+ * Appends suffix parts to the `user-agent` header.
+ * If a `user-agent` header already exists, the suffix parts are appended to it.
+ * If no `user-agent` header exists, a new one is created with the suffix parts.
+ * Automatically removes undefined entries from the headers.
+ *
+ * @param headers - The original headers.
+ * @param userAgentSuffixParts - The parts to append to the `user-agent` header.
+ * @returns The new headers with the `user-agent` header set or updated.
+ */
+export function withUserAgentSuffix(
+  headers: HeadersInit | Record<string, string | undefined> | undefined,
+  ...userAgentSuffixParts: string[]
+): Record<string, string> {
+  const normalizedHeaders = new Headers(normalizeHeaders(headers));
+
+  const currentUserAgentHeader = normalizedHeaders.get('user-agent') || '';
+
+  normalizedHeaders.set(
+    'user-agent',
+    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(' '),
+  );
+
+  return Object.fromEntries(normalizedHeaders.entries());
+}

package/src/without-trailing-slash.ts

@@ -0,0 +1,3 @@
+export function withoutTrailingSlash(url: string | undefined) {
+  return url?.replace(/\/$/, '');
+}

package/LICENSE

@@ -1,13 +0,0 @@
-Copyright 2023 Vercel, Inc.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.