smartcontext-proxy 0.1.0

package/adapters/openclaw/storage.ts

@@ -0,0 +1,183 @@
+import http from 'node:http';
+import type { StorageAdapter, Chunk, ScoredChunk, SearchOptions, Exchange } from '../../src/storage/types.js';
+
+/**
+ * OpenSearch storage adapter for SmartContext.
+ * Stores chunks and metrics in OpenSearch indices on Castle VPS.
+ */
+export class OpenClawStorageAdapter implements StorageAdapter {
+  name = 'openclaw-opensearch';
+  private baseUrl: string;
+  private chunksIndex = 'smartcontext-chunks';
+  private metricsIndex = 'smartcontext-metrics';
+  private logsIndex = 'smartcontext-logs';
+
+  constructor(esUrl: string = 'http://localhost:9201') {
+    this.baseUrl = esUrl;
+  }
+
+  async initialize(): Promise<void> {
+    // Create indices if they don't exist
+    for (const index of [this.chunksIndex, this.metricsIndex, this.logsIndex]) {
+      try {
+        await this.esRequest('PUT', `/${index}`, {
+          settings: { number_of_shards: 1, number_of_replicas: 0 },
+          mappings: index === this.chunksIndex ? this.chunkMappings() : undefined,
+        });
+      } catch {
+        // Index may already exist
+      }
+    }
+  }
+
+  async upsertChunks(chunks: Chunk[]): Promise<void> {
+    if (chunks.length === 0) return;
+
+    const bulkBody = chunks.flatMap((c) => [
+      JSON.stringify({ index: { _index: this.chunksIndex, _id: c.id } }),
+      JSON.stringify({
+        text: c.text,
+        embedding: c.embedding,
+        sessionId: c.sessionId,
+        timestamp: c.timestamp,
+        summary: c.metadata.summary,
+        tokenCount: c.metadata.tokenCount,
+        exchangeIndex: c.metadata.exchangeIndex,
+        files: c.metadata.files,
+        tools: c.metadata.tools,
+      }),
+    ]).join('\n') + '\n';
+
+    await this.esRequest('POST', '/_bulk', bulkBody, 'application/x-ndjson');
+  }
+
+  async search(embedding: number[], options: SearchOptions): Promise<ScoredChunk[]> {
+    const query: Record<string, unknown> = {
+      size: options.topK,
+      query: {
+        script_score: {
+          query: { match_all: {} },
+          script: {
+            source: "cosineSimilarity(params.query_vector, 'embedding') + 1.0",
+            params: { query_vector: embedding },
+          },
+        },
+      },
+    };
+
+    const result = await this.esRequest('POST', `/${this.chunksIndex}/_search`, query);
+    const parsed = JSON.parse(result);
+
+    return (parsed.hits?.hits || []).map((hit: Record<string, unknown>) => {
+      const source = hit._source as Record<string, unknown>;
+      let score = ((hit._score as number) - 1.0); // Remove the +1.0 offset
+
+      // Apply boosts
+      if (options.sessionBoost && source.sessionId === options.sessionBoost.sessionId) {
+        score += options.sessionBoost.boost;
+      }
+      if (options.fileBoost) {
+        const files = (source.files as string[]) || [];
+        if (options.fileBoost.patterns.some((p) => files.some((f) => f.includes(p)))) {
+          score += options.fileBoost.boost;
+        }
+      }
+
+      return {
+        id: hit._id as string,
+        text: source.text as string,
+        embedding: [],
+        sessionId: source.sessionId as string,
+        timestamp: source.timestamp as number,
+        score,
+        metadata: {
+          summary: source.summary as string,
+          tokenCount: source.tokenCount as number,
+          exchangeIndex: source.exchangeIndex as number,
+          files: source.files as string[],
+          tools: source.tools as string[],
+        },
+      } as ScoredChunk;
+    }).filter((c: ScoredChunk) => c.score >= options.minScore);
+  }
+
+  async appendLog(sessionId: string, exchange: Exchange): Promise<void> {
+    await this.esRequest('POST', `/${this.logsIndex}/_doc`, {
+      sessionId,
+      ...exchange,
+      indexedAt: new Date().toISOString(),
+    });
+  }
+
+  async getSessionLog(sessionId: string): Promise<Exchange[]> {
+    const result = await this.esRequest('POST', `/${this.logsIndex}/_search`, {
+      size: 1000,
+      query: { term: { sessionId } },
+      sort: [{ timestamp: 'asc' }],
+    });
+    const parsed = JSON.parse(result);
+    return (parsed.hits?.hits || []).map((h: Record<string, unknown>) => (h._source as unknown) as Exchange);
+  }
+
+  async getStats(): Promise<{ chunks: number; sessions: number; diskBytes: number }> {
+    try {
+      const result = await this.esRequest('GET', `/${this.chunksIndex}/_count`);
+      const parsed = JSON.parse(result);
+      return {
+        chunks: parsed.count || 0,
+        sessions: 0, // Would need aggregation
+        diskBytes: 0,
+      };
+    } catch {
+      return { chunks: 0, sessions: 0, diskBytes: 0 };
+    }
+  }
+
+  async close(): Promise<void> {
+    // No cleanup needed for HTTP client
+  }
+
+  private chunkMappings() {
+    return {
+      properties: {
+        text: { type: 'text' },
+        embedding: { type: 'dense_vector', dims: 768 },
+        sessionId: { type: 'keyword' },
+        timestamp: { type: 'long' },
+        summary: { type: 'text' },
+        tokenCount: { type: 'integer' },
+        exchangeIndex: { type: 'integer' },
+        files: { type: 'keyword' },
+        tools: { type: 'keyword' },
+      },
+    };
+  }
+
+  private esRequest(method: string, path: string, body?: unknown, contentType?: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const url = new URL(`${this.baseUrl}${path}`);
+      const bodyStr = typeof body === 'string' ? body : body ? JSON.stringify(body) : undefined;
+
+      const req = http.request(url, {
+        method,
+        headers: {
+          'Content-Type': contentType || 'application/json',
+          ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr).toString() } : {}),
+        },
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`ES ${method} ${path}: ${res.statusCode} ${data.slice(0, 200)}`));
+          } else {
+            resolve(data);
+          }
+        });
+      });
+      req.on('error', reject);
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  }
+}

