codehere 0.1.1 → 0.2.1

package/dist/infrastructure/observability/execution-tracer.js

@@ -6,12 +6,10 @@
  * Strategic: Critical for production reliability and debugging
  */
 import { randomUUID } from 'crypto';
-import { writeFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { getVersion } from '../../utils/version.js';
-// import { sanitizeForLogging } from '../security/input-validator.js'; // Function doesn't exist, removed
-import { getConfigManager } from '../config/config-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -22,10 +20,9 @@ export class ExecutionTracer {
     currentRun = null;
     tracesDir;
     constructor() {
-        // Store traces in data/traces/
-        const config = getConfigManager();
-        const dataDir = config.getDataDir();
-        this.tracesDir = join(dataDir, 'traces');
+        // Store traces in agent/data/traces/
+        const agentDir = join(__dirname, '../../..');
+        this.tracesDir = join(agentDir, 'data', 'traces');
         if (!existsSync(this.tracesDir)) {
             mkdirSync(this.tracesDir, { recursive: true });
         }
@@ -181,165 +178,9 @@ export class ExecutionTracer {
     }
     /**
      * Get current run ID
-     * Auto-creates a run if none exists to prevent null reference errors
      */
     getCurrentRunId() {
-        if (!this.currentRun) {
-            // Auto-create a run context if none exists
-            this.startRun('auto-run');
-        }
-        return this.currentRun.runId;
-    }
-    /**
-     * Export security audit trail for compliance
-     * P1 Security: Compliance-ready export formats
-     */
-    exportSecurityAuditTrail(options) {
-        const { format, startDate, endDate, includeInputs = false, includeOutputs = false, outputPath } = options;
-        // Collect all runs
-        const runs = [];
-        const files = readdirSync(this.tracesDir).filter(f => f.endsWith('.json'));
-        for (const file of files) {
-            try {
-                const run = this.getRun(file.replace('.json', ''));
-                if (!run)
-                    continue;
-                // Filter by date range if specified
-                if (startDate && run.startTime < startDate.getTime())
-                    continue;
-                if (endDate && run.startTime > endDate.getTime())
-                    continue;
-                runs.push(run);
-            }
-            catch {
-                // Skip invalid files
-            }
-        }
-        // Filter to security-relevant operations
-        const securityRuns = runs.filter(run => run.operation.includes('edit') ||
-            run.operation.includes('fix') ||
-            run.operation.includes('refactor') ||
-            run.traces.some(t => t.operationType === 'llm_call' ||
-                t.operationType === 'tool_invocation' ||
-                t.metadata?.injectionChecked ||
-                t.metadata?.securityScan));
-        // Generate export based on format
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const defaultPath = join(this.tracesDir, `security-audit-${timestamp}.${format}`);
-        const exportPath = outputPath || defaultPath;
-        if (format === 'json') {
-            const exportData = {
-                exportDate: new Date().toISOString(),
-                version: getVersion(),
-                totalRuns: securityRuns.length,
-                dateRange: {
-                    start: startDate?.toISOString(),
-                    end: endDate?.toISOString(),
-                },
-                runs: securityRuns.map(run => ({
-                    runId: run.runId,
-                    operation: run.operation,
-                    query: run.query,
-                    startTime: new Date(run.startTime).toISOString(),
-                    endTime: run.endTime ? new Date(run.endTime).toISOString() : undefined,
-                    duration: run.endTime ? run.endTime - run.startTime : undefined,
-                    traces: run.traces.map(trace => ({
-                        traceId: trace.traceId,
-                        operationType: trace.operationType,
-                        operationName: trace.operationName,
-                        timestamp: new Date(trace.timestamp).toISOString(),
-                        duration: trace.duration,
-                        error: trace.error,
-                        metadata: {
-                            ...trace.metadata,
-                            // Include security metadata
-                            injectionChecked: trace.metadata?.injectionChecked,
-                            securityScan: trace.metadata?.securityScan,
-                        },
-                        input: includeInputs ? trace.input : undefined,
-                        output: includeOutputs ? trace.output : undefined,
-                    })),
-                })),
-            };
-            writeFileSync(exportPath, JSON.stringify(exportData, null, 2), 'utf-8');
-        }
-        else if (format === 'jsonl') {
-            const lines = [];
-            for (const run of securityRuns) {
-                for (const trace of run.traces) {
-                    lines.push(JSON.stringify({
-                        runId: run.runId,
-                        operation: run.operation,
-                        query: run.query,
-                        traceId: trace.traceId,
-                        operationType: trace.operationType,
-                        operationName: trace.operationName,
-                        timestamp: new Date(trace.timestamp).toISOString(),
-                        duration: trace.duration,
-                        error: trace.error,
-                        metadata: trace.metadata,
-                        input: includeInputs ? trace.input : undefined,
-                        output: includeOutputs ? trace.output : undefined,
-                    }));
-                }
-            }
-            writeFileSync(exportPath, lines.join('\n'), 'utf-8');
-        }
-        else if (format === 'csv') {
-            const rows = [];
-            // CSV header
-            rows.push('runId,operation,query,traceId,operationType,operationName,timestamp,duration,error,injectionChecked,securityScan,model,temperature');
-            for (const run of securityRuns) {
-                for (const trace of run.traces) {
-                    const row = [
-                        run.runId,
-                        run.operation || '',
-                        (run.query || '').replace(/,/g, ';'), // Escape commas
-                        trace.traceId,
-                        trace.operationType,
-                        trace.operationName,
-                        new Date(trace.timestamp).toISOString(),
-                        trace.duration?.toString() || '',
-                        trace.error?.message || '',
-                        trace.metadata?.injectionChecked ? 'true' : 'false',
-                        trace.metadata?.securityScan ? 'true' : 'false',
-                        trace.metadata?.model || '',
-                        trace.metadata?.temperature?.toString() || '',
-                    ].map(field => `"${String(field).replace(/"/g, '""')}"`); // CSV escape
-                    rows.push(row.join(','));
-                }
-            }
-            writeFileSync(exportPath, rows.join('\n'), 'utf-8');
-        }
-        return exportPath;
-    }
-    /**
-     * List all runs (for audit trail export)
-     */
-    listAllRuns() {
-        const runs = [];
-        const files = readdirSync(this.tracesDir).filter(f => f.endsWith('.json'));
-        for (const file of files) {
-            try {
-                const run = this.getRun(file.replace('.json', ''));
-                if (run) {
-                    runs.push({
-                        runId: run.runId,
-                        operation: run.operation,
-                        timestamp: run.startTime,
-                        traceCount: run.traces.length,
-                    });
-                }
-            }
-            catch (err) {
-                // Skip invalid/corrupted files silently (common during development)
-                // Log only in debug mode to avoid noise
-                if (process.env.DEBUG) {
-                    console.warn(`Skipping corrupted trace file: ${file}`, err instanceof Error ? err.message : String(err));
-                }
-            }
-        }
-        return runs.sort((a, b) => b.timestamp - a.timestamp);
+        return this.currentRun?.runId || null;
     }
     /**
      * Sanitize input for storage (remove sensitive data, large objects)
@@ -381,20 +222,6 @@ export class ExecutionTracer {
         return output;
     }
 }
-// Singleton instance - Lazy-loaded to prevent synchronous file system operations during module import
-// This prevents CLI startup hang (same pattern as dependency-container.ts)
-let _executionTracerInstance;
-export const executionTracer = new Proxy({}, {
-    get(_target, prop) {
-        if (!_executionTracerInstance) {
-            _executionTracerInstance = new ExecutionTracer();
-        }
-        const value = _executionTracerInstance[prop];
-        // Bind methods to the instance to preserve 'this' context
-        if (typeof value === 'function') {
-            return value.bind(_executionTracerInstance);
-        }
-        return value;
-    }
-});
+// Singleton instance
+export const executionTracer = new ExecutionTracer();
 //# sourceMappingURL=execution-tracer.js.map

package/dist/infrastructure/protocols/mcp-helpers.js

@@ -0,0 +1,45 @@
+/**
+ * MCP helper functions — shared between MCP server and trust command.
+ * Extracted to avoid circular imports.
+ */
+import { readFileSync, statSync, readdirSync } from 'fs';
+import { join, extname } from 'path';
+// ── File collection ──────────────────────────────────────────────────────────
+const CODE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rb', '.go', '.java', '.cs', '.php',
+    '.sh', '.bash', '.zsh',
+    '.sql', '.html', '.vue', '.svelte',
+]);
+const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', '.codehere', '.codehere-cache']);
+export function collectFilesForMCP(target) {
+    const result = [];
+    function walk(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (CODE_EXTENSIONS.has(extname(entry.name))) {
+                try {
+                    result.push({ filepath: full, code: readFileSync(full, 'utf-8') });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    const stat = statSync(target);
+    if (stat.isFile()) {
+        return [{ filepath: target, code: readFileSync(target, 'utf-8') }];
+    }
+    walk(target);
+    return result;
+}
+// ── Scoring ──────────────────────────────────────────────────────────────────
+// Re-export score function using the shared scorer
+export { scoreFile as scoreFileForMCP } from '../security/trust-scorer.js';
+//# sourceMappingURL=mcp-helpers.js.map

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -0,0 +1,286 @@
+/**
+ * codehere MCP Server — Working Implementation
+ *
+ * Starts an HTTP server that speaks the Model Context Protocol.
+ * Exposes codehere's trust scanning tools to any MCP-compatible client:
+ * Claude Desktop, Cursor, Zed, Continue, Cline, and any agent that supports MCP.
+ *
+ * Tools exposed:
+ *   - codehere_trust    — score a file or code snippet (Layer 0, no API)
+ *   - codehere_scan     — scan an instruction/text for injection/threats
+ *   - codehere_review   — list findings for a codebase path
+ *   - codehere_audit    — read recent hook audit log entries
+ *
+ * Protocol: MCP over HTTP+SSE (Model Context Protocol Spec 2024-11)
+ * Authentication: Bearer token (optional, configurable)
+ *
+ * Usage:
+ *   codehere serve              # start on port 3773
+ *   codehere serve --port 8080  # custom port
+ */
+import http from 'http';
+import { readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
+import { scanPayload, calculateRiskScore } from '../hooks/claude-sdk-hook.js';
+// ── Tool definitions ─────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: 'codehere_trust',
+        description: 'Scan a file or code snippet for security vulnerabilities. Returns a trust score 0-100, grade, and plain-English findings. Zero API calls — runs entirely locally.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filepath: { type: 'string', description: 'Path to file (relative to cwd)' },
+                code: { type: 'string', description: 'Code content to scan (alternative to filepath)' },
+                verbose: { type: 'boolean', description: 'Include all findings with line numbers' },
+            },
+        },
+    },
+    {
+        name: 'codehere_scan',
+        description: 'Scan an instruction, prompt, or command text for injection attacks, credential theft attempts, destructive operations, and other threats. Returns block/allow decision with findings.',
+        inputSchema: {
+            type: 'object',
+            required: ['text'],
+            properties: {
+                text: { type: 'string', description: 'Text to scan (instruction, prompt, command)' },
+            },
+        },
+    },
+    {
+        name: 'codehere_review',
+        description: 'Review all files in a directory and return trust scores. Identifies the riskiest files to focus review effort.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path (default: current directory)' },
+                topN: { type: 'number', description: 'Return top N riskiest files (default: 10)' },
+            },
+        },
+    },
+    {
+        name: 'codehere_audit',
+        description: 'Read recent hook audit log entries — shows which tool calls codehere blocked or allowed in Claude Code sessions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Number of recent entries to return (default: 20)' },
+                blockedOnly: { type: 'boolean', description: 'Only return blocked events' },
+            },
+        },
+    },
+];
+// ── Tool handlers ────────────────────────────────────────────────────────────
+import { homedir } from 'os';
+const AUDIT_FILE_PATH = join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
+function handleTrust(params) {
+    const { filepath, code, verbose } = params;
+    let content;
+    let label;
+    if (code) {
+        content = code;
+        label = 'provided code';
+    }
+    else if (filepath) {
+        const resolved = join(process.cwd(), filepath);
+        if (!existsSync(resolved)) {
+            return JSON.stringify({ error: `File not found: ${filepath}` });
+        }
+        content = readFileSync(resolved, 'utf-8');
+        label = filepath;
+    }
+    else {
+        return JSON.stringify({ error: 'Provide either filepath or code' });
+    }
+    const result = scoreFileForMCP(label, content);
+    if (!verbose) {
+        // Compact response
+        return JSON.stringify({
+            score: result.score,
+            grade: result.grade,
+            summary: result.summary,
+            criticalCount: result.findings.filter(f => f.severity === 'critical').length,
+            highCount: result.findings.filter(f => f.severity === 'high').length,
+            recommendation: result.score >= 75
+                ? 'Safe — minor issues can be addressed in follow-up'
+                : result.score >= 60
+                    ? 'Review recommended before merge'
+                    : 'Block — resolve critical/high findings first',
+        });
+    }
+    return JSON.stringify(result, null, 2);
+}
+function handleScan(params) {
+    const text = String(params.text ?? '');
+    const findings = scanPayload(text);
+    const riskScore = calculateRiskScore(findings);
+    const criticalFindings = findings.filter(f => f.severity === 'critical');
+    const blocked = criticalFindings.length > 0 || riskScore >= 60;
+    return JSON.stringify({
+        blocked,
+        riskScore,
+        decision: blocked ? 'block' : 'allow',
+        reason: blocked
+            ? criticalFindings.length > 0
+                ? `${criticalFindings[0].category}: ${criticalFindings[0].description}`
+                : `Risk score ${riskScore}/100 exceeds threshold`
+            : 'No threats detected',
+        findings: findings.slice(0, 10), // cap at 10 to keep response small
+    });
+}
+function handleReview(params) {
+    const targetPath = String(params.path ?? process.cwd());
+    const topN = Number(params.topN ?? 10);
+    try {
+        const files = collectFilesForMCP(targetPath);
+        if (files.length === 0) {
+            return JSON.stringify({ message: 'No code files found', path: targetPath });
+        }
+        const results = files.map(f => scoreFileForMCP(relative(targetPath, f.filepath), f.code));
+        results.sort((a, b) => a.score - b.score); // worst first
+        const top = results.slice(0, topN);
+        const overallScore = Math.round(results.reduce((s, r) => s + r.score, 0) / results.length);
+        return JSON.stringify({
+            overallScore,
+            grade: overallScore >= 90 ? 'A' : overallScore >= 75 ? 'B' : overallScore >= 60 ? 'C' : overallScore >= 40 ? 'D' : 'F',
+            totalFiles: results.length,
+            riskiestFiles: top.map(r => ({
+                filepath: r.filepath,
+                score: r.score,
+                grade: r.grade,
+                summary: r.summary,
+                criticalCount: r.findings.filter(f => f.severity === 'critical').length,
+                highCount: r.findings.filter(f => f.severity === 'high').length,
+            })),
+        });
+    }
+    catch (e) {
+        return JSON.stringify({ error: String(e) });
+    }
+}
+function handleAudit(params) {
+    const limit = Number(params.limit ?? 20);
+    const blockedOnly = Boolean(params.blockedOnly);
+    if (!existsSync(AUDIT_FILE_PATH)) {
+        return JSON.stringify({ message: 'No audit log yet — install hooks first with: codehere hook install', entries: [] });
+    }
+    const lines = readFileSync(AUDIT_FILE_PATH, 'utf-8')
+        .split('\n')
+        .filter(Boolean)
+        .slice(-Math.min(limit * 3, 500)); // read more than needed to account for filter
+    const entries = lines
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter(Boolean)
+        .filter((e) => !blockedOnly || e.blocked)
+        .slice(-limit);
+    return JSON.stringify({ entries, total: entries.length });
+}
+// ── JSON-RPC dispatcher ──────────────────────────────────────────────────────
+function dispatch(req) {
+    const id = req.id;
+    const params = (req.params ?? {});
+    try {
+        switch (req.method) {
+            case 'initialize':
+                return {
+                    jsonrpc: '2.0', id,
+                    result: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: { tools: {} },
+                        serverInfo: { name: 'codehere', version: '0.2.0' },
+                    },
+                };
+            case 'tools/list':
+                return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+            case 'tools/call': {
+                const toolName = String(params.name ?? '');
+                const toolParams = (params.arguments ?? {});
+                let content;
+                switch (toolName) {
+                    case 'codehere_trust':
+                        content = handleTrust(toolParams);
+                        break;
+                    case 'codehere_scan':
+                        content = handleScan(toolParams);
+                        break;
+                    case 'codehere_review':
+                        content = handleReview(toolParams);
+                        break;
+                    case 'codehere_audit':
+                        content = handleAudit(toolParams);
+                        break;
+                    default:
+                        return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${toolName}` } };
+                }
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: content }] },
+                };
+            }
+            case 'ping':
+                return { jsonrpc: '2.0', id, result: {} };
+            default:
+                return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${req.method}` } };
+        }
+    }
+    catch (e) {
+        return { jsonrpc: '2.0', id, error: { code: -32603, message: String(e) } };
+    }
+}
+export function startMCPServer(options = {}) {
+    const port = options.port ?? 3773;
+    const host = options.host ?? '127.0.0.1'; // localhost only by default
+    const token = options.token;
+    const server = http.createServer((req, res) => {
+        // Auth check
+        if (token) {
+            const authHeader = req.headers.authorization ?? '';
+            if (authHeader !== `Bearer ${token}`) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+        }
+        // Health check
+        if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', server: 'codehere-mcp', version: '0.2.0', tools: TOOLS.length }));
+            return;
+        }
+        // MCP endpoint
+        if (req.method === 'POST' && req.url === '/mcp') {
+            let body = '';
+            req.on('data', chunk => { body += chunk; });
+            req.on('end', () => {
+                try {
+                    const mcpReq = JSON.parse(body);
+                    const mcpRes = dispatch(mcpReq);
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Allow-Origin': 'http://localhost',
+                    });
+                    res.end(JSON.stringify(mcpRes));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+            });
+            return;
+        }
+        // 404
+        res.writeHead(404);
+        res.end();
+    });
+    server.listen(port, host, () => {
+        // server started
+    });
+    return server;
+}
+//# sourceMappingURL=mcp-server-impl.js.map

