hydra-aidirector 1.3.0

package/dist/index.d.mts

@@ -0,0 +1,1028 @@
+/**
+ * Hydra Client Types
+ * Type definitions for the SDK
+ */
+/**
+ * Configuration for Hydra client
+ */
+interface HydraConfig {
+    /**
+     * Your Hydra secret key
+     * Get this from your dashboard at https://hydrai.dev/dashboard/keys
+     * Format: hyd_sk_<random>
+     */
+    secretKey: string;
+    /**
+     * API base URL
+     * @default 'http://localhost:3000' in development
+     * @example 'https://api.hydrai.dev'
+     */
+    baseUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 600000 (10 minutes)
+     */
+    timeout?: number;
+    /**
+     * Maximum number of retries for failed requests
+     * Set to 0 to disable retries
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Enable debug logging to console
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Options for the generate method
+ */
+interface GenerateOptions {
+    /**
+     * ID of the fallback chain to use
+     * Get chain IDs from your dashboard
+     */
+    chainId: string;
+    /**
+     * The prompt to send to the AI
+     */
+    prompt: string;
+    /**
+     * Optional JSON schema for response validation
+     * The AI will be instructed to return data matching this schema
+     * @example { name: 'string', age: 'number', tags: 'string[]' }
+     */
+    schema?: Record<string, unknown>;
+    /**
+     * Override the client timeout for this request
+     */
+    timeout?: number;
+    /**
+     * Skip the cache for this request.
+     * Useful for prompts that should always generate fresh responses.
+     * @default false
+     */
+    noCache?: boolean;
+    /**
+     * File attachments to include with the request.
+     * The server automatically handles:
+     * - File type detection (magic bytes)
+     * - Model compatibility checking
+     * - Automatic conversion (e.g., DOCX → PDF)
+     *
+     * @example
+     * ```typescript
+     * await client.generate({
+     *   chainId: 'my-chain',
+     *   prompt: 'Summarize this document',
+     *   files: [{
+     *     data: documentBuffer.toString('base64'),
+     *     filename: 'report.pdf',
+     *     mimeType: 'application/pdf',
+     *   }],
+     * });
+     * ```
+     */
+    files?: FileAttachment[];
+    /**
+     * Use the optimized 3-step generation flow.
+     * This minimizes Vercel compute costs by calling the Cloudflare Worker directly.
+     * Set to false to force legacy single-call mode.
+     * @default true
+     */
+    useOptimized?: boolean;
+    /**
+     * Cache scope for this request.
+     * - 'global': Cache is shared across all users (default)
+     * - 'user': Cache is scoped to the authenticated user
+     * - 'skip': Do not cache this response
+     * @default 'global'
+     */
+    cacheScope?: 'global' | 'user' | 'skip';
+    /**
+     * AbortSignal for request cancellation.
+     * Pass a signal from an AbortController to cancel the request.
+     * @example
+     * ```typescript
+     * const controller = new AbortController();
+     * setTimeout(() => controller.abort(), 5000);
+     * await client.generate({ chainId: 'x', prompt: 'y', signal: controller.signal });
+     * ```
+     */
+    signal?: AbortSignal;
+    /**
+     * Override max retries for this specific request.
+     * Set to 0 to disable retries for idempotent-sensitive operations.
+     */
+    maxRetries?: number;
+    /**
+     * Client-generated request ID for tracing and debugging.
+     * If not provided, one will be generated automatically.
+     */
+    requestId?: string;
+    /**
+     * Generation parameters
+     */
+    options?: GenerationParameters;
+}
+/**
+ * File attachment for generate requests.
+ * Pass files and the server handles detection/conversion automatically.
+ */
+interface FileAttachment {
+    /**
+     * File content as base64-encoded string
+     */
+    data: string;
+    /**
+     * Original filename (optional, helps with type detection)
+     */
+    filename?: string;
+    /**
+     * Claimed MIME type (optional, will be verified by server)
+     * If omitted, server will auto-detect from magic bytes
+     */
+    mimeType?: string;
+}
+/**
+ * AI generation parameters
+ */
+interface GenerationParameters {
+    /**
+     * Controls randomness (0 = deterministic, 2 = very random)
+     * @default 0.7
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Nucleus sampling parameter
+     * @default 1.0
+     */
+    topP?: number;
+    /**
+     * Top-K sampling parameter
+     */
+    topK?: number;
+    /**
+     * System prompt to prepend
+     */
+    systemPrompt?: string;
+    /**
+     * Enable thinking/reasoning mode for supported models.
+     * When enabled, the model will show its reasoning process.
+     * Only works with models that support thinking (e.g., Gemini 2.0 Flash Thinking).
+     */
+    thinkingMode?: boolean;
+}
+/**
+ * Result from the generate method
+ */
+interface GenerateResult {
+    /**
+     * Whether the request was successful
+     */
+    success: boolean;
+    /**
+     * The generated data
+     */
+    data: GenerateData;
+    /**
+     * Request metadata
+     */
+    meta: GenerateMeta;
+    /**
+     * Error information (only present if success is false)
+     */
+    error?: GenerateError;
+}
+/**
+ * Generated data
+ */
+interface GenerateData {
+    /**
+     * Schema-compliant objects (or all parsed objects if no schema)
+     */
+    valid: unknown[];
+    /**
+     * Objects that failed schema validation but were successfully parsed
+     */
+    invalid: unknown[];
+    /**
+     * Raw AI response text (useful for debugging)
+     */
+    rawContent?: string;
+    /**
+     * Report of auto-healed validation errors
+     * detailed log of how the system fixed invalid AI output
+     */
+    healingReport?: Array<{
+        original: unknown;
+        healed: unknown;
+        fixes: string[];
+    }>;
+}
+/**
+ * Generation metadata
+ */
+interface GenerateMeta {
+    /**
+     * Whether the response was served from cache
+     */
+    cached: boolean;
+    /**
+     * The model that generated the response
+     */
+    modelUsed: string;
+    /**
+     * Token usage
+     */
+    tokensUsed: TokenUsage;
+    /**
+     * Request latency in milliseconds
+     */
+    latencyMs: number;
+    /**
+     * Models attempted before success (includes failed models)
+     */
+    attemptedModels: string[];
+    /**
+     * Why the generation stopped
+     */
+    finishReason?: 'stop' | 'length' | 'content_filter' | 'error';
+    /**
+     * Whether JSON recovery was needed
+     */
+    recovered?: boolean;
+}
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    input: number;
+    output: number;
+    total?: number;
+}
+/**
+ * Error information
+ */
+interface GenerateError {
+    /**
+     * Error code for programmatic handling
+     */
+    code: string;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Whether the error can be retried
+     */
+    retryable?: boolean;
+    /**
+     * Additional error details
+     */
+    details?: Record<string, unknown>;
+}
+/**
+ * Callbacks for streaming generation
+ */
+interface StreamCallbacks {
+    /**
+     * Called for each text chunk received (legacy/backwards compatible)
+     */
+    onChunk?: (chunk: string) => void;
+    /**
+     * Called for each VALID JSON object parsed from stream
+     * This is the preferred callback for JSON streaming - each object is complete and parseable
+     */
+    onObject?: (object: unknown, index: number) => void;
+    /**
+     * Called when a JSON array starts in the stream
+     */
+    onArrayStart?: () => void;
+    /**
+     * Called when streaming is complete with full result
+     */
+    onComplete?: (result: StreamCompleteResult) => void;
+    /**
+     * Called if an error occurs
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called with progress updates
+     */
+    onProgress?: (progress: StreamProgress) => void;
+}
+/**
+ * Result passed to onComplete callback during streaming
+ */
+interface StreamCompleteResult {
+    /**
+     * All collected objects from the stream
+     */
+    objects: unknown[];
+    /**
+     * Total number of objects parsed
+     */
+    objectCount: number;
+    /**
+     * Token usage for the request
+     */
+    tokensUsed?: {
+        input: number;
+        output: number;
+    };
+    /**
+     * Whether the response was cached at stream end
+     */
+    cached?: boolean;
+}
+/**
+ * Streaming progress information
+ */
+interface StreamProgress {
+    /**
+     * Total characters received so far
+     */
+    charactersReceived: number;
+    /**
+     * Elapsed time in milliseconds
+     */
+    elapsedMs: number;
+    /**
+     * Current model being used
+     */
+    model: string;
+}
+/**
+ * Information about a fallback chain
+ */
+interface ChainInfo {
+    /**
+     * Unique chain identifier
+     */
+    id: string;
+    /**
+     * Human-readable chain name
+     */
+    name: string;
+    /**
+     * Chain description
+     */
+    description?: string;
+    /**
+     * Whether this is the default chain
+     */
+    isDefault: boolean;
+    /**
+     * Chain steps (models to try in order)
+     */
+    steps: ChainStep[];
+    /**
+     * Number of requests using this chain
+     */
+    requestCount?: number;
+    /**
+     * Date chain was created
+     */
+    createdAt?: string;
+}
+/**
+ * A step in a fallback chain
+ */
+interface ChainStep {
+    /**
+     * Model identifier
+     */
+    modelId: string;
+    /**
+     * Human-readable model name
+     */
+    modelName: string;
+    /**
+     * Provider (GEMINI, OPENROUTER)
+     */
+    provider: 'GEMINI' | 'OPENROUTER';
+    /**
+     * Step priority (lower = tried first)
+     */
+    priority: number;
+    /**
+     * Maximum retries for this step
+     */
+    maxRetries?: number;
+    /**
+     * Timeout for this step in milliseconds
+     */
+    timeoutMs?: number;
+}
+/**
+ * Information about an AI model
+ */
+interface ModelInfo {
+    /**
+     * Model identifier (use this in chains)
+     */
+    id: string;
+    /**
+     * Provider name
+     */
+    provider: 'GEMINI' | 'OPENROUTER';
+    /**
+     * Human-readable model name
+     */
+    displayName: string;
+    /**
+     * Model description
+     */
+    description?: string;
+    /**
+     * Maximum input tokens
+     */
+    inputTokenLimit?: number;
+    /**
+     * Maximum output tokens
+     */
+    outputTokenLimit?: number;
+    /**
+     * Whether model supports JSON mode
+     */
+    supportsJsonMode: boolean;
+    /**
+     * Whether model supports streaming
+     */
+    supportsStreaming?: boolean;
+    /**
+     * Whether model supports thinking/reasoning
+     */
+    supportsThinking?: boolean;
+    /**
+     * Whether model is free to use
+     */
+    isFree: boolean;
+    /**
+     * Pricing per 1M tokens (if available)
+     */
+    pricing?: {
+        input: number;
+        output: number;
+        currency: string;
+    };
+}
+/**
+ * Usage statistics
+ */
+interface UsageStats {
+    /**
+     * Total requests in period
+     */
+    totalRequests: number;
+    /**
+     * Successful requests
+     */
+    successfulRequests: number;
+    /**
+     * Failed requests
+     */
+    failedRequests: number;
+    /**
+     * Cached responses served
+     */
+    cachedResponses: number;
+    /**
+     * Total tokens used
+     */
+    totalTokens: TokenUsage;
+    /**
+     * Usage by model
+     */
+    byModel: Record<string, {
+        requests: number;
+        tokens: TokenUsage;
+    }>;
+    /**
+     * Average latency in milliseconds
+     */
+    avgLatencyMs: number;
+    /**
+     * Period start date
+     */
+    periodStart: string;
+    /**
+     * Period end date
+     */
+    periodEnd: string;
+}
+/**
+ * Health check result
+ */
+interface HealthResult {
+    /**
+     * Whether the API is healthy
+     */
+    ok: boolean;
+    /**
+     * Response latency in milliseconds
+     */
+    latencyMs: number;
+    /**
+     * API version
+     */
+    version?: string;
+    /**
+     * Current time on server
+     */
+    timestamp?: string;
+}
+/**
+ * Detailed health check result with component status
+ */
+interface DetailedHealthResult {
+    /**
+     * Overall status
+     */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /**
+     * Server timestamp
+     */
+    timestamp: string;
+    /**
+     * Server uptime in seconds
+     */
+    uptime: number;
+    /**
+     * Component status
+     */
+    components: {
+        database: {
+            status: string;
+            latencyMs: number;
+            message?: string;
+        };
+        redis: {
+            status: string;
+            latencyMs: number;
+            message?: string;
+        };
+        gemini: {
+            status: string;
+            errorRate: number;
+            recentErrors: number;
+        };
+        openrouter: {
+            status: string;
+            errorRate: number;
+            recentErrors: number;
+        };
+    };
+    /**
+     * 24h metrics
+     */
+    metrics: {
+        last24h: {
+            totalRequests: number;
+            successRate: number;
+            cacheHitRate: number;
+            avgLatencyMs: number;
+        };
+        errorsByCode: Record<string, number>;
+    };
+    /**
+     * Cache status
+     */
+    cache: {
+        totalEntries: number;
+        redisAvailable: boolean;
+    };
+}
+/**
+ * Webhook configuration for async notifications
+ */
+interface WebhookConfig {
+    /**
+     * Request ID to receive notifications for
+     */
+    requestId: string;
+    /**
+     * URL to call when request completes
+     */
+    url: string;
+    /**
+     * Optional secret for HMAC signing
+     */
+    secret?: string;
+    /**
+     * Number of retry attempts on failure
+     * @default 3
+     */
+    retryCount?: number;
+}
+
+/**
+ * Hydra Client SDK
+ *
+ * Production-grade client for the Hydra API gateway.
+ * Use in Next.js API routes, Server Actions, or any Node.js/Edge environment.
+ *
+ * Features:
+ * - 🔐 HMAC Authentication with browser support
+ * - ⚡ Configurable timeout (default 10 minutes)
+ * - 🔄 Automatic retries with exponential backoff
+ * - 📦 Structured error handling
+ * - 🎯 Full TypeScript support
+ *
+ * @example
+ * ```typescript
+ * import { Hydra } from 'hydra-aidirector';
+ *
+ * const client = new Hydra({
+ *   secretKey: process.env.HYDRA_SECRET_KEY!,
+ *   baseUrl: 'https://api.hydrai.dev',
+ * });
+ *
+ * const result = await client.generate({
+ *   chainId: 'my-chain',
+ *   prompt: 'Generate 5 user profiles',
+ *   schema: { name: 'string', age: 'number' },
+ * });
+ *
+ * if (result.success) {
+ *   console.log(result.data.valid);
+ * }
+ * ```
+ */
+declare class Hydra {
+    private readonly secretKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly keyPrefix;
+    private readonly debug;
+    constructor(config: HydraConfig);
+    /**
+     * Generate content using your fallback chain
+     *
+     * @param options - Generation options
+     * @returns Promise resolving to GenerateResult
+     * @throws HydraError subclasses on failure
+     *
+     * @example
+     * ```typescript
+     * const result = await client.generate({
+     *   chainId: 'production-chain',
+     *   prompt: 'List 3 programming languages',
+     *   options: { temperature: 0.7 },
+     * });
+     * ```
+     */
+    generate(options: GenerateOptions): Promise<GenerateResult>;
+    /**
+     * Optimized 3-step generation (minimizes Vercel compute costs)
+     *
+     * Step 1: Get token from Vercel (~50ms)
+     * Step 2: Call CF Worker directly (FREE)
+     * Step 3: Cache result in Vercel (~50ms)
+     *
+     * Total Vercel time: ~100ms vs 30-120s in legacy mode
+     */
+    private generateOptimized;
+    /**
+     * Cache completion from worker (Step 3 - async, non-blocking)
+     */
+    private cacheCompletionAsync;
+    /**
+     * Legacy single-call generation (higher Vercel compute cost)
+     */
+    private generateLegacy;
+    /**
+     * Generate content with streaming (for long responses)
+     *
+     * @param options - Generation options
+     * @param callbacks - Streaming callbacks
+     *
+     * @example
+     * ```typescript
+     * await client.generateStream(
+     *   { chainId: 'my-chain', prompt: 'Write a long story' },
+     *   {
+     *     onChunk: (chunk) => process.stdout.write(chunk),
+     *     onComplete: (result) => console.log('\nDone!', result.meta),
+     *     onError: (error) => console.error('Error:', error),
+     *   }
+     * );
+     * ```
+     */
+    generateStream(options: GenerateOptions, callbacks: StreamCallbacks): Promise<void>;
+    /**
+     * List available AI models
+     *
+     * @returns Array of available models
+     */
+    listModels(): Promise<ModelInfo[]>;
+    /**
+     * Get your fallback chains
+     * Note: Requires cookies/session from authenticated context
+     *
+     * @returns Array of chain configurations
+     */
+    listChains(): Promise<ChainInfo[]>;
+    /**
+     * Get usage statistics for your account
+     *
+     * @param options - Date range options
+     * @returns Usage statistics
+     */
+    getUsage(options?: {
+        startDate?: Date;
+        endDate?: Date;
+    }): Promise<UsageStats>;
+    /**
+     * Health check - verify API connection
+     *
+     * @returns Health status with latency
+     */
+    health(): Promise<{
+        ok: boolean;
+        latencyMs: number;
+        version?: string;
+    }>;
+    /**
+     * Create a new client with different configuration
+     * Useful for testing or switching environments
+     *
+     * @param overrides - Configuration overrides
+     * @returns New Hydra instance
+     */
+    withConfig(overrides: Partial<HydraConfig>): Hydra;
+    /**
+     * Register a webhook for async notifications
+     *
+     * @param config - Webhook configuration
+     * @returns Registration result
+     */
+    registerWebhook(config: {
+        requestId: string;
+        url: string;
+        secret?: string;
+        retryCount?: number;
+    }): Promise<{
+        registered: boolean;
+        message: string;
+    }>;
+    /**
+     * Unregister a webhook
+     *
+     * @param webhookId - ID of the webhook to unregister
+     * @returns Unregistration result
+     */
+    unregisterWebhook(webhookId: string): Promise<{
+        unregistered: boolean;
+        message: string;
+    }>;
+    /**
+     * List all registered webhooks
+     *
+     * @returns Array of webhook configurations
+     */
+    listWebhooks(): Promise<Array<{
+        id: string;
+        requestId: string;
+        url: string;
+        status: 'pending' | 'delivered' | 'failed';
+        retryCount: number;
+        createdAt: string;
+    }>>;
+    /**
+     * Update a webhook configuration
+     *
+     * @param webhookId - ID of the webhook to update
+     * @param updates - Fields to update
+     * @returns Updated webhook info
+     */
+    updateWebhook(webhookId: string, updates: {
+        url?: string;
+        retryCount?: number;
+    }): Promise<{
+        updated: boolean;
+        message: string;
+    }>;
+    /**
+     * Get detailed health information including component status
+     *
+     * @returns Detailed health status
+     */
+    healthDetailed(): Promise<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        timestamp: string;
+        uptime: number;
+        components: Record<string, unknown>;
+        metrics: Record<string, unknown>;
+    }>;
+    /**
+     * Generate content for multiple prompts in a single request
+     *
+     * @param chainId - Chain to use for all items
+     * @param items - Array of prompts with IDs
+     * @param options - Batch options
+     * @returns Batch generation results
+     */
+    generateBatch(chainId: string, items: Array<{
+        id: string;
+        prompt: string;
+        systemPrompt?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }>, options?: {
+        continueOnError?: boolean;
+    }): Promise<{
+        results: Array<{
+            id: string;
+            success: boolean;
+            data?: unknown[];
+            error?: string;
+        }>;
+        summary: {
+            total: number;
+            succeeded: number;
+            failed: number;
+            tokensUsed: {
+                input: number;
+                output: number;
+                total: number;
+            };
+        };
+    }>;
+    /**
+     * Make authenticated API request
+     */
+    private makeAuthenticatedRequest;
+    /**
+     * Fetch with timeout
+     */
+    private fetchWithTimeout;
+    /**
+     * Parse API error response
+     */
+    private parseError;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryable;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    /**
+     * Debug logging
+     */
+    private log;
+}
+
+/**
+ * Hydra Error Classes
+ * Structured error types for better error handling
+ */
+/**
+ * Base error class for Hydra errors
+ */
+declare class HydraError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly statusCode?: number;
+    readonly originalError?: Error;
+    constructor(message: string, code: string, options?: {
+        retryable?: boolean;
+        statusCode?: number;
+        cause?: Error;
+    });
+}
+/**
+ * Configuration error - invalid client setup
+ */
+declare class ConfigurationError extends HydraError {
+    constructor(message: string);
+}
+/**
+ * Authentication error - invalid or expired credentials
+ */
+declare class AuthenticationError extends HydraError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Rate limit error - too many requests
+ */
+declare class RateLimitError extends HydraError {
+    readonly retryAfterMs: number;
+    constructor(message: string, retryAfterMs?: number);
+}
+/**
+ * Timeout error - request took too long
+ */
+declare class TimeoutError extends HydraError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * Network error - connection failed
+ */
+declare class NetworkError extends HydraError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Chain error - fallback chain execution failed
+ */
+declare class ChainExecutionError extends HydraError {
+    readonly attemptedModels: string[];
+    constructor(message: string, attemptedModels?: string[]);
+}
+/**
+ * Validation error - schema validation failed
+ */
+declare class ValidationError extends HydraError {
+    readonly validationErrors: unknown[];
+    constructor(message: string, validationErrors?: unknown[]);
+}
+/**
+ * Server error - internal server error
+ */
+declare class ServerError extends HydraError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Quota exceeded error - monthly request limit reached
+ */
+declare class QuotaExceededError extends HydraError {
+    readonly tier: string;
+    readonly limit: number;
+    readonly used: number;
+    constructor(message: string, options: {
+        tier: string;
+        limit: number;
+        used: number;
+    });
+}
+/**
+ * Worker error - Cloudflare Worker execution failed
+ */
+declare class WorkerError extends HydraError {
+    readonly workerDurationMs?: number;
+    constructor(message: string, workerDurationMs?: number);
+}
+/**
+ * File processing error - attachment handling failed
+ */
+declare class FileProcessingError extends HydraError {
+    readonly filename?: string;
+    readonly mimeType?: string;
+    readonly reason: 'unsupported_type' | 'conversion_failed' | 'too_large' | 'corrupted';
+    constructor(message: string, options: {
+        filename?: string;
+        mimeType?: string;
+        reason: 'unsupported_type' | 'conversion_failed' | 'too_large' | 'corrupted';
+    });
+}
+/**
+ * Invalid schema error - provided schema is malformed
+ */
+declare class InvalidSchemaError extends HydraError {
+    readonly schemaPath?: string;
+    constructor(message: string, schemaPath?: string);
+}
+/**
+ * Check if error is an Hydra error
+ */
+declare function isHydraError(error: unknown): error is HydraError;
+/**
+ * Check if error is retryable
+ */
+declare function isRetryableError(error: unknown): boolean;
+
+/**
+ * HMAC Signature Generation
+ *
+ * Supports both Node.js (crypto) and browser (Web Crypto API) environments.
+ * The signature algorithm matches the server-side verification.
+ */
+/**
+ * Generate HMAC signature for request authentication
+ *
+ * Automatically detects environment and uses appropriate implementation.
+ *
+ * IMPORTANT: We hash the secret key first, then use the hash as HMAC key.
+ * This allows the server to verify using the stored hash (it never sees the full key).
+ */
+declare function generateSignature(secretKey: string, method: string, path: string, body: string, timestamp: number): Promise<string>;
+/**
+ * Get the key prefix for identification (sent in headers)
+ */
+declare function getKeyPrefix(secretKey: string): string;
+/**
+ * Validate secret key format
+ */
+declare function isValidSecretKey(secretKey: string): boolean;
+
+export { AuthenticationError, ChainExecutionError, type ChainInfo, type ChainStep, ConfigurationError, type DetailedHealthResult, type FileAttachment, FileProcessingError, type GenerateData, type GenerateError, type GenerateMeta, type GenerateOptions, type GenerateResult, type GenerationParameters, type HealthResult, Hydra, type HydraConfig, HydraError, InvalidSchemaError, type ModelInfo, NetworkError, QuotaExceededError, RateLimitError, ServerError, type StreamCallbacks, type StreamCompleteResult, type StreamProgress, TimeoutError, type TokenUsage, type UsageStats, ValidationError, type WebhookConfig, WorkerError, generateSignature, getKeyPrefix, isHydraError, isRetryableError, isValidSecretKey };