jiva-core 0.1.0

package/src/mcp/server-manager.ts

@@ -0,0 +1,168 @@
+/**
+ * MCP Server Manager
+ *
+ * Manages lifecycle of MCP servers based on configuration
+ */
+
+import { MCPClient } from './client.js';
+import { MCPServerConfig } from '../core/config.js';
+import { logger } from '../utils/logger.js';
+import { MCPError } from '../utils/errors.js';
+
+export class MCPServerManager {
+  private mcpClient: MCPClient;
+  private serverConfigs: Map<string, MCPServerConfig> = new Map();
+
+  constructor() {
+    this.mcpClient = new MCPClient();
+  }
+
+  /**
+   * Initialize servers from configuration
+   */
+  async initialize(servers: Record<string, MCPServerConfig>): Promise<void> {
+    logger.info('Initializing MCP servers...');
+
+    const serverEntries = Object.entries(servers);
+    const enabledServers = serverEntries.filter(([_, config]) => config.enabled);
+
+    logger.info(`Found ${enabledServers.length} enabled MCP servers`);
+
+    // Store configs
+    for (const [name, config] of serverEntries) {
+      this.serverConfigs.set(name, config);
+    }
+
+    // Connect to enabled servers
+    const connectionPromises = enabledServers.map(async ([name, config]) => {
+      try {
+        await this.connectServer(name, config);
+        return { name, success: true };
+      } catch (error) {
+        logger.warn(`Failed to connect to MCP server '${name}': ${error instanceof Error ? error.message : String(error)}`);
+        // Continue with other servers even if one fails
+        return { name, success: false };
+      }
+    });
+
+    const results = await Promise.allSettled(connectionPromises);
+
+    const connectedServers = this.mcpClient.getConnectedServers();
+
+    if (connectedServers.length > 0) {
+      logger.success(`MCP servers connected: ${connectedServers.join(', ')}`);
+    } else if (enabledServers.length > 0) {
+      logger.warn('No MCP servers connected. Agent will run without external tools.');
+    } else {
+      logger.info('No MCP servers enabled. Agent will run without external tools.');
+    }
+  }
+
+  /**
+   * Connect to a specific server
+   */
+  private async connectServer(name: string, config: MCPServerConfig): Promise<void> {
+    await this.mcpClient.connect(
+      name,
+      config.command,
+      config.args || [],
+      config.env
+    );
+  }
+
+  /**
+   * Add and connect to a new server
+   */
+  async addServer(name: string, config: MCPServerConfig): Promise<void> {
+    if (this.serverConfigs.has(name)) {
+      throw new MCPError(`Server '${name}' already exists`, name);
+    }
+
+    this.serverConfigs.set(name, config);
+
+    if (config.enabled) {
+      await this.connectServer(name, config);
+    }
+  }
+
+  /**
+   * Remove and disconnect from a server
+   */
+  async removeServer(name: string): Promise<void> {
+    await this.mcpClient.disconnect(name);
+    this.serverConfigs.delete(name);
+  }
+
+  /**
+   * Enable a server and connect
+   */
+  async enableServer(name: string): Promise<void> {
+    const config = this.serverConfigs.get(name);
+    if (!config) {
+      throw new MCPError(`Server '${name}' not found in configuration`, name);
+    }
+
+    config.enabled = true;
+
+    if (!this.mcpClient.isConnected(name)) {
+      await this.connectServer(name, config);
+    }
+  }
+
+  /**
+   * Disable a server and disconnect
+   */
+  async disableServer(name: string): Promise<void> {
+    const config = this.serverConfigs.get(name);
+    if (!config) {
+      throw new MCPError(`Server '${name}' not found in configuration`, name);
+    }
+
+    config.enabled = false;
+    await this.mcpClient.disconnect(name);
+  }
+
+  /**
+   * Get the MCP client instance
+   */
+  getClient(): MCPClient {
+    return this.mcpClient;
+  }
+
+  /**
+   * Get all server configurations
+   */
+  getServerConfigs(): Map<string, MCPServerConfig> {
+    return new Map(this.serverConfigs);
+  }
+
+  /**
+   * Cleanup all servers
+   */
+  async cleanup(): Promise<void> {
+    logger.info('Cleaning up MCP servers...');
+    await this.mcpClient.disconnectAll();
+  }
+
+  /**
+   * Get server status
+   */
+  getServerStatus(): Array<{
+    name: string;
+    enabled: boolean;
+    connected: boolean;
+    toolCount: number;
+  }> {
+    return Array.from(this.serverConfigs.entries()).map(([name, config]) => {
+      const connected = this.mcpClient.isConnected(name);
+      const tools = connected ? this.mcpClient.getServerTools(name) : [];
+
+      return {
+        name,
+        enabled: config.enabled,
+        connected,
+        toolCount: tools.length,
+      };
+    });
+  }
+}

package/src/models/base.ts