package/dist/infrastructure/providers/cohere-provider.js

@@ -13,8 +13,6 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { encoding_for_model } from 'tiktoken';
 import { retryWithBackoff, cohereCircuitBreaker } from '../../error-handler.js';
-import { sessionTokenTracker } from '../cost/session-token-tracker.js';
-import { getConfigManager } from '../config/config-manager.js';
 // Load .env (same pattern as CohereAIService)
 try {
     const __filename = fileURLToPath(import.meta.url);
@@ -167,13 +165,13 @@ export class CohereProvider {
         ];
     }
     getDefaultModel() {
-        // Check for environment variable override (highest priority)
+        // Check for environment variable override
         if (process.env.CODEHERE_COHERE_MODEL) {
             return process.env.CODEHERE_COHERE_MODEL;
         }
-        // Use ConfigManager for default model
-        const config = getConfigManager();
-        return config.getModel('chat') || config.getModel('default') || config.getPreference('defaultModel') || 'command-r-08-2024';
+        // Use command-r-08-2024 as default (command-r and command-r-plus were deprecated Sept 2025)
+        // Available live models: command-r-08-2024, command-r-plus-08-2024, command-a-03-2025, command-r7b-12-2024
+        return 'command-r-08-2024';
     }
     async chat(prompt, options) {
         const model = options?.model || this.getDefaultModel();
@@ -188,13 +186,6 @@ export class CohereProvider {
                 const text = response.text || 'No response generated';
                 const inputTokens = countTokens(prompt);
                 const outputTokens = countTokens(text);
-                // Track tokens for session cost display
-                sessionTokenTracker.record({
-                    operation: 'chat',
-                    model: model || 'command-r',
-                    inputTokens,
-                    outputTokens,
-                });
                 return {
                     text,
                     model: model || 'default',
@@ -258,13 +249,6 @@ export class CohereProvider {
             }
             const inputTokens = countTokens(prompt);
             const outputTokens = countTokens(fullText);
-            // Track tokens for session cost display
-            sessionTokenTracker.record({
-                operation: 'chat-stream',
-                model: model || 'command-r',
-                inputTokens,
-                outputTokens,
-            });
             return {
                 text: fullText,
                 model: model || 'default',
@@ -293,14 +277,6 @@ export class CohereProvider {
                     model: 'embed-english-v3.0',
                     inputType: 'search_document',
                 });
-                // Track tokens for session cost display
-                const inputTokens = texts.reduce((sum, t) => sum + countTokens(t), 0);
-                sessionTokenTracker.record({
-                    operation: 'embed',
-                    model: 'embed-english-v3.0',
-                    inputTokens,
-                    outputTokens: 0,
-                });
                 const embeddings = response.embeddings;
                 if (texts.length === 1) {
                     return embeddings[0];
@@ -388,11 +364,9 @@ export class CohereProvider {
         try {
             // Actually test API connectivity with a minimal API call
             // getModels() doesn't make an API call, so we need to test with a real endpoint
-            const config = getConfigManager();
-            const testModel = config.getModel('chat') || config.getModel('default') || 'command-r-08-2024';
             const response = await this.client.chat({
                 message: 'test',
-                model: testModel,
+                model: 'command-r-08-2024',
                 maxTokens: 1,
             });
             return true;

package/dist/infrastructure/providers/fake-provider.js

@@ -5,7 +5,6 @@
  * Phase 4D: FakeProvider Implementation
  * Provides deterministic outputs for testing and local demos without external API calls
  */
-import { sessionTokenTracker } from '../cost/session-token-tracker.js';
 /**
  * FakeProvider
  * Deterministic provider for testing and demos
@@ -52,13 +51,6 @@ export class FakeProvider {
         // Simple token counting (character-based estimate)
         const inputTokens = Math.ceil(prompt.length / 4);
         const outputTokens = Math.ceil(text.length / 4);
-        // Track tokens for session cost display (even in fake mode for consistency)
-        sessionTokenTracker.record({
-            operation: 'chat',
-            model: 'fake-model-v1',
-            inputTokens,
-            outputTokens,
-        });
         return {
             text,
             model: options?.model || this.defaultModel,

package/dist/infrastructure/providers/local-llm-provider.js

@@ -7,21 +7,15 @@
  */
 import { retryWithBackoff } from '../../error-handler.js';
 import { encoding_for_model } from 'tiktoken';
-import { getConfigManager } from '../config/config-manager.js';
 // Token counting (tiktoken for OpenAI-compatible models)
 let tokenEncoder = null;
 function getTokenEncoder() {
     if (!tokenEncoder) {
         try {
-            // Use default model from config for token encoding
-            const config = getConfigManager();
-            const defaultModel = config.getModel('default') || config.getPreference('defaultModel') || 'gpt-3.5-turbo';
-            // Map to OpenAI model for tiktoken (tiktoken uses OpenAI models)
-            const tiktokenModel = defaultModel.includes('gpt') ? defaultModel : 'gpt-3.5-turbo';
-            tokenEncoder = encoding_for_model(tiktokenModel);
+            tokenEncoder = encoding_for_model('gpt-3.5-turbo'); // OpenAI-compatible encoding
         }
         catch {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo');
+            tokenEncoder = encoding_for_model('gpt-4'); // Fallback
         }
     }
     return tokenEncoder;