package/dist/adapters/openclaw/embedding.d.ts

@@ -0,0 +1,8 @@
+import { OllamaEmbeddingAdapter } from '../../src/embedding/ollama.js';
+/**
+ * OpenClaw embedding adapter — wraps Ollama adapter with Beast PC defaults.
+ * Uses nomic-embed-text on Beast's GPU for fast embeddings.
+ */
+export declare class OpenClawEmbeddingAdapter extends OllamaEmbeddingAdapter {
+    constructor(ollamaUrl?: string, model?: string);
+}

package/dist/adapters/openclaw/embedding.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenClawEmbeddingAdapter = void 0;
+const ollama_js_1 = require("../../src/embedding/ollama.js");
+/**
+ * OpenClaw embedding adapter — wraps Ollama adapter with Beast PC defaults.
+ * Uses nomic-embed-text on Beast's GPU for fast embeddings.
+ */
+class OpenClawEmbeddingAdapter extends ollama_js_1.OllamaEmbeddingAdapter {
+    constructor(ollamaUrl = 'http://localhost:11434', model = 'nomic-embed-text') {
+        super(ollamaUrl, model);
+        this.name = 'openclaw-ollama';
+    }
+}
+exports.OpenClawEmbeddingAdapter = OpenClawEmbeddingAdapter;
+//# sourceMappingURL=embedding.js.map

