swarms 7.7.9__py3-none-any.whl → 7.8.0__py3-none-any.whl

swarms/agents/self_agent_builder.py

@@ -0,0 +1,40 @@
+from typing import Callable
+from swarms.schemas.agent_class_schema import AgentConfiguration
+from swarms.tools.create_agent_tool import create_agent_tool
+from swarms.prompts.agent_self_builder_prompt import (
+    generate_agent_system_prompt,
+)
+from swarms.tools.base_tool import BaseTool
+from swarms.structs.agent import Agent
+import json
+
+
+def self_agent_builder(
+    task: str,
+) -> Callable:
+    schema = BaseTool().base_model_to_dict(AgentConfiguration)
+    schema = [schema]
+
+    print(json.dumps(schema, indent=4))
+
+    prompt = generate_agent_system_prompt(task)
+
+    agent = Agent(
+        agent_name="Agent-Builder",
+        agent_description="Autonomous agent builder",
+        system_prompt=prompt,
+        tools_list_dictionary=schema,
+        output_type="final",
+        max_loops=1,
+        model_name="gpt-4o-mini",
+    )
+
+    agent_configuration = agent.run(
+        f"Create the agent configuration for the task: {task}"
+    )
+    print(agent_configuration)
+    print(type(agent_configuration))
+
+    build_new_agent = create_agent_tool(agent_configuration)
+
+    return build_new_agent

swarms/prompts/agent_self_builder_prompt.py

