@tyvm/knowhow 0.0.1

package/src/services/Mcp.ts

@@ -0,0 +1,270 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import Anthropic from "@anthropic-ai/sdk";
+
+import { McpConfig } from "../types";
+import { Tool } from "../clients";
+import { getConfig } from "../config";
+import { ToolsService } from "./Tools";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { MCPWebSocketTransport } from "./McpWebsocketTransport";
+
+type CachedTool = Anthropic.Tool;
+export type McpTool = CachedTool & {
+  inputSchema: CachedTool["input_schema"];
+};
+
+export const knowhowMcpClient = {
+  name: "knowhow-mcp-client",
+  version: "1.0.0",
+};
+export const knowhowConfig = {
+  capabilities: {
+    prompts: {},
+    resources: {},
+    tools: {},
+  },
+};
+
+export * from "./McpServer";
+export * from "./McpWebsocketTransport";
+
+export class McpService {
+  connected = [];
+  transports: Transport[] = [];
+  clients: Client[] = [];
+  config: McpConfig[] = [];
+  tools: Tool[] = [];
+  mcpPrefix = "mcp";
+
+  async createStdioClients(mcpServers: McpConfig[] = []) {
+    if (this.clients.length) {
+      return this.clients;
+    }
+
+    this.config = mcpServers;
+    this.transports = mcpServers.map((mcp) => {
+      const logFormat = `${mcp.name}: ${[
+        mcp.command,
+        ...mcp.args,
+        mcp.url,
+      ].join(" ")}`;
+
+      console.log("Creating transport for", logFormat);
+      if (mcp.command) {
+        return new StdioClientTransport(mcp as StdioServerParameters);
+      }
+      if (mcp?.params?.socket) {
+        return new MCPWebSocketTransport(mcp.params.socket);
+      }
+    });
+
+    this.clients = this.transports.map((transport) => {
+      return new Client(knowhowMcpClient, knowhowConfig);
+    });
+
+    return this.clients;
+  }
+
+  setMcpPrefix(prefix: string) {
+    this.mcpPrefix = prefix;
+  }
+
+  createClient(mcp: McpConfig, transport: Transport) {
+    this.config.push(mcp);
+    this.clients.push(new Client(knowhowMcpClient, knowhowConfig));
+    this.transports.push(transport);
+  }
+
+  async connectToConfigured(tools?: ToolsService) {
+    const config = await getConfig();
+
+    return this.connectTo(config.mcps, tools);
+  }
+
+  async connectTo(mcpServers: McpConfig[] = [], tools?: ToolsService) {
+    const clients = await this.createStdioClients(mcpServers);
+    await this.connectAll();
+
+    if (tools) {
+      await this.addTools(tools);
+    }
+  }
+
+  async addTools(tools: ToolsService) {
+    tools.addTools(await this.getTools());
+    tools.addFunctions(await this.getToolMap());
+  }
+
+  async copyFrom(mcp: McpService) {
+    this.clients.push(...mcp.clients);
+    this.transports.push(...mcp.transports);
+    this.config.push(...mcp.config);
+    this.connected.push(...mcp.connected);
+  }
+
+  async closeTransports() {
+    await Promise.all(
+      this.transports.map(async (transport, index) => {
+        this.connected[index] = false;
+        return transport.close();
+      })
+    );
+
+    this.transports = [];
+    this.connected = [];
+  }
+
+  async closeClients() {
+    await Promise.all(
+      this.clients.map((client) => {
+        return client.close();
+      })
+    );
+
+    this.clients = [];
+    this.connected = [];
+  }
+
+  async closeAll() {
+    await this.closeTransports();
+    await this.closeClients();
+  }
+
+  getClientIndex(clientName: string) {
+    const index = this.config.findIndex((mcp) => mcp.name === clientName);
+    return index;
+  }
+
+  parseToolName(toolName: string) {
+    const split = toolName.split("_");
+
+    if (split.length < 2) {
+      return null;
+    }
+
+    return split.slice(2).join("_");
+  }
+
+  getToolClientIndex(toolName: string) {
+    const split = toolName.split("_");
+
+    if (split.length < 2) {
+      return -1;
+    }
+
+    const index = Number(split[1]);
+    return index;
+  }
+
+  getToolClient(toolName: string) {
+    const index = this.getToolClientIndex(toolName);
+
+    if (index < 0) {
+      throw new Error(`Invalid tool name ${toolName}`);
+    }
+
+    return this.clients[index];
+  }
+
+  getFunction(toolName: string) {
+    const client = this.getToolClient(toolName);
+
+    const realName = this.parseToolName(toolName);
+    return async (args: any) => {
+      console.log("Calling tool", realName, "with args", args);
+      const tool = await client.callTool(
+        {
+          name: realName,
+          arguments: args,
+        },
+        CallToolResultSchema,
+        {
+          timeout: 10 * 60 * 1000,
+          maxTotalTimeout: 10 * 60 * 1000,
+        }
+      );
+      return tool;
+    };
+  }
+
+  async getFunctions() {
+    const tools = await this.getTools();
+    return tools.map((tool) => {
+      return this.getFunction(tool.function.name);
+    });
+  }
+
+  async getToolMap() {
+    const tools = await this.getTools();
+    return tools.reduce((acc, tool) => {
+      acc[tool.function.name] = this.getFunction(tool.function.name);
+      return acc;
+    }, {});
+  }
+
+  async connectAll() {
+    await Promise.all(
+      this.clients.map(async (client, index) => {
+        if (this.connected[index]) {
+          return;
+        }
+        await client.connect(this.transports[index]);
+        this.connected[index] = true;
+      })
+    );
+  }
+
+  async getClient() {
+    if (this.clients.length) {
+      return this.clients;
+    }
+
+    this.clients = await this.createStdioClients(this.config);
+
+    return this.clients;
+  }
+
+  async getTools() {
+    if (this.tools.length) {
+      return this.tools;
+    }
+
+    const tools = [] as Tool[];
+
+    for (let i = 0; i < this.config.length; i++) {
+      const config = this.config[i];
+      const client = this.clients[i];
+      const clientTools = await client.listTools();
+      const transformedTools = clientTools.tools.map((tool) => {
+        return this.toOpenAiTool(i, tool as any as McpTool);
+      });
+      tools.push(...transformedTools);
+    }
+
+    this.tools = tools;
+    return tools;
+  }
+
+  toOpenAiTool(index: number, tool: McpTool) {
+    const transformed: Tool = {
+      type: "function",
+      function: {
+        name: `${this.mcpPrefix}_${index}_${tool.name}`,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          positional: Boolean(tool.inputSchema.positional),
+          properties: tool.inputSchema.properties as any,
+          required: tool.inputSchema.required as string[],
+        },
+      },
+    };
+
+    return transformed;
+  }
+}
+
+export const Mcp = new McpService();

