recker 1.0.20-next.b961eae → 1.0.20-next.e194d90

package/README.md

@@ -131,14 +131,45 @@ const client = createClient({
 });
 ```
 
+## CLI (`rek`)
+
+A powerful terminal client that replaces curl:
+
+```bash
+# Install globally
+npm install -g recker
+
+# Simple requests
+rek httpbin.org/json
+rek POST api.com/users name="John" age:=30
+
+# Pipe to bash (like curl)
+rek -q https://get.docker.com | bash
+
+# Save to file
+rek -o data.json api.com/export
+
+# Interactive shell
+rek shell
+
+# Mock servers for testing
+rek serve http    # HTTP on :3000
+rek serve ws      # WebSocket on :8080
+rek serve hls     # HLS streaming on :8082
+```
+
+See [CLI Documentation](./docs/cli/01-overview.md) for more.
+
 ## Documentation
 
 - **[Quick Start](./docs/http/01-quickstart.md)** - Get running in 2 minutes
+- **[CLI Guide](./docs/cli/01-overview.md)** - Terminal client documentation
 - **[API Reference](./docs/reference/01-api.md)** - Complete API documentation
 - **[Configuration](./docs/http/05-configuration.md)** - Client options
 - **[Plugins](./docs/http/10-plugins.md)** - Extend functionality
 - **[AI Integration](./docs/ai/01-overview.md)** - OpenAI, Anthropic, and more
 - **[Protocols](./docs/protocols/01-websocket.md)** - WebSocket, DNS, WHOIS
+- **[Mock Servers](./docs/cli/08-mock-servers.md)** - Built-in test servers
 
 ## License
 

package/dist/ai/adaptive-timeout.d.ts

@@ -48,4 +48,3 @@ export declare class StreamTimeoutController {
 }
 export declare const adaptiveTimeouts: AdaptiveTimeoutManager;
 export {};
-//# sourceMappingURL=adaptive-timeout.d.ts.map

package/dist/ai/client.d.ts

@@ -20,4 +20,3 @@ export declare class UnifiedAIClient implements AIClient {
     private sleep;
 }
 export declare function createAI(config?: AIClientConfig): AIClient;
-//# sourceMappingURL=client.d.ts.map

package/dist/ai/client.js

@@ -1,6 +1,8 @@
 import { AIError, RateLimitError, ContextLengthError, OverloadedError } from './providers/base.js';
 import { OpenAIProvider } from './providers/openai.js';
 import { AnthropicProvider } from './providers/anthropic.js';
+import { GoogleProvider } from './providers/google.js';
+import { OllamaProvider } from './providers/ollama.js';
 class AIMetricsTracker {
     data = {
         totalRequests: 0,
@@ -155,6 +157,10 @@ export class UnifiedAIClient {
         this.providers.set('openai', new OpenAIProvider(openaiConfig));
         const anthropicConfig = this.config.providers?.anthropic || {};
         this.providers.set('anthropic', new AnthropicProvider(anthropicConfig));
+        const googleConfig = this.config.providers?.google || {};
+        this.providers.set('google', new GoogleProvider(googleConfig));
+        const ollamaConfig = this.config.providers?.ollama || {};
+        this.providers.set('ollama', new OllamaProvider(ollamaConfig));
     }
     getProvider(name) {
         const providerName = name || this.config.defaultProvider || 'openai';

package/dist/ai/index.d.ts

@@ -2,9 +2,11 @@ export { UnifiedAIClient, createAI } from './client.js';
 export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './providers/base.js';
 export { OpenAIProvider } from './providers/openai.js';
 export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export * from './vector/index.js';
 export { AdaptiveTimeoutManager, StreamTimeoutController, adaptiveTimeouts } from './adaptive-timeout.js';
 export { TokenRateLimiter, RateLimitExceededError, createRateLimiter, tokenEstimators, PROVIDER_RATE_LIMITS, } from './rate-limiter.js';
 export type { AIProvider, MessageRole, ChatMessage, ContentPart, ToolDefinition, ToolCall, TokenUsage, CostInfo, AILatency, AITimeoutOptions, AIRetryOptions, ResponseFormat, ChatOptions, EmbedOptions, AIResponse, EmbedResponse, StreamEventType, StreamEvent, TextStreamEvent, ToolCallStreamEvent, ToolCallDeltaStreamEvent, UsageStreamEvent, DoneStreamEvent, ErrorStreamEvent, AIStream, ProviderConfig, AIClientConfig, TokenRateLimitConfig, SemanticCacheConfig, CacheStorage, AIClient, AIMetrics, AIMetricsSummary, AgentTool, AgentConfig, AgentEventType, AgentStreamEvent, Agent, } from '../types/ai.js';
 export type { OpenAIConfig } from './providers/openai.js';
 export type { AnthropicConfig } from './providers/anthropic.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/ai/index.js

@@ -2,5 +2,8 @@ export { UnifiedAIClient, createAI } from './client.js';
 export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './providers/base.js';
 export { OpenAIProvider } from './providers/openai.js';
 export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export * from './vector/index.js';
 export { AdaptiveTimeoutManager, StreamTimeoutController, adaptiveTimeouts } from './adaptive-timeout.js';
 export { TokenRateLimiter, RateLimitExceededError, createRateLimiter, tokenEstimators, PROVIDER_RATE_LIMITS, } from './rate-limiter.js';

package/dist/ai/providers/anthropic.d.ts

@@ -61,4 +61,3 @@ export declare class AnthropicProvider extends BaseAIProvider {
     private parseAnthropicStream;
 }
 export {};
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/ai/providers/base.d.ts

@@ -46,4 +46,3 @@ export declare class OverloadedError extends AIError {
 export declare class AuthenticationError extends AIError {
     constructor(provider: AIProvider);
 }
-//# sourceMappingURL=base.d.ts.map

package/dist/ai/providers/google.d.ts

@@ -0,0 +1,59 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface GoogleConfig extends ProviderConfig {
+    apiVersion?: string;
+}
+interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    functionResponse?: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+}
+interface GeminiResponse {
+    candidates?: Array<{
+        content: GeminiContent;
+        finishReason?: string;
+        citationMetadata?: unknown;
+        tokenCount?: number;
+    }>;
+    promptFeedback?: {
+        blockReason?: string;
+    };
+    usageMetadata?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+}
+export declare class GoogleProvider extends BaseAIProvider {
+    private googleConfig;
+    constructor(config?: GoogleConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): GeminiContent[];
+    private transformContent;
+    private transformTools;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    private buildChatBody;
+    private makeRequest;
+    private handleError;
+    protected parseResponse(data: GeminiResponse, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(chunk: string, context: ProviderRequestContext): StreamEvent | null;
+}
+export {};

package/dist/ai/providers/google.js

@@ -0,0 +1,305 @@
+import { BaseAIProvider, AIError, RateLimitError, OverloadedError, AuthenticationError, } from './base.js';
+export class GoogleProvider extends BaseAIProvider {
+    googleConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'google' });
+        this.googleConfig = config;
+    }
+    getEnvApiKey() {
+        return process.env.GOOGLE_API_KEY;
+    }
+    getBaseUrl() {
+        const version = this.googleConfig.apiVersion || 'v1beta';
+        return this.config.baseUrl || `https://generativelanguage.googleapis.com/${version}`;
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+    }
+    transformMessages(messages) {
+        return messages
+            .filter((m) => m.role !== 'system')
+            .map((msg) => {
+            return {
+                role: msg.role === 'user' ? 'user' : 'model',
+                parts: this.transformContent(msg),
+            };
+        });
+    }
+    transformContent(msg) {
+        if (msg.role === 'tool') {
+            return [{
+                    functionResponse: {
+                        name: msg.name || 'unknown_tool',
+                        response: typeof msg.content === 'string' ? { content: msg.content } : { content: msg.content },
+                    },
+                }];
+        }
+        if (msg.tool_calls && msg.tool_calls.length > 0) {
+            const parts = [];
+            if (msg.content && typeof msg.content === 'string') {
+                parts.push({ text: msg.content });
+            }
+            msg.tool_calls.forEach((tc) => {
+                parts.push({
+                    functionCall: {
+                        name: tc.function.name,
+                        args: JSON.parse(tc.function.arguments || '{}'),
+                    },
+                });
+            });
+            return parts;
+        }
+        const content = msg.content;
+        if (typeof content === 'string') {
+            return [{ text: content }];
+        }
+        if (!content)
+            return [{ text: '' }];
+        return content.map((part) => {
+            if (part.type === 'text') {
+                return { text: part.text };
+            }
+            if (part.type === 'image_url') {
+                return { text: '[Image URL not supported directly in Gemini provider yet without base64]' };
+            }
+            if (part.type === 'image') {
+                const base64 = Buffer.from(part.data).toString('base64');
+                return {
+                    inlineData: {
+                        mimeType: part.mediaType,
+                        data: base64,
+                    },
+                };
+            }
+            return { text: '' };
+        });
+    }
+    transformTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return [{
+                functionDeclarations: tools.map((t) => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                })),
+            }];
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const model = options.model || this.config.defaultModel || 'gemini-2.5-flash';
+        const body = this.buildChatBody(options);
+        const response = await this.makeRequest(`/models/${model}:generateContent`, body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const model = options.model || this.config.defaultModel || 'gemini-2.5-flash';
+        const body = this.buildChatBody(options);
+        const response = await this.makeRequest(`/models/${model}:streamGenerateContent?alt=sse`, body, options.signal);
+        return this.parseSSEStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const model = options.model || 'text-embedding-004';
+        const isBatch = Array.isArray(options.input);
+        const method = isBatch ? 'batchEmbedContents' : 'embedContent';
+        const inputs = isBatch ? options.input : [options.input];
+        const requests = inputs.map(text => ({
+            model: `models/${model}`,
+            content: { parts: [{ text }] }
+        }));
+        const body = isBatch ? { requests } : { ...requests[0] };
+        const response = await this.makeRequest(`/models/${model}:${method}`, body, options.signal);
+        const data = await response.json();
+        let embeddings = [];
+        if (isBatch) {
+            embeddings = data.embeddings.map((e) => e.values);
+        }
+        else {
+            embeddings = [data.embedding.values];
+        }
+        const totalTokens = 0;
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        return {
+            embeddings,
+            usage: {
+                inputTokens: totalTokens,
+                outputTokens: 0,
+                totalTokens,
+            },
+            model,
+            provider: 'google',
+            latency,
+        };
+    }
+    buildChatBody(options) {
+        const messages = this.transformMessages(options.messages);
+        const systemMessage = options.messages.find(m => m.role === 'system');
+        let systemInstruction;
+        if (systemMessage) {
+            systemInstruction = {
+                parts: [{ text: typeof systemMessage.content === 'string' ? systemMessage.content : '' }]
+            };
+        }
+        else if (options.systemPrompt) {
+            systemInstruction = {
+                parts: [{ text: options.systemPrompt }]
+            };
+        }
+        const generationConfig = {};
+        if (options.temperature !== undefined)
+            generationConfig.temperature = options.temperature;
+        if (options.topP !== undefined)
+            generationConfig.topP = options.topP;
+        if (options.maxTokens !== undefined)
+            generationConfig.maxOutputTokens = options.maxTokens;
+        if (options.stop)
+            generationConfig.stopSequences = options.stop;
+        if (options.responseFormat?.type === 'json_object') {
+            generationConfig.responseMimeType = 'application/json';
+        }
+        const body = {
+            contents: messages,
+            generationConfig,
+            tools: this.transformTools(options.tools),
+        };
+        if (systemInstruction) {
+            body.systemInstruction = systemInstruction;
+        }
+        return body;
+    }
+    async makeRequest(endpoint, body, signal) {
+        const key = this.getApiKey();
+        const separator = endpoint.includes('?') ? '&' : '?';
+        const url = `${this.getBaseUrl()}${endpoint}${separator}key=${key}`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            await this.handleError(response);
+        }
+        return response;
+    }
+    async handleError(response) {
+        let errorData = {};
+        try {
+            errorData = await response.json();
+        }
+        catch {
+        }
+        const message = errorData.error?.message || response.statusText;
+        const status = errorData.error?.code || response.status;
+        switch (response.status) {
+            case 400:
+            case 401:
+                throw new AuthenticationError('google');
+            case 429:
+                throw new RateLimitError('google');
+            case 503:
+                throw new OverloadedError('google');
+        }
+        throw new AIError(message, 'google', String(status), response.status, response.status >= 500);
+    }
+    parseResponse(data, context) {
+        const candidate = data.candidates?.[0];
+        const parts = candidate?.content?.parts || [];
+        const content = parts
+            .filter(p => p.text)
+            .map(p => p.text)
+            .join('');
+        const toolCalls = parts
+            .filter(p => p.functionCall)
+            .map(p => ({
+            id: 'call_' + Math.random().toString(36).slice(2),
+            type: 'function',
+            function: {
+                name: p.functionCall.name,
+                arguments: JSON.stringify(p.functionCall.args),
+            }
+        }));
+        const usage = data.usageMetadata
+            ? {
+                inputTokens: data.usageMetadata.promptTokenCount,
+                outputTokens: data.usageMetadata.candidatesTokenCount,
+                totalTokens: data.usageMetadata.totalTokenCount,
+            }
+            : this.emptyUsage();
+        context.tokenCount = usage.outputTokens;
+        return {
+            content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: 'gemini',
+            provider: 'google',
+            cached: false,
+            finishReason: candidate?.finishReason === 'STOP' ? 'stop' : 'length',
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            raw: data,
+        };
+    }
+    parseStreamEvent(chunk, context) {
+        const data = JSON.parse(chunk);
+        const candidate = data.candidates?.[0];
+        if (!candidate)
+            return null;
+        if (data.usageMetadata) {
+            return {
+                type: 'usage',
+                usage: {
+                    inputTokens: data.usageMetadata.promptTokenCount,
+                    outputTokens: data.usageMetadata.candidatesTokenCount,
+                    totalTokens: data.usageMetadata.totalTokenCount,
+                }
+            };
+        }
+        const parts = candidate.content?.parts || [];
+        const textPart = parts.find(p => p.text);
+        if (textPart?.text) {
+            context.tokenCount++;
+            return {
+                type: 'text',
+                content: textPart.text,
+            };
+        }
+        const toolPart = parts.find(p => p.functionCall);
+        if (toolPart?.functionCall) {
+            return {
+                type: 'tool_call',
+                toolCall: {
+                    id: 'call_' + Math.random().toString(36).slice(2),
+                    type: 'function',
+                    function: {
+                        name: toolPart.functionCall.name,
+                        arguments: JSON.stringify(toolPart.functionCall.args),
+                    }
+                }
+            };
+        }
+        if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+            return {
+                type: 'done',
+                finishReason: 'stop',
+            };
+        }
+        return null;
+    }
+}

