first_commit

.python-version

@@ -0,0 +1 @@
+3.10.2

CodeAI_LOG.txt

@@ -0,0 +1 @@
+[{'role': 'system', 'content': '\n# Tools\n\n## Tool1:Code-Interpreter\n- You can read, write, and analyze files on a Linux Server using various languages, including Python, Node.js, and Bash.\n- Code-Interpreter will provide the output of the execution or time out after 60.0 seconds.\n- Save code-generated content, such as plots and graphs, to an external file with a distinct filename added to the data variable, separate from the code_filename.\n- All files MUST be saved and retrieved from the current folder. This step is crucial; correct code execution requires saving all files in the current folder.\n- Running code that requires a UI interface is prohibited, as it will fail. Instead, write alternate code without UI support. Matplotlib is supported.\n- For matplotlib animations, limit the duration to maximum 5 seconds and save them as GIFs without displaying the plot using `plot.show()`. Always Set repeat = False.\n- The start_cmd should be prefixed with sudo for proper code execution.\n- Generated Code should have clear and concise comments **within the code** that explains its purpose and functionality.\n\n### Code-interpreter Usage:\n1) Output data variable in `json` codeblock, conforming to the following grammar:\n```json\n{\n"language":"<Code language name such as python/bash/nodejs>",\n"packages":[<List of python/node packages to install>],\n"system_packages":[<List of apt packages to install>],\n"start_cmd":"Example- sudo python app.py or bash run.sh",\n"filename":"<filename of the file created by using code.>",\n"code_filename":"<filename of the code you are going to run using the start command.(Eg- run.sh , script.py , etc)",\n"port":"Specify the port for the Python app to open. Use \'\' if no port is needed.",\n}\n```  \nNote:code_filename , language and start_cmd are Required parameters and **should NOT be left empty**. \n2) After data output, present code in a **separate codeblock**\n```<code language>\n<Code goes here>\n```  \n- All code output calculations will be external and will be outputted by [system](#code_run_response), and you CANNOT provide expected output. \n- Do NOT provide explanations or additional text with code.\n[STOP REPLY AND WAIT FOR External code completion]\n\n3) Code Output Returns Error\nIf the code throws an error, you will rewrite the entire code using a different method, fixing the error. \n'}, {'role': 'system', 'content': '\n# Tools\n\n## Tool1:Code-Interpreter\n- You can read, write, and analyze files on a Linux Server using various languages, including Python, Node.js, and Bash.\n- Code-Interpreter will provide the output of the execution or time out after 60.0 seconds.\n- Save code-generated content, such as plots and graphs, to an external file with a distinct filename added to the data variable, separate from the code_filename.\n- All files MUST be saved and retrieved from the current folder. This step is crucial; correct code execution requires saving all files in the current folder.\n- Running code that requires a UI interface is prohibited, as it will fail. Instead, write alternate code without UI support. Matplotlib is supported.\n- For matplotlib animations, limit the duration to maximum 5 seconds and save them as GIFs without displaying the plot using `plot.show()`. Always Set repeat = False.\n- The start_cmd should be prefixed with sudo for proper code execution.\n- Generated Code should have clear and concise comments **within the code** that explains its purpose and functionality.\n\n### Code-interpreter Usage:\n1) Output data variable in `json` codeblock, conforming to the following grammar:\n```json\n{\n"language":"<Code language name such as python/bash/nodejs>",\n"packages":[<List of python/node packages to install>],\n"system_packages":[<List of apt packages to install>],\n"start_cmd":"Example- sudo python app.py or bash run.sh",\n"filename":"<filename of the file created by using code.>",\n"code_filename":"<filename of the code you are going to run using the start command.(Eg- run.sh , script.py , etc)",\n"port":"Specify the port for the Python app to open. Use \'\' if no port is needed.",\n}\n```  \nNote:code_filename , language and start_cmd are Required parameters and **should NOT be left empty**. \n2) After data output, present code in a **separate codeblock**\n```<code language>\n<Code goes here>\n```  \n- All code output calculations will be external and will be outputted by [system](#code_run_response), and you CANNOT provide expected output. \n- Do NOT provide explanations or additional text with code.\n[STOP REPLY AND WAIT FOR External code completion]\n\n3) Code Output Returns Error\nIf the code throws an error, you will rewrite the entire code using a different method, fixing the error. \n'}, {'role': 'user', 'content': 'Print out the fibonacci series It is mandatory for you to **Output data variable in `json` codeblock.** as program will fail without data variable'}]

Dockerfile

@@ -0,0 +1,22 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.11
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+EXPOSE 7860
+#ENTRYPOINT ["python"]
+WORKDIR /app
+CMD python app.py
+
+
+#CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

Procfile

@@ -0,0 +1 @@
+web: gunicorn main:app --timeout=2000

app.py

