recker 1.0.26 → 1.0.27

package/dist/browser/types/ai.d.ts

@@ -0,0 +1,267 @@
+export type AIProvider = 'openai' | 'anthropic' | 'google' | 'replicate' | 'huggingface' | 'ollama' | 'custom';
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export interface ChatMessage {
+    role: MessageRole;
+    content: string | ContentPart[];
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+export type ContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high';
+    };
+} | {
+    type: 'image';
+    data: Buffer | Uint8Array;
+    mediaType: string;
+};
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedTokens?: number;
+}
+export interface CostInfo {
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    currency: string;
+}
+export interface AILatency {
+    ttft: number;
+    tps: number;
+    total: number;
+    queued?: number;
+}
+export interface AITimeoutOptions {
+    firstToken?: number;
+    betweenTokens?: number;
+    total?: number;
+    adaptive?: boolean;
+}
+export interface AIRetryOptions {
+    on?: Array<'rate_limit' | 'overloaded' | 'timeout' | 'context_length_exceeded' | 'server_error'>;
+    backoff?: 'linear' | 'exponential' | 'decorrelated';
+    maxAttempts?: number;
+    fallback?: Record<string, string>;
+    reduceContext?: boolean;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+export type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    schema: Record<string, unknown>;
+};
+export interface ChatOptions {
+    provider?: AIProvider;
+    model?: string;
+    messages: ChatMessage[];
+    systemPrompt?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    stop?: string[];
+    tools?: ToolDefinition[];
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    responseFormat?: ResponseFormat;
+    timeout?: AITimeoutOptions;
+    retry?: AIRetryOptions;
+    metadata?: Record<string, unknown>;
+    signal?: AbortSignal;
+    stream?: boolean;
+}
+export interface EmbedOptions {
+    provider?: AIProvider;
+    model?: string;
+    input: string | string[];
+    dimensions?: number;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export interface AIResponse<T = string> {
+    content: T;
+    usage: TokenUsage;
+    latency: AILatency;
+    model: string;
+    provider: AIProvider;
+    cached: boolean;
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    toolCalls?: ToolCall[];
+    cost?: CostInfo;
+    raw?: unknown;
+}
+export interface EmbedResponse {
+    embeddings: number[][];
+    usage: TokenUsage;
+    model: string;
+    provider: AIProvider;
+    latency: AILatency;
+}
+export type StreamEventType = 'text' | 'tool_call' | 'tool_call_delta' | 'usage' | 'done' | 'error';
+export interface BaseStreamEvent {
+    type: StreamEventType;
+}
+export interface TextStreamEvent extends BaseStreamEvent {
+    type: 'text';
+    content: string;
+}
+export interface ToolCallStreamEvent extends BaseStreamEvent {
+    type: 'tool_call';
+    toolCall: ToolCall;
+}
+export interface ToolCallDeltaStreamEvent extends BaseStreamEvent {
+    type: 'tool_call_delta';
+    index: number;
+    delta: {
+        arguments?: string;
+    };
+}
+export interface UsageStreamEvent extends BaseStreamEvent {
+    type: 'usage';
+    usage: TokenUsage;
+}
+export interface DoneStreamEvent extends BaseStreamEvent {
+    type: 'done';
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    usage?: TokenUsage;
+}
+export interface ErrorStreamEvent extends BaseStreamEvent {
+    type: 'error';
+    error: Error;
+}
+export type StreamEvent = TextStreamEvent | ToolCallStreamEvent | ToolCallDeltaStreamEvent | UsageStreamEvent | DoneStreamEvent | ErrorStreamEvent;
+export type AIStream = AsyncIterable<StreamEvent>;
+export interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+    organization?: string;
+    projectId?: string;
+    headers?: Record<string, string>;
+}
+export interface AIClientConfig {
+    defaultProvider?: AIProvider;
+    defaultModel?: string;
+    providers?: Partial<Record<AIProvider, ProviderConfig>>;
+    timeout?: AITimeoutOptions;
+    retry?: AIRetryOptions;
+    observability?: boolean;
+    debug?: boolean;
+}
+export interface TokenRateLimitConfig {
+    tokensPerMinute?: number;
+    requestsPerMinute?: number;
+    strategy?: 'queue' | 'throw' | 'retry-after';
+    priority?: (req: ChatOptions) => 'high' | 'normal' | 'low';
+}
+export interface SemanticCacheConfig {
+    enabled?: boolean;
+    embedder?: string;
+    similarity?: number;
+    ttl?: number | string;
+    storage?: CacheStorage;
+}
+export interface CacheStorage {
+    get(key: string): Promise<unknown | undefined>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export interface AIClient {
+    chat(options: ChatOptions): Promise<AIResponse>;
+    chat(prompt: string): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    extend(defaults: Partial<ChatOptions>): AIClient;
+    readonly metrics: AIMetrics;
+}
+export interface AIMetrics {
+    totalRequests: number;
+    totalTokens: number;
+    totalCost: number;
+    avgLatency: {
+        ttft: number;
+        total: number;
+    };
+    errorRate: number;
+    cacheHitRate: number;
+    summary(): AIMetricsSummary;
+    reset(): void;
+}
+export interface AIMetricsSummary {
+    totalRequests: number;
+    totalTokens: number;
+    totalCost: number;
+    avgLatency: {
+        ttft: number;
+        total: number;
+    };
+    errorRate: number;
+    cacheHitRate: number;
+    byModel: Record<string, {
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+    byProvider: Record<string, {
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+}
+export interface AgentTool {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export interface AgentConfig {
+    provider?: AIProvider;
+    model?: string;
+    systemPrompt?: string;
+    tools?: AgentTool[];
+    maxIterations?: number;
+    iterationTimeout?: number;
+}
+export type AgentEventType = 'thinking' | 'tool_call' | 'tool_result' | 'text' | 'done' | 'error';
+export interface AgentStreamEvent {
+    type: AgentEventType;
+    content?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    result?: unknown;
+    error?: Error;
+}
+export interface Agent {
+    run(prompt: string): Promise<AIResponse>;
+    stream(prompt: string): AsyncIterable<AgentStreamEvent>;
+}

package/dist/browser/types/ai.js

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

package/dist/browser/types/index.d.ts

@@ -0,0 +1,351 @@
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'PROPFIND' | 'PROPPATCH' | 'MKCOL' | 'COPY' | 'MOVE' | 'LOCK' | 'UNLOCK' | 'LINK' | 'UNLINK';
+export interface ProgressEvent {
+    loaded: number;
+    transferred: number;
+    total?: number;
+    percent?: number;
+    rate?: number;
+    estimated?: number;
+    direction?: 'upload' | 'download';
+}
+export type ProgressCallback = (progress: ProgressEvent) => void;
+export interface TimeoutOptions {
+    lookup?: number;
+    connect?: number;
+    secureConnect?: number;
+    socket?: number;
+    send?: number;
+    response?: number;
+    request?: number;
+}
+export interface RedirectInfo {
+    from: string;
+    to: string;
+    status: number;
+    headers: Headers;
+}
+export interface RequestOptions {
+    method?: Method;
+    headers?: HeadersInit;
+    body?: BodyInit | null;
+    json?: any;
+    form?: Record<string, any>;
+    xml?: any;
+    params?: Record<string, string | number>;
+    signal?: AbortSignal;
+    throwHttpErrors?: boolean;
+    timeout?: number | TimeoutOptions;
+    onUploadProgress?: ProgressCallback;
+    onDownloadProgress?: ProgressCallback;
+    maxResponseSize?: number;
+    beforeRedirect?: (info: RedirectInfo) => void | false | string | Promise<void | false | string>;
+    maxRedirects?: number;
+    followRedirects?: boolean;
+    http2?: boolean;
+}
+export interface ReckerRequest {
+    url: string;
+    method: Method;
+    headers: Headers;
+    body: BodyInit | null;
+    signal?: AbortSignal;
+    throwHttpErrors?: boolean;
+    timeout?: TimeoutOptions;
+    onUploadProgress?: ProgressCallback;
+    onDownloadProgress?: ProgressCallback;
+    maxResponseSize?: number;
+    beforeRedirect?: (info: RedirectInfo) => void | false | string | Promise<void | false | string>;
+    maxRedirects?: number;
+    followRedirects?: boolean;
+    http2?: boolean;
+    withHeader(name: string, value: string): ReckerRequest;
+    withBody(body: BodyInit): ReckerRequest;
+    _hooks?: {
+        onDnsLookup?: (info: any) => void;
+        onTcpConnect?: (info: any) => void;
+        onTlsHandshake?: (info: any) => void;
+        onRequestSent?: () => void;
+        onResponseStart?: (info: any) => void;
+    };
+}
+export interface Timings {
+    queuing?: number;
+    dns?: number;
+    tls?: number;
+    tcp?: number;
+    firstByte?: number;
+    content?: number;
+    total?: number;
+}
+export interface ConcurrencyConfig {
+    max?: number;
+    requestsPerInterval?: number;
+    interval?: number;
+    runner?: {
+        concurrency?: number;
+        retries?: number;
+        retryDelay?: number;
+    };
+    agent?: AgentOptions & {
+        connections?: number | 'auto';
+    };
+    http2?: {
+        maxConcurrentStreams?: number | 'auto';
+    };
+}
+export interface HTTP2Settings {
+    headerTableSize?: number;
+    enablePush?: number;
+    initialWindowSize?: number;
+    maxFrameSize?: number;
+    maxConcurrentStreams?: number;
+    maxHeaderListSize?: number;
+    enableConnectProtocol?: number;
+}
+export interface ConnectionInfo {
+    protocol?: string;
+    cipher?: string;
+    remoteAddress?: string;
+    remotePort?: number;
+    localAddress?: string;
+    localPort?: number;
+    http2?: {
+        streamId?: number;
+        streamWeight?: number;
+        streamDependency?: number;
+        serverPush?: boolean;
+        settingsReceived?: boolean;
+        maxConcurrentStreams?: number;
+        currentStreams?: number;
+        pendingStreams?: number;
+        localWindowSize?: number;
+        remoteWindowSize?: number;
+        localSettings?: HTTP2Settings;
+        remoteSettings?: HTTP2Settings;
+    };
+    http3?: {
+        quicVersion?: string;
+        zeroRTT?: boolean;
+        maxStreams?: number;
+        handshakeConfirmed?: boolean;
+    };
+    reused?: boolean;
+    rtt?: number;
+}
+export type { Logger, MinimalLogger } from './logger.js';
+export { consoleLogger, silentLogger, createLevelLogger } from './logger.js';
+export interface SSEEvent {
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}
+export interface PaginationConfig {
+    pageParam?: string;
+    limitParam?: string;
+    offsetParam?: string;
+    resultsPath?: string;
+    nextCursorPath?: string;
+}
+export interface PageResult<T = any> {
+    data: T;
+    response: ReckerResponse;
+    pageNumber: number;
+}
+export type NextFunction = (req: ReckerRequest) => Promise<ReckerResponse>;
+export type Middleware = (req: ReckerRequest, next: NextFunction) => Promise<ReckerResponse>;
+export interface Transport {
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+}
+export interface CacheEntry {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    timestamp: number;
+    etag?: string;
+    lastModified?: string;
+    vary?: string;
+    expires?: number;
+    maxAge?: number;
+    sMaxAge?: number;
+    mustRevalidate?: boolean;
+    noCache?: boolean;
+    noStore?: boolean;
+    isPrivate?: boolean;
+    isPublic?: boolean;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+}
+export interface CacheStorage {
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export type CacheStrategy = 'cache-first' | 'network-only' | 'network-first' | 'stale-while-revalidate' | 'revalidate' | 'rfc-compliant';
+export type Plugin = (client: any) => void;
+export type HookFunction<T = void> = (req: ReckerRequest, extra?: any) => T | Promise<T>;
+export interface Hooks {
+    beforeRequest?: Array<(req: ReckerRequest) => ReckerRequest | void | Promise<ReckerRequest | void>>;
+    afterResponse?: Array<(req: ReckerRequest, res: ReckerResponse) => ReckerResponse | void | Promise<ReckerResponse | void>>;
+    onError?: Array<(error: Error, req: ReckerRequest) => ReckerResponse | void | Promise<ReckerResponse | void>>;
+    onRetry?: Array<(error: Error, attempt: number, delay: number, req: ReckerRequest) => void | Promise<void>>;
+    onUrlResolved?: Array<(template: string, url: string, params: Record<string, string | number>, req: ReckerRequest) => void | Promise<void>>;
+    onDnsLookup?: Array<(info: {
+        domain: string;
+        duration: number;
+        addresses?: string[];
+    }, req: ReckerRequest) => void>;
+    onTcpConnect?: Array<(info: {
+        remoteAddress: string;
+        remotePort?: number;
+        localAddress?: string;
+        localPort?: number;
+        duration: number;
+        reused?: boolean;
+    }, req: ReckerRequest) => void>;
+    onTlsHandshake?: Array<(info: {
+        protocol: string;
+        cipher: string;
+        duration: number;
+    }, req: ReckerRequest) => void>;
+    onSocketAssigned?: Array<(info: {
+        protocol: string;
+        reused: boolean;
+        remoteAddress: string;
+    }, req: ReckerRequest) => void>;
+    onRequestSent?: Array<(req: ReckerRequest) => void>;
+    onResponseStart?: Array<(info: {
+        status: number;
+        headers: Headers;
+    }, req: ReckerRequest) => void>;
+}
+export interface ProxyOptions {
+    url: string;
+    type?: 'http' | 'https' | 'socks4' | 'socks4a' | 'socks5';
+    auth?: {
+        username: string;
+        password: string;
+    };
+    headers?: Record<string, string>;
+    token?: string;
+    tunnel?: boolean;
+    bypass?: string[];
+    requestTls?: TLSOptions;
+    proxyTls?: TLSOptions;
+    http2?: boolean;
+    keepAliveTimeout?: number;
+    connectTimeout?: number;
+}
+export interface TLSOptions {
+    minVersion?: 'TLSv1' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+    maxVersion?: 'TLSv1' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+    ciphers?: string;
+    honorCipherOrder?: boolean;
+    ca?: string | Buffer | Array<string | Buffer>;
+    cert?: string | Buffer;
+    key?: string | Buffer;
+    passphrase?: string;
+    rejectUnauthorized?: boolean;
+    alpnProtocols?: string[];
+    servername?: string | false;
+    sessionTimeout?: number;
+    sessionIdContext?: string;
+}
+export interface DNSOptions {
+    override?: Record<string, string>;
+    servers?: string[];
+    timeout?: number;
+    preferIPv4?: boolean;
+}
+export interface XSRFOptions {
+    cookieName?: string;
+    headerName?: string;
+}
+export interface CookieJar {
+    getCookieString(url: string): Promise<string> | string;
+    setCookie(rawCookie: string, url: string): Promise<unknown> | unknown;
+}
+export interface CookieOptions {
+    jar?: CookieJar | boolean;
+    ignoreInvalid?: boolean;
+}
+export interface CompressionOptions {
+    algorithm?: 'gzip' | 'deflate' | 'br';
+    threshold?: number;
+    force?: boolean;
+    methods?: string[];
+}
+export interface HTTP2Options {
+    enabled?: boolean;
+    maxConcurrentStreams?: number;
+    pipelining?: number;
+}
+export interface AgentOptions {
+    connections?: number;
+    pipelining?: number;
+    keepAlive?: boolean;
+    keepAliveTimeout?: number;
+    keepAliveMaxTimeout?: number;
+    keepAliveTimeoutThreshold?: number;
+    connectTimeout?: number;
+    maxRequestsPerClient?: number;
+    maxCachedSessions?: number;
+    clientTtl?: number | null;
+    maxHeaderSize?: number;
+    perDomainPooling?: boolean;
+    localAddress?: string;
+}
+export interface ClientOptions {
+    baseUrl?: string;
+    headers?: HeadersInit;
+    middlewares?: Middleware[];
+    hooks?: Hooks;
+    plugins?: Plugin[];
+    transport?: Transport;
+    defaults?: {
+        params?: Record<string, string | number>;
+    };
+    pagination?: PaginationConfig;
+    debug?: boolean;
+    logger?: import('./logger.js').Logger;
+    proxy?: ProxyOptions | string;
+    tls?: TLSOptions;
+    dns?: DNSOptions;
+    xsrf?: boolean | XSRFOptions;
+    compression?: boolean | CompressionOptions;
+    http2?: boolean | HTTP2Options;
+    concurrency?: number | ConcurrencyConfig;
+    maxResponseSize?: number;
+    socketPath?: string;
+    cookies?: boolean | CookieOptions;
+    timeout?: number | TimeoutOptions;
+    observability?: boolean;
+    retry?: {
+        maxAttempts?: number;
+        delay?: number;
+        maxDelay?: number;
+        backoff?: 'linear' | 'exponential' | 'decorrelated';
+        jitter?: boolean;
+        statusCodes?: number[];
+    };
+}
+export interface ReckerResponse<T = unknown> {
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+    url: string;
+    timings?: Timings;
+    connection?: ConnectionInfo;
+    json<R = T>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): ReadableStream<Uint8Array> | null;
+    clone(): ReckerResponse<T>;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    raw: Response;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}

package/dist/browser/types/index.js

@@ -0,0 +1 @@
+export { consoleLogger, silentLogger, createLevelLogger } from './logger.js';

package/dist/browser/types/logger.d.ts

@@ -0,0 +1,16 @@
+export interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    debug(obj: object, message?: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    info(obj: object, message?: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    warn(obj: object, message?: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    error(obj: object, message?: string, ...args: unknown[]): void;
+}
+export type MinimalLogger = Partial<Logger> & {
+    info: Logger['info'];
+};
+export declare const consoleLogger: Logger;
+export declare const silentLogger: Logger;
+export declare function createLevelLogger(baseLogger: Logger, minLevel: 'debug' | 'info' | 'warn' | 'error'): Logger;

package/dist/browser/types/logger.js

@@ -0,0 +1,66 @@
+export const consoleLogger = {
+    debug: (msgOrObj, ...args) => {
+        if (typeof msgOrObj === 'object') {
+            console.debug(msgOrObj, ...args);
+        }
+        else {
+            console.debug(msgOrObj, ...args);
+        }
+    },
+    info: (msgOrObj, ...args) => {
+        if (typeof msgOrObj === 'object') {
+            console.info(msgOrObj, ...args);
+        }
+        else {
+            console.info(msgOrObj, ...args);
+        }
+    },
+    warn: (msgOrObj, ...args) => {
+        if (typeof msgOrObj === 'object') {
+            console.warn(msgOrObj, ...args);
+        }
+        else {
+            console.warn(msgOrObj, ...args);
+        }
+    },
+    error: (msgOrObj, ...args) => {
+        if (typeof msgOrObj === 'object') {
+            console.error(msgOrObj, ...args);
+        }
+        else {
+            console.error(msgOrObj, ...args);
+        }
+    },
+};
+export const silentLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export function createLevelLogger(baseLogger, minLevel) {
+    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    const minLevelNum = levels[minLevel];
+    return {
+        debug: (...args) => {
+            if (levels.debug >= minLevelNum) {
+                baseLogger.debug(...args);
+            }
+        },
+        info: (...args) => {
+            if (levels.info >= minLevelNum) {
+                baseLogger.info(...args);
+            }
+        },
+        warn: (...args) => {
+            if (levels.warn >= minLevelNum) {
+                baseLogger.warn(...args);
+            }
+        },
+        error: (...args) => {
+            if (levels.error >= minLevelNum) {
+                baseLogger.error(...args);
+            }
+        },
+    };
+}