@@ -0,0 +1,103 @@
+def generate_agent_system_prompt(task: str) -> str:
+    """
+    Returns an extremely detailed and production-level system prompt that guides an LLM
+    in generating a complete AgentConfiguration schema based on the input task.
+
+    This prompt is structured to elicit rigorous architectural decisions, precise language,
+    and well-justified parameter values. It reflects best practices in AI agent design.
+    """
+    return f"""
+    You are a deeply capable, autonomous agent architect tasked with generating a production-ready agent configuration. Your objective is to fully instantiate the `AgentConfiguration` schema for a highly specialized, purpose-driven AI agent tailored to the task outlined below.
+
+    --- TASK CONTEXT ---
+    You are to design an intelligent, self-sufficient agent whose behavior, cognitive capabilities, safety parameters, and operational bounds are entirely derived from the following user-provided task description:
+
+    **Task:** "{task}"
+
+    --- ROLE AND OBJECTIVE ---
+    You are not just a responder — you are an autonomous **system designer**, **architect**, and **strategist** responsible for building intelligent agents that will be deployed in real-world applications. Your responsibility includes choosing the most optimal behaviors, cognitive limits, resource settings, and safety thresholds to match the task requirements with precision and foresight.
+
+    You must instantiate **all fields** of the `AgentConfiguration` schema, as defined below. These configurations will be used directly by AI systems without human review — therefore, accuracy, reliability, and safety are paramount.
+
+    --- DESIGN PRINCIPLES ---
+    Follow these core principles in your agent design:
+    1. **Fitness for Purpose**: Tailor all parameters to optimize performance for the provided task. Understand the underlying problem domain deeply before configuring.
+    2. **Explainability**: The `agent_description` and `system_prompt` should clearly articulate what the agent does, how it behaves, and its guiding heuristics or ethics.
+    3. **Safety and Control**: Err on the side of caution. Enable guardrails unless you have clear justification to disable them.
+    4. **Modularity**: Your design should allow for adaptation and scaling. Prefer clear constraints over rigidly hard-coded behaviors.
+    5. **Dynamic Reasoning**: Allow adaptive behaviors only when warranted by the task complexity.
+    6. **Balance Creativity and Determinism**: Tune `temperature` and `top_p` appropriately. Analytical tasks should be conservative; generative or design tasks may tolerate more creative freedom.
+
+    --- FIELD-BY-FIELD DESIGN GUIDE ---
+
+    • **agent_name (str)**  
+    - Provide a short, expressive, and meaningful name.
+    - It should reflect domain expertise and purpose, e.g., `"ContractAnalyzerAI"`, `"BioNLPResearcher"`, `"CreativeUXWriter"`.
+
+    • **agent_description (str)**  
+    - Write a long, technically rich description.
+    - Include the agent’s purpose, operational style, areas of knowledge, and example outputs or use cases.
+    - Clarify what *not* to expect as well.
+
+    • **system_prompt (str)**  
+    - This is the most critical component.
+    - Write a 5–15 sentence instructional guide that defines the agent’s tone, behavioral principles, scope of authority, and personality.
+    - Include both positive (what to do) and negative (what to avoid) behavioral constraints.
+    - Use role alignment (“You are an expert...”) and inject grounding in real-world context or professional best practices.
+
+    • **max_loops (int)**  
+    - Choose a number of reasoning iterations. Use higher values (6–10) for exploratory, multi-hop, or inferential tasks.  
+    - Keep it at 1–2 for simple retrieval or summarization tasks.
+
+    • **dynamic_temperature_enabled (bool)**  
+    - Enable this for agents that must shift modes between creative and factual sub-tasks.
+    - Disable for deterministic, verifiable reasoning chains (e.g., compliance auditing, code validation).
+
+    • **model_name (str)**  
+    - Choose the most appropriate model family: `"gpt-4"`, `"gpt-4-turbo"`, `"gpt-3.5-turbo"`, etc.
+    - Use lightweight models only if latency, cost, or compute efficiency is a hard constraint.
+
+    • **safety_prompt_on (bool)**  
+    - Always `True` unless the agent is for internal, sandboxed research.
+    - This ensures harmful, biased, or otherwise inappropriate outputs are blocked or filtered.
+
+    • **temperature (float)**  
+    - For factual, analytical, or legal tasks: `0.2–0.5`
+    - For content generation or creative exploration: `0.6–0.9`
+    - Avoid values >1.0. They reduce coherence.
+
+    • **max_tokens (int)**  
+    - Reflect the expected size of the output per call.
+    - Use 500–1500 for concise tools, 3000–5000 for exploratory or report-generating agents.
+    - Never exceed the model limit (e.g., 8192 for GPT-4 Turbo).
+
+    • **context_length (int)**  
+    - Set based on how much previous conversation or document context the agent needs to retain.
+    - Typical range: 6000–16000 tokens. Use lower bounds to optimize performance if context retention isn't crucial.
+
+    --- EXAMPLES OF STRONG SYSTEM PROMPTS ---
+
+    Bad example:
+    > "You are a helpful assistant that provides answers about contracts."
+
+    ✅ Good example:
+    > "You are a professional legal analyst specializing in international corporate law. Your role is to evaluate contracts for risks, ambiguous clauses, and compliance issues. You speak in precise legal terminology and justify every assessment using applicable legal frameworks. Avoid casual language. Always flag high-risk clauses and suggest improvements based on best practices."
+
+    --- FINAL OUTPUT FORMAT ---
+
+    Output **only** the JSON object corresponding to the `AgentConfiguration` schema:
+
+    ```json
+    {{
+    "agent_name": "...",
+    "agent_description": "...",
+    "system_prompt": "...",
+    "max_loops": ...,
+    "dynamic_temperature_enabled": ...,
+    "model_name": "...",
+    "safety_prompt_on": ...,
+    "temperature": ...,
+    "max_tokens": ...,
+    "context_length": ...
+    }}
+    """

swarms/schemas/__init__.py

@@ -1,7 +1,12 @@
 from swarms.schemas.agent_step_schemas import Step, ManySteps
-
+from swarms.schemas.mcp_schemas import (
+    MCPConnection,
+    MultipleMCPConnections,
+)
 
 __all__ = [
     "Step",
     "ManySteps",
+    "MCPConnection",
+    "MultipleMCPConnections",
 ]

swarms/schemas/agent_class_schema.py