@@ -0,0 +1,63 @@
+/**
+ * Base model interfaces and types
+ */
+
+export interface Message {
+  role: 'system' | 'developer' | 'user' | 'assistant' | 'tool';
+  content: string | MessageContent[];
+  name?: string;
+  tool_call_id?: string;
+}
+
+export interface MessageContent {
+  type: 'text' | 'image_url';
+  text?: string;
+  image_url?: {
+    url: string;
+  };
+}
+
+export interface ModelResponse {
+  content: string;
+  toolCalls?: ToolCall[];
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  raw?: any;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+export interface ChatCompletionOptions {
+  model: string;
+  messages: Message[];
+  tools?: Tool[];
+  temperature?: number;
+  maxTokens?: number;
+  stream?: boolean;
+}
+
+export interface IModel {
+  chat(options: ChatCompletionOptions): Promise<ModelResponse>;
+  supportsVision(): boolean;
+  supportsToolCalling(): boolean;
+}

package/src/models/harmony.ts

@@ -0,0 +1,301 @@
+/**
+ * Harmony Response Format Handler
+ *
+ * Implements the Harmony format required by gpt-oss-120b models.
+ * Handles multi-channel output, tool calling, and structured message formatting.
+ *
+ * Reference: https://github.com/openai/harmony
+ */
+
+import { logger } from '../utils/logger.js';
+import { ToolCallError } from '../utils/errors.js';
+
+export interface HarmonyMessage {
+  role: 'system' | 'developer' | 'user' | 'assistant' | 'tool';
+  content: string | HarmonyContent[];
+  name?: string;
+  tool_call_id?: string;
+}
+
+export interface HarmonyContent {
+  type: 'text' | 'image_url';
+  text?: string;
+  image_url?: {
+    url: string;
+  };
+}
+
+export interface HarmonyToolDefinition {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+export interface HarmonyToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ParsedHarmonyResponse {
+  analysis?: string;
+  commentary?: string;
+  final?: string;
+  toolCalls: HarmonyToolCall[];
+  rawResponse: string;
+}
+
+/**
+ * Formats tools into Harmony's TypeScript-like syntax for the developer message
+ */
+export function formatToolsForHarmony(tools: HarmonyToolDefinition[]): string {
+  if (tools.length === 0) return '';
+
+  const toolDefinitions = tools.map(tool => {
+    const params = Object.entries(tool.parameters.properties || {})
+      .map(([name, schema]: [string, any]) => {
+        const required = tool.parameters.required?.includes(name) ? '' : '?';
+        const type = schema.type || 'any';
+        const description = schema.description ? ` // ${schema.description}` : '';
+        return `  ${name}${required}: ${type};${description}`;
+      })
+      .join('\n');
+
+    return `/**
+ * ${tool.description}
+ */
+function ${tool.name}(params: {
+${params}
+}): void;`;
+  }).join('\n\n');
+
+  return `# Available Tools
+
+You have access to the following tools:
+
+<namespace name="functions">
+${toolDefinitions}
+</namespace>
+
+## CRITICAL: How to Use Tools
+
+To execute a tool, you MUST use this EXACT format:
+
+<|call|>function_name({"param": "value"})<|return|>
+
+Example:
+<|call|>read_file({"path": "/path/to/file"})<|return|>
+
+## Rules:
+1. Use the EXACT function names from above (e.g., filesystem__read_file)
+2. Parameters MUST be valid JSON
+3. Do NOT output markdown code blocks with tool calls
+4. Do NOT explain what you're doing - just call the tool
+5. Output the tool call directly with the <|call|> and <|return|> markers
+
+WRONG - Do not do this:
+\`\`\`json
+{"action": "read_file", "parameters": {...}}
+\`\`\`
+
+CORRECT - Do this:
+<|call|>filesystem__read_file({"path": "/path"})<|return|>`;
+}
+
+/**
+ * Formats messages into Harmony format
+ */
+export function formatMessagesForHarmony(
+  messages: HarmonyMessage[],
+  tools?: HarmonyToolDefinition[]
+): HarmonyMessage[] {
+  const formattedMessages: HarmonyMessage[] = [];
+
+  // Process messages based on role hierarchy
+  for (const msg of messages) {
+    if (msg.role === 'developer' && tools && tools.length > 0) {
+      // Inject tool definitions into developer message
+      const toolSection = formatToolsForHarmony(tools);
+      const existingContent = typeof msg.content === 'string' ? msg.content : '';
+      formattedMessages.push({
+        ...msg,
+        content: `${existingContent}\n\n${toolSection}`,
+      });
+    } else {
+      formattedMessages.push(msg);
+    }
+  }
+
+  return formattedMessages;
+}
+
+/**
+ * Parses Harmony response with multi-channel support
+ *
+ * Expected format:
+ * <|channel|>analysis
+ * [chain of thought content]
+ * <|channel|>final
+ * [final response]
+ * <|call|>function_name({"param": "value"})<|return|>
+ */
+export function parseHarmonyResponse(response: string): ParsedHarmonyResponse {
+  const result: ParsedHarmonyResponse = {
+    toolCalls: [],
+    rawResponse: response,
+  };
+
+  // Parse channels
+  const channelRegex = /<\|channel\|>(\w+)\s*([\s\S]*?)(?=<\|channel\|>|<\|call\|>|$)/g;
+  let match;
+
+  while ((match = channelRegex.exec(response)) !== null) {
+    const channelName = match[1];
+    const channelContent = match[2].trim();
+
+    if (channelName === 'analysis') {
+      result.analysis = channelContent;
+    } else if (channelName === 'commentary') {
+      result.commentary = channelContent;
+    } else if (channelName === 'final') {
+      result.final = channelContent;
+    }
+  }
+
+  // Parse tool calls
+  const toolCallRegex = /<\|call\|>([\s\S]*?)<\|return\|>/g;
+  let toolMatch;
+  let callId = 0;
+
+  while ((toolMatch = toolCallRegex.exec(response)) !== null) {
+    const toolCallContent = toolMatch[1].trim();
+
+    try {
+      // Parse function call: function_name({"param": "value"})
+      const functionMatch = /^(\w+)\(([\s\S]*)\)$/.exec(toolCallContent);
+
+      if (functionMatch) {
+        const functionName = functionMatch[1];
+        const argsString = functionMatch[2];
+
+        // Validate JSON
+        let parsedArgs;
+        try {
+          parsedArgs = JSON.parse(argsString);
+        } catch (e) {
+          logger.warn(`Failed to parse tool call arguments for ${functionName}: ${argsString}`);
+          // Try to fix common JSON issues
+          const fixedArgs = argsString
+            .replace(/'/g, '"')  // Replace single quotes
+            .replace(/(\w+):/g, '"$1":');  // Quote unquoted keys
+
+          try {
+            parsedArgs = JSON.parse(fixedArgs);
+            logger.debug(`Successfully fixed and parsed arguments: ${fixedArgs}`);
+          } catch (e2) {
+            throw new ToolCallError(
+              `Invalid JSON in tool call arguments: ${argsString}`,
+              functionName
+            );
+          }
+        }
+
+        result.toolCalls.push({
+          id: `call_${callId++}`,
+          type: 'function',
+          function: {
+            name: functionName,
+            arguments: JSON.stringify(parsedArgs),
+          },
+        });
+      } else {
+        logger.warn(`Failed to parse tool call format: ${toolCallContent}`);
+      }
+    } catch (error) {
+      logger.error('Error parsing tool call', error);
+    }
+  }
+
+  // If no channels found, treat entire response as final
+  if (!result.analysis && !result.commentary && !result.final && result.toolCalls.length === 0) {
+    result.final = response.trim();
+  }
+
+  return result;
+}
+
+/**
+ * Extracts assistant message with malformed tool call detection
+ * This handles cases where gpt-oss-120b generates incorrect tool call formats
+ */
+export function extractAssistantMessage(response: string): string {
+  // Remove channel markers and tool calls to get clean message
+  let cleaned = response
+    .replace(/<\|channel\|>\w+/g, '')
+    .replace(/<\|call\|>[\s\S]*?<\|return\|>/g, '')
+    .replace(/<\|start\|>/g, '')
+    .replace(/<\|end\|>/g, '')
+    .replace(/<\|message\|>/g, '')
+    .trim();
+
+  // Handle malformed patterns like "assistant<|channel|>analysis"
+  cleaned = cleaned.replace(/assistant<\|channel\|>\w+/g, '');
+
+  return cleaned;
+}
+
+/**
+ * Validates tool call against available tools
+ */
+export function validateToolCall(
+  toolCall: HarmonyToolCall,
+  availableTools: HarmonyToolDefinition[]
+): boolean {
+  const tool = availableTools.find(t => t.name === toolCall.function.name);
+
+  if (!tool) {
+    logger.warn(`Tool not found: ${toolCall.function.name}`);
+    return false;
+  }
+
+  try {
+    const args = JSON.parse(toolCall.function.arguments);
+    const required = tool.parameters.required || [];
+
+    // Check required parameters
+    for (const param of required) {
+      if (!(param in args)) {
+        logger.warn(`Missing required parameter '${param}' for tool ${tool.name}`);
+        return false;
+      }
+    }
+
+    return true;
+  } catch (error) {
+    logger.error(`Invalid arguments for tool ${tool.name}`, error);
+    return false;
+  }
+}
+
+/**
+ * Formats tool result for Harmony format
+ */
+export function formatToolResult(
+  toolCallId: string,
+  toolName: string,
+  result: any
+): HarmonyMessage {
+  return {
+    role: 'tool',
+    name: toolName,
+    tool_call_id: toolCallId,
+    content: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+  };
+}