@chainfuse/ai-tools 0.1.0

package/dist/providers/rawProviders.mjs

@@ -0,0 +1,215 @@
+import { BufferHelpers, CryptoHelpers, Helpers } from '@chainfuse/helpers';
+import { AiBase } from '../base.mjs';
+export class AiRawProviders extends AiBase {
+    // 2628288 seconds is what cf defines as 1 month in their cache rules
+    cacheTtl = 2628288;
+    oaiOpenai(args) {
+        return import('@ai-sdk/openai').then(async ({ createOpenAI }) => createOpenAI({
+            baseURL: new URL(['v1', this.config.gateway.accountId, this.config.environment, 'openai'].join('/'), 'https://gateway.ai.cloudflare.com').toString(),
+            apiKey: this.config.providers.openAi.apiToken,
+            organization: this.config.providers.openAi.organization,
+            headers: {
+                'cf-aig-authorization': `Bearer ${this.config.gateway.apiToken}`,
+                'cf-aig-metadata': JSON.stringify({
+                    dataspaceId: (await BufferHelpers.uuidConvert(args.dataspaceId)).utf8,
+                    executor: JSON.stringify(args.executor),
+                    // Generate incomplete id because we don't have the body to hash yet. Fill it in in the `fetch()`
+                    idempotencyId: args.idempotencyId ?? (await BufferHelpers.generateUuid).utf8.slice(0, 23),
+                    serverInfo: JSON.stringify({
+                        name: 'openai',
+                    }),
+                    /**
+                     * Blank at first, add after request finishes
+                     * CF AI Gateway allows only editing existing metadata not creating new ones after the request is made
+                     */
+                    timing: JSON.stringify({}),
+                }),
+                ...(args.cache && { 'cf-aig-cache-ttl': (typeof args.cache === 'boolean' ? (args.cache ? this.cacheTtl : 0) : args.cache).toString() }),
+                ...(args.skipCache && { 'cf-aig-skip-cache': 'true' }),
+            },
+            compatibility: 'strict',
+            fetch: async (input, rawInit) => {
+                const headers = new Headers(rawInit?.headers);
+                const metadataHeader = JSON.parse(headers.get('cf-aig-metadata'));
+                if (metadataHeader.idempotencyId.split('-').length === 4) {
+                    metadataHeader.idempotencyId = `${metadataHeader.idempotencyId}-${(await CryptoHelpers.getHash('SHA-256', await new Request(input, rawInit).arrayBuffer())).slice(0, 12)}`;
+                    headers.set('cf-aig-metadata', JSON.stringify(metadataHeader));
+                }
+                if (args.logging ?? this.config.environment !== 'production')
+                    console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.magenta(rawInit?.method), this.chalk.magenta(new URL(new Request(input).url).pathname));
+                return fetch(input, { ...rawInit, headers }).then(async (response) => {
+                    if (args.logging ?? this.config.environment !== 'production')
+                        console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), response.ok ? this.chalk.green(response.status) : this.chalk.red(response.status), response.ok ? this.chalk.green(new URL(response.url).pathname) : this.chalk.red(new URL(response.url).pathname));
+                    // Inject it to have it available for retries
+                    const mutableHeaders = new Headers(response.headers);
+                    mutableHeaders.set('X-Idempotency-Id', metadataHeader.idempotencyId);
+                    if (response.ok) {
+                        return new Response(response.body, { ...response, headers: mutableHeaders });
+                    }
+                    else {
+                        const [body1, body2] = response.body.tee();
+                        console.error('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.red(JSON.stringify(await new Response(body1, response).json())));
+                        return new Response(body2, { ...response, headers: mutableHeaders });
+                    }
+                });
+            },
+        }));
+    }
+    azOpenai(args, server) {
+        return import('@ai-sdk/azure').then(async ({ createAzure }) => createAzure({
+            apiKey: this.config.providers.azureOpenAi.apiTokens[`AZURE_API_KEY_${server.toUpperCase().replaceAll('-', '_')}`],
+            /**
+             * @link https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#api-specs
+             * From the table, pick the `Latest GA release` for `Data plane - inference`
+             */
+            apiVersion: '2024-10-21',
+            baseURL: new URL(['v1', this.config.gateway.accountId, this.config.environment, 'azure-openai', server.toLowerCase()].join('/'), 'https://gateway.ai.cloudflare.com').toString(),
+            headers: {
+                'cf-aig-authorization': `Bearer ${this.config.gateway.apiToken}`,
+                'cf-aig-metadata': JSON.stringify({
+                    dataspaceId: (await BufferHelpers.uuidConvert(args.dataspaceId)).utf8,
+                    executor: JSON.stringify(args.executor),
+                    // Generate incomplete id because we don't have the body to hash yet. Fill it in in the `fetch()`
+                    idempotencyId: args.idempotencyId ?? (await BufferHelpers.generateUuid).utf8.slice(0, 23),
+                    serverInfo: JSON.stringify({
+                        name: 'openai',
+                    }),
+                    /**
+                     * Blank at first, add after request finishes
+                     * CF AI Gateway allows only editing existing metadata not creating new ones after the request is made
+                     */
+                    timing: JSON.stringify({}),
+                }),
+                ...(args.cache && { 'cf-aig-cache-ttl': (typeof args.cache === 'boolean' ? (args.cache ? this.cacheTtl : 0) : args.cache).toString() }),
+                ...(args.skipCache && { 'cf-aig-skip-cache': 'true' }),
+            },
+            fetch: async (input, rawInit) => {
+                const headers = new Headers(rawInit?.headers);
+                const metadataHeader = JSON.parse(headers.get('cf-aig-metadata'));
+                if (metadataHeader.idempotencyId.split('-').length === 4) {
+                    metadataHeader.idempotencyId = `${metadataHeader.idempotencyId}-${(await CryptoHelpers.getHash('SHA-256', await new Request(input, rawInit).arrayBuffer())).slice(0, 12)}`;
+                    headers.set('cf-aig-metadata', JSON.stringify(metadataHeader));
+                }
+                if (args.logging ?? this.config.environment !== 'production')
+                    console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.magenta(rawInit?.method), this.chalk.magenta(new URL(new Request(input).url).pathname));
+                return fetch(input, { ...rawInit, headers }).then(async (response) => {
+                    if (args.logging ?? this.config.environment !== 'production')
+                        console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), response.ok ? this.chalk.green(response.status) : this.chalk.red(response.status), response.ok ? this.chalk.green(new URL(response.url).pathname) : this.chalk.red(new URL(response.url).pathname));
+                    // Inject it to have it available for retries
+                    const mutableHeaders = new Headers(response.headers);
+                    mutableHeaders.set('X-Idempotency-Id', metadataHeader.idempotencyId);
+                    if (response.ok) {
+                        return new Response(response.body, { ...response, headers: mutableHeaders });
+                    }
+                    else {
+                        const [body1, body2] = response.body.tee();
+                        console.error('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.red(JSON.stringify(await new Response(body1, response).json())));
+                        return new Response(body2, { ...response, headers: mutableHeaders });
+                    }
+                });
+            },
+        }));
+    }
+    anthropic(args) {
+        return import('@ai-sdk/anthropic').then(async ({ createAnthropic }) => createAnthropic({
+            baseURL: new URL(['v1', this.config.gateway.accountId, this.config.environment, 'anthropic'].join('/'), 'https://gateway.ai.cloudflare.com').toString(),
+            apiKey: this.config.providers.anthropic.apiToken,
+            headers: {
+                'cf-aig-authorization': `Bearer ${this.config.gateway.apiToken}`,
+                'cf-aig-metadata': JSON.stringify({
+                    dataspaceId: (await BufferHelpers.uuidConvert(args.dataspaceId)).utf8,
+                    executor: JSON.stringify(args.executor),
+                    // Generate incomplete id because we don't have the body to hash yet. Fill it in in the `fetch()`
+                    idempotencyId: args.idempotencyId ?? (await BufferHelpers.generateUuid).utf8.slice(0, 23),
+                    serverInfo: JSON.stringify({
+                        name: 'openai',
+                    }),
+                    /**
+                     * Blank at first, add after request finishes
+                     * CF AI Gateway allows only editing existing metadata not creating new ones after the request is made
+                     */
+                    timing: JSON.stringify({}),
+                }),
+                ...(args.cache && { 'cf-aig-cache-ttl': (typeof args.cache === 'boolean' ? (args.cache ? this.cacheTtl : 0) : args.cache).toString() }),
+                ...(args.skipCache && { 'cf-aig-skip-cache': 'true' }),
+            },
+            fetch: async (input, rawInit) => {
+                const headers = new Headers(rawInit?.headers);
+                const metadataHeader = JSON.parse(headers.get('cf-aig-metadata'));
+                if (metadataHeader.idempotencyId.split('-').length === 4) {
+                    metadataHeader.idempotencyId = `${metadataHeader.idempotencyId}-${(await CryptoHelpers.getHash('SHA-256', await new Request(input, rawInit).arrayBuffer())).slice(0, 12)}`;
+                    headers.set('cf-aig-metadata', JSON.stringify(metadataHeader));
+                }
+                if (args.logging ?? this.config.environment !== 'production')
+                    console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.magenta(rawInit?.method), this.chalk.magenta(new URL(new Request(input).url).pathname));
+                return fetch(input, { ...rawInit, headers }).then(async (response) => {
+                    if (args.logging ?? this.config.environment !== 'production')
+                        console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), response.ok ? this.chalk.green(response.status) : this.chalk.red(response.status), response.ok ? this.chalk.green(new URL(response.url).pathname) : this.chalk.red(new URL(response.url).pathname));
+                    // Inject it to have it available for retries
+                    const mutableHeaders = new Headers(response.headers);
+                    mutableHeaders.set('X-Idempotency-Id', metadataHeader.idempotencyId);
+                    if (response.ok) {
+                        return new Response(response.body, { ...response, headers: mutableHeaders });
+                    }
+                    else {
+                        const [body1, body2] = response.body.tee();
+                        console.error('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.red(JSON.stringify(await new Response(body1, response).json())));
+                        return new Response(body2, { ...response, headers: mutableHeaders });
+                    }
+                });
+            },
+        }));
+    }
+    restWorkersAi(args) {
+        return import('@ai-sdk/openai').then(async ({ createOpenAI }) => createOpenAI({
+            baseURL: new URL(['v1', this.config.gateway.accountId, this.config.environment, 'workers-ai', 'v1'].join('/'), 'https://gateway.ai.cloudflare.com').toString(),
+            apiKey: this.config.providers.workersAi.apiToken,
+            headers: {
+                'cf-aig-authorization': `Bearer ${this.config.gateway.apiToken}`,
+                'cf-aig-metadata': JSON.stringify({
+                    dataspaceId: (await BufferHelpers.uuidConvert(args.dataspaceId)).utf8,
+                    executor: JSON.stringify(args.executor),
+                    // Generate incomplete id because we don't have the body to hash yet. Fill it in in the `fetch()`
+                    idempotencyId: args.idempotencyId ?? (await BufferHelpers.generateUuid).utf8.slice(0, 23),
+                    serverInfo: JSON.stringify({
+                        name: 'openai',
+                    }),
+                    /**
+                     * Blank at first, add after request finishes
+                     * CF AI Gateway allows only editing existing metadata not creating new ones after the request is made
+                     */
+                    timing: JSON.stringify({}),
+                }),
+                ...(args.cache && { 'cf-aig-cache-ttl': (typeof args.cache === 'boolean' ? (args.cache ? this.cacheTtl : 0) : args.cache).toString() }),
+                ...(args.skipCache && { 'cf-aig-skip-cache': 'true' }),
+            },
+            compatibility: 'compatible',
+            name: 'workersai',
+            fetch: async (input, rawInit) => {
+                const headers = new Headers(rawInit?.headers);
+                const metadataHeader = JSON.parse(headers.get('cf-aig-metadata'));
+                if (metadataHeader.idempotencyId.split('-').length === 4) {
+                    metadataHeader.idempotencyId = `${metadataHeader.idempotencyId}-${(await CryptoHelpers.getHash('SHA-256', await new Request(input, rawInit).arrayBuffer())).slice(0, 12)}`;
+                    headers.set('cf-aig-metadata', JSON.stringify(metadataHeader));
+                }
+                if (args.logging ?? this.config.environment !== 'production')
+                    console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.magenta(rawInit?.method), this.chalk.magenta(new URL(new Request(input).url).pathname));
+                return fetch(input, { ...rawInit, headers }).then(async (response) => {
+                    if (args.logging ?? this.config.environment !== 'production')
+                        console.info('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), response.ok ? this.chalk.green(response.status) : this.chalk.red(response.status), response.ok ? this.chalk.green(new URL(response.url).pathname) : this.chalk.red(new URL(response.url).pathname));
+                    // Inject it to have it available for retries
+                    const mutableHeaders = new Headers(response.headers);
+                    mutableHeaders.set('X-Idempotency-Id', metadataHeader.idempotencyId);
+                    if (response.ok) {
+                        return new Response(response.body, { ...response, headers: mutableHeaders });
+                    }
+                    else {
+                        const [body1, body2] = response.body.tee();
+                        console.error('ai', 'raw provider', this.chalk.rgb(...Helpers.uniqueIdColor(metadataHeader.idempotencyId))(`[${metadataHeader.idempotencyId}]`), this.chalk.red(JSON.stringify(await new Response(body1, response).json())));
+                        return new Response(body2, { ...response, headers: mutableHeaders });
+                    }
+                });
+            },
+        }));
+    }
+}

