recker 1.0.43 → 1.0.44

package/dist/browser/presets/aws.js

@@ -0,0 +1,68 @@
+import { awsSignatureV4Plugin } from '../plugins/auth.js';
+function getServiceEndpoint(service, region) {
+    const globalServices = ['iam', 'sts', 'cloudfront', 'route53'];
+    if (globalServices.includes(service)) {
+        return `https://${service}.amazonaws.com`;
+    }
+    const specialEndpoints = {
+        's3': `https://s3.${region}.amazonaws.com`,
+        'execute-api': `https://${region}.execute-api.amazonaws.com`,
+        'logs': `https://logs.${region}.amazonaws.com`,
+        'events': `https://events.${region}.amazonaws.com`,
+        'states': `https://states.${region}.amazonaws.com`,
+        'bedrock-runtime': `https://bedrock-runtime.${region}.amazonaws.com`,
+    };
+    if (specialEndpoints[service]) {
+        return specialEndpoints[service];
+    }
+    return `https://${service}.${region}.amazonaws.com`;
+}
+export function aws(options) {
+    const baseUrl = options.endpoint ?? getServiceEndpoint(options.service, options.region);
+    return {
+        baseUrl,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        timeout: 30 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        plugins: [
+            awsSignatureV4Plugin({
+                accessKeyId: options.accessKeyId,
+                secretAccessKey: options.secretAccessKey,
+                region: options.region,
+                service: options.service,
+                sessionToken: options.sessionToken,
+            })
+        ]
+    };
+}
+export function awsS3(options) {
+    return aws({ ...options, service: 's3' });
+}
+export function awsDynamoDB(options) {
+    return aws({ ...options, service: 'dynamodb' });
+}
+export function awsLambda(options) {
+    return aws({ ...options, service: 'lambda' });
+}
+export function awsSQS(options) {
+    return aws({ ...options, service: 'sqs' });
+}
+export function awsSNS(options) {
+    return aws({ ...options, service: 'sns' });
+}
+export function awsSES(options) {
+    return aws({ ...options, service: 'ses' });
+}
+export function awsSecretsManager(options) {
+    return aws({ ...options, service: 'secretsmanager' });
+}
+export function awsBedrock(options) {
+    return aws({ ...options, service: 'bedrock-runtime' });
+}

package/dist/browser/presets/azure-openai.d.ts

