@chainfuse/ai-tools 0.1.0

package/dist/serverSelector/base.mjs

@@ -0,0 +1,137 @@
+import { Helpers } from '@chainfuse/helpers';
+import haversine from 'haversine-distance';
+import { AiBase } from '../base.mjs';
+export var PrivacyRegion;
+(function (PrivacyRegion) {
+    PrivacyRegion["Australian_Privacy_Principles"] = "APPs";
+    PrivacyRegion["Brazil_General_Data_protection_Law"] = "LGPD";
+    PrivacyRegion["Canada_Personal_Information_Protection_and_Electronic_Documents_Act"] = "PIPEDA";
+    PrivacyRegion["General_Data_Protection_Regulation"] = "GDPR";
+    PrivacyRegion["Indian_Personal_Protection"] = "PDP";
+    PrivacyRegion["Japan_Act_on_the_Protection_of_Personal_Information"] = "APPI";
+    PrivacyRegion["Korean_Personal_Information_Protection_Act"] = "PIPA";
+    PrivacyRegion["Norwegian_Personal_Data_Act"] = "NPDA";
+    PrivacyRegion["SouthAfrica_Protection_Personal_Information_Act"] = "PoPIA";
+    PrivacyRegion["Swiss_Federal_Act_on_Data_Protection"] = "revFADP";
+    PrivacyRegion["UK_General_Data_Protection_Regulation"] = "UK-GDPR";
+})(PrivacyRegion || (PrivacyRegion = {}));
+export class ServerSelector extends AiBase {
+    servers = new Set();
+    static determinePrivacyRegion(country, continent) {
+        const regions = new Set();
+        if (country) {
+            switch (country.toUpperCase()) {
+                case 'AU':
+                    regions.add(PrivacyRegion.Australian_Privacy_Principles);
+                    break;
+                case 'BR':
+                    regions.add(PrivacyRegion.Brazil_General_Data_protection_Law);
+                    break;
+                case 'CA':
+                    regions.add(PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+                case 'IN':
+                    regions.add(PrivacyRegion.Indian_Personal_Protection);
+                    break;
+                case 'JP':
+                    regions.add(PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+                case 'KR':
+                    regions.add(PrivacyRegion.Korean_Personal_Information_Protection_Act);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+                case 'NO':
+                    regions.add(PrivacyRegion.Norwegian_Personal_Data_Act);
+                    regions.add(PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information);
+                    regions.add(PrivacyRegion.Korean_Personal_Information_Protection_Act);
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+                case 'ZA':
+                    regions.add(PrivacyRegion.SouthAfrica_Protection_Personal_Information_Act);
+                    break;
+                case 'CH':
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information);
+                    regions.add(PrivacyRegion.Korean_Personal_Information_Protection_Act);
+                    regions.add(PrivacyRegion.Norwegian_Personal_Data_Act);
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+                case 'GB':
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act);
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information);
+                    regions.add(PrivacyRegion.Korean_Personal_Information_Protection_Act);
+                    regions.add(PrivacyRegion.Norwegian_Personal_Data_Act);
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+            }
+        }
+        if (continent) {
+            switch (continent.toUpperCase()) {
+                case 'EU':
+                    regions.add(PrivacyRegion.General_Data_Protection_Regulation);
+                    regions.add(PrivacyRegion.Canada_Personal_Information_Protection_and_Electronic_Documents_Act);
+                    regions.add(PrivacyRegion.Japan_Act_on_the_Protection_of_Personal_Information);
+                    regions.add(PrivacyRegion.Korean_Personal_Information_Protection_Act);
+                    regions.add(PrivacyRegion.Norwegian_Personal_Data_Act);
+                    regions.add(PrivacyRegion.Swiss_Federal_Act_on_Data_Protection);
+                    regions.add(PrivacyRegion.UK_General_Data_Protection_Regulation);
+                    break;
+            }
+        }
+        return Array.from(regions);
+    }
+    closestServers(requiredCapability, userCoordinate = {
+        lat: this.config.geoRouting?.userCoordinate?.lat ?? '0',
+        lon: this.config.geoRouting?.userCoordinate?.lon ?? '0',
+    }, privacyRegion = ServerSelector.determinePrivacyRegion(this.config.geoRouting?.country, this.config.geoRouting?.continent)) {
+        // Skip over the rest of logic if the server can't handle the incoming request
+        // @ts-expect-error it's always strings, just sometimes string literals
+        const featureFilteredServers = requiredCapability ? Array.from(this.servers).filter((server) => server.languageModelAvailability.includes(requiredCapability) || server.textEmbeddingModelAvailability.includes(requiredCapability)) : Array.from(this.servers);
+        if (featureFilteredServers.length > 0) {
+            // Skip over servers not in the save privacy region except if undefined, then you can use any
+            const privacyRegionFilteredServers = featureFilteredServers.filter((server) => privacyRegion.length === 0 || (server.region && privacyRegion.includes(server.region)));
+            if (privacyRegionFilteredServers.length > 0) {
+                // Calculate distance for each server and store it as a tuple [Server, distance]
+                const serversWithDistances = privacyRegionFilteredServers.map((server) => {
+                    // Match decimal point length
+                    return [
+                        server,
+                        haversine({
+                            lat: Helpers.precisionFloat(userCoordinate.lat),
+                            lon: Helpers.precisionFloat(userCoordinate.lon),
+                        }, {
+                            lat: server.coordinate.lat,
+                            lon: server.coordinate.lon,
+                        }),
+                    ];
+                });
+                // Sort the servers by distance
+                serversWithDistances.sort((a, b) => a[1] - b[1]);
+                // Extract the ids of the sorted servers
+                const sortedServers = serversWithDistances.map(([server]) => server);
+                return sortedServers;
+            }
+            else {
+                throw new Error(`No server with the capability ${requiredCapability} available in a region covered under ${JSON.stringify(privacyRegion)}`);
+            }
+        }
+        else {
+            throw new Error(`No server with the capability ${requiredCapability} available`);
+        }
+    }
+}