package/dist/adapters/openclaw/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * smartcontext-adapter-openclaw
+ *
+ * OpenClaw-specific adapter for SmartContext Proxy.
+ * Uses OpenSearch on Castle for storage and Beast Ollama for embeddings.
+ * Auto-discovers config from ~/.openclaw/
+ */
+export { OpenClawStorageAdapter } from './storage.js';
+export { OpenClawEmbeddingAdapter } from './embedding.js';
+export { SessionImporter } from './session-importer.js';
+export interface OpenClawConfig {
+    ocHome: string;
+    esUrl: string;
+    ollamaUrl: string;
+    ollamaModel: string;
+}
+/** Auto-discover OpenClaw config from filesystem */
+export declare function discoverConfig(ocHome?: string): OpenClawConfig;

package/dist/adapters/openclaw/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * smartcontext-adapter-openclaw
+ *
+ * OpenClaw-specific adapter for SmartContext Proxy.
+ * Uses OpenSearch on Castle for storage and Beast Ollama for embeddings.
+ * Auto-discovers config from ~/.openclaw/
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionImporter = exports.OpenClawEmbeddingAdapter = exports.OpenClawStorageAdapter = void 0;
+exports.discoverConfig = discoverConfig;
+var storage_js_1 = require("./storage.js");
+Object.defineProperty(exports, "OpenClawStorageAdapter", { enumerable: true, get: function () { return storage_js_1.OpenClawStorageAdapter; } });
+var embedding_js_1 = require("./embedding.js");
+Object.defineProperty(exports, "OpenClawEmbeddingAdapter", { enumerable: true, get: function () { return embedding_js_1.OpenClawEmbeddingAdapter; } });
+var session_importer_js_1 = require("./session-importer.js");
+Object.defineProperty(exports, "SessionImporter", { enumerable: true, get: function () { return session_importer_js_1.SessionImporter; } });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Auto-discover OpenClaw config from filesystem */
+function discoverConfig(ocHome) {
+    const home = ocHome || node_path_1.default.join(process.env['HOME'] || '.', '.openclaw');
+    // Read openclaw.json for model and API settings
+    let esUrl = process.env['ES_URL'] || 'http://localhost:9201';
+    let ollamaUrl = 'http://localhost:11434';
+    let ollamaModel = 'nomic-embed-text';
+    const configPath = node_path_1.default.join(home, 'openclaw.json');
+    if (node_fs_1.default.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf-8'));
+            if (config.models?.providers?.ollama?.baseUrl) {
+                ollamaUrl = config.models.providers.ollama.baseUrl;
+            }
+        }
+        catch { }
+    }
+    return { ocHome: home, esUrl, ollamaUrl, ollamaModel };
+}
+//# sourceMappingURL=index.js.map

package/dist/adapters/openclaw/session-importer.d.ts

@@ -0,0 +1,22 @@
+import type { StorageAdapter } from '../../src/storage/types.js';
+import type { EmbeddingAdapter } from '../../src/embedding/types.js';
+/**
+ * Import OC gateway session logs into SmartContext storage.
+ * Reads JSONL session logs, chunks them, embeds, and stores.
+ */
+export declare class SessionImporter {
+    private storage;
+    private embedding;
+    constructor(storage: StorageAdapter, embedding: EmbeddingAdapter);
+    /**
+     * Import sessions from OC gateway log directory.
+     * @param logDir Path to OC session logs (e.g., ~/.openclaw/logs/sessions/)
+     * @param onProgress Callback for progress reporting
+     */
+    importFromDirectory(logDir: string, onProgress?: (msg: string) => void): Promise<{
+        imported: number;
+        chunks: number;
+        errors: number;
+    }>;
+    private parseSessionLog;
+}

