add mcp for web (#6411)

* add mcp for web

* update /jan/v1 endpoint to /v1

* update mise and makefile

* update yarn lock

* use mcp oauth properly

Author: dinhlongviolin1

Makefile

@@ -40,9 +40,11 @@ install-web-app: config-yarn
 	yarn install
 
 dev-web-app: install-web-app
+	yarn build:core
 	yarn dev:web-app
 
 build-web-app: install-web-app
+	yarn build:core
 	yarn build:web-app
 
 serve-web-app: 

core/src/browser/extension.ts

@@ -7,6 +7,7 @@ export enum ExtensionTypeEnum {
   Inference = 'inference',
   Model = 'model',
   SystemMonitoring = 'systemMonitoring',
+  MCP = 'mcp',
   HuggingFace = 'huggingFace',
   Engine = 'engine',
   Hardware = 'hardware',

core/src/browser/extensions/index.ts

@@ -14,6 +14,11 @@ export { InferenceExtension } from './inference'
  */
 export { AssistantExtension } from './assistant'
 
+/**
+ * MCP extension for managing tools and server communication.
+ */
+export { MCPExtension } from './mcp'
+
 /**
  * Base AI Engines.
  */

core/src/browser/extensions/mcp.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { MCPExtension } from './mcp'
+import { ExtensionTypeEnum } from '../extension'
+import { MCPTool, MCPToolCallResult } from '../../types'
+
+class TestMCPExtension extends MCPExtension {
+  constructor() {
+    super('test://mcp', 'test-mcp')
+  }
+
+  async getTools(): Promise<MCPTool[]> {
+    return [
+      {
+        name: 'test_tool',
+        description: 'A test tool',
+        inputSchema: { type: 'object' },
+        server: 'test-server'
+      }
+    ]
+  }
+
+  async callTool(toolName: string, args: Record<string, unknown>): Promise<MCPToolCallResult> {
+    return {
+      error: '',
+      content: [{ type: 'text', text: `Called ${toolName} with ${JSON.stringify(args)}` }]
+    }
+  }
+
+  async getConnectedServers(): Promise<string[]> {
+    return ['test-server']
+  }
+
+  async refreshTools(): Promise<void> {
+    // Mock implementation
+  }
+
+  async isHealthy(): Promise<boolean> {
+    return true
+  }
+
+  async onLoad(): Promise<void> {
+    // Mock implementation
+  }
+
+  onUnload(): void {
+    // Mock implementation
+  }
+}
+
+describe('MCPExtension', () => {
+  let mcpExtension: TestMCPExtension
+
+  beforeEach(() => {
+    mcpExtension = new TestMCPExtension()
+  })
+
+  describe('type', () => {
+    it('should return MCP extension type', () => {
+      expect(mcpExtension.type()).toBe(ExtensionTypeEnum.MCP)
+    })
+  })
+
+  describe('getTools', () => {
+    it('should return array of MCP tools', async () => {
+      const tools = await mcpExtension.getTools()
+      expect(tools).toHaveLength(1)
+      expect(tools[0]).toEqual({
+        name: 'test_tool',
+        description: 'A test tool',
+        inputSchema: { type: 'object' },
+        server: 'test-server'
+      })
+    })
+  })
+
+  describe('callTool', () => {
+    it('should call tool and return result', async () => {
+      const result = await mcpExtension.callTool('test_tool', { param: 'value' })
+      expect(result).toEqual({
+        error: '',
+        content: [{ type: 'text', text: 'Called test_tool with {"param":"value"}' }]
+      })
+    })
+  })
+
+  describe('getConnectedServers', () => {
+    it('should return list of connected servers', async () => {
+      const servers = await mcpExtension.getConnectedServers()
+      expect(servers).toEqual(['test-server'])
+    })
+  })
+
+  describe('isHealthy', () => {
+    it('should return health status', async () => {
+      const healthy = await mcpExtension.isHealthy()
+      expect(healthy).toBe(true)
+    })
+  })
+})

core/src/browser/extensions/mcp.ts

@@ -0,0 +1,21 @@
+import { MCPInterface, MCPTool, MCPToolCallResult } from '../../types'
+import { BaseExtension, ExtensionTypeEnum } from '../extension'
+
+/**
+ * MCP (Model Context Protocol) extension for managing tools and server communication.
+ * @extends BaseExtension
+ */
+export abstract class MCPExtension extends BaseExtension implements MCPInterface {
+  /**
+   * MCP extension type.
+   */
+  type(): ExtensionTypeEnum | undefined {
+    return ExtensionTypeEnum.MCP
+  }
+
+  abstract getTools(): Promise<MCPTool[]>
+  abstract callTool(toolName: string, args: Record<string, unknown>): Promise<MCPToolCallResult>
+  abstract getConnectedServers(): Promise<string[]>
+  abstract refreshTools(): Promise<void>
+  abstract isHealthy(): Promise<boolean>
+}

core/src/types/index.ts

@@ -10,3 +10,4 @@ export * from './api'
 export * from './setting'
 export * from './engine'
 export * from './hardware'
+export * from './mcp'

core/src/types/mcp/index.ts

@@ -0,0 +1,2 @@
+export * from './mcpEntity'
+export * from './mcpInterface'

core/src/types/mcp/mcpEntity.ts

@@ -0,0 +1,24 @@
+/**
+ * MCP (Model Context Protocol) entities
+ */
+
+export interface MCPTool {
+  name: string
+  description: string
+  inputSchema: Record<string, unknown>
+  server: string
+}
+
+export interface MCPToolCallResult {
+  error: string
+  content: Array<{
+    type?: string
+    text: string
+  }>
+}
+
+export interface MCPServerInfo {
+  name: string
+  connected: boolean
+  tools?: MCPTool[]
+}

core/src/types/mcp/mcpInterface.ts

@@ -0,0 +1,32 @@
+/**
+ * MCP (Model Context Protocol) interface
+ */
+
+import { MCPTool, MCPToolCallResult } from './mcpEntity'
+
+export interface MCPInterface {
+  /**
+   * Get all available MCP tools
+   */
+  getTools(): Promise<MCPTool[]>
+
+  /**
+   * Call a specific MCP tool
+   */
+  callTool(toolName: string, args: Record<string, unknown>): Promise<MCPToolCallResult>
+
+  /**
+   * Get list of connected MCP servers
+   */
+  getConnectedServers(): Promise<string[]>
+
+  /**
+   * Refresh the list of available tools
+   */
+  refreshTools(): Promise<void>
+
+  /**
+   * Check if MCP service is healthy
+   */
+  isHealthy(): Promise<boolean>
+}

extensions-web/package.json

@@ -30,5 +30,8 @@
   "peerDependencies": {
     "@janhq/core": "*",
     "zustand": "^5.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.5"
   }
 }