import express from 'express';

// This mimics the "ask_model" logic in Python.
function computeSum(input) {
  return {
    result: input.a + input.b,
  };
}

async function main() {
  const app = express();

  // Middleware to parse JSON bodies
  app.use(express.json());

  // POST endpoint to handle requests
  app.post('/sum', (req, res) => {
    try {
      // We expect an object with { a: number, b: number }
      const input = req.body;
      const output = computeSum(input);
      return res.status(200).json(output);
    } catch (err) {
      return res.status(400).json({ error: 'Invalid request', details: err });
    }
  });

  // Start the server
  const port = 8080;
  app.listen(port, () => {
    console.log(`Listening on http://localhost:${port}/`);
  });
}

// Run the main function
main().catch((err) => {
  console.error(err);
  process.exit(1);
});


import { RoomClient, websocketProtocol } from "@meshagent/meshagent";

async function main() {
    try {
        // Define a unique room name and chose your participant name
        const roomName = "my-room";
        const participantName = "participant-name";

        // Document name (the extension identifies the schema)
        const path = "hello-world.document";

        // Establish communication channel using participant token
        const protocol = await websocketProtocol({
            roomName,
            participantName,
        });

        // Instantiate a new RoomClient for interacting with the room
        const room = new RoomClient({protocol});

        // Connect to the room
        await room.start();

        // Open our document
        const meshDocument = await room.sync.open(path);

        // Wait for the document to sync from the server
        await meshDocument.synchronized;

        // Append body with text
        meshDocument.root.createChildElement("body", {
            text: "hello world!"
        });

        // sleep 2 seconds
        await new Promise((resolve) => setTimeout(resolve, 2000));

        // Close the document 
        await room.sync.close(path);

    } catch (error) {
        console.error("Error:", error);
    }
}

main();



import { RoomClient, websocketProtocol } from "@meshagent/meshagent";

async function main() {
    try {
        const roomName = 'quickstart';
        const participantName = 'my user';

        // Document path in the MeshAgent environment
        const path = 'sample-agent.document';

        const protocol = await websocketProtocol({roomName, participantName});

        const room = new RoomClient({protocol});

        // Connect to the room (automatically creating it if it doesn't exist)
        await room.start();

        // Add Agents to the room
        await room.agents.call({
            name: 'meshagent.document-writer',
            url: 'https://api.meshagent.life/agents/meshagent.document-writer',
            arguments: { },
        });

        // Ask an agent to do some work in the document.
        // The "meshagent.document-writer" agent writes content to the document.
        await room.agents.ask({
            agentName: 'meshagent.document-writer',
            arguments: {
                path,
                prompt: 'write a paragraph about AI and how agents are shaping the future',
            },
        });

        console.log(
            'Take a look at it at',
            `https://studio.meshagent.com/projects/${projectId}/rooms/${roomName}?p=${path}`
        );

        // Always disconnect when done
        await room.disconnect();

    } catch (error) {
        console.error('Error:', error);
    }
}

main();



import { RoomClient, websocketProtocol } from 'meshagent-ts';

async function main() {
    try {
        const roomName = 'quickstart';
        const participantName = 'my user';

        const protocol = await websocketProtocol({ roomName, participantName });
        const room = new RoomClient({ protocol });

        // Connect to the room
        await room.start();

        // Document path in the MeshAgent environment
        const path = 'sample.document';

        // the document will be automatically created if it does not already exist
        // open the document and start synchronizing it
        const document = await room.sync.open(path, { create: true });

        // the document will be automatically created if it does not already exist
        // open the document and start synchronizing it
        document.root.createChildElement('body', { text: 'hello world!' });

        // Always disconnect when done
        console.log('Disconnecting from room...');

        // Close the document and stop synchronizing it
        await room.sync.close(path);

        // Dispose of the room to clean up resources
        room.dispose();

    } catch (error) {
        console.error('Error:', error);
    }
}

main();


import { RoomClient, websocketProtocol } from "@meshagent/meshagent";

