morpheus-cli 0.1.4 → 0.1.6

package/dist/runtime/memory/sqlite.js

@@ -1,5 +1,5 @@
 import { BaseListChatMessageHistory } from "@langchain/core/chat_history";
-import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
+import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 import Database from "better-sqlite3";
 import * as fs from "fs-extra";
 import * as path from "path";
@@ -8,9 +8,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     lc_namespace = ["langchain", "stores", "message", "sqlite"];
     db;
     sessionId;
+    limit;
     constructor(fields) {
         super();
         this.sessionId = fields.sessionId;
+        this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
         const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
         // Ensure the directory exists
@@ -80,36 +82,115 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
           session_id TEXT NOT NULL,
           type TEXT NOT NULL,
           content TEXT NOT NULL,
-          created_at INTEGER NOT NULL
+          created_at INTEGER NOT NULL,
+          input_tokens INTEGER,
+          output_tokens INTEGER,
+          total_tokens INTEGER,
+          cache_read_tokens INTEGER
         );
         
         CREATE INDEX IF NOT EXISTS idx_messages_session_id 
         ON messages(session_id);
       `);
+            this.migrateTable();
         }
         catch (error) {
             throw new Error(`Failed to create messages table: ${error}`);
         }
     }
+    /**
+     * Checks for missing columns and adds them if necessary.
+     */
+    migrateTable() {
+        try {
+            const tableInfo = this.db.pragma('table_info(messages)');
+            const columns = new Set(tableInfo.map(c => c.name));
+            const newColumns = [
+                'input_tokens',
+                'output_tokens',
+                'total_tokens',
+                'cache_read_tokens'
+            ];
+            for (const col of newColumns) {
+                if (!columns.has(col)) {
+                    try {
+                        this.db.exec(`ALTER TABLE messages ADD COLUMN ${col} INTEGER`);
+                    }
+                    catch (e) {
+                        // Ignore error if column already exists (race condition or check failed)
+                        console.warn(`[SQLite] Failed to add column ${col}: ${e}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[SQLite] Migration check failed: ${error}`);
+        }
+    }
     /**
      * Retrieves all messages for the current session from the database.
      * @returns Promise resolving to an array of BaseMessage objects
      */
     async getMessages() {
         try {
-            const stmt = this.db.prepare("SELECT type, content FROM messages WHERE session_id = ? ORDER BY id ASC");
-            const rows = stmt.all(this.sessionId);
+            // Fetch new columns
+            const stmt = this.db.prepare("SELECT type, content, input_tokens, output_tokens, total_tokens, cache_read_tokens FROM messages WHERE session_id = ? ORDER BY id ASC LIMIT ?");
+            const rows = stmt.all(this.sessionId, this.limit);
             return rows.map((row) => {
+                let msg;
+                // Reconstruct usage metadata if present
+                const usage_metadata = row.total_tokens != null ? {
+                    input_tokens: row.input_tokens || 0,
+                    output_tokens: row.output_tokens || 0,
+                    total_tokens: row.total_tokens || 0,
+                    input_token_details: row.cache_read_tokens ? { cache_read: row.cache_read_tokens } : undefined
+                } : undefined;
                 switch (row.type) {
                     case "human":
-                        return new HumanMessage(row.content);
+                        msg = new HumanMessage(row.content);
+                        break;
                     case "ai":
-                        return new AIMessage(row.content);
+                        try {
+                            // Attempt to parse structured content (for tool calls)
+                            const parsed = JSON.parse(row.content);
+                            if (parsed && typeof parsed === 'object' && Array.isArray(parsed.tool_calls)) {
+                                msg = new AIMessage({
+                                    content: parsed.text || "",
+                                    tool_calls: parsed.tool_calls
+                                });
+                            }
+                            else {
+                                msg = new AIMessage(row.content);
+                            }
+                        }
+                        catch {
+                            // Fallback for legacy text-only messages
+                            msg = new AIMessage(row.content);
+                        }
+                        break;
                     case "system":
-                        return new SystemMessage(row.content);
+                        msg = new SystemMessage(row.content);
+                        break;
+                    case "tool":
+                        try {
+                            const parsed = JSON.parse(row.content);
+                            msg = new ToolMessage({
+                                content: parsed.content,
+                                tool_call_id: parsed.tool_call_id || 'unknown',
+                                name: parsed.name
+                            });
+                        }
+                        catch {
+                            msg = new ToolMessage({ content: row.content, tool_call_id: 'unknown' });
+                        }
+                        break;
                     default:
                         throw new Error(`Unknown message type: ${row.type}`);
                 }
+                if (usage_metadata) {
+                    msg.usage_metadata = usage_metadata;
+                }
+                return msg;
             });
         }
         catch (error) {
@@ -136,14 +217,50 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             else if (message instanceof SystemMessage) {
                 type = "system";
             }
+            else if (message instanceof ToolMessage) {
+                type = "tool";
+            }
             else {
                 throw new Error(`Unsupported message type: ${message.constructor.name}`);
             }
             const content = typeof message.content === "string"
                 ? message.content
                 : JSON.stringify(message.content);
-            const stmt = this.db.prepare("INSERT INTO messages (session_id, type, content, created_at) VALUES (?, ?, ?, ?)");
-            stmt.run(this.sessionId, type, content, Date.now());
+            // Extract usage metadata
+            // 1. Try generic usage_metadata (LangChain standard)
+            // 2. Try extraUsage (passed via some adapters) - attached to additional_kwargs usually, but we might pass it differently
+            // The Spec says we might pass it to chat(), but addMessage receives a BaseMessage. 
+            // So we should expect usage to be on the message object properties.
+            const anyMsg = message;
+            const usage = anyMsg.usage_metadata || anyMsg.response_metadata?.usage || anyMsg.response_metadata?.tokenUsage || anyMsg.usage;
+            const inputTokens = usage?.input_tokens ?? null;
+            const outputTokens = usage?.output_tokens ?? null;
+            const totalTokens = usage?.total_tokens ?? null;
+            const cacheReadTokens = usage?.input_token_details?.cache_read ?? usage?.cache_read_tokens ?? null;
+            // Handle special content serialization for Tools
+            let finalContent = "";
+            if (type === 'ai' && (message.tool_calls?.length ?? 0) > 0) {
+                // Serialize tool calls with content
+                finalContent = JSON.stringify({
+                    text: message.content,
+                    tool_calls: message.tool_calls
+                });
+            }
+            else if (type === 'tool') {
+                const tm = message;
+                finalContent = JSON.stringify({
+                    content: tm.content,
+                    tool_call_id: tm.tool_call_id,
+                    name: tm.name
+                });
+            }
+            else {
+                finalContent = typeof message.content === "string"
+                    ? message.content
+                    : JSON.stringify(message.content);
+            }
+            const stmt = this.db.prepare("INSERT INTO messages (session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+            stmt.run(this.sessionId, type, finalContent, Date.now(), inputTokens, outputTokens, totalTokens, cacheReadTokens);
         }
         catch (error) {
             // Check for specific SQLite errors
@@ -161,6 +278,22 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to add message: ${error}`);
         }
     }
