Calling Built-in tools (#418)

* Built in tools rnd 1

Signed-off-by: Trevor Grant <[email protected]>

* Builtin Tool Calling Works

Signed-off-by: Trevor Grant <[email protected]>

---------

Signed-off-by: Trevor Grant <[email protected]>

Author: rawkintrevo

webapp/packages/api/user-service/agent_factory/__init__.py

@@ -1,3 +1,4 @@
+# webapp/packages/api/user-service/agent_factory/__init__.py
 from .remote_mcp_client import RemoteMCPClient
 from .prompts import how_to_use_tools, \
     how_to_use_litellm, \
@@ -10,7 +11,9 @@
 import asyncio
 
 from services.database_service import get_database_service
+from services.llm_service import call_llm
 from config import settings
+from config.provider_config import PROVIDER_CONFIG
 
 async def generate_agent_code(request: GenerateCodeRequest):
     """
@@ -112,13 +115,26 @@ async def generate_agent_code(request: GenerateCodeRequest):
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": request.description},
     ]
+
+    # Build tools list from config
+    built_in_tools = []
+    model_tool_config = PROVIDER_CONFIG.get(provider, {}).get("models", {}).get(model, {}).get("built_in_tools", [])
+    if request.built_in_tools:
+        for tool_id in request.built_in_tools:
+            tool_conf = next((t for t in model_tool_config if t["id"] == tool_id), None)
+            if tool_conf:
+                built_in_tools.append(tool_conf["tool_config"])
 
     config = request.composer_model_config.parameters
-    code_gen_task = acompletion(
-                model=f"{provider}/{model}",
-                messages=code_gen_messages,
-                **config
-            )
+    
+    async def code_gen_with_thoughts():
+        return await call_llm(
+            provider=provider,
+            model=model,
+            messages=code_gen_messages,
+            parameters=config,
+            tools=built_in_tools if built_in_tools else None,
+        )
 
     # ---- Friendly Name and Docstring Generation Task ----
     name_doc_prompt = f"""
@@ -157,15 +173,12 @@ async def generate_agent_code(request: GenerateCodeRequest):
     )
 
     # ---- Run tasks concurrently ----
-    code_response, name_doc_response = await asyncio.gather(
-        code_gen_task,
+    (code_body, thoughts), name_doc_response = await asyncio.gather(
+        code_gen_with_thoughts(),
         name_doc_gen_task
     )
 
     # ---- Process Code Generation Response ----
-    code_body = code_response.choices[0].message.content
- 
-
     # Clean up potential markdown formatting from the response
     if code_body.strip().startswith("```python"):
         code_body = code_body.strip()[len("```python"):].strip()
@@ -202,5 +215,4 @@ async def run(input_dict, tools):
         friendly_name = "parsing_error_function"
         docstring = f"Could not parse docstring from LLM response:\n{name_doc_content}"
 
-    return GenerateCodeResponse(code=full_code, friendly_name=friendly_name, docstring=docstring)
-
+    return GenerateCodeResponse(code=full_code, friendly_name=friendly_name, docstring=docstring, thoughts=thoughts)

webapp/packages/api/user-service/agent_factory/demo_factory.py

@@ -1,9 +1,11 @@
 # webapp/packages/api/user-service/agent_factory/demo_factory.py
 from .prompts import how_to_build_demo_app_template
-from litellm import acompletion
 from models.demo import GenerateDemoCodeRequest, GenerateDemoCodeResponse, DeployedApi
 import json
 
+from services.llm_service import call_llm
+from config.provider_config import PROVIDER_CONFIG
+
 def _format_api_docs(apis: list[DeployedApi]) -> str:
     """Formats the API information into a markdown string for the prompt."""
     if not apis:
@@ -55,13 +57,23 @@ async def generate_demo_code(request: GenerateDemoCodeRequest) -> GenerateDemoCo
     if provider == "openai":
         config['response_format'] = { "type": "json_object" }
 
-    response = await acompletion(
-        model=f"{provider}/{model}",
+    # Build tools list from config
+    built_in_tools = []
+    model_tool_config = PROVIDER_CONFIG.get(provider, {}).get("models", {}).get(model, {}).get("built_in_tools", [])
+    if request.built_in_tools:
+        for tool_id in request.built_in_tools:
+            tool_conf = next((t for t in model_tool_config if t["id"] == tool_id), None)
+            if tool_conf:
+                built_in_tools.append(tool_conf["tool_config"])
+
+    response_content, thoughts = await call_llm(
+        provider=provider,
+        model=model,
         messages=messages,
-        **config
+        parameters=config,
+        tools=built_in_tools if built_in_tools else None
     )
 
-    response_content = response.choices[0].message.content
     try:
         # Clean up potential markdown
         if response_content.strip().startswith("```json"):
@@ -70,7 +82,11 @@ async def generate_demo_code(request: GenerateDemoCodeRequest) -> GenerateDemoCo
             response_content = response_content.strip()[:-len("```")].strip()
 
         code_json = json.loads(response_content)
-        return GenerateDemoCodeResponse(**code_json)
+        
+        # Ensure the response includes the thoughts
+        response_obj = GenerateDemoCodeResponse(**code_json)
+        response_obj.thoughts = thoughts
+        return response_obj
     except (json.JSONDecodeError, TypeError) as e:
         print(f"Error parsing demo code JSON from LLM: {e}")
         print(f"LLM response was: {response_content}")

webapp/packages/api/user-service/config/provider_config.py

@@ -52,6 +52,32 @@
                     }
                 }
             },