async function main() {
    try {
        // Define a unique room name and chose your participant name
        const roomName = "my-room";
        const participantName = "participant-name";

        // Initialize the communication protocol
        const protocol = await websocketProtocol({roomName, participantName});

        // Instantiate a new RoomClient for interacting with the room
        const room = new RoomClient({protocol});

        // Connect to the room
        await room.start();

        // Sleep for 5 seconds to allow the connection to establish
        await new Promise(resolve => setTimeout(resolve, 5000));

        room.dispose();

    } catch (error) {
        console.error("Error starting the room client:", error);
    }
}
main();


import {
  SchemaRegistry,
  SchemaRegistration,
  MeshSchema,
  ElementType,
  ChildProperty,
  ValueProperty,
} from '@meshagent/meshagent';

// Define the schema
const sample = new MeshSchema({
  rootTagName: 'sample',
  elements: [
    new ElementType({
      tagName: 'sample',
      description: 'test',
      properties: [
        new ChildProperty({
          name: 'children',
          description: 'desc',
          childTagNames: ['child'],
        }),
      ],
    }),
    new ElementType({
      tagName: 'child',
      description: 'child',
      properties: [
        new ValueProperty({
          name: 'prop',
          description: 'desc',
          type: 'number',
        }),
      ],
    }),
  ],
});

// Main async function to run the server
async function main() {
  const server = new SchemaRegistry({
    schemas: [
      new SchemaRegistration({
        name: 'sample',
        schema: sample,
      }),
    ],
  });

  // Start the server
  await server.run();
}

// Entry point
if (require.main === module) {
  try {
    main();
  } catch (error) {
    console.error('Error:', error);
  }
}


import {
  MeshSchema,
  ElementType,
  ChildProperty,
  ValueProperty,
} from '@meshagent/meshagent';

// Create the schema
const schema = new MeshSchema({
  rootTagName: 'html',
  elements: [
    new ElementType({
      tagName: 'html',
      properties: [
        // A ChildProperty describes the type of children that an element allows.
        // There can be at most one child property for each element type, but
        // the child property can allow multiple types of child elements.
        new ChildProperty({
          name: 'children',
          childTagNames: ['body'],
        }),
      ],
    }),
    new ElementType({
      tagName: 'body',
      properties: [
        // Our body can only contain paragraph elements.
        new ChildProperty({
          name: 'children',
          childTagNames: ['p'],
        }),
      ],
    }),
    new ElementType({
      tagName: 'p',
      properties: [
        // A ValueProperty describes an attribute that contains a single value.
        new ValueProperty({
          name: 'class',
          type: 'string',
        }),
      ],
    }),
  ],
});



// Check existence
const exists = await room.storage.exists("example.txt");
if (!exists) {
    // Create it
    const handle = await room.storage.open("example.txt");
    await room.storage.write(handle, new TextEncoder().encode("Hello, Storage!"));
    await room.storage.close(handle);
}

// Download content
const response = await room.storage.download("example.txt");
console.log("Downloaded content:", response.data);

// Delete it
await room.storage.delete("example.txt");


// index.js
const express = require('express');
const bodyParser = require('body-parser');
const { websocketRoomUrl, participantToken } = require('meshagent');

const app = express();

app.use(bodyParser.json());

// Example of user "database"
const users = [
  {
    id: 1,
    username: 'john',
    password: 'password123'
  },
  {
    id: 2,
    username: 'jane',
    password: 'mypassword'
  },
];

/**
 * POST /authorize-meshagent-user
 *
 * This route simulates user authentication. 
 *
 * On successful validation of username and password,
 * it returns a JWT token for the user.
 */
app.post('/authorize-user', (req, res) => {
  const {
      username,
      password,
      roomName,
      participantName,
  } = req.body;

  // Find a matching user in our "database"
  const user = users.find((u) => u.username === username && u.password === password);

  if (!user) {
    return res.status(401).json({ error: 'Invalid credentials' });
  }

  const url = websocketRoomUrl({roomName});
  const jwt = participantToken({participantName, roomName});

  return res.json({url, jwt});
});