package/src/services/McpServer.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { Tool, ToolProp } from "../clients/types";
+import { ToolsService } from "./Tools";
+import { MCPWebSocketTransport } from "./McpWebsocketTransport";
+import { WebSocket } from "ws";
+
+export class McpServerService {
+  server: McpServer | null = null;
+  constructor(private toolsService: ToolsService) {}
+  registeredTools = new Set<string>();
+
+  createServer(name: string, version: string) {
+    if (this.server) {
+      return this;
+    }
+
+    this.server = new McpServer({
+      name,
+      version,
+    });
+
+    return this;
+  }
+
+  toZodSchema(properties: { [key: string]: ToolProp }): z.ZodObject<any> {
+    const schema: Record<string, z.ZodTypeAny> = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (value.type === "string") {
+        schema[key] = z.string();
+      } else if (value.type === "number") {
+        schema[key] = z.number();
+      } else if (value.type === "boolean") {
+        schema[key] = z.boolean();
+      } else if (value.type === "array" && value?.items?.properties) {
+        schema[key] = z.array(this.toZodSchema(value.items.properties));
+      } else if (value.type === "object" && value.properties) {
+        schema[key] = this.toZodSchema(value.properties);
+      } else {
+        schema[key] = z.any();
+      }
+    }
+    return z.object(schema);
+  }
+
+  withTools(tools: Tool[]) {
+    for (const tool of tools) {
+      const props = tool.function.parameters.properties;
+
+      if (!props) {
+        console.warn(`Tool ${tool.function.name} has no properties`);
+        continue;
+      }
+
+      if (this.registeredTools.has(tool.function.name)) {
+        console.log(`Tool ${tool.function.name} already registered`);
+        continue;
+      }
+
+      console.log(`Registering tool ${tool.function.name}`);
+      this.registeredTools.add(tool.function.name);
+
+      const shape = this.toZodSchema(props).shape;
+
+      this.server.tool(
+        tool.function.name,
+        tool.function.description,
+        shape,
+        async (args, extra) => {
+          const fn = this.toolsService.getFunction(tool.function.name);
+
+          let response = "" as string | any;
+          if (tool.function.parameters.positional) {
+            response = await fn(...Object.values(args));
+          } else {
+            response = await fn(args);
+          }
+
+          if (response && typeof response === "object" && response.content) {
+            return response;
+          }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text:
+                  typeof response === "string"
+                    ? response
+                    : JSON.stringify(response),
+              },
+            ],
+          };
+        }
+      );
+    }
+    return this;
+  }
+
+  createServerWithAllTools(name: string, version: string) {
+    return this.createServer(name, version).withTools(
+      this.toolsService.getTools()
+    );
+  }
+
+  async runStdioServer() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error(`MCP Server running on stdio`);
+  }
+
+  async runWsServer(ws: WebSocket) {
+    const transport = new MCPWebSocketTransport(ws);
+    await this.server.connect(transport);
+    console.error(`MCP Server running on websocket`);
+  }
+}

