gthinking 1.3.0 → 2.1.1

package/dist/core/config.d.ts

@@ -0,0 +1,1419 @@
+/**
+ * Configuration for gthinking v2.0.0
+ * Centralized configuration management
+ */
+import { z } from 'zod';
+/**
+ * LLM Provider configuration schema
+ */
+export declare const LLMProviderConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["gemini", "claude", "openai", "kimi", "custom", "cli"]>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    cliCommand: z.ZodDefault<z.ZodString>;
+    cliArgs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    cliPromptPassingMethod: z.ZodDefault<z.ZodEnum<["stdin", "arg"]>>;
+    cliPromptFlag: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    rateLimitPerMinute: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number;
+    maxRetries?: number;
+    provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    cliCommand?: string;
+    cliArgs?: string[];
+    cliPromptPassingMethod?: "stdin" | "arg";
+    cliPromptFlag?: string;
+    rateLimitPerMinute?: number;
+}, {
+    timeout?: number;
+    maxRetries?: number;
+    provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    cliCommand?: string;
+    cliArgs?: string[];
+    cliPromptPassingMethod?: "stdin" | "arg";
+    cliPromptFlag?: string;
+    rateLimitPerMinute?: number;
+}>;
+export type LLMProviderConfig = z.infer<typeof LLMProviderConfigSchema>;
+/**
+ * Search configuration schema
+ */
+export declare const SearchConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    providers: z.ZodDefault<z.ZodArray<z.ZodEnum<["google", "bing", "brave", "duckduckgo"]>, "many">>;
+    apiKeys: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    cacheResults: z.ZodDefault<z.ZodBoolean>;
+    cacheTTL: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number;
+    maxResults?: number;
+    enabled?: boolean;
+    providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+    apiKeys?: Record<string, string>;
+    cacheResults?: boolean;
+    cacheTTL?: number;
+}, {
+    timeout?: number;
+    maxResults?: number;
+    enabled?: boolean;
+    providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+    apiKeys?: Record<string, string>;
+    cacheResults?: boolean;
+    cacheTTL?: number;
+}>;
+export type SearchConfig = z.infer<typeof SearchConfigSchema>;
+/**
+ * Cache configuration schema
+ */
+export declare const CacheConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    checkInterval: z.ZodDefault<z.ZodNumber>;
+    persistence: z.ZodDefault<z.ZodEnum<["none", "file", "redis"]>>;
+    persistencePath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled?: boolean;
+    maxSize?: number;
+    defaultTTL?: number;
+    checkInterval?: number;
+    persistence?: "file" | "redis" | "none";
+    persistencePath?: string;
+}, {
+    enabled?: boolean;
+    maxSize?: number;
+    defaultTTL?: number;
+    checkInterval?: number;
+    persistence?: "file" | "redis" | "none";
+    persistencePath?: string;
+}>;
+export type CacheConfig = z.infer<typeof CacheConfigSchema>;
+/**
+ * Logging configuration schema
+ */
+export declare const LoggingConfigSchema: z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    enableConsole: z.ZodDefault<z.ZodBoolean>;
+    enableFile: z.ZodDefault<z.ZodBoolean>;
+    logDir: z.ZodDefault<z.ZodString>;
+    maxFiles: z.ZodDefault<z.ZodNumber>;
+    maxSize: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    level?: "debug" | "info" | "warn" | "error";
+    enableConsole?: boolean;
+    enableFile?: boolean;
+    logDir?: string;
+    maxFiles?: number;
+    maxSize?: string;
+}, {
+    level?: "debug" | "info" | "warn" | "error";
+    enableConsole?: boolean;
+    enableFile?: boolean;
+    logDir?: string;
+    maxFiles?: number;
+    maxSize?: string;
+}>;
+export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+/**
+ * Stage configuration schema
+ */
+export declare const StageConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    parallel: z.ZodDefault<z.ZodBoolean>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number;
+    maxRetries?: number;
+    enabled?: boolean;
+    parallel?: boolean;
+    required?: boolean;
+}, {
+    timeout?: number;
+    maxRetries?: number;
+    enabled?: boolean;
+    parallel?: boolean;
+    required?: boolean;
+}>;
+export type StageConfig = z.infer<typeof StageConfigSchema>;
+/**
+ * Pipeline configuration schema
+ */
+export declare const PipelineConfigSchema: z.ZodObject<{
+    stages: z.ZodDefault<z.ZodObject<{
+        search: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        analysis: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        reasoning: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        learning: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        planning: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        creativity: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        synthesis: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+        evaluation: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            parallel: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }, {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        search?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        analysis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        reasoning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        learning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        planning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        creativity?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        synthesis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        evaluation?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+    }, {
+        search?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        analysis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        reasoning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        learning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        planning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        creativity?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        synthesis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        evaluation?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+    }>>;
+    enableDynamicPipeline: z.ZodDefault<z.ZodBoolean>;
+    enableStreaming: z.ZodDefault<z.ZodBoolean>;
+    maxConcurrentStages: z.ZodDefault<z.ZodNumber>;
+    defaultTimeout: z.ZodDefault<z.ZodNumber>;
+    errorHandling: z.ZodDefault<z.ZodEnum<["stop", "continue"]>>;
+}, "strip", z.ZodTypeAny, {
+    stages?: {
+        search?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        analysis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        reasoning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        learning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        planning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        creativity?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        synthesis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        evaluation?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+    };
+    enableDynamicPipeline?: boolean;
+    enableStreaming?: boolean;
+    maxConcurrentStages?: number;
+    defaultTimeout?: number;
+    errorHandling?: "stop" | "continue";
+}, {
+    stages?: {
+        search?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        analysis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        reasoning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        learning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        planning?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        creativity?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        synthesis?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+        evaluation?: {
+            timeout?: number;
+            maxRetries?: number;
+            enabled?: boolean;
+            parallel?: boolean;
+            required?: boolean;
+        };
+    };
+    enableDynamicPipeline?: boolean;
+    enableStreaming?: boolean;
+    maxConcurrentStages?: number;
+    defaultTimeout?: number;
+    errorHandling?: "stop" | "continue";
+}>;
+export type PipelineConfig = z.infer<typeof PipelineConfigSchema>;
+/**
+ * Main configuration schema
+ */
+export declare const GThinkingConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    llm: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodEnum<["gemini", "claude", "openai", "kimi", "custom", "cli"]>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cliCommand: z.ZodDefault<z.ZodString>;
+        cliArgs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        cliPromptPassingMethod: z.ZodDefault<z.ZodEnum<["stdin", "arg"]>>;
+        cliPromptFlag: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        rateLimitPerMinute: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number;
+        maxRetries?: number;
+        provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        cliCommand?: string;
+        cliArgs?: string[];
+        cliPromptPassingMethod?: "stdin" | "arg";
+        cliPromptFlag?: string;
+        rateLimitPerMinute?: number;
+    }, {
+        timeout?: number;
+        maxRetries?: number;
+        provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        cliCommand?: string;
+        cliArgs?: string[];
+        cliPromptPassingMethod?: "stdin" | "arg";
+        cliPromptFlag?: string;
+        rateLimitPerMinute?: number;
+    }>>;
+    search: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providers: z.ZodDefault<z.ZodArray<z.ZodEnum<["google", "bing", "brave", "duckduckgo"]>, "many">>;
+        apiKeys: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        cacheResults: z.ZodDefault<z.ZodBoolean>;
+        cacheTTL: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number;
+        maxResults?: number;
+        enabled?: boolean;
+        providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+        apiKeys?: Record<string, string>;
+        cacheResults?: boolean;
+        cacheTTL?: number;
+    }, {
+        timeout?: number;
+        maxResults?: number;
+        enabled?: boolean;
+        providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+        apiKeys?: Record<string, string>;
+        cacheResults?: boolean;
+        cacheTTL?: number;
+    }>>;
+    cache: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxSize: z.ZodDefault<z.ZodNumber>;
+        defaultTTL: z.ZodDefault<z.ZodNumber>;
+        checkInterval: z.ZodDefault<z.ZodNumber>;
+        persistence: z.ZodDefault<z.ZodEnum<["none", "file", "redis"]>>;
+        persistencePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean;
+        maxSize?: number;
+        defaultTTL?: number;
+        checkInterval?: number;
+        persistence?: "file" | "redis" | "none";
+        persistencePath?: string;
+    }, {
+        enabled?: boolean;
+        maxSize?: number;
+        defaultTTL?: number;
+        checkInterval?: number;
+        persistence?: "file" | "redis" | "none";
+        persistencePath?: string;
+    }>>;
+    logging: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+        enableConsole: z.ZodDefault<z.ZodBoolean>;
+        enableFile: z.ZodDefault<z.ZodBoolean>;
+        logDir: z.ZodDefault<z.ZodString>;
+        maxFiles: z.ZodDefault<z.ZodNumber>;
+        maxSize: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "debug" | "info" | "warn" | "error";
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logDir?: string;
+        maxFiles?: number;
+        maxSize?: string;
+    }, {
+        level?: "debug" | "info" | "warn" | "error";
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logDir?: string;
+        maxFiles?: number;
+        maxSize?: string;
+    }>>;
+    pipeline: z.ZodDefault<z.ZodObject<{
+        stages: z.ZodDefault<z.ZodObject<{
+            search: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            analysis: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            reasoning: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            learning: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            planning: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            creativity: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            synthesis: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+            evaluation: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                maxRetries: z.ZodDefault<z.ZodNumber>;
+                parallel: z.ZodDefault<z.ZodBoolean>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }, {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        }, {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        }>>;
+        enableDynamicPipeline: z.ZodDefault<z.ZodBoolean>;
+        enableStreaming: z.ZodDefault<z.ZodBoolean>;
+        maxConcurrentStages: z.ZodDefault<z.ZodNumber>;
+        defaultTimeout: z.ZodDefault<z.ZodNumber>;
+        errorHandling: z.ZodDefault<z.ZodEnum<["stop", "continue"]>>;
+    }, "strip", z.ZodTypeAny, {
+        stages?: {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        };
+        enableDynamicPipeline?: boolean;
+        enableStreaming?: boolean;
+        maxConcurrentStages?: number;
+        defaultTimeout?: number;
+        errorHandling?: "stop" | "continue";
+    }, {
+        stages?: {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        };
+        enableDynamicPipeline?: boolean;
+        enableStreaming?: boolean;
+        maxConcurrentStages?: number;
+        defaultTimeout?: number;
+        errorHandling?: "stop" | "continue";
+    }>>;
+    security: z.ZodDefault<z.ZodObject<{
+        enableInputSanitization: z.ZodDefault<z.ZodBoolean>;
+        enableRateLimiting: z.ZodDefault<z.ZodBoolean>;
+        maxRequestsPerMinute: z.ZodDefault<z.ZodNumber>;
+        maxQueryLength: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enableInputSanitization?: boolean;
+        enableRateLimiting?: boolean;
+        maxRequestsPerMinute?: number;
+        maxQueryLength?: number;
+    }, {
+        enableInputSanitization?: boolean;
+        enableRateLimiting?: boolean;
+        maxRequestsPerMinute?: number;
+        maxQueryLength?: number;
+    }>>;
+    session: z.ZodDefault<z.ZodObject<{
+        maxSessions: z.ZodDefault<z.ZodNumber>;
+        sessionTTL: z.ZodDefault<z.ZodNumber>;
+        enablePersistence: z.ZodDefault<z.ZodBoolean>;
+        persistencePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        persistencePath?: string;
+        maxSessions?: number;
+        sessionTTL?: number;
+        enablePersistence?: boolean;
+    }, {
+        persistencePath?: string;
+        maxSessions?: number;
+        sessionTTL?: number;
+        enablePersistence?: boolean;
+    }>>;
+    metrics: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        collectDetailedMetrics: z.ZodDefault<z.ZodBoolean>;
+        metricsInterval: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean;
+        collectDetailedMetrics?: boolean;
+        metricsInterval?: number;
+    }, {
+        enabled?: boolean;
+        collectDetailedMetrics?: boolean;
+        metricsInterval?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    search?: {
+        timeout?: number;
+        maxResults?: number;
+        enabled?: boolean;
+        providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+        apiKeys?: Record<string, string>;
+        cacheResults?: boolean;
+        cacheTTL?: number;
+    };
+    cache?: {
+        enabled?: boolean;
+        maxSize?: number;
+        defaultTTL?: number;
+        checkInterval?: number;
+        persistence?: "file" | "redis" | "none";
+        persistencePath?: string;
+    };
+    llm?: {
+        timeout?: number;
+        maxRetries?: number;
+        provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        cliCommand?: string;
+        cliArgs?: string[];
+        cliPromptPassingMethod?: "stdin" | "arg";
+        cliPromptFlag?: string;
+        rateLimitPerMinute?: number;
+    };
+    metrics?: {
+        enabled?: boolean;
+        collectDetailedMetrics?: boolean;
+        metricsInterval?: number;
+    };
+    session?: {
+        persistencePath?: string;
+        maxSessions?: number;
+        sessionTTL?: number;
+        enablePersistence?: boolean;
+    };
+    version?: string;
+    logging?: {
+        level?: "debug" | "info" | "warn" | "error";
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logDir?: string;
+        maxFiles?: number;
+        maxSize?: string;
+    };
+    pipeline?: {
+        stages?: {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        };
+        enableDynamicPipeline?: boolean;
+        enableStreaming?: boolean;
+        maxConcurrentStages?: number;
+        defaultTimeout?: number;
+        errorHandling?: "stop" | "continue";
+    };
+    security?: {
+        enableInputSanitization?: boolean;
+        enableRateLimiting?: boolean;
+        maxRequestsPerMinute?: number;
+        maxQueryLength?: number;
+    };
+}, {
+    search?: {
+        timeout?: number;
+        maxResults?: number;
+        enabled?: boolean;
+        providers?: ("google" | "bing" | "brave" | "duckduckgo")[];
+        apiKeys?: Record<string, string>;
+        cacheResults?: boolean;
+        cacheTTL?: number;
+    };
+    cache?: {
+        enabled?: boolean;
+        maxSize?: number;
+        defaultTTL?: number;
+        checkInterval?: number;
+        persistence?: "file" | "redis" | "none";
+        persistencePath?: string;
+    };
+    llm?: {
+        timeout?: number;
+        maxRetries?: number;
+        provider?: "gemini" | "claude" | "openai" | "kimi" | "custom" | "cli";
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        cliCommand?: string;
+        cliArgs?: string[];
+        cliPromptPassingMethod?: "stdin" | "arg";
+        cliPromptFlag?: string;
+        rateLimitPerMinute?: number;
+    };
+    metrics?: {
+        enabled?: boolean;
+        collectDetailedMetrics?: boolean;
+        metricsInterval?: number;
+    };
+    session?: {
+        persistencePath?: string;
+        maxSessions?: number;
+        sessionTTL?: number;
+        enablePersistence?: boolean;
+    };
+    version?: string;
+    logging?: {
+        level?: "debug" | "info" | "warn" | "error";
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logDir?: string;
+        maxFiles?: number;
+        maxSize?: string;
+    };
+    pipeline?: {
+        stages?: {
+            search?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            analysis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            reasoning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            learning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            planning?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            creativity?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            synthesis?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+            evaluation?: {
+                timeout?: number;
+                maxRetries?: number;
+                enabled?: boolean;
+                parallel?: boolean;
+                required?: boolean;
+            };
+        };
+        enableDynamicPipeline?: boolean;
+        enableStreaming?: boolean;
+        maxConcurrentStages?: number;
+        defaultTimeout?: number;
+        errorHandling?: "stop" | "continue";
+    };
+    security?: {
+        enableInputSanitization?: boolean;
+        enableRateLimiting?: boolean;
+        maxRequestsPerMinute?: number;
+        maxQueryLength?: number;
+    };
+}>;
+export type GThinkingConfig = z.infer<typeof GThinkingConfigSchema>;
+/**
+ * Default configuration
+ */
+export declare const defaultConfig: GThinkingConfig;
+/**
+ * Configuration manager class
+ */
+export declare class ConfigManager {
+    private config;
+    private validators;
+    constructor(initialConfig?: Partial<GThinkingConfig>);
+    /**
+     * Get the current configuration
+     * @returns The current configuration
+     */
+    getConfig(): GThinkingConfig;
+    /**
+     * Get a specific configuration value
+     * @param path - The configuration path (e.g., 'llm.provider')
+     * @returns The configuration value
+     */
+    get<T>(path: string): T | undefined;
+    /**
+     * Update the configuration
+     * @param updates - Configuration updates
+     */
+    updateConfig(updates: Partial<GThinkingConfig>): void;
+    /**
+     * Update a specific configuration value
+     * @param path - The configuration path
+     * @param value - The new value
+     */
+    set<T>(path: string, value: T): void;
+    /**
+     * Load configuration from environment variables
+     */
+    loadFromEnvironment(): void;
+    /**
+     * Register a custom validator
+     * @param path - The configuration path
+     * @param validator - The validator function
+     */
+    registerValidator(path: string, validator: (value: unknown) => boolean): void;
+    /**
+     * Merge configurations
+     * @param base - Base configuration
+     * @param override - Override configuration
+     * @returns Merged configuration
+     */
+    private mergeConfig;
+    /**
+     * Validate the configuration
+     */
+    private validateConfig;
+}
+export declare const configManager: ConfigManager;
+//# sourceMappingURL=config.d.ts.map