@@ -0,0 +1,10 @@
+import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
+export interface AzureOpenAIPresetOptions {
+    resourceName: string;
+    apiKey: string;
+    apiVersion?: string;
+    deploymentName?: string;
+    model?: string;
+}
+export declare function azureOpenai(options: AzureOpenAIPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/browser/presets/azure-openai.js

@@ -0,0 +1,35 @@
+export function azureOpenai(options) {
+    const apiVersion = options.apiVersion || '2024-02-15-preview';
+    const baseUrl = options.deploymentName
+        ? `https://${options.resourceName}.openai.azure.com/openai/deployments/${options.deploymentName}`
+        : `https://${options.resourceName}.openai.azure.com/openai`;
+    const _aiConfig = {
+        provider: 'azure-openai',
+        apiKey: options.apiKey,
+        model: options.model ?? options.deploymentName ?? 'gpt-4o',
+        resourceName: options.resourceName,
+        deploymentName: options.deploymentName,
+        apiVersion,
+        memory: { maxPairs: 12 },
+    };
+    return {
+        baseUrl,
+        headers: {
+            'api-key': options.apiKey,
+            'Content-Type': 'application/json',
+        },
+        defaults: {
+            params: {
+                'api-version': apiVersion,
+            }
+        },
+        timeout: 10 * 60 * 1000,
+        retry: {
+            maxAttempts: 5,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        _aiConfig,
+    };
+}

package/dist/browser/presets/azure.d.ts

@@ -0,0 +1,41 @@
+import { ClientOptions } from '../types/index.js';
+export interface AzurePresetOptions {
+    subscriptionId?: string;
+    resourceGroup?: string;
+    auth: AzureAuthOptions;
+}
+export type AzureAuthOptions = {
+    type: 'bearer';
+    token: string | (() => string | Promise<string>);
+} | {
+    type: 'shared-key';
+    accountName: string;
+    accountKey: string;
+} | {
+    type: 'sas';
+    sasToken: string;
+};
+export type AzureService = 'management' | 'storage-blob' | 'storage-queue' | 'storage-table' | 'storage-file' | 'cosmos-db' | 'keyvault' | 'servicebus' | 'eventhubs' | 'functions' | 'cognitive' | 'devops' | 'graph' | 'monitor' | 'containerregistry';
+export interface AzureFullPresetOptions extends AzurePresetOptions {
+    service: AzureService;
+    accountName?: string;
+    region?: string;
+}
+export declare function azure(options: AzureFullPresetOptions): ClientOptions;
+export declare function azureResourceManager(options: Omit<AzurePresetOptions, 'service'> & {
+    subscriptionId: string;
+}): ClientOptions;
+export declare function azureBlobStorage(options: Omit<AzurePresetOptions, 'service'> & {
+    accountName: string;
+}): ClientOptions;
+export declare function azureKeyVault(options: Omit<AzurePresetOptions, 'service'> & {
+    accountName: string;
+}): ClientOptions;
+export declare function azureCosmosDB(options: Omit<AzurePresetOptions, 'service'> & {
+    accountName: string;
+}): ClientOptions;
+export declare function microsoftGraph(options: Omit<AzurePresetOptions, 'service'>): ClientOptions;
+export declare function azureDevOps(options: Omit<AzurePresetOptions, 'service'>): ClientOptions;
+export declare function azureCognitiveServices(options: Omit<AzurePresetOptions, 'service'> & {
+    region: string;
+}): ClientOptions;

package/dist/browser/presets/azure.js

@@ -0,0 +1,104 @@
+function getAzureServiceUrl(service, options) {
+    const { subscriptionId, accountName, region } = options;
+    switch (service) {
+        case 'management':
+            return 'https://management.azure.com';
+        case 'storage-blob':
+            return `https://${accountName}.blob.core.windows.net`;
+        case 'storage-queue':
+            return `https://${accountName}.queue.core.windows.net`;
+        case 'storage-table':
+            return `https://${accountName}.table.core.windows.net`;
+        case 'storage-file':
+            return `https://${accountName}.file.core.windows.net`;
+        case 'cosmos-db':
+            return `https://${accountName}.documents.azure.com`;
+        case 'keyvault':
+            return `https://${accountName}.vault.azure.net`;
+        case 'servicebus':
+            return `https://${accountName}.servicebus.windows.net`;
+        case 'eventhubs':
+            return `https://${accountName}.servicebus.windows.net`;
+        case 'cognitive':
+            return `https://${region || 'eastus'}.api.cognitive.microsoft.com`;
+        case 'devops':
+            return 'https://dev.azure.com';
+        case 'graph':
+            return 'https://graph.microsoft.com/v1.0';
+        case 'monitor':
+            return 'https://management.azure.com';
+        case 'containerregistry':
+            return `https://${accountName}.azurecr.io`;
+        default:
+            return 'https://management.azure.com';
+    }
+}
+function createAzureAuthMiddleware(auth) {
+    return async (req, next) => {
+        let newReq = req;
+        if (auth.type === 'bearer') {
+            const token = typeof auth.token === 'function'
+                ? await auth.token()
+                : auth.token;
+            newReq = req.withHeader('Authorization', `Bearer ${token}`);
+        }
+        else if (auth.type === 'sas') {
+            const url = new URL(req.url);
+            const sasParams = new URLSearchParams(auth.sasToken.startsWith('?') ? auth.sasToken.slice(1) : auth.sasToken);
+            sasParams.forEach((value, key) => url.searchParams.set(key, value));
+            newReq = { ...req, url: url.toString() };
+        }
+        else if (auth.type === 'shared-key') {
+            const authHeader = `SharedKey ${auth.accountName}:${auth.accountKey}`;
+            newReq = req.withHeader('Authorization', authHeader);
+        }
+        return next(newReq);
+    };
+}
+export function azure(options) {
+    const baseUrl = getAzureServiceUrl(options.service, {
+        subscriptionId: options.subscriptionId,
+        resourceGroup: options.resourceGroup,
+        accountName: options.accountName,
+        region: options.region,
+    });
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (options.service === 'management' || options.service === 'monitor') {
+        headers['x-ms-version'] = '2023-01-01';
+    }
+    return {
+        baseUrl,
+        headers,
+        timeout: 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        middlewares: [createAzureAuthMiddleware(options.auth)]
+    };
+}
+export function azureResourceManager(options) {
+    return azure({ ...options, service: 'management' });
+}
+export function azureBlobStorage(options) {
+    return azure({ ...options, service: 'storage-blob' });
+}
+export function azureKeyVault(options) {
+    return azure({ ...options, service: 'keyvault' });
+}
+export function azureCosmosDB(options) {
+    return azure({ ...options, service: 'cosmos-db' });
+}
+export function microsoftGraph(options) {
+    return azure({ ...options, service: 'graph' });
+}
+export function azureDevOps(options) {
+    return azure({ ...options, service: 'devops' });
+}
+export function azureCognitiveServices(options) {
+    return azure({ ...options, service: 'cognitive' });
+}

package/dist/browser/presets/chaturbate.d.ts

@@ -0,0 +1,2 @@
+import { ClientOptions } from '../types/index.js';
+export default function chaturbate(): ClientOptions;

package/dist/browser/presets/chaturbate.js

@@ -0,0 +1,17 @@
+export default function chaturbate() {
+    return {
+        useCurl: true,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Referer': 'https://chaturbate.com/',
+            'Origin': 'https://chaturbate.com',
+            'Accept': '*/*',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'cross-site',
+            'Connection': 'keep-alive',
+            'Pragma': 'no-cache',
+            'Cache-Control': 'no-cache'
+        }
+    };
+}

package/dist/browser/presets/cloudflare.d.ts

@@ -0,0 +1,12 @@
+import { ClientOptions } from '../types/index.js';
+export interface CloudflarePresetOptions {
+    apiToken?: string;
+    apiKey?: string;
+    email?: string;
+}
+export declare function cloudflare(options: CloudflarePresetOptions): ClientOptions;
+export interface CloudflareWorkersAIPresetOptions {
+    accountId: string;
+    apiToken: string;
+}
+export declare function cloudflareWorkersAI(options: CloudflareWorkersAIPresetOptions): ClientOptions;

package/dist/browser/presets/cloudflare.js

@@ -0,0 +1,39 @@
+export function cloudflare(options) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (options.apiToken) {
+        headers['Authorization'] = `Bearer ${options.apiToken}`;
+    }
+    else if (options.apiKey && options.email) {
+        headers['X-Auth-Key'] = options.apiKey;
+        headers['X-Auth-Email'] = options.email;
+    }
+    return {
+        baseUrl: 'https://api.cloudflare.com/client/v4',
+        headers,
+        timeout: 30 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        }
+    };
+}
+export function cloudflareWorkersAI(options) {
+    return {
+        baseUrl: `https://api.cloudflare.com/client/v4/accounts/${options.accountId}/ai`,
+        headers: {
+            'Authorization': `Bearer ${options.apiToken}`,
+            'Content-Type': 'application/json',
+        },
+        timeout: 5 * 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        }
+    };
+}