package/dist/adapters/openclaw/session-importer.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionImporter = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const chunker_js_1 = require("../../src/context/chunker.js");
+/**
+ * Import OC gateway session logs into SmartContext storage.
+ * Reads JSONL session logs, chunks them, embeds, and stores.
+ */
+class SessionImporter {
+    storage;
+    embedding;
+    constructor(storage, embedding) {
+        this.storage = storage;
+        this.embedding = embedding;
+    }
+    /**
+     * Import sessions from OC gateway log directory.
+     * @param logDir Path to OC session logs (e.g., ~/.openclaw/logs/sessions/)
+     * @param onProgress Callback for progress reporting
+     */
+    async importFromDirectory(logDir, onProgress) {
+        let imported = 0;
+        let totalChunks = 0;
+        let errors = 0;
+        if (!node_fs_1.default.existsSync(logDir)) {
+            onProgress?.(`Directory not found: ${logDir}`);
+            return { imported, chunks: totalChunks, errors };
+        }
+        const files = node_fs_1.default.readdirSync(logDir).filter((f) => f.endsWith('.jsonl') || f.endsWith('.json'));
+        onProgress?.(`Found ${files.length} session files`);
+        for (const file of files) {
+            try {
+                const filePath = node_path_1.default.join(logDir, file);
+                const sessionId = node_path_1.default.basename(file, node_path_1.default.extname(file));
+                const content = node_fs_1.default.readFileSync(filePath, 'utf-8');
+                const messages = this.parseSessionLog(content);
+                if (messages.length === 0)
+                    continue;
+                const chunks = (0, chunker_js_1.chunkConversation)(messages, sessionId);
+                if (chunks.length === 0)
+                    continue;
+                // Embed chunks in batches
+                const batchSize = 10;
+                for (let i = 0; i < chunks.length; i += batchSize) {
+                    const batch = chunks.slice(i, i + batchSize);
+                    const texts = batch.map((c) => c.text);
+                    const embeddings = await this.embedding.embed(texts);
+                    for (let j = 0; j < batch.length; j++) {
+                        batch[j].embedding = embeddings[j];
+                    }
+                }
+                await this.storage.upsertChunks(chunks);
+                imported++;
+                totalChunks += chunks.length;
+                onProgress?.(`Imported ${file}: ${chunks.length} chunks`);
+            }
+            catch (err) {
+                errors++;
+                onProgress?.(`Error importing ${file}: ${err}`);
+            }
+        }
+        onProgress?.(`Done: ${imported} sessions, ${totalChunks} chunks, ${errors} errors`);
+        return { imported, chunks: totalChunks, errors };
+    }
+    parseSessionLog(content) {
+        const messages = [];
+        for (const line of content.split('\n').filter(Boolean)) {
+            try {
+                const entry = JSON.parse(line);
+                // Support different OC log formats
+                if (entry.role && entry.content) {
+                    messages.push({
+                        role: entry.role,
+                        content: typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content),
+                        timestamp: entry.timestamp ? new Date(entry.timestamp).getTime() : undefined,
+                    });
+                }
+                else if (entry.type === 'user_message' || entry.type === 'assistant_message') {
+                    messages.push({
+                        role: entry.type === 'user_message' ? 'user' : 'assistant',
+                        content: entry.text || entry.content || '',
+                        timestamp: entry.timestamp ? new Date(entry.timestamp).getTime() : undefined,
+                    });
+                }
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+        return messages;
+    }
+}
+exports.SessionImporter = SessionImporter;
+//# sourceMappingURL=session-importer.js.map

package/dist/adapters/openclaw/storage.d.ts

@@ -0,0 +1,26 @@
+import type { StorageAdapter, Chunk, ScoredChunk, SearchOptions, Exchange } from '../../src/storage/types.js';
+/**
+ * OpenSearch storage adapter for SmartContext.
+ * Stores chunks and metrics in OpenSearch indices on Castle VPS.
+ */
+export declare class OpenClawStorageAdapter implements StorageAdapter {
+    name: string;
+    private baseUrl;
+    private chunksIndex;
+    private metricsIndex;
+    private logsIndex;
+    constructor(esUrl?: string);
+    initialize(): Promise<void>;
+    upsertChunks(chunks: Chunk[]): Promise<void>;
+    search(embedding: number[], options: SearchOptions): Promise<ScoredChunk[]>;
+    appendLog(sessionId: string, exchange: Exchange): Promise<void>;
+    getSessionLog(sessionId: string): Promise<Exchange[]>;
+    getStats(): Promise<{
+        chunks: number;
+        sessions: number;
+        diskBytes: number;
+    }>;
+    close(): Promise<void>;
+    private chunkMappings;
+    private esRequest;
+}

package/dist/adapters/openclaw/storage.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenClawStorageAdapter = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+/**
+ * OpenSearch storage adapter for SmartContext.
+ * Stores chunks and metrics in OpenSearch indices on Castle VPS.
+ */
+class OpenClawStorageAdapter {
+    name = 'openclaw-opensearch';
+    baseUrl;
+    chunksIndex = 'smartcontext-chunks';
+    metricsIndex = 'smartcontext-metrics';
+    logsIndex = 'smartcontext-logs';
+    constructor(esUrl = 'http://localhost:9201') {
+        this.baseUrl = esUrl;
+    }
+    async initialize() {
+        // Create indices if they don't exist
+        for (const index of [this.chunksIndex, this.metricsIndex, this.logsIndex]) {
+            try {
+                await this.esRequest('PUT', `/${index}`, {
+                    settings: { number_of_shards: 1, number_of_replicas: 0 },
+                    mappings: index === this.chunksIndex ? this.chunkMappings() : undefined,
+                });
+            }
+            catch {
+                // Index may already exist
+            }
+        }
+    }
+    async upsertChunks(chunks) {
+        if (chunks.length === 0)
+            return;
+        const bulkBody = chunks.flatMap((c) => [
+            JSON.stringify({ index: { _index: this.chunksIndex, _id: c.id } }),
+            JSON.stringify({
+                text: c.text,
+                embedding: c.embedding,
+                sessionId: c.sessionId,
+                timestamp: c.timestamp,
+                summary: c.metadata.summary,
+                tokenCount: c.metadata.tokenCount,
+                exchangeIndex: c.metadata.exchangeIndex,
+                files: c.metadata.files,
+                tools: c.metadata.tools,
+            }),
+        ]).join('\n') + '\n';
+        await this.esRequest('POST', '/_bulk', bulkBody, 'application/x-ndjson');
+    }
+    async search(embedding, options) {
+        const query = {
+            size: options.topK,
+            query: {
+                script_score: {
+                    query: { match_all: {} },
+                    script: {
+                        source: "cosineSimilarity(params.query_vector, 'embedding') + 1.0",
+                        params: { query_vector: embedding },
+                    },
+                },
+            },
+        };
+        const result = await this.esRequest('POST', `/${this.chunksIndex}/_search`, query);
+        const parsed = JSON.parse(result);
+        return (parsed.hits?.hits || []).map((hit) => {
+            const source = hit._source;
+            let score = (hit._score - 1.0); // Remove the +1.0 offset
+            // Apply boosts
+            if (options.sessionBoost && source.sessionId === options.sessionBoost.sessionId) {
+                score += options.sessionBoost.boost;
+            }
+            if (options.fileBoost) {
+                const files = source.files || [];
+                if (options.fileBoost.patterns.some((p) => files.some((f) => f.includes(p)))) {
+                    score += options.fileBoost.boost;
+                }
+            }
+            return {
+                id: hit._id,
+                text: source.text,
+                embedding: [],
+                sessionId: source.sessionId,
+                timestamp: source.timestamp,
+                score,
+                metadata: {
+                    summary: source.summary,
+                    tokenCount: source.tokenCount,
+                    exchangeIndex: source.exchangeIndex,
+                    files: source.files,
+                    tools: source.tools,
+                },
+            };
+        }).filter((c) => c.score >= options.minScore);
+    }
+    async appendLog(sessionId, exchange) {
+        await this.esRequest('POST', `/${this.logsIndex}/_doc`, {
+            sessionId,
+            ...exchange,
+            indexedAt: new Date().toISOString(),
+        });
+    }
+    async getSessionLog(sessionId) {
+        const result = await this.esRequest('POST', `/${this.logsIndex}/_search`, {
+            size: 1000,
+            query: { term: { sessionId } },
+            sort: [{ timestamp: 'asc' }],
+        });
+        const parsed = JSON.parse(result);
+        return (parsed.hits?.hits || []).map((h) => h._source);
+    }
+    async getStats() {
+        try {
+            const result = await this.esRequest('GET', `/${this.chunksIndex}/_count`);
+            const parsed = JSON.parse(result);
+            return {
+                chunks: parsed.count || 0,
+                sessions: 0, // Would need aggregation
+                diskBytes: 0,
+            };
+        }
+        catch {
+            return { chunks: 0, sessions: 0, diskBytes: 0 };
+        }
+    }
+    async close() {
+        // No cleanup needed for HTTP client
+    }
+    chunkMappings() {
+        return {
+            properties: {
+                text: { type: 'text' },
+                embedding: { type: 'dense_vector', dims: 768 },
+                sessionId: { type: 'keyword' },
+                timestamp: { type: 'long' },
+                summary: { type: 'text' },
+                tokenCount: { type: 'integer' },
+                exchangeIndex: { type: 'integer' },
+                files: { type: 'keyword' },
+                tools: { type: 'keyword' },
+            },
+        };
+    }
+    esRequest(method, path, body, contentType) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`${this.baseUrl}${path}`);
+            const bodyStr = typeof body === 'string' ? body : body ? JSON.stringify(body) : undefined;
+            const req = node_http_1.default.request(url, {
+                method,
+                headers: {
+                    'Content-Type': contentType || 'application/json',
+                    ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr).toString() } : {}),
+                },
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 400) {
+                        reject(new Error(`ES ${method} ${path}: ${res.statusCode} ${data.slice(0, 200)}`));
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (bodyStr)
+                req.write(bodyStr);
+            req.end();
+        });
+    }
+}
+exports.OpenClawStorageAdapter = OpenClawStorageAdapter;
+//# sourceMappingURL=storage.js.map

