Added new beam design agent

agent_server/chat_completions.py

@@ -21,6 +21,10 @@ from agents.json_tool_calling_agents import (
     generate_tool_calling_agent_with_search_and_code,
 )
 
+from agents.agent_with_custom_beam_design_tools import generate_beam_agent
+
+
+# Model name from env
 MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen3-1.7B")
 
 
@@ -79,6 +83,8 @@ def agent_for_model(model_name: str):
         return generate_tool_calling_agent_with_search_and_code()
     if model_name == "generator-with-managed-critic":
         return generate_generator_with_managed_critic()
+    if model_name == "custom-agent-with-beam-design-tools":
+        return generate_beam_agent()
     raise ValueError(f"Unknown model id: {model_name}")
 
 

agent_server/models.py

@@ -12,6 +12,12 @@ def models_payload() -> dict:
     return {
         "object": "list",
         "data": [
+            {
+                "id": "custom-agent-with-beam-design-tools",
+                "object": "model",
+                "created": now,
+                "owned_by": "you",
+            },
             {
                 "id": "generator-with-managed-critic",
                 "object": "model",

agents/agent_with_custom_beam_design_tools.py

@@ -0,0 +1,128 @@
+import os
+
+import smolagents
+import smolagents.tools
+
+# Rectangular section properties tool
+class RectSectionPropsTool(smolagents.tools.Tool):
+    name = "rect_section_props"
+    description = (
+        "Rectangular section properties."
+    )
+    inputs = {
+        "b": {"type": "number", "description": "Width in meters"},
+        "h": {"type": "number", "description": "Height in meters"},
+    }
+    output_type = "object"
+
+    def forward(self, b: float, h: float) -> dict:
+        if b <= 0 or h <= 0:
+            raise ValueError("b and h must be positive.")
+        A = b * h
+        I = b * (h**3) / 12.0
+        S = I / (h / 2.0)       # = b*h^2/6
+        return {"A": A, "I": I, "S": S}
+
+# Circle section properties tool
+class CircleSectionPropsTool(smolagents.tools.Tool):
+    name = "circle_section_props"
+    description = (
+        "Circular section properties."
+    )
+    inputs = {
+        "d": {"type": "number", "description": "Diameter in meters"},
+    }
+    output_type = "object"
+
+    def forward(self, d: float) -> dict:
+        if d <= 0:
+            raise ValueError("d must be positive.")
+        A = math.pi * (d**2) / 4.0
+        I = math.pi * (d**4) / 64.0
+        S = I / (d / 2.0)       # = π d^3 / 32
+        return {"A": A, "I": I, "S": S}
+
+
+# Mass tool
+class BeamMassTool(smolagents.tools.Tool):
+    name = "beam_mass"
+    description = (
+        "Beam mass [kg]."
+    )
+    inputs = {
+        "L": {"type": "number", "description": "Length in meters"},
+        "rho": {"type": "number", "description": "Material density in kg/m^3"},
+        "A": {"type": "number", "description": "Cross-sectional area in m^2 (optional)"},
+    }
+    output_type = "number"
+
+    def forward(self, L: float, rho: float, A: float) -> float:
+        if L <= 0 or rho <= 0 or A <= 0:
+            raise ValueError("L, rho, and A must be positive.")
+        return rho * A * L
+
+# Deflection tool
+class BeamDeflectionTool(smolagents.tools.Tool):
+    name = "beam_deflection"
+    description = (
+        "Max deflection δ [m] for simple cases."
+    )
+    inputs = {
+        "P": {"type": "number", "description": "Point load in Newtons"},
+        "L": {"type": "number", "description": "Span length in meters"},
+        "E": {"type": "number", "description": "Young's modulus in Pascals"},
+        "I": {"type": "number", "description": "Second moment in m^4 (optional)"},
+        "bc": {"type": "string", "description": "Boundary case: 'cantilever_end' or 'ss_center'"},
+    }
+    output_type = "number"
+
+    def forward(self, P: float, L: float, E: float, bc: str, I: float) -> float:
+        if any(x <= 0 for x in [P, L, E, I]):
+            raise ValueError("P, L, E, I must be positive.")
+        key = str(bc).lower().strip()
+        if key in ["cantilever", "cantilever_end", "cantilver_end", "cantilever-tip", "cantilever_tip"]:
+            return P * (L**3) / (3.0 * E * I)
+        elif key in ["ss", "ss_center", "simply_supported_center", "simply supported center", "simply_supported"]:
+            return P * (L**3) / (48.0 * E * I)
+        else:
+            raise ValueError("Unsupported bc. Use 'cantilever_end' or 'ss_center'.")
+
+
+
+# Bending stress tool
+class BeamBendingStressTool(smolagents.tools.Tool):
+    name = "beam_bending_stress"
+    description = (
+        "Max bending stress σ_max [Pa]."
+    )
+    inputs = {
+        "M": {"type": "number", "description": "Bending moment in N·m"},
+        "I": {"type": "number", "description": "Second moment in m^4 (optional)"},
+        "c": {"type": "number", "description": "Neutral axis distance in m (optional)"},
+    }
+    output_type = "number"
+
+    def forward(self, M: float, I: float, c: float) -> float:
+        if M <= 0:
+            raise ValueError("M must be positive.")
+        return M *c/I
+
+def generate_beam_agent() -> smolagents.CodeAgent:
+    # Define the agent with all of these tools.
+    return smolagents.CodeAgent(
+        tools=[
+            BeamMassTool(),
+            BeamDeflectionTool(),
+            BeamBendingStressTool(),
+            RectSectionPropsTool(),
+            CircleSectionPropsTool(),
+        ],
+        model=smolagents.models.OpenAIServerModel(
+            model_id=os.getenv("AGENT_MODEL", ""),
+            api_base=os.getenv("UPSTREAM_OPENAI_BASE", "").rstrip("/"),
+            api_key=os.getenv("OPENAI_API_KEY"),
+        ),
+        name="BeamAgent",
+        add_base_tools=False,
+        max_steps=12,
+)

agents/code_writing_agents.py

@@ -8,7 +8,7 @@ def generate_code_writing_agent_with_tools(
     tools=None, name: str = "code_writing_agent_without_tools"
 ):
     """
-    Create a code-writing agent without any extra tools.
+    Create a code-writing agent wwith a specific set of tools (defaults to none)
     """
     if tools is None:
         tools = []
@@ -37,7 +37,7 @@ def generate_code_writing_agent_without_tools():
 
 def generate_code_writing_agent_with_search():
     """
-    Create a code-writing agent without any extra tools.
+    Create a code-writing agent with search tools.
     """
     tools = [smolagents.WebSearchTool(max_results=5)]
     return generate_code_writing_agent_with_tools(

agents/generator_and_critic.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import os
 
 import smolagents.models
-from smolagents import CodeAgent, ToolCallingAgent
+from smolagents import ToolCallingAgent
 
 # ---------------- Agent Prompts ----------------
 GENERATOR_INSTRUCTIONS = """
 You are the Generator. Your goal is to produce a concise draft that strictly satisfies the caller's constraints.
 Use the managed agent named "critic_agent" to iteratively improve your draft.
+When the draft is complete and ready, return it to the user with the final answer tool.
 """
 
 CRITIC_INSTRUCTIONS = """