package/dist/browser/presets/cohere.d.ts

@@ -0,0 +1,7 @@
+import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
+export interface CoherePresetOptions {
+    apiKey: string;
+    model?: string;
+}
+export declare function cohere(options: CoherePresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/browser/presets/cohere.js

@@ -0,0 +1,22 @@
+export function cohere(options) {
+    const _aiConfig = {
+        provider: 'cohere',
+        apiKey: options.apiKey,
+        model: options.model ?? 'command-a-03-2025',
+        memory: { maxPairs: 12 },
+    };
+    return {
+        baseUrl: 'https://api.cohere.ai/v1',
+        headers: {
+            'Authorization': `Bearer ${options.apiKey}`,
+        },
+        timeout: 5 * 60 * 1000,
+        retry: {
+            maxAttempts: 5,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        _aiConfig,
+    };
+}

package/dist/browser/presets/deepseek.d.ts

@@ -0,0 +1,7 @@
+import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
+export interface DeepSeekPresetOptions {
+    apiKey: string;
+    model?: string;
+}
+export declare function deepseek(options: DeepSeekPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/browser/presets/deepseek.js

@@ -0,0 +1,22 @@
+export function deepseek(options) {
+    const _aiConfig = {
+        provider: 'deepseek',
+        apiKey: options.apiKey,
+        model: options.model ?? 'deepseek-v3.2',
+        memory: { maxPairs: 12 },
+    };
+    return {
+        baseUrl: 'https://api.deepseek.com/v1',
+        headers: {
+            'Authorization': `Bearer ${options.apiKey}`,
+        },
+        timeout: 10 * 60 * 1000,
+        retry: {
+            maxAttempts: 5,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        _aiConfig,
+    };
+}

package/dist/browser/presets/digitalocean.d.ts

@@ -0,0 +1,5 @@
+import { ClientOptions } from '../types/index.js';
+export interface DigitalOceanPresetOptions {
+    token: string;
+}
+export declare function digitalocean(options: DigitalOceanPresetOptions): ClientOptions;

package/dist/browser/presets/digitalocean.js

@@ -0,0 +1,16 @@
+export function digitalocean(options) {
+    return {
+        baseUrl: 'https://api.digitalocean.com/v2',
+        headers: {
+            'Authorization': `Bearer ${options.token}`,
+            'Content-Type': 'application/json',
+        },
+        timeout: 30 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        }
+    };
+}

package/dist/browser/presets/discord.d.ts

@@ -0,0 +1,6 @@
+import { ClientOptions } from '../types/index.js';
+export interface DiscordPresetOptions {
+    token: string;
+    tokenType?: 'Bot' | 'Bearer';
+}
+export declare function discord(options: DiscordPresetOptions): ClientOptions;

package/dist/browser/presets/discord.js

@@ -0,0 +1,17 @@
+export function discord(options) {
+    const tokenType = options.tokenType || 'Bot';
+    return {
+        baseUrl: 'https://discord.com/api/v10',
+        headers: {
+            'Authorization': `${tokenType} ${options.token}`,
+            'Content-Type': 'application/json',
+        },
+        timeout: 30 * 1000,
+        retry: {
+            maxAttempts: 5,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        }
+    };
+}

package/dist/browser/presets/elevenlabs.d.ts

@@ -0,0 +1,6 @@
+import { ClientOptions } from '../types/index.js';
+export interface ElevenLabsPresetOptions {
+    apiKey: string;
+}
+export declare function elevenlabs(options: ElevenLabsPresetOptions): ClientOptions;
+export declare const elevenlabsVoices: (options: ElevenLabsPresetOptions) => ClientOptions;

package/dist/browser/presets/elevenlabs.js

@@ -0,0 +1,20 @@
+export function elevenlabs(options) {
+    return {
+        baseUrl: 'https://api.elevenlabs.io/v1',
+        headers: {
+            'xi-api-key': options.apiKey,
+            'Content-Type': 'application/json',
+        },
+        timeout: 3 * 60 * 1000,
+        retry: {
+            maxAttempts: 2,
+            backoff: 'exponential',
+            delay: 2000,
+            statusCodes: [408, 429, 500, 502, 503, 504],
+        }
+    };
+}
+export const elevenlabsVoices = (options) => ({
+    ...elevenlabs(options),
+    baseUrl: 'https://api.elevenlabs.io/v1/voices',
+});

package/dist/browser/presets/enhancers.d.ts

@@ -0,0 +1,20 @@
+import type { ClientOptions } from '../types/index.js';
+export declare const mobile: () => ClientOptions;
+export declare const desktop: () => ClientOptions;
+export declare const chrome: () => ClientOptions;
+export declare const bot: () => ClientOptions;
+export declare const google: () => ClientOptions;
+export declare const curl: () => ClientOptions;
+export declare const retry: () => ClientOptions;
+export declare const insecure: () => ClientOptions;
+export declare const failfast: () => ClientOptions;
+export declare const nocache: () => ClientOptions;
+export declare const json: () => ClientOptions;
+export declare const xml: () => ClientOptions;
+export declare const csv: () => ClientOptions;
+export declare const text: () => ClientOptions;
+export declare const html: () => ClientOptions;
+export declare const image: () => ClientOptions;
+export declare const local: () => ClientOptions;
+export declare const local8000: () => ClientOptions;
+export declare const local8080: () => ClientOptions;

package/dist/browser/presets/enhancers.js

@@ -0,0 +1,85 @@
+export const mobile = () => ({
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1'
+    }
+});
+export const desktop = () => ({
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    }
+});
+export const chrome = desktop;
+export const bot = () => ({
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)'
+    }
+});
+export const google = bot;
+export const curl = () => ({
+    headers: {
+        'User-Agent': 'curl/8.5.0',
+        'Accept': '*/*'
+    }
+});
+export const retry = () => ({
+    retry: {
+        maxAttempts: 3,
+        delay: 1000,
+        backoff: 'exponential',
+        statusCodes: [408, 429, 500, 502, 503, 504]
+    }
+});
+export const insecure = () => ({
+    tls: {
+        rejectUnauthorized: false
+    }
+});
+export const failfast = () => ({
+    timeout: 2000,
+    retry: { maxAttempts: 0 }
+});
+export const nocache = () => ({
+    headers: {
+        'Cache-Control': 'no-cache, no-store',
+        'Pragma': 'no-cache'
+    }
+});
+export const json = () => ({
+    headers: {
+        'Accept': 'application/json'
+    }
+});
+export const xml = () => ({
+    headers: {
+        'Accept': 'application/xml, text/xml'
+    }
+});
+export const csv = () => ({
+    headers: {
+        'Accept': 'text/csv'
+    }
+});
+export const text = () => ({
+    headers: {
+        'Accept': 'text/plain'
+    }
+});
+export const html = () => ({
+    headers: {
+        'Accept': 'text/html'
+    }
+});
+export const image = () => ({
+    headers: {
+        'Accept': 'image/*'
+    }
+});
+export const local = () => ({
+    baseUrl: 'http://localhost:3000'
+});
+export const local8000 = () => ({
+    baseUrl: 'http://localhost:8000'
+});
+export const local8080 = () => ({
+    baseUrl: 'http://localhost:8080'
+});