package/dist/providers/types.d.mts

@@ -0,0 +1,26 @@
+import type { OpenAIChatSettings, OpenAIEmbeddingSettings } from '@ai-sdk/openai/internal';
+import type { EmbeddingModelV1, LanguageModelV1 } from '@ai-sdk/provider';
+import type { AzureChatModels, AzureEmbeddingModels, cloudflareModelPossibilities } from '@chainfuse/types';
+import type { Provider } from 'ai';
+export interface AzureOpenAIProvider extends Provider {
+    (deploymentId: AzureChatModels, settings?: OpenAIChatSettings): LanguageModelV1;
+    /**
+  Creates an Azure OpenAI chat model for text generation.
+     */
+    languageModel(deploymentId: AzureChatModels, settings?: OpenAIChatSettings): LanguageModelV1;
+    /**
+  Creates an Azure OpenAI model for text embeddings.
+     */
+    textEmbeddingModel(deploymentId: AzureEmbeddingModels, settings?: OpenAIEmbeddingSettings): EmbeddingModelV1<string>;
+}
+export interface CloudflareOpenAIProvider extends Provider {
+    (deploymentId: cloudflareModelPossibilities<'Text Generation'>, settings?: OpenAIChatSettings): LanguageModelV1;
+    /**
+  Creates an Azure OpenAI chat model for text generation.
+     */
+    languageModel(deploymentId: cloudflareModelPossibilities<'Text Generation'>, settings?: OpenAIChatSettings): LanguageModelV1;
+    /**
+  Creates an Azure OpenAI model for text embeddings.
+     */
+    textEmbeddingModel(deploymentId: cloudflareModelPossibilities<'Text Embeddings'>, settings?: OpenAIEmbeddingSettings): EmbeddingModelV1<string>;
+}