@@ -0,0 +1,91 @@
+"""
+This is a schema that enables the agent to generate it's self.
+
+
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional
+
+
+class AgentConfiguration(BaseModel):
+    """
+    Comprehensive configuration schema for autonomous agent creation and management.
+
+    This Pydantic model defines all the necessary parameters to create, configure,
+    and manage an autonomous agent with specific behaviors, capabilities, and constraints.
+    It enables dynamic agent generation with customizable properties and allows
+    arbitrary additional fields for extensibility.
+
+    All fields are required with no defaults, forcing explicit configuration of the agent.
+    The schema supports arbitrary additional parameters through the extra='allow' configuration.
+
+    Attributes:
+        agent_name: Unique identifier name for the agent
+        agent_description: Detailed description of the agent's purpose and capabilities
+        system_prompt: Core system prompt that defines the agent's behavior and personality
+        max_loops: Maximum number of reasoning loops the agent can perform
+        dynamic_temperature_enabled: Whether to enable dynamic temperature adjustment
+        model_name: The specific LLM model to use for the agent
+        safety_prompt_on: Whether to enable safety prompts and guardrails
+        temperature: Controls response randomness and creativity
+        max_tokens: Maximum tokens in a single response
+        context_length: Maximum conversation context length
+        frequency_penalty: Penalty for token frequency to reduce repetition
+        presence_penalty: Penalty for token presence to encourage diverse topics
+        top_p: Nucleus sampling parameter for token selection
+        tools: List of tools/functions available to the agent
+    """
+
+    agent_name: Optional[str] = Field(
+        description="Unique and descriptive name for the agent. Should be clear, concise, and indicative of the agent's purpose or domain expertise.",
+    )
+
+    agent_description: Optional[str] = Field(
+        description="Comprehensive description of the agent's purpose, capabilities, expertise area, and intended use cases. This helps users understand what the agent can do and when to use it.",
+    )
+
+    system_prompt: Optional[str] = Field(
+        description="The core system prompt that defines the agent's personality, behavior, expertise, and response style. This is the foundational instruction that shapes how the agent interacts and processes information.",
+    )
+
+    max_loops: Optional[int] = Field(
+        description="Maximum number of reasoning loops or iterations the agent can perform when processing complex tasks. Higher values allow for more thorough analysis but consume more resources.",
+    )
+
+    dynamic_temperature_enabled: Optional[bool] = Field(
+        description="Whether to enable dynamic temperature adjustment during conversations. When enabled, the agent can adjust its creativity/randomness based on the task context - lower for factual tasks, higher for creative tasks.",
+    )
+
+    model_name: Optional[str] = Field(
+        description="The specific language model to use for this agent. Should be a valid model identifier that corresponds to available LLM models in the system.",
+    )
+
+    safety_prompt_on: Optional[bool] = Field(
+        description="Whether to enable safety prompts and content guardrails. When enabled, the agent will have additional safety checks to prevent harmful, biased, or inappropriate responses.",
+    )
+
+    temperature: Optional[float] = Field(
+        description="Controls the randomness and creativity of the agent's responses. Lower values (0.0-0.3) for more focused and deterministic responses, higher values (0.7-1.0) for more creative and varied outputs.",
+    )
+
+    max_tokens: Optional[int] = Field(
+        description="Maximum number of tokens the agent can generate in a single response. Controls the length and detail of agent outputs.",
+    )
+
+    context_length: Optional[int] = Field(
+        description="Maximum context length the agent can maintain in its conversation memory. Affects how much conversation history the agent can reference.",
+    )
+
+    task: Optional[str] = Field(
+        description="The task that the agent will perform.",
+    )
+
+    class Config:
+        """Pydantic model configuration."""
+
+        extra = "allow"  # Allow arbitrary additional fields
+        allow_population_by_field_name = True
+        validate_assignment = True
+        use_enum_values = True
+        arbitrary_types_allowed = True  # Allow arbitrary types

swarms/schemas/agent_mcp_errors.py

@@ -0,0 +1,18 @@
+class AgentMCPError(Exception):
+    pass
+
+
+class AgentMCPConnectionError(AgentMCPError):
+    pass
+
+
+class AgentMCPToolError(AgentMCPError):
+    pass
+
+
+class AgentMCPToolNotFoundError(AgentMCPError):
+    pass
+
+
+class AgentMCPToolInvalidError(AgentMCPError):
+    pass

swarms/schemas/agent_tool_schema.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional, Callable
+from swarms.schemas.mcp_schemas import MCPConnection
+
+
+class AgentToolTypes(BaseModel):
+    tool_schema: List[Dict[str, Any]]
+    mcp_connection: MCPConnection
+    tool_model: Optional[BaseModel]
+    tool_functions: Optional[List[Callable]]
+
+    class Config:
+        arbitrary_types_allowed = True

swarms/schemas/llm_agent_schema.py

@@ -0,0 +1,92 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Union, Any, Literal
+from litellm.types import (
+    ChatCompletionPredictionContentParam,
+)
+
+
+class LLMCompletionRequest(BaseModel):
+    """Schema for LLM completion request parameters."""
+
+    model: Optional[str] = Field(
+        default=None,
+        description="The name of the language model to use for text completion",
+    )
+    temperature: Optional[float] = Field(
+        default=0.5,
+        description="Controls randomness of the output (0.0 to 1.0)",
+    )
+    top_p: Optional[float] = Field(
+        default=None,
+        description="Controls diversity via nucleus sampling",
+    )
+    n: Optional[int] = Field(
+        default=None, description="Number of completions to generate"
+    )
+    stream: Optional[bool] = Field(
+        default=None, description="Whether to stream the response"
+    )
+    stream_options: Optional[dict] = Field(
+        default=None, description="Options for streaming response"
+    )
+    stop: Optional[Any] = Field(
+        default=None,
+        description="Up to 4 sequences where the API will stop generating",
+    )
+    max_completion_tokens: Optional[int] = Field(
+        default=None,
+        description="Maximum tokens for completion including reasoning",
+    )
+    max_tokens: Optional[int] = Field(
+        default=None,
+        description="Maximum tokens in generated completion",
+    )
+    prediction: Optional[ChatCompletionPredictionContentParam] = (
+        Field(
+            default=None,
+            description="Configuration for predicted output",
+        )
+    )
+    presence_penalty: Optional[float] = Field(
+        default=None,
+        description="Penalizes new tokens based on existence in text",
+    )
+    frequency_penalty: Optional[float] = Field(
+        default=None,
+        description="Penalizes new tokens based on frequency in text",
+    )
+    logit_bias: Optional[dict] = Field(
+        default=None,
+        description="Modifies probability of specific tokens",
+    )
+    reasoning_effort: Optional[Literal["low", "medium", "high"]] = (
+        Field(
+            default=None,
+            description="Level of reasoning effort for the model",
+        )
+    )
+    seed: Optional[int] = Field(
+        default=None, description="Random seed for reproducibility"
+    )
+    tools: Optional[List] = Field(
+        default=None,
+        description="List of tools available to the model",
+    )
+    tool_choice: Optional[Union[str, dict]] = Field(
+        default=None, description="Choice of tool to use"
+    )
+    logprobs: Optional[bool] = Field(
+        default=None,
+        description="Whether to return log probabilities",
+    )
+    top_logprobs: Optional[int] = Field(
+        default=None,
+        description="Number of most likely tokens to return",
+    )
+    parallel_tool_calls: Optional[bool] = Field(
+        default=None,
+        description="Whether to allow parallel tool calls",
+    )
+
+    class Config:
+        allow_arbitrary_types = True

swarms/schemas/mcp_schemas.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+from typing import Dict, List, Any, Optional
+
+
+class MCPConnection(BaseModel):
+    type: Optional[str] = Field(
+        default="mcp",
+        description="The type of connection, defaults to 'mcp'",
+    )
+    url: Optional[str] = Field(
+        default="localhost:8000/sse",
+        description="The URL endpoint for the MCP server",
+    )
+    tool_configurations: Optional[Dict[Any, Any]] = Field(
+        default=None,
+        description="Dictionary containing configuration settings for MCP tools",
+    )
+    authorization_token: Optional[str] = Field(
+        default=None,
+        description="Authentication token for accessing the MCP server",
+    )
+    transport: Optional[str] = Field(
+        default="sse",
+        description="The transport protocol to use for the MCP server",
+    )
+    headers: Optional[Dict[str, str]] = Field(
+        default=None, description="Headers to send to the MCP server"
+    )
+    timeout: Optional[int] = Field(
+        default=5, description="Timeout for the MCP server"
+    )
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class MultipleMCPConnections(BaseModel):
+    connections: List[MCPConnection] = Field(
+        default=[], description="List of MCP connections"
+    )
+
+    class Config:
+        arbitrary_types_allowed = True

swarms/structs/__init__.py

@@ -78,6 +78,8 @@ from swarms.structs.swarming_architectures import (
     star_swarm,
 )
 from swarms.structs.auto_swarm_builder import AutoSwarmBuilder
+from swarms.structs.council_judge import CouncilAsAJudge
+from swarms.structs.batch_agent_execution import batch_agent_execution
 
 __all__ = [
     "Agent",
@@ -146,4 +148,6 @@ __all__ = [
     "get_agents_info",
     "get_swarms_info",
     "AutoSwarmBuilder",
+    "CouncilAsAJudge",
+    "batch_agent_execution",
 ]