@@ -0,0 +1,211 @@
+import threading
+from flask import Flask, url_for, redirect
+from flask import request as req
+from flask_cors import CORS
+import helpers.helper as helper
+from helpers.provider import *
+from utils.llms import gpt4,gpt4stream
+app = Flask(__name__)
+CORS(app)
+import queue
+from utils.functions import allocate
+from werkzeug.utils import secure_filename
+import os
+from PIL import Image
+#find . -maxdepth 1 -type f -mmin -10
+#docker run dezsh/inlets client --url=wss://inlets-testing-secret.onrender.com  --upstream=http://192.168.1.8:1331 --token=secret --insecure
+#QxYciPJQwwfb1zBu
+#corcel nineteen AI
+app.config['UPLOAD_FOLDER'] = "static"
+
+@app.route("/v1/chat/completions", methods=['POST'])
+@app.route("/chat/completions", methods=['POST'])
+@app.route("/", methods=['POST'])
+def chat_completions2():
+    all_request_data = {}
+    all_request_data['json'] = req.get_json(silent=True) or {}
+    all_request_data['headers'] = dict(req.headers)
+
+    all_request_data['args'] = req.args.to_dict(flat=False)
+    all_request_data['form'] = req.form.to_dict(flat=False)
+    try:
+        all_request_data['raw_data'] = req.data.decode('utf-8')
+    except Exception:
+        all_request_data['raw_data'] = f"Could not decode raw data (length: {len(req.data)})"
+
+
+    # # --- Now you can access your original values from this dict ---
+    # print("--- Consolidated Request Data ---")
+    # print(json.dumps(all_request_data, indent=2))
+    # print("--------------------------------")
+
+    streaming = req.json.get('stream', False)
+    model = req.json.get('model', 'gpt-4-turbo')
+    messages = req.json.get('messages')
+    api_keys = req.headers.get('Authorization').replace('Bearer ', '')
+    functions = req.json.get('functions')
+    tools = req.json.get('tools')
+    response_format = req.json.get('response_format')
+    if streaming:
+        helper.stopped=True
+
+
+    if tools!=None:
+        allocate(messages,api_keys,model,tools)
+    else:
+        allocate(messages,api_keys,model,[])
+
+    t = time.time()
+
+    def stream_response(messages,model,api_keys="",functions=[],tools=[]):
+        helper.q = queue.Queue() # create a queue to store the response lines
+        if helper.stopped:
+            helper.stopped=False 
+
+
+
+        threading.Thread(target=gpt4stream,args=(messages,model,api_keys)).start() # start the thread
+        
+        started=False
+        while True: # loop until the queue is empty
+            try:
+                if 20>time.time()-t>18 and not started :
+                    yield 'data: %s\n\n' % json.dumps(helper.streamer("> Thinking"), separators=(',' ':'))
+                    time.sleep(2)
+                elif time.time()-t>20 and not started :
+                    yield 'data: %s\n\n' % json.dumps(helper.streamer("."), separators=(',' ':'))
+                    time.sleep(1)
+                if time.time()-t>100 and not started:
+                    yield 'data: %s\n\n' % json.dumps(helper.streamer("Still Thinking...Do not terminate"), separators=(',' ':'))
+                    break
+
+                line = helper.q.get(block=False)
+                if "RESULT: " in line:
+                    line=line.replace("RESULT: ","")
+                    if tools !=None:
+                        yield f'data: {json.dumps(helper.stream_func(line,"tools"))}\n\n'
+                    else:
+                        yield f'data: {json.dumps(helper.end())}\n\n'
+
+                    break
+
+
+                if line == "END":
+                    yield f'data: {json.dumps(helper.end())}\n\n'
+                    break
+                if not started:
+                    started = True
+                    yield 'data: %s\n\n' % json.dumps(helper.streamer("\n\n"), separators=(',' ':'))
+
+
+                yield 'data: %s\n\n' % json.dumps(helper.streamer(line), separators=(',' ':'))
+
+                helper.q.task_done() # mark the task as done
+
+
+            except helper.queue.Empty: 
+                pass
+            except Exception as e:
+                print(e)
+
+    
+
+
+
+
+
+    if not streaming :
+        if functions != None :
+            k=gpt4(messages,None,model)
+            return helper.func_output(k,"functions")
+        elif tools!=None:
+
+            k=gpt4(messages,None,model)
+            return helper.func_output(k,"tools")
+
+        else:
+
+            print("USING GPT_4 NO STREAM")
+            print(model)
+
+            k=gpt4(messages,response_format,model)
+            return helper.output(k)
+
+    elif  streaming   : 
+        return app.response_class(stream_response(messages,model,api_keys,functions,tools), mimetype='text/event-stream')
+    
+
+
+
+
+
+@app.route('/upload', methods=['GET','POST'])
+def index():
+ 
+    # If a post method then handle file upload
+    if req.method == 'POST':
+ 
+        if 'file' not in req.files:
+            return redirect('/')
+ 
+        file = req.files['file']
+ 
+ 
+        if file :
+            filename = secure_filename(file.filename)
+            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+            if ("camera" in file.filename or "capture" in file.filename or "IMG" in file.filename or "Screenshot"  in file.filename) :
+                img=Image.open(f"static/{filename}")
+                img.thumbnail((512, 512),Image.Resampling.LANCZOS)
+
+                img.save(f"static/{filename}")
+
+            return filename
+ 
+ 
+    # Get Files in the directory and create list items to be displayed to the user
+    file_list = ''
+    for f in os.listdir(app.config['UPLOAD_FOLDER']):
+        # Create link html
+        link = url_for("static", filename=f) 
+        file_list = file_list + '<li><a href="%s">%s</a></li>' % (link, f)
+ 
+    # Format return HTML - allow file upload and list all available files
+    return_html = '''
+    <!doctype html>
+    <title>Upload File</title>
+    <h1>Upload File</h1>
+    <form method=post enctype=multipart/form-data>
+            <input type=file name=file><br>
+            <input type=submit value=Upload>
+    </form>
+    <hr>
+    <h1>Files</h1>
+    <ol>%s</ol>
+    ''' % file_list
+ 
+    return return_html
+
+
+@app.route('/')
+def yellow_name():
+   return f'Hello world!'
+
+
+
+@app.route("/v1/models")
+@app.route("/models")
+def models():
+    print("Models")
+    return helper.model
+
+
+
+if __name__ == '__main__':
+    config = {
+        'host': '0.0.0.0',
+        'port': 1337,
+        'debug': True,
+    }
+
+    app.run(**config)

app_combination.py

@@ -0,0 +1,132 @@
+from flask import Flask, url_for, redirect
+from flask import request as req
+from flask_cors import CORS
+import helpers.helper as helper
+from helpers.provider import *
+from utils.llms import chat,chatstream
+app = Flask(__name__)
+CORS(app)
+from utils.functions import allocate
+from werkzeug.utils import secure_filename
+import os
+
+
+
+app.config['UPLOAD_FOLDER'] = "static"
+
+@app.route("/v1/chat/completions", methods=['POST'])
+@app.route("/chat/completions", methods=['POST'])
+@app.route("/", methods=['POST'])
+def chat_completions2():
+
+    streaming = req.json.get('stream', False)
+    model = req.json.get('model', 'gpt-4-turbo')
+    messages = req.json.get('messages')
+    api_keys = req.headers.get('Authorization').replace('Bearer ', '')
+    tools = req.json.get('tools')
+    response_format = req.json.get('response_format')
+
+    allocate(messages,model,tools)
+
+
+    def stream_response(messages,model,tools):
+        for line in chatstream(messages,model,api_keys):
+            if "RESULT: " in line:
+                line=line.replace("RESULT: ","")
+                if tools !=None:
+                    yield f'data: {json.dumps(helper.stream_func(line,"tools"))}\n\n'
+                else:
+                    yield f'data: {json.dumps(helper.end())}\n\n'
+                break
+            yield 'data: %s\n\n' % json.dumps(helper.streamer(line), separators=(',', ':'))
+
+
+
+
+    if not streaming :
+        if tools!=None:
+
+            k=chat(messages,None,model)
+            return helper.func_output(k,"tools")
+
+        else:
+
+            print("NO STREAM")
+            print(model)
+
+            k=chat(messages,response_format,model)
+            return helper.output(k)
+
+    elif  streaming   : 
+        return app.response_class(stream_response(messages,model,tools), mimetype='text/event-stream')
+    
+
+
+
+
+
+@app.route('/upload', methods=['GET','POST'])
+def index():
+ 
+    # If a post method then handle file upload
+    if req.method == 'POST':
+ 
+        if 'file' not in req.files:
+            return redirect('/')
+ 
+        file = req.files['file']
+ 
+ 
+        if file :
+            filename = secure_filename(file.filename)
+            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+
+            return filename
+ 
+ 
+    # Get Files in the directory and create list items to be displayed to the user
+    file_list = ''
+    for f in os.listdir(app.config['UPLOAD_FOLDER']):
+        # Create link html
+        link = url_for("static", filename=f) 
+        file_list = file_list + '<li><a href="%s">%s</a></li>' % (link, f)
+ 
+    # Format return HTML - allow file upload and list all available files
+    return_html = '''
+    <!doctype html>
+    <title>Upload File</title>
+    <h1>Upload File</h1>
+    <form method=post enctype=multipart/form-data>
+            <input type=file name=file><br>
+            <input type=submit value=Upload>
+    </form>
+    <hr>
+    <h1>Files</h1>
+    <ol>%s</ol>
+    ''' % file_list
+ 
+    return return_html
+
+
+@app.route('/')
+def yellow_name():
+   return f'All good!'
+
+
+
+@app.route("/v1/models")
+@app.route("/models")
+def models():
+    print("Models")
+    return helper.model
+
+
+
+if __name__ == '__main__':
+    config = {
+        'host': '0.0.0.0',
+        'port': 1337,
+        'debug': True,
+    }
+
+    app.run(**config)

data.json

@@ -0,0 +1 @@
+{}

extensions/anycreator.py

@@ -0,0 +1,31 @@
+import random
+import urllib.request
+import requests
+import time
+import urllib.request
+data={}
+imgur=[]
+def getimage(query):
+
+    payload = {
+        "model": "absolutereality_v181.safetensors [3d9d4d2b]",
+        "prompt": str(query)
+    }
+
+    response = requests.post("https://api.prodia.com/v1/sd/generate", json=payload, headers={"accept": "application/json","content-type": "application/json","X-Prodia-Key": "da6053eb-c352-4374-a459-2a9a5eaaa64b"})
+    jobid=response.json()["job"]
+    while True:
+        response = requests.get(f"https://api.prodia.com/v1/job/{jobid}", headers={"accept": "application/json","X-Prodia-Key": "da6053eb-c352-4374-a459-2a9a5eaaa64b"})
+        if response.json()["status"]=="succeeded":
+            image=response.json()["imageUrl"]
+            break
+        time.sleep(0.5)
+
+    filename=f"static/image{random.randint(1,1000)}.png"
+
+    urllib.request.urlretrieve(image, filename)
+
+    return filename
+
+
+