// Start the Express server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Client service running on http://localhost:${PORT}`);
});



"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var meshagent_1 = require("@meshagent/meshagent");
function main() {
    return __awaiter(this, void 0, void 0, function () {
        var roomName, participantName, protocol, room, error_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 4, , 5]);
                    roomName = "my-room";
                    participantName = "participant-name";
                    return [4 /*yield*/, (0, meshagent_1.websocketProtocol)({ roomName: roomName, participantName: participantName })];
                case 1:
                    protocol = _a.sent();
                    room = new meshagent_1.RoomClient({ protocol: protocol });
                    // Connect to the room
                    return [4 /*yield*/, room.start()];
                case 2:
                    // Connect to the room
                    _a.sent();
                    // Sleep for 5 seconds to allow the connection to establish
                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5000); })];
                case 3:
                    // Sleep for 5 seconds to allow the connection to establish
                    _a.sent();
                    room.dispose();
                    return [3 /*break*/, 5];
                case 4:
                    error_1 = _a.sent();
                    console.error("Error starting the room client:", error_1);
                    return [3 /*break*/, 5];
                case 5: return [2 /*return*/];
            }
        });
    });
}
main();


"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var meshagent_1 = require("@meshagent/meshagent");
function main() {
    return __awaiter(this, void 0, void 0, function () {
        var roomName, participantName, protocol, room, exists, handle, response, error_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 10, , 11]);
                    roomName = "my-room";
                    participantName = "participant-name";
                    return [4 /*yield*/, (0, meshagent_1.websocketProtocol)({ roomName: roomName, participantName: participantName })];
                case 1:
                    protocol = _a.sent();
                    room = new meshagent_1.RoomClient({ protocol: protocol });
                    // Connect to the room
                    return [4 /*yield*/, room.start()];
                case 2:
                    // Connect to the room
                    _a.sent();
                    return [4 /*yield*/, room.storage.exists("example.txt")];
                case 3:
                    exists = _a.sent();
                    if (!!exists) return [3 /*break*/, 7];
                    return [4 /*yield*/, room.storage.open("example.txt")];
                case 4:
                    handle = _a.sent();
                    return [4 /*yield*/, room.storage.write(handle, new TextEncoder().encode("Hello, Storage!"))];
                case 5:
                    _a.sent();
                    return [4 /*yield*/, room.storage.close(handle)];
                case 6:
                    _a.sent();
                    _a.label = 7;
                case 7: return [4 /*yield*/, room.storage.download("example.txt")];
                case 8:
                    response = _a.sent();
                    console.log("Downloaded content:", response.data);
                    // Delete it
                    return [4 /*yield*/, room.storage.delete("example.txt")];
                case 9:
                    // Delete it
                    _a.sent();
                    room.dispose();
                    return [3 /*break*/, 11];
                case 10:
                    error_1 = _a.sent();
                    console.error("Error starting the room client:", error_1);
                    return [3 /*break*/, 11];
                case 11: return [2 /*return*/];
            }
        });
    });
}
main();


Tools provided by this Server	Short Description
`collect_config`	Collect the config to be used for connection to mcp server
`find_mcp`	Find the MCP servers by given name
`install_mcp`	Install the MCP server on your local machine.

Parameters	Type	Description
`client`	`string`	The client to install
`qualifiedName`	`string`	The qualified name of the MCP server to install. ex) @bbangjooo/mcp-finder-mcp-server
`config`	`object` (optional)	Configuration schema

Overview

Tools

Smithery CLI

Running the Agent and Tool in the Cloud

Tools Available

Summary

Tools Details

Tool: `collect_config`

Tool: `find_mcp`

Tool: `install_mcp`

Useful Links

Overview

Tools

​Running the Agent and Tool in the Cloud

​Tools Available

​Summary

​Tools Details

​Tool: collect_config

​Tool: find_mcp

​Tool: install_mcp

​Useful Links