package/dist/config/auto-detect.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderConfig, SmartContextConfig } from './schema.js';
+export declare function detectProviders(): Record<string, ProviderConfig>;
+export declare function buildConfig(overrides?: Partial<SmartContextConfig>): SmartContextConfig;

package/dist/config/auto-detect.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProviders = detectProviders;
+exports.buildConfig = buildConfig;
+const defaults_js_1 = require("./defaults.js");
+const PROVIDER_ENV_MAP = {
+    anthropic: {
+        envKey: 'ANTHROPIC_API_KEY',
+        baseUrl: 'https://api.anthropic.com',
+    },
+    openai: {
+        envKey: 'OPENAI_API_KEY',
+        baseUrl: 'https://api.openai.com',
+    },
+    google: {
+        envKey: 'GOOGLE_API_KEY',
+        baseUrl: 'https://generativelanguage.googleapis.com',
+    },
+    openrouter: {
+        envKey: 'OPENROUTER_API_KEY',
+        baseUrl: 'https://openrouter.ai/api',
+    },
+};
+function detectProviders() {
+    const providers = {};
+    for (const [name, { envKey, baseUrl }] of Object.entries(PROVIDER_ENV_MAP)) {
+        const apiKey = process.env[envKey];
+        if (apiKey) {
+            providers[name] = { apiKey, baseUrl };
+        }
+    }
+    // Ollama: detect by host, no API key needed
+    const ollamaHost = process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+    providers['ollama'] = { apiKey: '', baseUrl: ollamaHost };
+    return providers;
+}
+function buildConfig(overrides) {
+    const providers = detectProviders();
+    return {
+        ...defaults_js_1.DEFAULT_CONFIG,
+        providers,
+        ...overrides,
+        proxy: { ...defaults_js_1.DEFAULT_CONFIG.proxy, ...overrides?.proxy },
+        context: { ...defaults_js_1.DEFAULT_CONFIG.context, ...overrides?.context },
+        logging: { ...defaults_js_1.DEFAULT_CONFIG.logging, ...overrides?.logging },
+    };
+}
+//# sourceMappingURL=auto-detect.js.map

package/dist/config/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { SmartContextConfig } from './schema.js';
+export declare const DEFAULT_CONFIG: SmartContextConfig;