function_support.py

@@ -0,0 +1,71 @@
+
+from typing import Any, Dict, List, Optional
+from langchain_core.prompts import SystemMessagePromptTemplate
+import json
+
+DEFAULT_SYSTEM_TEMPLATE = """You have access to the following tools:
+
+{tools}
+
+If using tools , You must respond with a JSON object in a JSON codeblock inside think matching the following schema.
+
+
+```json
+[
+{{
+"tool": <name of the selected tool>,
+"tool_input": <parameters for the selected tool, matching the tool's JSON schema>
+}}
+]
+```
+
+"""  # noqa: E501
+
+DEFAULT_RESPONSE_FUNCTION = {
+    "name": "__conversational_response",
+    "description": (
+        "Respond conversationally if no other tools should be called for a given query."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "response": {
+                "type": "string",
+                "description": "Conversational response to the user.",
+            },
+        },
+        "required": ["response"],
+    },
+}
+def _function(**kwargs: Any,):
+    functions = kwargs.get("functions", [])
+    tools=kwargs.get("tools", [])
+
+
+    if "type" not in tools and "function" not in tools:
+        functions=tools
+        functions = [
+            fn for fn in functions 
+        ]
+        if not functions:
+            raise ValueError(
+                'If "function_call" is specified, you must also pass a matching \
+    function in "functions".'
+            )
+    elif "tools" in kwargs:
+        functions = [
+            fn["function"] for fn in tools
+        ]
+        # del kwargs["function_call"]
+    # elif ""
+    # elif not functions:
+    # functions.append(DEFAULT_RESPONSE_FUNCTION)
+    system_message_prompt_template = SystemMessagePromptTemplate.from_template(
+        DEFAULT_SYSTEM_TEMPLATE
+    )
+    system_message = system_message_prompt_template.format(
+        tools=json.dumps(functions, indent=2)
+    )
+    if "functions" in kwargs:
+        del kwargs["functions"]
+    return system_message.content

har_and_cookies/auth_LambdaChat.json

@@ -0,0 +1 @@
+{"cookies": {"hf-chat": "167f7c78-2d32-4d5b-acec-0f77246c09e2"}}

har_and_cookies/blackbox.json

@@ -0,0 +1 @@
+{"validated_value": "00f37b34-a166-4efb-bce5-1312d87f2f94"}

helpers/helper.py