package/dist/providers/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/registry.d.mts

@@ -0,0 +1,11 @@
+import { AiBase } from './base.mjs';
+import type { AiRequestConfig } from './types.mjs';
+export declare class AiRegistry extends AiBase {
+    providers(args: AiRequestConfig): Promise<Readonly<{
+        openai: import("@ai-sdk/openai").OpenAIProvider;
+        azure: import("./providers/types.mjs").AzureOpenAIProvider;
+        anthropic: import("@ai-sdk/anthropic").AnthropicProvider;
+        workersai: import("./providers/types.mjs").CloudflareOpenAIProvider;
+    }>>;
+    registry(args: AiRequestConfig): Promise<import("ai").Provider>;
+}

package/dist/registry.mjs

@@ -0,0 +1,16 @@
+import { experimental_createProviderRegistry as createProviderRegistry } from 'ai';
+import { AiBase } from './base.mjs';
+import { AiCustomProviders } from './providers/customProviders.mjs';
+export class AiRegistry extends AiBase {
+    async providers(args) {
+        return Object.freeze({
+            openai: await new AiCustomProviders(this.config).oaiOpenai(args),
+            azure: await new AiCustomProviders(this.config).azOpenai(args),
+            anthropic: await new AiCustomProviders(this.config).anthropic(args),
+            workersai: await new AiCustomProviders(this.config).cfWorkersAi(args),
+        });
+    }
+    async registry(args) {
+        return createProviderRegistry(await this.providers(args));
+    }
+}