package/src/services/McpWebsocketTransport.ts

@@ -0,0 +1,64 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  JSONRPCMessage,
+  JSONRPCMessageSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { WebSocket } from "ws";
+
+export class MCPWebSocketTransport implements Transport {
+  protected _socket: WebSocket;
+  onmessage?: (message: JSONRPCMessage) => void;
+  onerror?: (error: Error) => void;
+  onclose?: () => void;
+
+  constructor(socket: WebSocket) {
+    this._socket = socket;
+  }
+
+  async start(): Promise<void> {
+    this._socket.on("message", (data: any) => {
+      try {
+        let parsed: unknown;
+        if (typeof data === "string") {
+          parsed = JSON.parse(data);
+        } else if (Buffer.isBuffer(data)) {
+          parsed = JSON.parse(data.toString("utf-8"));
+        } else {
+          parsed = JSON.parse(data.toString());
+        }
+        console.log("MCPW Message received", JSON.stringify(parsed));
+        const message = JSONRPCMessageSchema.parse(parsed);
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error as Error);
+      }
+    });
+
+    this._socket.on("close", () => {
+      this.onclose?.();
+    });
+
+    this._socket.on("error", (err) => {
+      this.onerror?.(err as Error);
+    });
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const json = JSON.stringify(message);
+      console.log("MCPWs sending", json);
+      this._socket.send(json, (error?: Error) => {
+        if (error) {
+          this.onerror?.(error);
+          return reject(error);
+        }
+        resolve();
+      });
+    });
+  }
+
+  async close(): Promise<void> {
+    this._socket.close();
+  }
+}

package/src/services/S3.ts

@@ -0,0 +1,126 @@
+import {
+  S3Client,
+  HeadBucketCommand,
+  CreateBucketCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  GetObjectCommandInput,
+  PutObjectCommandInput,
+} from "@aws-sdk/client-s3";
+
+import fs from "fs/promises";
+import { createWriteStream } from "fs";
+import * as path from "path";
+import { pipeline } from "stream";
+import * as util from "util";
+import axios from "axios";
+
+import { createReadStream } from "fs";
+const pipelineAsync = util.promisify(pipeline);
+
+export class S3Service {
+  private s3: S3Client;
+
+  constructor() {
+    this.s3 = new S3Client();
+  }
+
+  async uploadFile(
+    filePath: string,
+    bucketName: string,
+    key: string
+  ): Promise<void> {
+    const fileContent = await fs.readFile(filePath);
+
+    const params = {
+      Bucket: bucketName,
+      Key: key,
+      Body: fileContent,
+    };
+
+    // create bucket if it doesn't exist
+    try {
+      await this.s3.send(new HeadBucketCommand({ Bucket: bucketName }));
+    } catch (error) {
+      const statusCode = error.$metadata.httpStatusCode;
+      if (statusCode === 404) {
+        await this.s3.send(new CreateBucketCommand({ Bucket: bucketName }));
+        console.log(`Bucket ${bucketName} created successfully`);
+      } else {
+        throw error;
+      }
+    }
+
+    await this.s3.send(new PutObjectCommand(params));
+    console.log(`File uploaded successfully to ${bucketName}/${key}`);
+  }
+
+  async downloadFile(
+    bucketName: string,
+    key: string,
+    destinationPath: string
+  ): Promise<void> {
+    const params = {
+      Bucket: bucketName,
+      Key: key,
+    };
+    const { Body } = await this.s3.send(new GetObjectCommand(params));
+    const fileStream = createWriteStream(destinationPath);
+
+    await pipelineAsync(Body as NodeJS.ReadableStream, fileStream);
+
+    console.log(
+      `File downloaded successfully from ${bucketName}/${key} to ${destinationPath}`
+    );
+  }
+
+  async uploadToPresignedUrl(
+    presignedUrl: string,
+    filePath: string
+  ): Promise<void> {
+    try {
+      const fileStream = createReadStream(filePath);
+      const fileStats = await fs.stat(filePath);
+
+      const response = await axios.put(presignedUrl, fileStream, {
+        headers: {
+          "Content-Length": fileStats.size,
+        },
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+      });
+
+      if (response.status === 200) {
+        console.log("File uploaded successfully to pre-signed URL");
+      } else {
+        throw new Error(`Upload failed with status code: ${response.status}`);
+      }
+    } catch (error) {
+      console.error("Error uploading file to pre-signed URL:", error);
+      throw error;
+    }
+  }
+
+  async downloadFromPresignedUrl(
+    presignedUrl: string,
+    destinationPath: string
+  ): Promise<void> {
+    try {
+      const response = await axios.get(presignedUrl, {
+        responseType: "stream",
+      });
+
+      const fileStream = createWriteStream(destinationPath);
+      await pipelineAsync(response.data, fileStream);
+
+      console.log(
+        `File downloaded successfully from pre-signed URL to ${destinationPath}`
+      );
+    } catch (error) {
+      console.error("Error downloading file from pre-signed URL:", error);
+      throw error;
+    }
+  }
+}
+
+export const AwsS3 = new S3Service();