package/dist/serverSelector/types.d.mts

@@ -0,0 +1,9 @@
+import type { AzureChatModels, AzureEmbeddingModels, Coordinate } from '@chainfuse/types';
+import type { PrivacyRegion } from './base.mjs';
+export interface Server {
+    id: string;
+    coordinate: Coordinate;
+    region?: PrivacyRegion;
+    languageModelAvailability: AzureChatModels[] | string[];
+    textEmbeddingModelAvailability: AzureEmbeddingModels[] | string[];
+}

package/dist/serverSelector/types.mjs

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

package/dist/types.d.mts

@@ -0,0 +1,101 @@
+import type { PrefixedUuid, RawCoordinate, UuidExport } from '@chainfuse/types';
+import type { Ai, IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
+import type haversine from 'haversine-distance';
+export interface AiConfig {
+    gateway: {
+        accountId: string;
+        apiToken: string;
+    };
+    geoRouting?: {
+        userCoordinate?: RawCoordinate;
+        country?: IncomingRequestCfProperties['country'];
+        continent?: IncomingRequestCfProperties['continent'];
+    };
+    environment: 'production' | 'preview';
+    providers: AiConfigProviders;
+}
+export interface AiConfigProviders {
+    anthropic: AiConfigAnthropic;
+    azureOpenAi: AiConfigAzOpenai;
+    openAi: AiConfigOaiOpenai;
+    workersAi: AiConfigWorkersai;
+}
+export interface AiConfigAnthropic {
+    apiToken: `sk-ant-${string}`;
+}
+export interface AiConfigAzOpenai {
+    apiTokens: Record<`AZURE_API_KEY_${string}`, string>;
+}
+export interface AiConfigOaiOpenai {
+    apiToken: `sk-${string}`;
+    organization: `org-${string}`;
+}
+export interface AiConfigWorkersaiRest {
+    apiToken: string;
+}
+/**
+ * @deprecated Not functional. Use REST instead
+ */
+export type AiConfigWorkersaiBinding = Ai;
+export type AiConfigWorkersai = AiConfigWorkersaiRest | AiConfigWorkersaiBinding;
+/**
+ * It's a UUID, but the last block is SHA256 of the request body
+ */
+export type AiRequestIdempotencyId = UuidExport['utf8'];
+export interface AiRequestExecutor {
+    type: 'worker' | 'queue' | 'workflow' | 'githubCicd';
+    id: string;
+}
+export interface AiRequestConfig {
+    /**
+     * Sets if a response should be cached (1 month) or for any custom duration
+     * @default true
+     */
+    cache?: boolean | number;
+    dataspaceId: PrefixedUuid | UuidExport['utf8'] | UuidExport['hex'];
+    /**
+     * Service identification of caller
+     */
+    executor: AiRequestExecutor;
+    /**
+     * Identify the same request across multiple calls. If not provided, a new id will be generated
+     * Structure: <UUIDv7>.<last 8 of SHA256 of body>
+     */
+    idempotencyId?: AiRequestIdempotencyId;
+    /**
+     * Logging includes anything up to the ai call. For ai call info, see ai gateway
+     * @default false (on production environment), true (on preview environment)
+     */
+    logging?: boolean;
+    /**
+     * Force a response to be generated even if a matching request is already cached (without changing cache setting)
+     * @default false
+     */
+    skipCache?: boolean;
+}
+export interface AiRequestMetadataServerInfo {
+    name: 'anthropic' | 'cloudflare' | 'openai';
+}
+export interface AiRequestMetadataServerInfoWithLocation {
+    name: `${'azure' | 'google'}-${string}`;
+    /**
+     * @returns distance in meters
+     */
+    distance: ReturnType<typeof haversine>;
+}
+export interface AiRequestMetadataTiming {
+    modelTime?: number;
+    fromCache: boolean;
+    totalRoundtripTime: number;
+}
+export interface AiRequestMetadata {
+    dataspaceId: AiRequestConfig['dataspaceId'];
+    serverInfo: AiRequestMetadataServerInfo | AiRequestMetadataServerInfoWithLocation | string;
+    idempotencyId: AiRequestIdempotencyId;
+    executor: AiRequestExecutor | string;
+    timing: AiRequestMetadataTiming | string;
+}
+/**
+ * Extracts the chunk type from an asynchronous iterable.
+ */
+export type AiStreamChunkType<T> = T extends AsyncIterable<infer U> ? Awaited<U> : never;

package/dist/types.mjs

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

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@chainfuse/ai-tools",
+	"version": "0.1.0",
+	"description": "",
+	"author": "ChainFuse",
+	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/ai-tools#readme",
+	"license": "Apache-2.0",
+	"main": "./dist/index.mjs",
+	"directories": {
+		"lib": "dist",
+		"test": "__tests__"
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ChainFuse/packages.git"
+	},
+	"scripts": {
+		"fmt": "prettier --check .",
+		"fmt:fix": "prettier --write .",
+		"lint": "eslint .",
+		"lint:fix": "npm run lint -- --fix",
+		"clean": "npx -y rimraf@latest ./dist ./.tsbuildinfo",
+		"build": "tsc",
+		"build:clean": "npm run build -- --build --clean && npm run build",
+		"pretest": "tsc --project tsconfig.tests.json",
+		"test": "node --env-file-if-exists=.dev.vars --enable-source-maps --test --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout"
+	},
+	"type": "module",
+	"bugs": {
+		"url": "https://github.com/ChainFuse/packages/issues"
+	},
+	"types": "./dist/index.d.mts",
+	"engines": {
+		"node": ">=22.11.0"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.mjs",
+			"types": "./dist/index.d.mts"
+		}
+	},
+	"prettier": "@demosjarco/prettier-config",
+	"dependencies": {
+		"@ai-sdk/anthropic": "^1.0.6",
+		"@ai-sdk/azure": "^1.0.15",
+		"@ai-sdk/openai": "^1.0.5",
+		"@chainfuse/helpers": "^0.5.0",
+		"@chainfuse/types": "^1.4.0",
+		"ai": "^4.0.25",
+		"chalk": "^5.4.1",
+		"haversine-distance": "^1.2.3",
+		"workers-ai-provider": "^0.0.10"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "^4.20241230.0",
+		"openai": "^4.77.3"
+	},
+	"gitHead": "13881adbb875a4b1680448205ff9e0ac55577f72"
+}