@@ -0,0 +1,178 @@
+from helpers.provider import *
+from helpers.models import model
+import re,ast
+
+def streamer(tok):
+        completion_timestamp = int(time.time())
+        completion_id = ''.join(random.choices(
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+        completion_tokens = num_tokens_from_string(tok)
+
+        completion_data = {
+            'id': f'chatcmpl-{completion_id}',
+            'object': 'chat.completion.chunk',
+            'created': completion_timestamp,
+            'model': 'gpt-4',
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": completion_tokens,
+                "total_tokens": completion_tokens,
+            },
+            'choices': [
+                {
+                    'delta': {
+                        'role':"assistant",
+                        'content':tok
+                    },
+                    'index': 0,
+                    'finish_reason': None
+                }
+            ]
+        }
+        return completion_data
+
+def end():
+    completion_timestamp = int(time.time())
+    completion_id = ''.join(random.choices(
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+
+    end_completion_data = {
+        'id': f'chatcmpl-{completion_id}',
+        'object': 'chat.completion.chunk',
+        'created': completion_timestamp,
+        'model': model,
+        'provider': 'openai',
+        'choices': [
+            {
+                'index': 0,
+                'delta': {},
+                'finish_reason': 'stop',
+            }
+        ],
+    }
+    return end_completion_data
+
+
+def output(tok):
+        completion_timestamp = int(time.time())
+        completion_id = ''.join(random.choices(
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+        completion_tokens = 11
+
+        return {
+            'id': 'chatcmpl-%s' % completion_id,
+            'object': 'chat.completion',
+            'created': completion_timestamp,
+            'model': "gpt-4-0125-preview",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": completion_tokens,
+                "total_tokens": completion_tokens,
+            },
+            'choices': [{
+                'message': {
+                    'role': 'assistant',
+                    'content': tok
+                },
+                'finish_reason': 'stop',
+                'index': 0
+            }]
+        }
+
+def stream_func(tok,type_tool):
+        print("-"*500)
+        print(f"streaming {type_tool}")
+        completion_timestamp = int(time.time())
+        completion_id = ''.join(random.choices(
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+        completion_tokens = 11
+        tool_calls=[]
+        regex = r'```json\n(.*?)\n```'
+        matches = re.findall(regex, tok, re.DOTALL)
+        print(matches)
+
+
+        if matches !=[]:
+        
+            info_blocks = ast.literal_eval(matches[0])
+
+            for info_block in info_blocks:
+                tok=tok.replace(f"```json\n{info_block}\n```",'')
+
+                tool_data=info_block
+                # to_add={"function":{"arguments":re.sub(r"(?<!\w)'(.*?)'(?!\w)", r'"\1"', str(tool_data["tool_input"])),"name":tool_data["tool"]},"id":f"call_3GjyYbPEskNsP67fkjyXj{random.randint(100,999)}","type":"function"}
+                to_add={"function":{"arguments":json.dumps(tool_data["tool_input"]),"name":tool_data["tool"]},"id":f"call_3GjyYbPEskNsP67fkjyXj{random.randint(100,999)}","type":"function"}
+
+                print(to_add)
+                tool_calls.append(to_add)
+
+        completion_data = {
+            'id': f'chatcmpl-{completion_id}',
+            'object': 'chat.completion.chunk',
+            'created': completion_timestamp,
+            'model': 'gpt-4',
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": completion_tokens,
+                "total_tokens": completion_tokens,
+            },
+            'choices': [
+                {
+                    'delta': {
+                        'role':"assistant",
+                        'content':"",
+                        "tool_calls":tool_calls,
+                    },
+                    'index': 0,
+                    'finish_reason': "",                    }
+            ]
+        }
+
+        return completion_data
+def func_output(tok,type_tool):
+        print("-"*500)
+        print(f"OUTPUTTING {type_tool}")
+        completion_timestamp = int(time.time())
+        completion_id = ''.join(random.choices(
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+        completion_tokens = 11
+        tool_calls=[]
+        regex = r'```json\n(.*?)\n```'
+        matches = re.findall(regex, tok, re.DOTALL)
+        print(matches)
+
+
+        if matches !=[]:
+        
+            info_blocks = ast.literal_eval(matches[0])
+
+            for info_block in info_blocks:
+                tok=tok.replace(f"```json\n{info_block}\n```",'')
+
+                tool_data=info_block
+                # to_add={"function":{"arguments":re.sub(r"(?<!\w)'(.*?)'(?!\w)", r'"\1"', str(tool_data["tool_input"])),"name":tool_data["tool"]},"id":f"call_3GjyYbPEskNsP67fkjyXj{random.randint(100,999)}","type":"function"}
+                to_add={"function":{"arguments":json.dumps(tool_data["tool_input"]),"name":tool_data["tool"]},"id":f"call_3GjyYbPEskNsP67fkjyXj{random.randint(100,999)}","type":"function"}
+
+                print(to_add)
+                tool_calls.append(to_add)
+
+        return {
+            'id': 'chatcmpl-%s' % completion_id,
+            'object': 'chat.completion',
+            'created': completion_timestamp,
+            'model': "gpt-4.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": completion_tokens,
+                "total_tokens": completion_tokens,
+            },
+            'choices': [{
+                'message': {
+                    'role': 'assistant',
+                    'content': tok,
+                    "tool_calls":tool_calls
+                },
+                'finish_reason': '',
+                'index': 0
+            }]
+        }

helpers/models.py

@@ -0,0 +1,225 @@
+model = {
+    "data": [
+
+        {
+            "id": "gemini-2.0-flash-thinking-exp-01-21",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 819792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "hidden":False,
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "gemini-2.5-pro-exp-03-25",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 819792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "hidden":False,
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "qwen-qwq-32b",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 81792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "QwQ-32B",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 81792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "gemini-2.0-flash-thinking-exp-01-21",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 819792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "deepseek-r1-distill-llama-70b",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 819792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "DeepSeekR1-togetherAI",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 819792,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "DeepSeekV3-togetherAI",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 812192,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "llama-3.3-70b-versatile",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 813392,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "gpt-4-0125-preview-web",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 8192,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "gpt-4-1106-vision-preview",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 8192,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+        {
+            "id": "gpt-4-0613-web",
+            "object": "model",
+            "owned_by": "reversed",
+            "tokens": 8192,
+            "fallbacks": [
+                "gpt-3.5-turbo-16k"
+            ],
+            "endpoints": [
+                "/api/chat/completions"
+            ],
+            "limits": [
+                "2/minute",
+                "300/day"
+            ],
+            "public": True,
+            "permission": []
+        },
+    ],
+    "object": "list"
+}
+

helpers/provider.py

@@ -0,0 +1,15 @@
+import json
+import requests
+import time
+import tiktoken
+import random
+
+TOKEN = "5182224145:AAEjkSlPqV-Q3rH8A9X8HfCDYYEQ44v_qy0"
+chat_id = "5075390513"
+
+def num_tokens_from_string(string: str, encoding_name: str = "cl100k_base") -> int:
+    """Returns the number of tokens in a text string."""
+    encoding = tiktoken.get_encoding(encoding_name)
+    num_tokens = len(encoding.encode(string))
+    return num_tokens
+

requirements.txt

@@ -0,0 +1,25 @@
+Flask
+flask_cors
+requests
+revchatgpt
+gunicorn>=20.1.0
+g4f>=0.4.9.6
+tiktoken
+PyExecJS
+pyimgur
+transformers
+werkzeug
+e2b==0.17.1
+openpyxl
+beautifulsoup4
+google-generativeai
+Pillow
+requests_futures
+langchain_core
+unofficial-claude-api
+opencv-python 
+langchain_community
+tool_calling_llm
+langchain
+langchain-core
+litellm

tests/apppy.py

@@ -0,0 +1,32 @@
+
+# from g4f.Provider import DeepInfraChat,Glider,Liaobots,Blackbox,ChatGptEs,LambdaChat,TypeGPT
+# DeepInfraChat.models = ["google/gemma-3-27b-it","deepseek-ai/DeepSeek-R1-Turbo","Qwen/QwQ-32B","deepseek-ai/DeepSeek-R1","deepseek-ai/DeepSeek-V3-0324","meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","meta-llama/Llama-4-Scout-17B-16E-Instruct","microsoft/Phi-4-multimodal-instruct"]
+# deepinframodels=["meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","microsoft/Phi-4-multimodal-instruct","google/gemma-3-27b-it","meta-llama/Llama-4-Scout-17B-16E-Instruct"]
+# REASONING_CORRESPONDANCE = {"DeepSeek-R1-Glider":Glider, "DeepSeekR1-LAMBDA":LambdaChat,"DeepSeekR1":DeepInfraChat,"deepseek-slow":TypeGPT}
+# REASONING_QWQ = {"qwq-32b":DeepInfraChat}
+# from g4f.client import Client
+# client = Client()
+
+# cunk=""
+
+# providers=REASONING_CORRESPONDANCE
+# model_name="deepseek-r1"
+
+# for provider in providers:
+#         try:
+#             response = client.chat.completions.create(
+#                 provider=providers[provider],
+#                 model=model_name,
+#                 messages=[{"role": "user", "content": f"Hi!"}],
+#                 stream=True
+
+#                 # Add any other necessary parameters
+#             )
+#             for part in response:
+#                 # print(part)
+#                 cunk=cunk+(str(part.choices[0].delta.content) or "")
+#                 print(str(part.choices[0].delta.content),end="")
+#             break
+#         except Exception as e:
+#             print(f"Error with {provider}: {e}")
+#             pass

tests/e2bdev.py

@@ -0,0 +1,455 @@
+from mcp.server.fastmcp import FastMCP
+import time
+from litellm import completion
+import os
+import glob
+import http.client
+import json
+import openpyxl
+import shutil
+from google import genai
+import pexpect
+
+client = genai.Client(api_key="AIzaSyDtP05TyoIy9j0uPL7_wLEhgQEE75AZQSc")
+source_dir = "/app/uploads/temp"
+destination_dir = "/app/code_interpreter"
+files_list=[]
+downloaded_files=[]
+
+from openai import OpenAI
+clienty = OpenAI(api_key="xyz", base_url="https://akiko19191-backend.hf.space/")
+
+mcp = FastMCP("code_sandbox")
+data={}
+result=""
+import requests
+import os
+from bs4 import BeautifulSoup  # For parsing HTML
+
+Parent=pexpect.spawn('bash')
+
+
+
+def transfer_files():
+    try:
+        for item in os.listdir(source_dir):
+            item_path = os.path.join(source_dir, item)
+            if os.path.isdir(item_path): # Check if it's a directory
+                for filename in os.listdir(item_path):
+                    source_file_path = os.path.join(item_path, filename)
+                    destination_file_path = os.path.join(destination_dir, filename)
+                    if not os.path.exists(destination_file_path):
+                        shutil.move(source_file_path, destination_file_path)
+    except:
+        pass
+def transfer_files2():
+    try:
+        for item in os.listdir("/app/uploads"):
+            if "temp" not in item:
+                item_path = os.path.join(source_dir, item)
+                if os.path.isdir(item_path): # Check if it's a directory
+                    for filename in os.listdir(item_path):
+                        source_file_path = os.path.join(item_path, filename)
+                        destination_file_path = os.path.join(destination_dir, filename.split("__")[1])
+                        if not os.path.exists(destination_file_path):
+                            shutil.move(source_file_path, destination_file_path)
+    except:
+        pass
+def upload_file(file_path, upload_url):
+    """Uploads a file to the specified server endpoint."""
+
+    try:
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Prepare the file for upload
+        with open(file_path, "rb") as file:
+            files = {"file": (os.path.basename(file_path), file)}  #  Important: Provide filename
+
+            # Send the POST request
+            response = requests.post(upload_url, files=files)
+
+            # Check the response status code
+            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+
+            # Parse and print the response
+            if response.status_code == 200:
+                print(f"File uploaded successfully.  Filename returned by server: {response.text}")
+                return response.text # Return the filename returned by the server
+            else:
+                print(f"Upload failed. Status code: {response.status_code}, Response: {response.text}")
+                return None
+
+    except FileNotFoundError as e:
+        print(e)
+        return None  # or re-raise the exception if you want the program to halt
+    except requests.exceptions.RequestException as e:
+        print(f"Upload failed. Network error: {e}")
+        return None
+
+
+TOKEN = "5182224145:AAEjkSlPqV-Q3rH8A9X8HfCDYYEQ44v_qy0"
+chat_id = "5075390513"
+from requests_futures.sessions import FuturesSession
+session = FuturesSession()
+
+def run(cmd, timeout_sec,forever_cmd):
+    global Parent
+    if forever_cmd == 'true':
+        Parent.close()
+        Parent = pexpect.spawn("bash")
+        command="cd /app/code_interpreter/ && "+cmd
+
+        Parent.sendline(command)
+        Parent.readline().decode()
+        return str(Parent.readline().decode())    
+    t=time.time()
+    child = pexpect.spawn("bash")
+    output=""
+    command="cd /app/code_interpreter/ && "+cmd
+
+    child.sendline('PROMPT_COMMAND="echo END"')
+    child.readline().decode()
+    child.readline().decode()
+
+    child.sendline(command)
+
+    while (not child.eof() ) and (time.time()-t<timeout_sec):
+        x=child.readline().decode()
+        output=output+x
+        print(x)
+        if "END" in x :
+            output=output.replace("END","")
+            child.close()
+            break
+        if "true" in forever_cmd:
+            break
+    return output
+
+@mcp.tool()
+def analyse_audio(audiopath,query) -> dict:
+    """Ask another AI model about audios.The AI model can listen to the audio and give answers.Eg-query:Generate detailed minutes of meeting from the audio clip,audiopath='/app/code_interpreter/<audioname>'.Note:The audios are automatically present  in the /app/code_interpreter directory."""
+    transfer_files2()
+    myfile = client.files.upload(file=audiopath)
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, myfile]
+    )
+    return {"Output":str(response.text)}
+
+@mcp.tool()
+def analyse_video(videopath,query) -> dict:
+    """Ask another AI model about videos.The AI model can see the videos and give answers.Eg-query:Create a very detailed transcript and summary of the video,videopath='/app/code_interpreter/<videoname>'Note:The videos are automatically present  in the /app/code_interpreter directory."""
+    transfer_files2()
+    video_file = client.files.upload(file=videopath)
+
+    while video_file.state.name == "PROCESSING":
+        print('.', end='')
+        time.sleep(1)
+        video_file = client.files.get(name=video_file.name)
+
+    if video_file.state.name == "FAILED":
+        raise ValueError(video_file.state.name)
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, video_file]
+    )
+    return {"Output":str(response.text)}
+
+
+@mcp.tool()
+def analyse_images(imagepath,query) -> dict:
+    """Ask another AI model about images.The AI model can see the images and give answers.Eg-query:Who is the person in this image?,imagepath='/app/code_interpreter/<imagename>'.Note:The images are automatically present  in the /app/code_interpreter directory."""
+    transfer_files2()
+    video_file = client.files.upload(file=imagepath)
+
+
+    response = client.models.generate_content(
+    model='gemini-2.0-flash',
+    contents=[query, video_file]
+    )
+    return {"Output":str(response.text)}
+
+
+# @mcp.tool()
+# def generate_images(imagepath,query) -> dict:
+#     """Ask another AI model to generate images based on the query and the image path.Set image path as an empty string , if you dont want to edit images , but rather generate images.Eg-query:Generate a cartoon version of this image,imagepath='/app/code_interpreter/<imagename>'.Note:The images are automatically present  in the /app/code_interpreter directory."""
+#     transfer_files2()
+#     video_file = client.files.upload(file=imagepath)
+
+
+#     response = client.models.generate_content(
+#     model='gemini-2.0-flash',
+#     contents=[query, video_file]
+#     )
+#     return {"Output":str(response.text)}
+
+@mcp.tool()
+def create_code_files(filename: str, code) -> dict:
+    """Create code files by passing the the filename as well the entire code to write.The file is created by default in the /app/code_interpreter directory.Note:All user uploaded files that you might need to work upon are stored in the /app/code_interpreter directory."""
+    global destination_dir
+    transfer_files()
+    transfer_files2()
+    if not os.path.exists(os.path.join(destination_dir, filename)):
+        
+        if isinstance(code, dict):
+            with open(os.path.join(destination_dir, filename), 'w', encoding='utf-8') as f:
+                json.dump(code, f, ensure_ascii=False, indent=4)
+        else:
+            f = open(os.path.join(destination_dir, filename), "w")
+            f.write(str(code))
+            f.close()
+        return {"info":"The referenced code files were created successfully."}
+
+    else:
+        if isinstance(code, dict):
+            with open(os.path.join(destination_dir, filename), 'w', encoding='utf-8') as f:
+                json.dump(code, f, ensure_ascii=False, indent=4)
+        else:
+            f = open(os.path.join(destination_dir, filename), "w")
+            f.write(str(code))
+            f.close()
+        return {"info":"The referenced code files were created successfully."}
+        # return {"info":"The referenced code files already exist. Please rename the file or delete the existing one."}
+
+    
+@mcp.tool()
+def run_code(language:str,packages:str,filename: str, code: str,start_cmd:str,forever_cmd:str) -> dict:
+    """  
+    Execute code in a controlled environment with package installation and file handling.
+    Args:
+        language:Programming language of the code (eg:"python", "nodejs", "bash","html",etc).
+        packages: Space-separated list of packages to install.(python packages are installed if language set to python and npm packages are installed if language set to nodejs).
+                  Preinstalled python packages: gradio, XlsxWriter, openpyxl , mpxj , jpype1.
+                  Preinstalled npm packages: express, ejs, chart.js.
+        filename:Name of the file to create (stored in /app/code_interpreter/).
+        code:Full code to write to the file.
+        start_cmd:Command to execute the file (e.g., "python /app/code_interpreter/app.py" 
+                  or "bash /app/code_interpreter/app.py").
+                  Leave blank ('') if only file creation is needed / start_cmd not required.
+        forever_cmd:If 'true', the command will run indefinitely.Set to 'true', when runnig a website/server.Run all servers/website on port 1337. If 'false', the command will time out after 300 second and the result will be returned.
+    Notes:
+        - All user-uploaded files are in /app/code_interpreter/.
+        - After execution, embed a download link (or display images/gifs/videos directly in markdown format) in your response.
+        - bash/apk packages cannot be installed.
+        - When editing and subsequently re-executing the server with the forever_cmd='true' setting, the previous server instance will be automatically terminated, and the updated server will commence operation. This functionality negates the requirement for manual process termination commands such as pkill node.    
+        - The opened ports can be externally accessed at https://suitable-liked-ibex.ngrok-free.app/ (ONLY if the website is running successfully)
+        - Do not use `plt.show()` in this headless environment. Save visualizations directly (e.g., `plt.savefig("happiness_img.png")` or export GIFs/videos).  
+    """
+    global destination_dir
+    package_names = packages.strip()
+    if "python" in language:
+        command="pip install  --break-system-packages "
+    elif "node" in language:
+        command="npm install "
+    else:
+        command="ls"
+    if  packages != "" and packages != " ":
+        package_logs=run(
+            f"{command} {package_names}", timeout_sec=300,forever_cmd= 'false' 
+        )
+        if "ERROR" in package_logs:
+            return {"package_installation_log":package_logs,"info":"Package installation failed. Please check the package names. Tip:Try using another package/method to accomplish the task."}
+    transfer_files2()
+    transfer_files()
+    f = open(os.path.join(destination_dir, filename), "w")
+    f.write(code)
+    f.close()
+    global files_list
+    if start_cmd != "" and start_cmd != " ":
+        stdot=run(start_cmd, 120,forever_cmd)
+    else:
+        stdot="File created successfully."
+    onlyfiles = glob.glob("/app/code_interpreter/*")
+    onlyfiles=list(set(onlyfiles)-set(files_list))
+    uploaded_filenames=[]
+    for files in onlyfiles:
+        try:
+            uploaded_filename = upload_file(files, "https://opengpt-4ik5.onrender.com/upload")
+            uploaded_filenames.append(f"https://opengpt-4ik5.onrender.com/static/{uploaded_filename}")
+        except:
+            pass
+    files_list=onlyfiles
+    return {"output":stdot,"Files_download_link":uploaded_filenames}
+
+
+@mcp.tool()
+def run_code_files(start_cmd:str,forever_cmd:str) -> dict:
+    """Executes a shell command to run code files from /app/code_interpreter.
+    Runs the given `start_cmd`. The execution behavior depends on `forever_cmd`.
+    Any server/website started should use port 1337.
+    Args:
+        start_cmd (str): The shell command to execute the code.
+                         (e.g., ``python /app/code_interpreter/app.py`` or ``node /app/code_interpreter/server.js``).
+                         Files must be in ``/app/code_interpreter``.
+        forever_cmd (str): Execution mode.
+                           - ``'true'``: Runs indefinitely (for servers/websites).
+                           - ``'false'``: Runs up to 300s, captures output.
+    Returns:
+        dict: A dictionary containing:
+              - ``'output'`` (str): Captured stdout (mainly when forever_cmd='false').
+              - ``'Files_download_link'`` (Any): Links/identifiers for downloadable files.
+    Notes:
+        - After execution, embed a download link (or display images/gifs/videos directly in markdown format) in your response.
+        - When editing and subsequently re-executing the server with the forever_cmd='true' setting, the previous server instance will be automatically terminated, and the updated server will commence operation. This functionality negates the requirement for manual process termination commands such as pkill node.    
+        - The opened ports can be externally accessed at https://suitable-liked-ibex.ngrok-free.app/ (ONLY if the website is running successfully)
+    """    
+    global files_list
+
+    stdot=run(start_cmd, 300,forever_cmd)
+    onlyfiles = glob.glob("/app/code_interpreter/*")
+    onlyfiles=list(set(onlyfiles)-set(files_list))
+    uploaded_filenames=[]
+    for files in onlyfiles:
+        try:
+            uploaded_filename = upload_file(files, "https://opengpt-4ik5.onrender.com/upload")
+            uploaded_filenames.append(f"https://opengpt-4ik5.onrender.com/static/{uploaded_filename}")
+        except:
+            pass
+    files_list=onlyfiles
+    return {"output":stdot,"Files_download_link":uploaded_filenames}
+
+
+@mcp.tool()
+def run_shell_command(cmd:str,forever_cmd:str) -> dict:
+    """Executes a shell command in a sandboxed Alpine Linux environment.
+    Runs the provided `cmd` string within a bash shell. Commands are executed
+    relative to the `/app/code_interpreter/` working directory by default.
+    The execution behavior (indefinite run vs. timeout) is controlled by
+    the `forever_cmd` parameter.
+    Important Environment Notes:
+        - The execution environment is **Alpine Linux**. Commands should be
+          compatible .
+        - `sudo` commands are restricted for security reasons.Hence commands which require elevated privelages like `apk add` CANNOT be executed.Instead try to use `pip install` or `npm install` commands. 
+        - Standard bash features like `&&`, `||`, pipes (`|`), etc., are supported.
+    Args:
+        cmd (str): The shell command to execute.
+                   Example: ``mkdir test_dir && ls -l``
+        forever_cmd (str): Determines the execution mode.
+                           - ``'true'``: Runs the command indefinitely. Suitable
+                             for starting servers or long-running processes.
+                             Output capture might be limited.
+                           - ``'false'``: Runs the command until completion or
+                             a 300-second timeout, whichever comes first.
+                             Captures standard output.
+    Returns:
+        dict: A dictionary containing the execution results:
+              - ``'output'`` (str): The captured standard output (stdout) and potentially
+                standard error (stderr) from the command.
+    """    
+    transfer_files()
+    transfer_files2()
+    output=run(cmd, 300,forever_cmd)
+    return {"output":output}
+
+
+
+@mcp.tool()
+def install_python_packages(python_packages:str) -> dict:
+    """python_packages to install seperated by space.eg-(python packages:numpy matplotlib).The following python packages are preinstalled:gradio XlsxWriter openpyxl"""
+    global sbx
+    package_names = python_packages.strip()
+    command="pip install"
+    if not package_names:
+        return
+
+    stdot=run(
+        f"{command} --break-system-packages {package_names}", timeout_sec=300, forever_cmd= 'false' 
+    )
+
+    return {"stdout":stdot,"info":"Ran package installation command"}
+
+@mcp.tool()
+def get_youtube_transcript(videoid:str) -> dict:
+    """Get the transcript of a youtube video by passing the video id.Eg videoid=ZacjOVVgoLY"""
+    conn = http.client.HTTPSConnection("youtube-transcript3.p.rapidapi.com")
+    headers = {
+        'x-rapidapi-key': "2a155d4498mshd52b7d6b7a2ff86p10cdd0jsn6252e0f2f529",
+        'x-rapidapi-host': "youtube-transcript3.p.rapidapi.com"
+    }
+    conn.request("GET",f"/api/transcript?videoId={videoid}", headers=headers)
+
+    res = conn.getresponse()
+    data = res.read()
+    return json.loads(data)
+
+@mcp.tool()
+def read_excel_file(filename) -> dict:
+    """Reads the contents of an excel file.Returns a dict with key :value pair  = cell location:cell content.Always run this command first , when working with excels.The excel file is automatically present  in the /app/code_interpreter directory. """
+    global destination_dir
+    transfer_files2()
+    transfer_files()
+
+    workbook = openpyxl.load_workbook(os.path.join(destination_dir, filename))
+
+    # Create an empty dictionary to store the data
+    excel_data_dict = {}
+
+    # Iterate over all sheets
+    for sheet_name in workbook.sheetnames:
+        sheet = workbook[sheet_name]
+        # Iterate over all rows and columns
+        for row in sheet.iter_rows():
+            for cell in row:
+                # Get cell coordinate (e.g., 'A1') and value
+                cell_coordinate = cell.coordinate
+                cell_value = cell.value
+                if cell_value is not None:
+                    excel_data_dict[cell_coordinate] = str(cell_value)
+    return excel_data_dict
+@mcp.tool()
+def scrape_websites(url_list:list,query:str) -> list:
+    """Scrapes specific website content.query is the question you want to ask about the content of the website.e.g-query:Give .pptx links in the website,Summarise the content in very  great detail,etc.Maximum 4 urls can be passed at a time."""
+
+    conn = http.client.HTTPSConnection("scrapeninja.p.rapidapi.com")
+
+
+    headers = {
+    'x-rapidapi-key': "2a155d4498mshd52b7d6b7a2ff86p10cdd0jsn6252e0f2f529",
+    'x-rapidapi-host': "scrapeninja.p.rapidapi.com",
+    'Content-Type': "application/json"
+    }
+    Output=""
+    links=""
+    content=""
+    for urls in url_list:
+        payload = {"url" :urls} 
+        payload=json.dumps(payload)
+        conn.request("POST", "/scrape", payload, headers)
+        res = conn.getresponse()
+        data = res.read()
+        content=content+str(data.decode("utf-8"))
+        
+    #Only thing llama 4 is good for.
+
+    response = clienty.chat.completions.create(
+        model="meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+        messages=[
+        {"role": "user", "content": f"{query} [CONTENT]:{content}"}
+    ],stream=True
+    )
+    for chunk in response:
+        Output = Output +str(chunk.choices[0].delta.content)
+    #--------------
+    response2 = clienty.chat.completions.create(
+        model="meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+        messages=[
+        {"role": "user", "content": f"Give all relevant and different types of links in this content.The links may be relevant image links , file links , video links , website links , etc .You must give Minimum 30 links and maximum 50 links.[CONTENT]:{content}"}
+    ],stream=True
+    )
+    for chunk in response2:
+        links = links +str(chunk.choices[0].delta.content)
+    return {"website_content":Output,"relevant_links":links}
+
+
+
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    Ngrok=pexpect.spawn('bash')
+    Ngrok.sendline("ngrok http --url=suitable-liked-ibex.ngrok-free.app 1337 --config /home/node/.config/ngrok/ngrok.yml")
+    Ngrok.readline().decode()
+    mcp.run(transport='stdio')

tests/new.py

@@ -0,0 +1,29 @@
+from openai import OpenAI
+client = OpenAI(base_url="http://192.168.1.7:1337/")
+from rubbish import x
+
+completion = client.chat.completions.create(
+  model="deepseek-reasoner",
+  messages=[
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": f"Hi!"}, 
+  ],
+  stream=True
+)
+for chunk in completion:
+    # print(chunk)
+    print(chunk.choices[0].delta.content,end="")
+    # print("****************")
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/prompts.txt

@@ -0,0 +1,16 @@
+After successfully completing a tool Call, run the next tool Call.
+Eg - after the create code file, you must run the run code file tool Call. 
+Note:Do NOT run the same tool Call consecutively. I am telling you this because you often make mistakes of running the same tool Call with the same code again and again. Maybe you are forgetting that you have run the tool Call previously. Please don't forget this. 
+Important note:Always respond in natural language after a particular tool Call has been successfully completed. Start initialising the next required tool Call. 
+
+Your purpose:
+You have been especially designed to work with excel files. You have all the tools available to you to work with the excel files.
+You must primarily use python and openpyxl to work with the excel files. Always save the files with a different name each time , this is important.Do not save the files with the same name that was given to you. 
+If you have any confusions if you are to use this cell or that cell for fetching the data for a formula, always clarify with the user first.
+Always read the excel files before you start writing the code files.
+
+Your main job is to work with Excel files using Python and the openpyxl library. You have all the tools needed to handle these files. Always save changes with a new filename—never overwrite the original file. Before writing any code, carefully read the Excel file to understand its structure. If you're unsure about which cells to use for formulas or data, ask the user for clarification first. Keep your approach simple and clear.
+Important Info:Always run the next tool after completing one (e.g., create code → run code). Never repeat the same tool.Respond to user after completion giving file links.
+
+Your main job is to work with Excel files using Python and the openpyxl library. You have all the tools needed to handle these files. Always save changes with a new filename—never overwrite the original file. Before writing any code, carefully read the Excel file to understand its structure. If you're unsure about which cells to use for formulas or data, ask the user for clarification first. Keep your approach simple and clear.Always try to insert excel formulas to accomplish the tasks rather than using python code to calculate the tasks. Eg : use the excel SUM formula to calculate SUM.
+Important Info:Always run the next tool after completing one (e.g., create code → run code). Never run the same tool with the same content consecutively.Respond to user after all task completion giving file links.

tests/tests.py

@@ -0,0 +1,34 @@
+# from litellm import completion
+# from openai import OpenAI
+
+# client = OpenAI(
+#   base_url="http://192.168.1.7:1337",
+
+#   api_key="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",
+
+# )
+
+# completion = client.chat.completions.create(
+
+#   model="google/gemini-2.0-flash-001",
+
+#   messages= [
+
+#     { "role": "user", "content": "What's the weather like in London?" }
+
+#   ],
+
+
+# )
+# print(completion.choices[0].message)
+
+from g4f.client import Client
+
+client = Client()
+response = client.images.generate(
+    model="flux",
+    prompt="a white siamese cat",
+    response_format="url"
+)
+
+print(f"Generated image URL: {response.data[0].url}")

tests/usefull_funcs.py

@@ -0,0 +1,19 @@
+import tiktoken
+import re
+
+def split_text_into_chunks(text, max_tokens=100000, encoding_name="cl100k_base"):
+    enc = tiktoken.get_encoding(encoding_name)
+    tokens = enc.encode(text)
+    chunks = []
+    for i in range(0, len(tokens), max_tokens):
+        chunk = tokens[i:i+max_tokens]
+        chunks.append(enc.decode(chunk))
+    return chunks
+
+
+# print(completion.choices[0].message.content)
+
+def extract_https_links(text):
+    # Finds all HTTPS URLs starting with "https://" followed by non-whitespace characters
+    return re.findall(r'\b((?:https?://)?(?:(?:www\.)?(?:[\da-z\.-]+)\.(?:[a-z]{2,6})|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)|(?:(?:[0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(?::[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(?:ffff(?::0{1,4}){0,1}:){0,1}(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])))(?::[0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])?(?:/[\w\.-]*)*/?)\b', text)
+

utils/__init__.py

@@ -0,0 +1,47 @@
+import tiktoken
+
+
+def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0301"):
+    """Returns the number of tokens used by a list of messages."""
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        print("Warning: model not found. Using cl100k_base encoding.")
+        encoding = tiktoken.get_encoding("cl100k_base")
+    if model == "gpt-3.5-turbo":
+        print(
+            "Warning: gpt-3.5-turbo may change over time. Returning num tokens assuming gpt-3.5-turbo-0301."
+        )
+        return num_tokens_from_messages(messages, model="gpt-3.5-turbo-0301")
+    elif model == "gpt-4":
+        print(
+            "Warning: gpt-4 may change over time. Returning num tokens assuming gpt-4-0314."
+        )
+        return num_tokens_from_messages(messages, model="gpt-4-0314")
+    elif model == "gpt-3.5-turbo-0301":
+        tokens_per_message = (
+            4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+        )
+        tokens_per_name = -1  # if there's a name, the role is omitted
+    elif model == "gpt-4":
+        tokens_per_message = 3
+        tokens_per_name = 1
+    else:
+        raise NotImplementedError(
+            f"""num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
+        )
+    num_tokens = 0
+    for message in messages:
+        num_tokens += tokens_per_message
+        for key, value in message.items():
+            num_tokens += len(encoding.encode(value))
+            if key == "name":
+                num_tokens += tokens_per_name
+    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
+    return num_tokens
+
+def num_tokens_from_string(string: str ) -> int:
+    """Returns the number of tokens in a text string."""
+    encoding =tiktoken.encoding_for_model("gpt-4-0314")
+    num_tokens = len(encoding.encode(string))
+    return num_tokens

utils/functions.py

@@ -0,0 +1,50 @@
+import re
+from function_support import _function
+
+def extract_links(text):
+    url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+
+    urls = re.findall(url_pattern, text)
+    return urls
+
+
+
+def allocate(messages,model,functs):
+    if "gemini" not in model:
+        for msg in messages:
+            if isinstance(msg["content"],list):
+                msg["content"]=msg["content"][0]["text"]
+
+
+    for msg in messages:
+        if "tool" in msg["role"]:
+            msg["role"]="user"
+            msg["content"]=f"Tool {msg['name']} returned response: {msg['content']}. Now you must output the next tool Call or respond to user in natural language  after the task has been completed. "
+            del msg['name']
+            del msg["tool_call_id"]
+        if "tool_calls" in msg:
+            add=""
+            for tools in msg["tool_calls"]:
+                add=f"""
+```json
+[
+    {{
+    "tool":"{tools["function"]["name"]}",
+    "tool_input":{tools["function"]["arguments"]}
+    }}
+]
+```"""
+
+            msg["content"]=add
+            del msg["tool_calls"]
+
+
+    if functs !=None:
+        function_call=_function(tools=functs)
+        messages.insert(1,{"role": "system", "content": function_call})
+
+
+
+
+
+

utils/llms.py

@@ -0,0 +1,263 @@
+import os
+from g4f.client import Client
+from litellm import completion
+import random
+import json
+import os
+
+from g4f.Provider import DeepInfraChat,Glider,LambdaChat,TypeGPT
+
+gemini_api_keys=json.loads(os.environ.get("GEMINI_KEY_LIST"))
+groq_api_keys=json.loads(os.environ.get("GROQ_API_KEYS"))
+chutes_key=os.environ.get("CHUTES_API_KEY")
+github_key=os.environ.get("GITHUB_API_KEY")
+
+DeepInfraChat.models = ["google/gemma-3-27b-it","deepseek-ai/DeepSeek-R1-Turbo","Qwen/QwQ-32B","deepseek-ai/DeepSeek-R1","deepseek-ai/DeepSeek-V3-0324","meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","meta-llama/Llama-4-Scout-17B-16E-Instruct","microsoft/Phi-4-multimodal-instruct"]
+
+deepinframodels=["meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","microsoft/Phi-4-multimodal-instruct","google/gemma-3-27b-it","meta-llama/Llama-4-Scout-17B-16E-Instruct"]
+chutes_models={"MAI-DS-R1-FP8":"microsoft/MAI-DS-R1-FP8","DeepSeek-V3-0324":"deepseek-ai/DeepSeek-V3-0324","deepseek-reasoner":"deepseek-ai/DeepSeek-R1","GLM-4-32B-0414":"THUDM/GLM-4-32B-0414","GLM-Z1-32B-0414":"THUDM/GLM-Z1-32B-0414"}
+github_models={"gpt4.1":"gpt-4.1","gpt-4o":"gpt-4o","o4-mini":"o4-mini"}
+
+REASONING_CORRESPONDANCE = {"DeepSeek-R1-Glider":Glider, "DeepSeekR1-LAMBDA":LambdaChat,"DeepSeekR1":DeepInfraChat,"deepseek-slow":TypeGPT}
+os.environ["GEMINI_API_KEY"] =random.choice(gemini_api_keys)
+
+REASONING_QWQ = {"qwq-32b":DeepInfraChat}
+
+
+CHAT_CORRESPONDANCE = {"DeepSeek-V3":DeepInfraChat}
+
+client = Client()
+
+        
+
+def chat(messages,response_format,model="gpt-4"):
+        if len(messages) ==1:
+            messages[0]["role"]="user"
+        response = completion(
+            model="gemini/gemini-2.0-flash", 
+            messages=messages,
+            response_format=response_format
+        )
+        return str(response.choices[0].message.content)
+
+
+
+def chatstream(messages,model,api_keys):
+    print(f"-------{model}--------")
+    global llmfree
+    global llmdeepseek
+    global llmgroq
+
+    cunk=""
+
+    if model in deepinframodels:
+        try:
+            response = client.chat.completions.create(
+                provider=DeepInfraChat,
+                model=model,
+                messages=messages,
+                stream=True
+
+            )
+            for part in response:
+                cunk=cunk+(part.choices[0].delta.content or "")
+                if "```json" not in cunk or "```" not in cunk:
+                    yield (part.choices[0].delta.content or "")
+        except Exception as e:
+            pass
+        yield ("RESULT: "+cunk)
+
+    elif model == "DeepSeekR1-togetherAI":
+        response = completion(model="together_ai/deepseek-ai/DeepSeek-R1", messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+
+        yield("RESULT: "+cunk)
+    
+    elif model == "DeepSeekV3-togetherAI":
+        response = completion(model="together_ai/deepseek-ai/DeepSeek-V3", messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+        yield("RESULT: "+cunk)
+
+    elif model=="groq/deepseek-r1-distill-llama-70b":
+        os.environ["GROQ_API_KEY"] =random.choice(groq_api_keys)
+
+        response = completion(model="groq/deepseek-r1-distill-llama-70b", messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+        yield("RESULT: "+cunk)
+    elif model=="groq/qwq-32b":
+        os.environ["GROQ_API_KEY"] =random.choice(groq_api_keys)
+        response = completion(model="groq/qwen-qwq-32b", messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+
+        yield("RESULT: "+cunk)
+
+    elif model=="llama-3.3-70b-versatile":
+        response = completion(model="groq/llama-3.3-70b-versatile", messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+
+        yield("RESULT: "+cunk)
+    elif model in chutes_models:
+        response = completion(model=f"openai/{chutes_models[model]}",api_key=chutes_key,base_url="https://llm.chutes.ai/v1", messages=messages, stream=True)
+        if model == "MAI-DS-R1-FP8" or model == "GLM-Z1-32B-0414":
+
+            yield("<think> \n")
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            x=str(part.choices[0].delta.content)
+            # print(part.choices[0])
+            # x=x.replace(">","> \n \n s ")
+            # # if "</think>" in str(part.choices[0].delta.content):
+            # #     yield(part.choices[0].delta.content.replace("</think>","") or "")
+            # #     print(part.choices[0].delta.content.replace("</think>","</think> \n \n ") or "", end="")
+            if "```json" not in cunk:
+                if "None" not  in x:
+                    yield(x or "")
+                print(x,end="")
+        yield("RESULT: "+cunk)
+
+    elif model in github_models:
+        response = completion(model=f"github/{github_models[model]}",api_key=github_key, messages=messages, stream=True)
+
+        cunk=""
+        for part in response:
+            cunk=cunk+(part.choices[0].delta.content or "")
+            
+            if "```json" not in cunk:
+                yield(part.choices[0].delta.content or "")
+        yield("RESULT: "+cunk)
+
+    elif "gemini" in model: 
+        for key in gemini_api_keys:
+            try:
+                os.environ["GEMINI_API_KEY"] =key
+
+                response = completion(model=f"gemini/{model}", messages=messages, stream=True)
+
+                cunk=""
+                for part in response:
+                    cunk=cunk+(part.choices[0].delta.content or "")
+                    print(part.choices[0].delta.content or "", end="")
+                    if "```json" not in cunk:
+                        yield(part.choices[0].delta.content or "")
+
+                break         
+            except:
+                pass            
+        print("STOPPING")
+        yield("RESULT: "+cunk)
+
+    elif model=="deepseek.r1" or model=="deepseek-chat":
+
+        cunk=""
+
+        if "chat" in model:
+            providers = CHAT_CORRESPONDANCE
+            model_name="deepseek-ai/DeepSeek-V3-0324"
+        else:
+            providers = REASONING_CORRESPONDANCE
+            model_name="deepseek-r1"
+
+        for provider in providers:
+            try:
+                response = client.chat.completions.create(
+                    provider=providers[provider],
+                    model=model_name,
+                    messages=messages,
+                    stream=True
+
+                    # Add any other necessary parameters
+                )
+                for part in response:
+                    # print(part)
+                    cunk=cunk+(str(part.choices[0].delta.content) or "")
+
+                    if ("```json" not in cunk or "```" not in cunk) and (str(part.choices[0].delta.content) != "None"):
+                        yield(str(part.choices[0].delta.content) or "")
+                break
+            except Exception as e:
+                #yield(str(e)) 
+                print(e)
+                pass
+        print("STOPPING")
+        yield("RESULT: "+cunk)
+
+
+    elif model=="qwq-32b" :
+        yield("<think>")
+        cunk=""
+        providers=REASONING_QWQ
+        for provider in providers:
+            try:
+                response = client.chat.completions.create(
+                    provider=providers[provider],
+                    model="Qwen/QwQ-32B",
+                    messages=messages,
+                    stream=True
+
+                    # Add any other necessary parameters
+                )
+                for part in response:
+                    cunk=cunk+(part.choices[0].delta.content or "")
+                    if "```json" not in cunk or "```" not in cunk:
+                        yield(part.choices[0].delta.content or "")
+
+                break
+            except Exception as e:
+                
+                pass
+        yield("RESULT: "+cunk)
+
+
+    elif "DeepSeek" in model and "dev" in model:
+        cunk=""
+
+        if "V3" in model:
+            providers = CHAT_CORRESPONDANCE
+        else:
+            providers = REASONING_CORRESPONDANCE
+        for provider in providers:
+            try:
+                response = client.chat.completions.create(
+                    provider=providers[provider],
+                    model="deepseek-r1",
+                    messages=messages,
+                    stream=True
+
+                    # Add any other necessary parameters
+                )
+                for part in response:
+                    cunk=cunk+(part.choices[0].delta.content or "")
+                break
+            except Exception as e:
+                pass
+        print("STOPPING")
+        yield("RESULT: "+cunk)