+            "gpt-4.1-mini": {
+                "api_style": "responses",
+                "parameters": {
+                    "temperature": {
+                        "type": "float",
+                        "default": 0.7,
+                        "min": 0.0,
+                        "max": 2.0,
+                        "description": "Controls randomness"
+                    },
+                    "max_tokens": {
+                        "type": "integer",
+                        "default": 2048,
+                        "min": 1,
+                        "max": 4096,
+                        "description": "Maximum tokens in response"
+                    }
+                },
+                "built_in_tools": [
+                    {
+                        "id": "web_search",
+                        "description": "Performs a web search.",
+                        "tool_config": {"type": "web_search_preview", "search_context_size": "low"}
+                    }
+                ]
+            },
             "gpt-4.1-nano": {
                 "parameters": {
                     "temperature": {
@@ -89,7 +115,14 @@
                         "default": 0,
                         "choices": ["disable", "low", "medium", "high"],
                     }
-                }
+                },
+                "built_in_tools": [
+                    {
+                        "id": "google_search",
+                        "description": "Performs a Google search.",
+                        "tool_config": {"google_search": {}}
+                    }
+                ]
             }
         }
     },
@@ -126,7 +159,14 @@
                         "max": 100,
                         "description": "Top-k sampling"
                     }
-                }
+                },
+                "built_in_tools": [
+                    {
+                        "id": "web_search",
+                        "description": "Performs a web search.",
+                        "tool_config": {"name": "web_search"}
+                    }
+                ]
             },
             "claude-3-sonnet": {
                 "parameters": {

webapp/packages/api/user-service/main.py

@@ -22,14 +22,29 @@
 from services.database_service import get_database_service, DatabaseService
 from config import settings
 from services.mcp_client_service import McpClientService, get_mcp_client_service
-# New imports for observability
+
 from services.observability_service import (
     get_observability_service,
     ObservabilityMiddleware,
     ObservabilityService,
     get_sanitized_request_data
 )
 
+from services.llm_service import call_llm
+
+# Import the shared provider configuration
+from config.provider_config import PROVIDER_CONFIG as APP_PROVIDER_CONFIG
+from models.agent import (
+    GenerateCodeRequest, GenerateCodeResponse, RunCodeRequest, 
+    RunCodeResponse, Agent, CreateAgentRequest, Deployment, DeployedApi
+)
+from models.demo import (
+    GenerateDemoCodeRequest, GenerateDemoCodeResponse,
+    CreateDemoAppRequest, DemoApp
+)
+
+from agent_factory.remote_mcp_client import RemoteMCPClient
+
 
 # --- Firebase Admin SDK Initialization ---
 if settings.APP_ENV == "firebase":
@@ -60,18 +75,6 @@ async def startup_event():
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
 
-# Import the shared provider configuration
-from config.provider_config import PROVIDER_CONFIG as APP_PROVIDER_CONFIG
-from models.agent import (
-    GenerateCodeRequest, GenerateCodeResponse, RunCodeRequest, 
-    RunCodeResponse, Agent, CreateAgentRequest, Deployment, DeployedApi
-)
-from models.demo import (
-    GenerateDemoCodeRequest, GenerateDemoCodeResponse,
-    CreateDemoAppRequest, DemoApp
-)
-
-from agent_factory.remote_mcp_client import RemoteMCPClient
 
 
 frontend_url = os.getenv("FRONTEND_URL", "http://localhost:3000")
@@ -116,19 +119,6 @@ async def get_current_user(request: Request, token: str = Depends(oauth2_scheme)
         raise HTTPException(status_code=500, detail=f"Authentication error: {e}")
 
 
-# Models
-class ChatMessage(BaseModel):
-    role: str = Field(..., pattern="^(user|assistant|system)$")
-    content: str
-
-class ChatRequest(BaseModel):
-    messages: List[ChatMessage]
-    provider: str = "openai"
-    model: str = "gpt-3.5-turbo"
-    parameters: Dict[str, Any] = {}
-    stream: bool = False
-
-
 class ListMcpToolsRequest(BaseModel):
     mcp_url: str
     auth_token: Optional[str] = None
@@ -143,7 +133,7 @@ class FetchSpecRequest(BaseModel):
     url: str
 
 # Import models after defining local ones to avoid circular dependencies
-from models.chat import ChatResponse, ProviderConfig, SessionData
+from models.chat import ChatRequest, ChatMessage, ChatResponse, ProviderConfig, SessionData
 
 
 # --- Dependencies ---
@@ -164,31 +154,42 @@ async def process_chat(ticket_id: str, request: ChatRequest, user: dict, req: Re
         ticket_data = {
             "status": "processing",
             "created_at": datetime.utcnow().isoformat(), # Use isoformat for JSON serialization
-            "request": request.dict()
+            "request": request.dict(by_alias=True)
         }
         db_service.save("tickets", ticket_id, ticket_data)
 
         # Convert messages to format expected by litellm
         messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
 
-        model_name = f"{request.provider}/{request.model}" if request.provider not in ["openai", "azure"] else request.model
+        # Build tools list from config
+        built_in_tools = []
+        model_tool_config = APP_PROVIDER_CONFIG.get(request.provider, {}).get("models", {}).get(request.model, {}).get("built_in_tools", [])
+        if request.built_in_tools:
+            for tool_id in request.built_in_tools:
+                tool_conf = next((t for t in model_tool_config if t["id"] == tool_id), None)
+                if tool_conf:
+                    built_in_tools.append(tool_conf["tool_config"])
+
 
-        logger.log("INFO", "llm_request", f"Initiating LLM call to {model_name}", metadata={"request": get_sanitized_request_data(req)})
+        logger.log("INFO", "llm_request", f"Initiating LLM call to {request.provider}/{request.model}", metadata={"request": get_sanitized_request_data(req)})
 
-        response = await litellm.acompletion(
-            model=model_name,
+        content, thoughts = await call_llm(
+            provider=request.provider,
+            model=request.model,
             messages=messages,
-            **request.parameters
+            parameters=request.parameters,
+            tools=built_in_tools if built_in_tools else None
         )
 
         # Update ticket with success
         ticket_data.update({
             "status": "completed",
             "completed_at": datetime.utcnow().isoformat(),
             "result": {
-                "content": response.choices[0].message.content,
-                "model": response.model,
-                "usage": response.usage.dict() if response.usage else None
+                "content": content,
+                "thoughts": thoughts,
+                "model": f"{request.provider}/{request.model}",
+                # Usage data is not consistently available across both litellm APIs, so omitting for now
             }
         })
         db_service.save("tickets", ticket_id, ticket_data)
@@ -736,7 +737,7 @@ def build_cors_headers(req, *, origin_override=None):
         # "access-control-allow-credentials": "true",
     }
 
-@https_fn.on_request(memory=1024)
+@https_fn.on_request(memory=2048, timeout_sec=540)
 def api(req: https_fn.Request):
     """
     An HTTPS Cloud Function that wraps the FastAPI application.

webapp/packages/api/user-service/models/agent.py

@@ -1,3 +1,4 @@
+ # webapp/packages/api/user-service/models/agent.py
 from pydantic import BaseModel, Field
 from pydantic.config import ConfigDict
 from pydantic.alias_generators import to_camel
@@ -21,12 +22,15 @@ class GenerateCodeRequest(BaseModel):
     invokable_models: Optional[List[ProviderConfig]] = Field(None, alias="invokableModels")
     swagger_specs: Optional[List[SwaggerSpec]] = Field(None, alias="swaggerSpecs")
     gofannon_agents: Optional[List[str]] = Field(None, alias="gofannonAgents")
+    built_in_tools: Optional[List[str]] = Field(default_factory=list, alias="builtInTools")
     model_config = ConfigDict(populate_by_name=True)
 
 class GenerateCodeResponse(BaseModel):
     code: str
     friendly_name: str = Field(..., alias="friendlyName")
     docstring: str
+    thoughts: Optional[Any] = None
+
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -42,6 +46,8 @@ class CreateAgentRequest(BaseModel):
     output_schema: Optional[Dict[str, Any]] = Field(..., alias="outputSchema")
     invokable_models: Optional[List[ProviderConfig]] = Field(None, alias="invokableModels")
     gofannon_agents: Optional[List[str]] = Field(default_factory=list, alias="gofannonAgents")
+    composer_thoughts: Optional[Any] = Field(None, alias="composerThoughts")
+
 
     model_config = ConfigDict(
         populate_by_name=True,   
@@ -82,3 +88,4 @@ class DeployedApi(BaseModel):
     input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
     output_schema: Dict[str, Any] = Field(..., alias="outputSchema")
     model_config = ConfigDict(populate_by_name=True)
+    

webapp/packages/api/user-service/models/chat.py

@@ -1,4 +1,5 @@
-from pydantic import BaseModel, Field
+# webapp/packages/api/user-service/models/chat.py
+from pydantic import BaseModel, Field, ConfigDict
 from typing import Optional, Dict, Any, List
 from enum import Enum
 from datetime import datetime
@@ -19,6 +20,9 @@ class ChatRequest(BaseModel):
     model: str = "gpt-3.5-turbo"
     parameters: Dict[str, Any] = {} # Renamed from 'config' to 'parameters'
     stream: bool = False
+    built_in_tools: Optional[List[str]] = Field(default_factory=list, alias="builtInTools")
+    model_config = ConfigDict(populate_by_name=True)
+
 
 class ChatResponse(BaseModel):
     ticket_id: str