recker 1.0.43 → 1.0.44

package/dist/browser/presets/oracle.js

@@ -0,0 +1,117 @@
+import { createSign } from 'node:crypto';
+function getOCIServiceUrl(service, region) {
+    const serviceUrls = {
+        'core': `https://iaas.${region}.oraclecloud.com`,
+        'objectstorage': `https://objectstorage.${region}.oraclecloud.com`,
+        'database': `https://database.${region}.oraclecloud.com`,
+        'identity': `https://identity.${region}.oraclecloud.com`,
+        'containerengine': `https://containerengine.${region}.oraclecloud.com`,
+        'functions': `https://functions.${region}.oraclecloud.com`,
+        'streaming': `https://streaming.${region}.oraclecloud.com`,
+        'logging': `https://logging.${region}.oraclecloud.com`,
+        'monitoring': `https://telemetry.${region}.oraclecloud.com`,
+        'vault': `https://vaults.${region}.oraclecloud.com`,
+        'kms': `https://kms.${region}.oraclecloud.com`,
+        'nosql': `https://nosql.${region}.oraclecloud.com`,
+        'apm': `https://apm.${region}.oraclecloud.com`,
+        'generativeai': `https://generativeai.${region}.oraclecloud.com`,
+        'aidocument': `https://document.${region}.oraclecloud.com`,
+        'aivision': `https://vision.${region}.oraclecloud.com`,
+    };
+    return serviceUrls[service] || `https://${service}.${region}.oraclecloud.com`;
+}
+function createOCISigningMiddleware(options) {
+    const keyId = `${options.tenancyId}/${options.userId}/${options.fingerprint}`;
+    return async (req, next) => {
+        const url = new URL(req.url);
+        const now = new Date();
+        const dateStr = now.toUTCString();
+        const headersToSign = ['date', '(request-target)', 'host'];
+        const methodsWithBody = ['POST', 'PUT', 'PATCH'];
+        if (methodsWithBody.includes(req.method.toUpperCase())) {
+            headersToSign.push('content-length', 'content-type', 'x-content-sha256');
+        }
+        const signingParts = [];
+        const headerValues = {
+            'date': dateStr,
+            '(request-target)': `${req.method.toLowerCase()} ${url.pathname}${url.search}`,
+            'host': url.host,
+        };
+        let bodyHash = '';
+        if (methodsWithBody.includes(req.method.toUpperCase())) {
+            let bodyContent = '';
+            if (req.body) {
+                if (typeof req.body === 'string') {
+                    bodyContent = req.body;
+                }
+                else if (req.body instanceof ArrayBuffer) {
+                    bodyContent = Buffer.from(req.body).toString();
+                }
+            }
+            const crypto = await import('node:crypto');
+            bodyHash = crypto.createHash('sha256').update(bodyContent).digest('base64');
+            headerValues['content-length'] = Buffer.byteLength(bodyContent).toString();
+            headerValues['content-type'] = 'application/json';
+            headerValues['x-content-sha256'] = bodyHash;
+        }
+        for (const header of headersToSign) {
+            signingParts.push(`${header}: ${headerValues[header]}`);
+        }
+        const signingString = signingParts.join('\n');
+        const sign = createSign('RSA-SHA256');
+        sign.update(signingString);
+        let signature;
+        if (options.passphrase) {
+            signature = sign.sign({ key: options.privateKey, passphrase: options.passphrase }, 'base64');
+        }
+        else {
+            signature = sign.sign(options.privateKey, 'base64');
+        }
+        const authHeader = `Signature version="1",keyId="${keyId}",algorithm="rsa-sha256",headers="${headersToSign.join(' ')}",signature="${signature}"`;
+        let newReq = req
+            .withHeader('Authorization', authHeader)
+            .withHeader('Date', dateStr)
+            .withHeader('Host', url.host);
+        if (methodsWithBody.includes(req.method.toUpperCase())) {
+            newReq = newReq
+                .withHeader('x-content-sha256', bodyHash)
+                .withHeader('Content-Type', 'application/json');
+        }
+        return next(newReq);
+    };
+}
+export function oracle(options) {
+    const baseUrl = getOCIServiceUrl(options.service, options.region);
+    return {
+        baseUrl,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        timeout: 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504]
+        },
+        middlewares: [createOCISigningMiddleware(options)]
+    };
+}
+export function ociCompute(options) {
+    return oracle({ ...options, service: 'core' });
+}
+export function ociObjectStorage(options) {
+    return oracle({ ...options, service: 'objectstorage' });
+}
+export function ociDatabase(options) {
+    return oracle({ ...options, service: 'database' });
+}
+export function ociKubernetes(options) {
+    return oracle({ ...options, service: 'containerengine' });
+}
+export function ociGenerativeAI(options) {
+    return oracle({ ...options, service: 'generativeai' });
+}
+export function ociVault(options) {
+    return oracle({ ...options, service: 'vault' });
+}

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

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

package/dist/browser/presets/perplexity.js

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

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

@@ -0,0 +1,8 @@
+import { ClientOptions } from '../types/index.js';
+export interface PineconePresetOptions {
+    apiKey: string;
+    environment?: string;
+    host?: string;
+}
+export declare function pinecone(options: PineconePresetOptions): ClientOptions;
+export declare function pineconeControl(options: Omit<PineconePresetOptions, 'host' | 'environment'>): ClientOptions;

package/dist/browser/presets/pinecone.js

@@ -0,0 +1,42 @@
+export function pinecone(options) {
+    let baseUrl;
+    if (options.host) {
+        baseUrl = `https://${options.host}`;
+    }
+    else if (options.environment) {
+        baseUrl = `https://controller.${options.environment}.pinecone.io`;
+    }
+    else {
+        baseUrl = 'https://api.pinecone.io';
+    }
+    return {
+        baseUrl,
+        headers: {
+            'Api-Key': options.apiKey,
+            'Content-Type': 'application/json',
+        },
+        timeout: 5 * 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504],
+        }
+    };
+}
+export function pineconeControl(options) {
+    return {
+        baseUrl: 'https://api.pinecone.io',
+        headers: {
+            'Api-Key': options.apiKey,
+            'Content-Type': 'application/json',
+        },
+        timeout: 60 * 1000,
+        retry: {
+            maxAttempts: 3,
+            backoff: 'exponential',
+            delay: 1000,
+            statusCodes: [408, 429, 500, 502, 503, 504],
+        }
+    };
+}

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

@@ -0,0 +1,23 @@
+import { ClientOptions } from '../types/index.js';
+import type { AIProvider } from '../types/ai.js';
+export type PresetFactory = (options: any) => ClientOptions;
+export interface PresetInfo {
+    name: string;
+    displayName: string;
+    patterns: RegExp[];
+    factory: PresetFactory;
+    category: 'ai' | 'cloud' | 'saas' | 'devtools';
+    requiredAuth: string[];
+    docsUrl?: string;
+    aiProvider?: AIProvider;
+    defaultModel?: string;
+    chatEndpoint?: string;
+}
+export declare const presetRegistry: PresetInfo[];
+export declare function detectPreset(url: string): PresetInfo | undefined;
+export declare function getPreset(name: string): PresetInfo | undefined;
+export declare function listPresets(category?: 'ai' | 'cloud' | 'saas' | 'devtools'): PresetInfo[];
+export declare function listAIPresets(): PresetInfo[];
+export declare function listCloudPresets(): PresetInfo[];
+export declare function listSaaSPresets(): PresetInfo[];
+export declare function listDevToolsPresets(): PresetInfo[];