package/dist/browser/presets/fireworks.d.ts

@@ -0,0 +1,7 @@
+import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
+export interface FireworksPresetOptions {
+    apiKey: string;
+    model?: string;
+}
+export declare function fireworks(options: FireworksPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/browser/presets/fireworks.js

@@ -0,0 +1,22 @@
+export function fireworks(options) {
+    const _aiConfig = {
+        provider: 'fireworks',
+        apiKey: options.apiKey,
+        model: options.model ?? 'accounts/fireworks/models/llama-v3p3-70b-instruct',
+        memory: { maxPairs: 12 },
+    };
+    return {
+        baseUrl: 'https://api.fireworks.ai/inference/v1',
+        headers: {
+            'Authorization': `Bearer ${options.apiKey}`,
+        },
+        timeout: 5 * 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 500,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        _aiConfig,
+    };
+}

package/dist/browser/presets/gcp.d.ts

@@ -0,0 +1,34 @@
+import { ClientOptions } from '../types/index.js';
+export interface GCPPresetOptions {
+    projectId: string;
+    auth: GCPAuthOptions;
+    region?: string;
+}
+export type GCPAuthOptions = {
+    type: 'api-key';
+    apiKey: string;
+} | {
+    type: 'oauth';
+    accessToken: string | (() => string | Promise<string>);
+} | {
+    type: 'service-account';
+    keyFile?: string;
+    credentials?: GCPServiceAccountCredentials;
+};
+export interface GCPServiceAccountCredentials {
+    client_email: string;
+    private_key: string;
+    token_uri?: string;
+}
+export type GCPService = 'compute' | 'storage' | 'bigquery' | 'pubsub' | 'firestore' | 'functions' | 'run' | 'cloudsql' | 'kubernetes' | 'aiplatform' | 'translate' | 'vision' | 'speech' | 'language' | 'secretmanager' | 'iam' | 'logging' | 'monitoring';
+export declare function gcp(options: GCPPresetOptions & {
+    service: GCPService;
+}): ClientOptions;
+export declare function gcpStorage(options: GCPPresetOptions): ClientOptions;
+export declare function gcpCompute(options: GCPPresetOptions): ClientOptions;
+export declare function gcpBigQuery(options: GCPPresetOptions): ClientOptions;
+export declare function gcpPubSub(options: GCPPresetOptions): ClientOptions;
+export declare function gcpCloudRun(options: GCPPresetOptions): ClientOptions;
+export declare function gcpVertexAI(options: GCPPresetOptions): ClientOptions;
+export declare function gcpFirestore(options: GCPPresetOptions): ClientOptions;
+export declare function gcpSecretManager(options: GCPPresetOptions): ClientOptions;