+    /**
+     * Retrieves aggregated usage statistics for all messages in the database.
+     */
+    async getGlobalUsageStats() {
+        try {
+            const stmt = this.db.prepare("SELECT SUM(input_tokens) as totalInput, SUM(output_tokens) as totalOutput FROM messages");
+            const row = stmt.get();
+            return {
+                totalInputTokens: row.totalInput || 0,
+                totalOutputTokens: row.totalOutput || 0
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get usage stats: ${error}`);
+        }
+    }
     /**
      * Clears all messages for the current session from the database.
      */

package/dist/runtime/providers/factory.js

@@ -3,38 +3,82 @@ import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOllama } from "@langchain/ollama";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ProviderError } from "../errors.js";
+import { createAgent, createMiddleware } from "langchain";
+// import { MultiServerMCPClient, } from "@langchain/mcp-adapters"; // REMOVED
+import { z } from "zod";
+import { DisplayManager } from "../display.js";
+import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool } from "../tools/index.js";
 export class ProviderFactory {
-    static create(config) {
+    static async create(config, tools = []) {
+        let display = DisplayManager.getInstance();
+        const toolMonitoringMiddleware = createMiddleware({
+            name: "ToolMonitoringMiddleware",
+            wrapToolCall: (request, handler) => {
+                display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ToolCall' });
+                display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ToolCall' });
+                try {
+                    const result = handler(request);
+                    display.log("Tool completed successfully", { level: "info", source: 'ToolCall' });
+                    return result;
+                }
+                catch (e) {
+                    display.log(`Tool failed: ${e}`, { level: "error", source: 'ToolCall' });
+                    throw e;
+                }
+            },
+        });
+        let model;
+        const responseSchema = z.object({
+            content: z.string().describe("The main response content from the agent"),
+        });
+        // Removed direct MCP client instantiation
         try {
             switch (config.provider) {
                 case 'openai':
-                    return new ChatOpenAI({
+                    model = new ChatOpenAI({
                         modelName: config.model,
                         temperature: config.temperature,
                         apiKey: config.api_key, // LangChain will also check process.env.OPENAI_API_KEY
                     });
+                    break;
                 case 'anthropic':
-                    return new ChatAnthropic({
+                    model = new ChatAnthropic({
                         modelName: config.model,
                         temperature: config.temperature,
                         apiKey: config.api_key,
                     });
+                    break;
                 case 'ollama':
                     // Ollama usually runs locally, api_key optional
-                    return new ChatOllama({
+                    model = new ChatOllama({
                         model: config.model,
                         temperature: config.temperature,
                         baseUrl: config.api_key, // Sometimes users might overload api_key for base URL or similar, but simplified here
                     });
+                    break;
                 case 'gemini':
-                    return new ChatGoogleGenerativeAI({
+                    model = new ChatGoogleGenerativeAI({
                         model: config.model,
                         temperature: config.temperature,
-                        apiKey: config.api_key,
+                        apiKey: config.api_key
                     });
+                    break;
                 default:
                     throw new Error(`Unsupported provider: ${config.provider}`);
             }
+            const toolsForAgent = [
+                ...tools,
+                ConfigQueryTool,
+                ConfigUpdateTool,
+                DiagnosticTool,
+                MessageCountTool,
+                TokenUsageTool
+            ];
+            return createAgent({
+                model: model,
+                tools: toolsForAgent,
+                middleware: [toolMonitoringMiddleware]
+            });
         }
         catch (error) {
             let suggestion = "Check your configuration and API keys.";

package/dist/runtime/scaffold.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import { PATHS } from '../config/paths.js';
 import { ConfigManager } from '../config/manager.js';
+import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
 import chalk from 'chalk';
 import ora from 'ora';
 export async function scaffold() {
@@ -22,6 +23,10 @@ export async function scaffold() {
         else {
             await configManager.load(); // Load if exists (although load handles existence check too)
         }
+        // Create mcps.json if not exists
+        if (!(await fs.pathExists(PATHS.mcps))) {
+            await fs.writeJson(PATHS.mcps, DEFAULT_MCP_TEMPLATE, { spaces: 2 });
+        }
         spinner.succeed('Morpheus environment ready at ' + chalk.cyan(PATHS.root));
     }
     catch (error) {

package/dist/runtime/tools/__tests__/factory.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ToolsFactory } from '../factory.js';
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+vi.mock("@langchain/mcp-adapters", () => {
+    return {
+        MultiServerMCPClient: vi.fn(),
+    };
+});
+vi.mock("../../display.js", () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        })
+    }
+}));
+describe('ToolsFactory', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should create tools successfully', async () => {
+        const mockGetTools = vi.fn().mockResolvedValue(['tool1', 'tool2']);
+        // Mock the constructor and getTools method
+        MultiServerMCPClient.mockImplementation(function () {
+            return {
+                getTools: mockGetTools
+            };
+        });
+        const tools = await ToolsFactory.create();
+        expect(MultiServerMCPClient).toHaveBeenCalled();
+        expect(mockGetTools).toHaveBeenCalled();
+        expect(tools).toEqual(['tool1', 'tool2']);
+    });
+    it('should return empty array on failure', async () => {
+        MultiServerMCPClient.mockImplementation(function () {
+            return {
+                getTools: vi.fn().mockRejectedValue(new Error('MCP Failed'))
+            };
+        });
+        const tools = await ToolsFactory.create();
+        expect(tools).toEqual([]);
+    });
+});

package/dist/runtime/tools/__tests__/tools.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ConfigQueryTool, ConfigUpdateTool } from '../config-tools.js';
+import { DiagnosticTool } from '../diagnostic-tools.js';
+import { MessageCountTool, TokenUsageTool } from '../analytics-tools.js';
+import { ConfigManager } from '../../../config/manager.js';
+// Mock the ConfigManager for testing
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn(() => ({
+            load: vi.fn(async () => ({
+                llm: { provider: 'openai', model: 'gpt-4' },
+                logging: { enabled: true, level: 'info' },
+                ui: { enabled: true, port: 3000 }
+            })),
+            get: vi.fn(() => ({
+                llm: { provider: 'openai', model: 'gpt-4' },
+                logging: { enabled: true, level: 'info' },
+                ui: { enabled: true, port: 3000 }
+            })),
+            save: vi.fn(async (newConfig) => {
+                // Mock save implementation
+            })
+        }))
+    }
+}));
+describe('Config Tools', () => {
+    describe('ConfigQueryTool', () => {
+        it('should query all configuration values when no key is provided', async () => {
+            const result = await ConfigQueryTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('llm');
+            expect(parsedResult).toHaveProperty('logging');
+            expect(parsedResult).toHaveProperty('ui');
+        });
+        it('should query specific configuration value when key is provided', async () => {
+            const result = await ConfigQueryTool.invoke({ key: 'llm' });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('llm');
+            const llmConfig = parsedResult.llm;
+            expect(llmConfig).toHaveProperty('provider');
+            expect(llmConfig).toHaveProperty('model');
+        });
+    });
+    describe('ConfigUpdateTool', () => {
+        it('should update configuration values', async () => {
+            const updates = { 'ui.port': 4000 };
+            const result = await ConfigUpdateTool.invoke({ updates });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('success', true);
+        });
+        it('should return error when update fails', async () => {
+            // Create a new mock instance for this specific test
+            const originalGetInstance = ConfigManager.getInstance;
+            const mockGetInstance = vi.fn(() => ({
+                load: vi.fn(async () => ({
+                    llm: { provider: 'openai', model: 'gpt-4' },
+                    logging: { enabled: true, level: 'info' },
+                    ui: { enabled: true, port: 3000 }
+                })),
+                get: vi.fn(() => ({
+                    llm: { provider: 'openai', model: 'gpt-4' },
+                    logging: { enabled: true, level: 'info' },
+                    ui: { enabled: true, port: 3000 }
+                })),
+                save: vi.fn(async () => {
+                    throw new Error('Save failed');
+                })
+            }));
+            // Replace the getInstance method temporarily
+            ConfigManager.getInstance = mockGetInstance;
+            const updates = { 'invalid.field': 'value' };
+            const result = await ConfigUpdateTool.invoke({ updates });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('error');
+            // Restore the original method
+            ConfigManager.getInstance = originalGetInstance;
+        });
+    });
+});
+describe('DiagnosticTool', () => {
+    it('should return a diagnostic report with component statuses', async () => {
+        const result = await DiagnosticTool.invoke({});
+        const parsedResult = JSON.parse(result);
+        expect(parsedResult).toHaveProperty('timestamp');
+        expect(parsedResult).toHaveProperty('components');
+        expect(parsedResult.components).toHaveProperty('config');
+        expect(parsedResult.components).toHaveProperty('storage');
+        expect(parsedResult.components).toHaveProperty('network');
+        expect(parsedResult.components).toHaveProperty('agent');
+    });
+});
+describe('Analytics Tools', () => {
+    // Note: These tools now use the existing SQLite class and access the database
+    describe('MessageCountTool', () => {
+        it('should return message count', async () => {
+            const result = await MessageCountTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            // Should return a number (message count) or an error if database doesn't exist
+            if (typeof parsedResult === 'object' && parsedResult.error) {
+                // If there's an error (e.g., database doesn't exist), that's acceptable in test environment
+                expect(parsedResult).toHaveProperty('error');
+            }
+            else {
+                // Otherwise, should return a number
+                expect(typeof parsedResult).toBe('number');
+            }
+        });
+    });
+    describe('TokenUsageTool', () => {
+        it('should return token usage statistics', async () => {
+            const result = await TokenUsageTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            // Should return token statistics or an error if database doesn't exist
+            if (typeof parsedResult === 'object' && parsedResult.error) {
+                // If there's an error (e.g., database doesn't exist), that's acceptable in test environment
+                expect(parsedResult).toHaveProperty('error');
+            }
+            else {
+                // Otherwise, should return token statistics
+                expect(parsedResult).toHaveProperty('totalTokens');
+                expect(parsedResult).toHaveProperty('inputTokens');
+                expect(parsedResult).toHaveProperty('outputTokens');
+                expect(parsedResult).toHaveProperty('timestamp');
+            }
+        });
+    });
+});

package/dist/runtime/tools/analytics-tools.js

@@ -0,0 +1,73 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import path from "path";
+import Database from "better-sqlite3";
+import { homedir } from "os";
+// Tool for querying message counts from the database
+const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+export const MessageCountTool = tool(async ({ timeRange }) => {
+    try {
+        // Connect to database
+        const db = new Database(dbPath);
+        let query = "SELECT COUNT(*) as count FROM messages";
+        const params = [];
+        if (timeRange) {
+            query += " WHERE timestamp BETWEEN ? AND ?";
+            params.push(timeRange.start);
+            params.push(timeRange.end);
+        }
+        const result = db.prepare(query).get(params);
+        db.close();
+        return JSON.stringify(result.count);
+    }
+    catch (error) {
+        console.error("Error in MessageCountTool:", error);
+        return JSON.stringify({ error: `Failed to count messages: ${error.message}` });
+    }
+}, {
+    name: "message_count",
+    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    schema: z.object({
+        timeRange: z.object({
+            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+        }).optional(),
+    }),
+});
+// Tool for querying token usage statistics from the database
+export const TokenUsageTool = tool(async ({ timeRange }) => {
+    try {
+        // Connect to database
+        const db = new Database(dbPath);
+        let query = "SELECT SUM(input_tokens) as inputTokens, SUM(output_tokens) as outputTokens, SUM(input_tokens + output_tokens) as totalTokens FROM messages";
+        const params = [];
+        if (timeRange) {
+            query += " WHERE timestamp BETWEEN ? AND ?";
+            params.push(timeRange.start);
+            params.push(timeRange.end);
+        }
+        const result = db.prepare(query).get(params);
+        db.close();
+        // Handle potential null values
+        const tokenStats = {
+            totalTokens: result.totalTokens || 0,
+            inputTokens: result.inputTokens || 0,
+            outputTokens: result.outputTokens || 0,
+            timestamp: new Date().toISOString()
+        };
+        return JSON.stringify(tokenStats);
+    }
+    catch (error) {
+        console.error("Error in TokenUsageTool:", error);
+        return JSON.stringify({ error: `Failed to get token usage: ${error.message}` });
+    }
+}, {
+    name: "token_usage",
+    description: "Returns token usage statistics. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    schema: z.object({
+        timeRange: z.object({
+            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+        }).optional(),
+    }),
+});

package/dist/runtime/tools/config-tools.js

@@ -0,0 +1,70 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import { ConfigManager } from "../../config/manager.js";
+// Tool for querying configuration values
+export const ConfigQueryTool = tool(async ({ key }) => {
+    try {
+        const configManager = ConfigManager.getInstance();
+        // Load config if not already loaded
+        await configManager.load();
+        const config = configManager.get();
+        if (key) {
+            // Return specific configuration value
+            const value = config[key];
+            return JSON.stringify({ [key]: value });
+        }
+        else {
+            // Return all configuration values
+            return JSON.stringify(config);
+        }
+    }
+    catch (error) {
+        console.error("Error in ConfigQueryTool:", error);
+        return JSON.stringify({ error: "Failed to query configuration" });
+    }
+}, {
+    name: "config_query",
+    description: "Queries current configuration values. Accepts an optional 'key' parameter to get a specific configuration value, or no parameter to get all configuration values.",
+    schema: z.object({
+        key: z.string().optional(),
+    }),
+});
+// Tool for updating configuration values
+export const ConfigUpdateTool = tool(async ({ updates }) => {
+    try {
+        const configManager = ConfigManager.getInstance();
+        // Load current config
+        await configManager.load();
+        const currentConfig = configManager.get();
+        // Create new config with updates
+        const newConfig = { ...currentConfig, ...updates };
+        // Save the updated config
+        await configManager.save(newConfig);
+        return JSON.stringify({ success: true, message: "Configuration updated successfully" });
+    }
+    catch (error) {
+        console.error("Error in ConfigUpdateTool:", error);
+        return JSON.stringify({ error: `Failed to update configuration: ${error.message}` });
+    }
+}, {
+    name: "config_update",
+    description: "Updates configuration values with validation. Accepts an 'updates' object containing key-value pairs to update.",
+    schema: z.object({
+        updates: z.object({
+            // Define common config properties that might be updated
+            // Using optional fields to allow flexible updates
+            "llm.provider": z.string().optional(),
+            "llm.model": z.string().optional(),
+            "llm.temperature": z.number().optional(),
+            "llm.api_key": z.string().optional(),
+            "ui.enabled": z.boolean().optional(),
+            "ui.port": z.number().optional(),
+            "logging.enabled": z.boolean().optional(),
+            "logging.level": z.enum(['debug', 'info', 'warn', 'error']).optional(),
+            "audio.enabled": z.boolean().optional(),
+            "audio.provider": z.string().optional(),
+            "memory.limit": z.number().optional(),
+            // Add more specific fields as needed, or use a catch-all for other properties
+        }).passthrough(), // Allow additional properties not explicitly defined
+    }),
+});