package/dist/ai/providers/index.d.ts

@@ -4,4 +4,7 @@ export { OpenAIProvider } from './openai.js';
 export type { OpenAIConfig } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
 export type { AnthropicConfig } from './anthropic.js';
-//# sourceMappingURL=index.d.ts.map
+export { GoogleProvider } from './google.js';
+export type { GoogleConfig } from './google.js';
+export { OllamaProvider } from './ollama.js';
+export type { OllamaConfig } from './ollama.js';

package/dist/ai/providers/index.js

@@ -1,3 +1,5 @@
 export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './base.js';
 export { OpenAIProvider } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
+export { GoogleProvider } from './google.js';
+export { OllamaProvider } from './ollama.js';

package/dist/ai/providers/ollama.d.ts

@@ -0,0 +1,44 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface OllamaConfig extends ProviderConfig {
+    keepAlive?: string;
+}
+interface OllamaMessage {
+    role: string;
+    content: string;
+    images?: string[];
+}
+interface OllamaResponse {
+    model: string;
+    created_at: string;
+    message: {
+        role: string;
+        content: string;
+        images?: string[] | null;
+    };
+    done: boolean;
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    prompt_eval_duration?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export declare class OllamaProvider extends BaseAIProvider {
+    private ollamaConfig;
+    constructor(config?: OllamaConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): OllamaMessage[];
+    private extractContentAndImages;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    private buildChatBody;
+    private makeRequest;
+    protected parseResponse(data: OllamaResponse, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(_chunk: string, _context: ProviderRequestContext): StreamEvent | null;
+    protected parseNDJSONStream(response: Response, context: ProviderRequestContext): AIStream;
+}
+export {};