package/dist/serverSelector/azure.d.mts

@@ -0,0 +1,5 @@
+import { ServerSelector } from './base.mjs';
+import type { Server } from './types.mjs';
+export declare class AzureServerSelector extends ServerSelector {
+    readonly servers: Set<Server>;
+}

package/dist/serverSelector/azure.mjs

@@ -0,0 +1,240 @@
+import { PrivacyRegion, ServerSelector } from './base.mjs';
+export class AzureServerSelector extends ServerSelector {
+    // From: https://gist.github.com/demosjarco/2091b3a197e530f1402e9dfec6666cd8
+    servers = new Set([
+        {
+            id: 'OpenAi-AU-NewSouthWales',
+            coordinate: {
+                lat: -33.86,
+                lon: 151.2094,
+            },
+            region: PrivacyRegion.Australian_Privacy_Principles,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-BR-SaoPauloState',
+            coordinate: {
+                lat: -23.55,
+                lon: -46.633,
+            },
+            region: PrivacyRegion.Brazil_General_Data_protection_Law,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAI-CA-Toronto',
+            coordinate: {
+                lat: 43.653,
+                lon: -79.383,
+            },
+            region: PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act,
+            languageModelAvailability: [],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAI-CA-Quebec',
+            coordinate: {
+                lat: 46.817,
+                lon: -71.217,
+            },
+            region: PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-small', 'text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-US-Virginia',
+            coordinate: {
+                lat: 37.3719,
+                lon: -79.8164,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-small', 'text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-US-Virginia2',
+            coordinate: {
+                lat: 36.6681,
+                lon: -78.3889,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-small', 'text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Paris',
+            coordinate: {
+                lat: 46.3772,
+                lon: 2.373,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Frankfurt',
+            coordinate: {
+                lat: 50.110924,
+                lon: 8.682127,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-JP-Tokyo',
+            coordinate: {
+                lat: 35.68,
+                lon: 139.77,
+            },
+            region: PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-KR-Seoul',
+            coordinate: {
+                lat: 37.5665,
+                lon: 126.978,
+            },
+            region: PrivacyRegion.Korean_Personal_Information_Protection_Act,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-US-Illinois',
+            coordinate: {
+                lat: 41.8819,
+                lon: -87.6278,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-NO-Oslo',
+            coordinate: {
+                lat: 59.913868,
+                lon: 10.752245,
+            },
+            region: PrivacyRegion.Norwegian_Personal_Data_Act,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Warsaw',
+            coordinate: {
+                lat: 52.23334,
+                lon: 21.01666,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-ZA-Johannesburg',
+            coordinate: {
+                lat: 28.21837,
+                lon: -25.73134,
+            },
+            region: PrivacyRegion.SouthAfrica_Protection_Personal_Information_Act,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-US-Texas',
+            coordinate: {
+                lat: 29.4167,
+                lon: -98.5,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-IN-Chennai',
+            coordinate: {
+                lat: 12.9822,
+                lon: 80.1636,
+            },
+            region: PrivacyRegion.Indian_Personal_Protection,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Gavle',
+            coordinate: {
+                lat: 60.67488,
+                lon: 17.14127,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o-mini', 'gpt-4o'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Madrid',
+            coordinate: {
+                lat: 3.4209,
+                lon: 40.4259,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-CH-Geneva',
+            coordinate: {
+                lat: 46.204391,
+                lon: 6.143158,
+            },
+            region: PrivacyRegion.Swiss_Federal_Act_on_Data_Protection,
+            languageModelAvailability: [],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-CH-Zurich',
+            coordinate: {
+                lat: 47.451542,
+                lon: 8.564572,
+            },
+            region: PrivacyRegion.Swiss_Federal_Act_on_Data_Protection,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-UK-London',
+            coordinate: {
+                lat: 50.941,
+                lon: -0.799,
+            },
+            region: PrivacyRegion.UK_General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+        {
+            id: 'OpenAi-EU-Netherlands',
+            coordinate: {
+                lat: 52.3667,
+                lon: 4.9,
+            },
+            region: PrivacyRegion.General_Data_Protection_Regulation,
+            languageModelAvailability: ['gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-US-California',
+            coordinate: {
+                lat: 37.783,
+                lon: -122.417,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: [],
+        },
+        {
+            id: 'OpenAi-US-Phoenix',
+            coordinate: {
+                lat: 33.448376,
+                lon: -112.074036,
+            },
+            languageModelAvailability: ['gpt-35-turbo', 'gpt-4-turbo', 'gpt-4o', 'gpt-4o-mini'],
+            textEmbeddingModelAvailability: ['text-embedding-3-large'],
+        },
+    ]);
+}

package/dist/serverSelector/base.d.mts

@@ -0,0 +1,22 @@
+import type { RawCoordinate } from '@chainfuse/types';
+import type { IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
+import { AiBase } from '../base.mjs';
+import type { Server } from './types.mjs';
+export declare enum PrivacyRegion {
+    Australian_Privacy_Principles = "APPs",
+    Brazil_General_Data_protection_Law = "LGPD",
+    Canada_Personal_Information_Protection_and_Electronic_Documents_Act = "PIPEDA",
+    General_Data_Protection_Regulation = "GDPR",
+    Indian_Personal_Protection = "PDP",
+    Japan_Act_on_the_Protection_of_Personal_Information = "APPI",
+    Korean_Personal_Information_Protection_Act = "PIPA",
+    Norwegian_Personal_Data_Act = "NPDA",
+    SouthAfrica_Protection_Personal_Information_Act = "PoPIA",
+    Swiss_Federal_Act_on_Data_Protection = "revFADP",
+    UK_General_Data_Protection_Regulation = "UK-GDPR"
+}
+export declare abstract class ServerSelector extends AiBase {
+    readonly servers: Set<Server>;
+    static determinePrivacyRegion(country?: IncomingRequestCfProperties['country'], continent?: IncomingRequestCfProperties['continent']): PrivacyRegion[];
+    closestServers(requiredCapability?: (Server['languageModelAvailability'] | Server['textEmbeddingModelAvailability'])[number], userCoordinate?: RawCoordinate, privacyRegion?: PrivacyRegion[]): Server[];
+}