GPT Dynamic Toolchain Builder

What It Does

Installation

git clone <repository_url>
   cd gpt_dynamic_toolchain

pip install -r requirements.txt

Usage

{
       "tools": [
           {
               "name": "tool1",
               "description": "A test tool",
               "parameters": {
                   "param1": "value1"
               }
           }
       ],
       "workflow": [
           {
               "tool": "tool1",
               "input": {
                   "param1": "value1"
               }
           }
       ]
   }

python -m gpt_dynamic_toolchain --config toolchain.json

{
       "outputs": [
           {
               "tool": "tool1",
               "output": {
                   "simulated_output": "Executed tool1 with input {'param1': 'value1'}"
               }
           }
       ]
   }

Source Code

import json
import argparse
from jsonschema import validate, ValidationError
import openai

def validate_toolchain_schema(toolchain):
    """Validate the toolchain JSON against a predefined schema."""
    schema = {
        "type": "object",
        "properties": {
            "tools": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "description": {"type": "string"},
                        "parameters": {"type": "object"}
                    },
                    "required": ["name", "description", "parameters"]
                }
            },
            "workflow": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "tool": {"type": "string"},
                        "input": {"type": "object"}
                    },
                    "required": ["tool", "input"]
                }
            }
        },
        "required": ["tools", "workflow"]
    }
    validate(instance=toolchain, schema=schema)

def execute_toolchain(toolchain):
    """Execute the toolchain workflow and return the outputs."""
    tool_registry = {tool['name']: tool for tool in toolchain['tools']}
    outputs = []

    for step in toolchain['workflow']:
        tool_name = step['tool']
        input_data = step['input']

        if tool_name not in tool_registry:
            raise ValueError(f"Tool '{tool_name}' not found in the registry.")

        tool = tool_registry[tool_name]
        output = simulate_tool_execution(tool, input_data)
        outputs.append({"tool": tool_name, "output": output})

    return outputs

def simulate_tool_execution(tool, input_data):
    """Simulate the execution of a tool. Replace this with actual GPT-5.5 API calls."""
    # Placeholder for GPT-5.5 API integration
    return {"simulated_output": f"Executed {tool['name']} with input {input_data}"}

def main():
    parser = argparse.ArgumentParser(description="GPT Dynamic Toolchain Builder")
    parser.add_argument("--config", type=str, required=True, help="Path to the toolchain JSON configuration file.")
    args = parser.parse_args()

    try:
        with open(args.config, "r") as file:
            toolchain = json.load(file)

        validate_toolchain_schema(toolchain)
        outputs = execute_toolchain(toolchain)

        print(json.dumps({"outputs": outputs}, indent=4))

    except FileNotFoundError:
        print(f"Error: Configuration file '{args.config}' not found.")
    except json.JSONDecodeError:
        print("Error: Invalid JSON format in the configuration file.")
    except ValidationError as e:
        print(f"Error: Toolchain configuration validation failed. {e.message}")
    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    main()