package/src/services/Tools.ts

@@ -0,0 +1,65 @@
+import { ChatCompletionTool } from "openai/resources/chat";
+import { includedTools } from "../agents/tools/list";
+import { Tool } from "../clients/types";
+
+export class ToolsService {
+  tools = [] as Tool[];
+
+  functions = {};
+
+  getTools() {
+    return this.tools;
+  }
+
+  getToolsByNames(names: string[]) {
+    return this.tools.filter((tool) => names.includes(tool.function.name));
+  }
+
+  copyToolsFrom(toolNames: string[], toolsService: ToolsService) {
+    const tools = toolsService.getToolsByNames(toolNames);
+    this.addTools(tools);
+
+    for (const name of toolNames) {
+      this.setFunction(name, toolsService.getFunction(name));
+    }
+  }
+
+  getToolNames() {
+    return this.tools.map((tool) => tool.function.name);
+  }
+
+  getTool(name: string): Tool {
+    return this.tools.find((tool) => tool.function.name === name);
+  }
+
+  getFunction(name: string) {
+    // return this.functions[name] || allTools.addInternalTools(allTools)[name];
+    return this.functions[name];
+  }
+
+  setFunction(name: string, func: (...args: any) => any) {
+    this.functions[name] = func;
+  }
+
+  setFunctions(names: string[], funcs: ((...args: any) => any)[]) {
+    for (let i = 0; i < names.length; i++) {
+      this.setFunction(names[i], funcs[i]);
+    }
+  }
+
+  addTool(tool: Tool) {
+    this.tools.push(tool);
+  }
+
+  addTools(tools: Tool[]) {
+    this.tools.push(...tools);
+  }
+
+  addFunctions(fns: { [fnName: string]: (...args: any) => any }) {
+    for (const fnName of Object.keys(fns)) {
+      this.setFunction(fnName, fns[fnName]);
+    }
+  }
+}
+
+export const Tools = new ToolsService();

package/src/services/flags.ts

@@ -0,0 +1,52 @@
+export class FlagsService {
+  flags = {};
+  log = false;
+
+  constructor(flags: string[] = [], log = false) {
+    this.register(flags);
+    this.log = log;
+  }
+
+  register(flags: string[]) {
+    flags.forEach((flag) => {
+      this.flags[flag] = false;
+    });
+  }
+
+  enable(flag: string) {
+    this.flags[flag] = true;
+    if (this.log) {
+      console.log(`${flag} is now enabled \n`);
+    }
+  }
+
+  disable(flag: string) {
+    this.flags[flag] = false;
+    if (this.log) {
+      console.log(`${flag} is now disabled \n`);
+    }
+  }
+
+  flip(flag: string) {
+    this.flags[flag] = !this.flags[flag];
+    if (this.log) {
+      const status = this.flags[flag] ? "enabled" : "disabled";
+      const message = `${flag} is now ${status}`;
+      console.log(message);
+    }
+  }
+
+  enableLogging() {
+    this.log = true;
+  }
+
+  disableLogging() {
+    this.log = false;
+  }
+
+  enabled(flag: string): boolean {
+    return this.flags[flag];
+  }
+}
+
+export const Flags = new FlagsService();

package/src/services/index.ts

@@ -0,0 +1,8 @@
+export * from "./AgentService";
+export * from "./EventService";
+export * from "./flags";
+export * from "./GitHub";
+export * from "./S3";
+export * from "./Tools";
+export * as MCP from "./Mcp";
+export * from "./EmbeddingService";