alita-sdk 0.3.182__py3-none-any.whl → 0.3.183__py3-none-any.whl

alita_sdk/runtime/langchain/assistant.py

@@ -6,7 +6,6 @@ from langchain.agents import (
     AgentExecutor, create_openai_tools_agent,
     create_json_chat_agent)
 from langgraph.store.base import BaseStore
-
 from .agents.xml_chat import create_xml_chat_agent
 from .langraph_agent import create_graph
 from langchain_core.messages import (
@@ -67,8 +66,10 @@ class Assistant:
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools
         self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client, memory_store=self.store)
-        if app_type == "pipeline":
+        if app_type in ["pipeline", "predict", "react"]:
             self.prompt = data['instructions']
+            if tools:
+                self.tools += tools
         else:
             self.tools += tools
             messages = [SystemMessage(content=data['instructions'])]
@@ -121,6 +122,8 @@ class Assistant:
             return self.getOpenAIToolsAgentExecutor()
         elif self.app_type == 'xml':
             return self.getXMLAgentExecutor()
+        elif self.app_type in ['predict', 'react']:
+            return self.getLangGraphReactAgent()
         else:
             self.tools = [EchoTool()] + self.tools
             return self.getAgentExecutor()
@@ -149,6 +152,125 @@ class Assistant:
         agent = create_openai_tools_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
+    def getLangGraphReactAgent(self):
+        """
+        Create a LangGraph react agent using a tool-calling agent pattern.
+        This creates a proper LangGraphAgentRunnable with modern tool support.
+        """
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        
+        # Set up memory/checkpointer if available
+        checkpointer = None
+        if self.memory is not None:
+            checkpointer = self.memory
+        elif self.store is not None:
+            # Convert store to checkpointer if needed
+            from langgraph.checkpoint.memory import MemorySaver
+            checkpointer = MemorySaver()
+        else:
+            # Ensure we have a checkpointer for conversation persistence
+            from langgraph.checkpoint.memory import MemorySaver
+            checkpointer = MemorySaver()
+            logger.info("Using default MemorySaver for conversation persistence")
+        
+        # Extract all messages from prompt/chat history for LangGraph
+        chat_history_messages = []
+        prompt_instructions = None
+        
+        if hasattr(self.prompt, 'messages') and self.prompt.messages:
+            # Extract all messages from the prompt to use as chat history
+            for message in self.prompt.messages:
+                # Skip placeholders (MessagesPlaceholder instances) as they are not actual messages
+                if hasattr(message, 'variable_name'):  # MessagesPlaceholder has variable_name attribute
+                    continue
+                # Skip template messages (contains {{variable}} patterns)
+                if hasattr(message, 'content') and isinstance(message.content, str) and '{{' in message.content and '}}' in message.content:
+                    continue
+                # Include actual chat history messages
+                chat_history_messages.append(message)
+        
+        # Only use prompt_instructions if explicitly specified (for predict app_type)
+        if self.app_type == "predict" and isinstance(self.prompt, str):
+            prompt_instructions = self.prompt
+        
+        # Create a unified YAML schema with conditional tool binding
+        # Build the base node configuration
+        node_config = {
+            'id': 'agent',
+            'type': 'llm',
+            'prompt': {
+                'template': prompt_instructions or "You are a helpful assistant."
+            },
+            'input': ['messages'],
+            'output': ['messages'],
+            'transition': 'END'
+        }
+        
+        # Add tool binding only if tools are present
+        if simple_tools:
+            tool_names = [tool.name for tool in simple_tools]
+            tool_names_yaml = str(tool_names).replace("'", '"')  # Convert to YAML-compatible format
+            node_config['tool_names'] = tool_names_yaml
+            logger.info("Binding tools: %s", tool_names)
+        
+        # Properly setup the prompt for YAML
+        import yaml
+        escaped_prompt = prompt_instructions or "You are a helpful assistant."
+        
+        # Create the schema as a dictionary first, then convert to YAML
+        state_messages_config = {'type': 'list'}
+        
+        # Only set initial messages if there's actual conversation history (not just system prompts)
+        actual_conversation_messages = [
+            msg for msg in chat_history_messages 
+            if not isinstance(msg, SystemMessage)  # Exclude system messages as they're handled by prompt template
+        ]
+        
+        if actual_conversation_messages:
+            state_messages_config['value'] = actual_conversation_messages
+            logger.info(f"Setting initial conversation history with {len(actual_conversation_messages)} messages")
+        
+        schema_dict = {
+            'name': 'react_agent',
+            'state': {
+                'messages': state_messages_config
+            },
+            'nodes': [{
+                'id': 'agent',
+                'type': 'llm',
+                'prompt': {
+                    'template': escaped_prompt
+                },
+                'input': ['messages'],
+                'output': ['messages'],
+                'transition': 'END'
+            }],
+            'entry_point': 'agent'
+        }
+        
+        # Add tool-specific parameters only if tools exist
+        if simple_tools:
+            schema_dict['nodes'][0]['tool_names'] = tool_names
+        
+        # Convert to YAML string
+        yaml_schema = yaml.dump(schema_dict, default_flow_style=False, allow_unicode=True)
+        
+        # Use create_graph function to build the agent like other graph types
+        from .langraph_agent import create_graph
+    
+        agent = create_graph(
+            client=self.client,
+            yaml_schema=yaml_schema,
+            tools=simple_tools,
+            memory=checkpointer,
+            store=self.store,
+            debug=False,
+            for_subgraph=False
+        )
+        
+        return agent
+
     def pipeline(self):
         memory = self.memory
         #

alita_sdk/runtime/langchain/langraph_agent.py

@@ -6,7 +6,7 @@ from typing import Dict
 import yaml
 import ast
 from langchain_core.callbacks import dispatch_custom_event
-from langchain_core.messages import HumanMessage
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, BaseMessage
 from langchain_core.runnables import Runnable
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
@@ -498,14 +498,36 @@ def create_graph(
                     var: get_type_hints(state_class).get(var, str).__name__
                     for var in output_vars
                 }
+                
+                # Check if tools should be bound to this LLM node
+                tool_names = node.get('tool_names', []) if isinstance(node.get('tool_names'), list) else []
+                
+                # Filter tools if specific tool names are provided
+                available_tools = []
+            
+                if tool_names:
+                    # Filter tools by name
+                    tool_dict = {tool.name: tool for tool in tools if isinstance(tool, BaseTool)}
+                    available_tools = [tool_dict[name] for name in tool_names if name in tool_dict]
+                    if len(available_tools) != len(tool_names):
+                        missing_tools = [name for name in tool_names if name not in tool_dict]
+                        logger.warning(f"Some tools not found for LLM node {node_id}: {missing_tools}")
+                else:
+                    # Use all available tools
+                    available_tools = [tool for tool in tools if isinstance(tool, BaseTool)]
+                
                 lg_builder.add_node(node_id, LLMNode(
-                    client=client, prompt=node.get('prompt', {}),
-                    name=node['id'], return_type='dict',
+                    client=client, 
+                    prompt=node.get('prompt', {}),
+                    name=node['id'], 
+                    return_type='dict',
                     response_key=node.get('response_key', 'messages'),
                     structured_output_dict=output_vars_dict,
                     output_variables=output_vars,
                     input_variables=node.get('input', ['messages']),
-                    structured_output=node.get('structured_output', False)))
+                    structured_output=node.get('structured_output', False),
+                    available_tools=available_tools,
+                    tool_names=tool_names))
             elif node_type == 'router':
                 # Add a RouterNode as an independent node
                 lg_builder.add_node(node_id, RouterNode(
@@ -604,6 +626,29 @@ def create_graph(
     return compiled.validate()
 
 
+def convert_dict_to_message(msg_dict):
+    """Convert a dictionary message to a LangChain message object."""
+    if isinstance(msg_dict, BaseMessage):
+        return msg_dict  # Already a LangChain message
+    
+    if isinstance(msg_dict, dict):
+        role = msg_dict.get('role', 'user')
+        content = msg_dict.get('content', '')
+        
+        if role == 'user':
+            return HumanMessage(content=content)
+        elif role == 'assistant':
+            return AIMessage(content=content)
+        elif role == 'system':
+            return SystemMessage(content=content)
+        else:
+            # Default to HumanMessage for unknown roles
+            return HumanMessage(content=content)
+    
+    # If it's neither dict nor BaseMessage, convert to string and make HumanMessage
+    return HumanMessage(content=str(msg_dict))
+
+
 class LangGraphAgentRunnable(CompiledStateGraph):
     def __init__(self, *args, output_variables=None, **kwargs):
         super().__init__(*args, **kwargs)
@@ -612,16 +657,28 @@ class LangGraphAgentRunnable(CompiledStateGraph):
     def invoke(self, input: Union[dict[str, Any], Any],
                config: Optional[RunnableConfig] = None,
                *args, **kwargs):
-
+        logger.info(f"Incomming Input: {input}")
         if not config.get("configurable", {}).get("thread_id"):
             config["configurable"] = {"thread_id": str(uuid4())}
         thread_id = config.get("configurable", {}).get("thread_id")
+        # Handle chat history and current input properly
         if input.get('chat_history') and not input.get('messages'):
-            input['messages'] = input.pop('chat_history')
+            # Convert chat history dict messages to LangChain message objects
+            chat_history = input.pop('chat_history')
+            input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
+        
+        # Append current input to existing messages instead of overwriting
         if input.get('input'):
-            input['messages'] = [{"role": "user", "content": input.get('input')}]
+            current_message = HumanMessage(content=input.get('input'))
+            if input.get('messages'):
+                # Ensure existing messages are LangChain objects
+                input['messages'] = [convert_dict_to_message(msg) for msg in input['messages']]
+                # Append to existing messages
+                input['messages'].append(current_message)
+            else:
+                # No existing messages, create new list
+                input['messages'] = [current_message]
         logging.info(f"Input: {thread_id} - {input}")
-
         if self.checkpointer and self.checkpointer.get_tuple(config):
             self.update_state(config, input)
             result = super().invoke(None, config=config, *args, **kwargs)

alita_sdk/runtime/llms/alita.py

@@ -35,7 +35,7 @@ from langchain_core.messages import (AIMessageChunk, BaseMessage, HumanMessage,
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.runnables import run_in_executor
 from langchain_community.chat_models.openai import generate_from_stream, _convert_delta_to_message_chunk
-from ..clients import AlitaClient
+from ..clients.client import AlitaClient
 from pydantic import Field, model_validator, field_validator, ValidationInfo
 
 logger = logging.getLogger(__name__)

alita_sdk/runtime/tools/llm.py

@@ -1,46 +1,148 @@
+import json
 import logging
 from traceback import format_exc
-from typing import Any, Optional, Dict, List
+from typing import Any, Optional, Dict, List, Union
 
-from langchain_core.messages import HumanMessage, BaseMessage
+from langchain_core.messages import HumanMessage, BaseMessage, SystemMessage, AIMessage
 from langchain_core.tools import BaseTool, ToolException
+from langchain_core.runnables import RunnableConfig
+from pydantic import Field
 
 from ..langchain.utils import _extract_json, create_pydantic_model, create_params
 
 logger = logging.getLogger(__name__)
 
 
-def create_llm_input(prompt: Dict[str, str], params: Dict[str, Any], kwargs: Dict[str, Any]) -> list[BaseMessage]:
-    logger.info(f"Creating LLM input with prompt: {prompt}, params: {params}, kwargs: {kwargs}")
-    if prompt.get('type') == 'fstring' and params:
+def create_llm_input_with_messages(
+    prompt: Dict[str, str], 
+    messages: List[BaseMessage], 
+    params: Dict[str, Any]
+) -> List[BaseMessage]:
+    """
+    Create LLM input by combining system prompt with chat history messages.
+    
+    Args:
+        prompt: The prompt configuration with template
+        messages: List of chat history messages
+        params: Additional parameters for prompt formatting
+        
+    Returns:
+        List of messages to send to LLM
+    """
+    logger.info(f"Creating LLM input with messages: {len(messages)} messages, params: {params}")
+    
+    # Build the input messages
+    input_messages = []
+    
+    # Add system message from prompt if available
+    if prompt and prompt.get('template'):
         try:
-            return [HumanMessage(content=prompt['value'].format(**params))]
+            system_content = prompt['template'].format(**params) if params else prompt['template']
+            input_messages.append(SystemMessage(content=system_content))
         except KeyError as e:
-            error_msg = f"KeyError in input formatting - make sure you have added all required state variables as input to the node: {e}"
+            error_msg = f"KeyError in prompt formatting: {e}. Available params: {list(params.keys())}"
             logger.error(error_msg)
             raise ToolException(error_msg)
-    else:
-        return kwargs.get("messages") + [HumanMessage(prompt['value'])]
+    
+    # Add the chat history messages
+    if messages:
+        input_messages.extend(messages)
+    
+    return input_messages
 
 
 class LLMNode(BaseTool):
-    name: str = 'LLMNode'
-    prompt: Dict[str, str]
-    description: str = 'This is tool node for LLM'
-    client: Any = None
-    return_type: str = "str"
-    response_key: str = "messages"
-    structured_output_dict: Optional[dict[str, str]] = None
-    output_variables: Optional[List[str]] = None
-    input_variables: Optional[List[str]] = None
-    structured_output: Optional[bool] = False
+    """Enhanced LLM node with chat history and tool binding support"""
+    
+    # Override BaseTool required fields
+    name: str = Field(default='LLMNode', description='Name of the LLM node')
+    description: str = Field(default='This is tool node for LLM with chat history and tool support', description='Description of the LLM node')
+    
+    # LLM-specific fields
+    prompt: Dict[str, str] = Field(default_factory=dict, description='Prompt configuration')
+    client: Any = Field(default=None, description='LLM client instance')
+    return_type: str = Field(default="str", description='Return type')
+    response_key: str = Field(default="messages", description='Response key')
+    structured_output_dict: Optional[dict[str, str]] = Field(default=None, description='Structured output dictionary')
+    output_variables: Optional[List[str]] = Field(default=None, description='Output variables')
+    input_variables: Optional[List[str]] = Field(default=None, description='Input variables')
+    structured_output: Optional[bool] = Field(default=False, description='Whether to use structured output')
+    available_tools: Optional[List[BaseTool]] = Field(default=None, description='Available tools for binding')
+    tool_names: Optional[List[str]] = Field(default=None, description='Specific tool names to filter')
 
-    def _run(self, *args, **kwargs):
-        params = create_params(self.input_variables, kwargs)
-        logger.info(f"LLM Node params: {params}")
-        llm_input = create_llm_input(self.prompt, params, kwargs)
+    def get_filtered_tools(self) -> List[BaseTool]:
+        """
+        Filter available tools based on tool_names list.
+        
+        Returns:
+            List of filtered tools
+        """
+        if not self.available_tools:
+            return []
+            
+        if not self.tool_names:
+            # If no specific tool names provided, return all available tools
+            return self.available_tools
+            
+        # Filter tools by name
+        filtered_tools = []
+        available_tool_names = {tool.name: tool for tool in self.available_tools}
+        
+        for tool_name in self.tool_names:
+            if tool_name in available_tool_names:
+                filtered_tools.append(available_tool_names[tool_name])
+                logger.debug(f"Added tool '{tool_name}' to LLM node")
+            else:
+                logger.warning(f"Tool '{tool_name}' not found in available tools: {list(available_tool_names.keys())}")
+        
+        return filtered_tools
+
+    def invoke(
+        self,
+        state: Union[str, dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> dict:
+        """
+        Invoke the LLM node with proper message handling and tool binding.
+        
+        Args:
+            state: The current state containing messages and other variables
+            config: Optional runnable config
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            Updated state with LLM response
+        """
+        # Extract messages from state
+        
+        messages = state.get("messages", []) if isinstance(state, dict) else []
+        logger.info(f"Invoking LLMNode with {len(messages)} messages")
+        logger.info("Messages: %s", messages)
+        # Create parameters for prompt formatting from state
+        params = {}
+        if isinstance(state, dict):
+            for var in self.input_variables or []:
+                if var != "messages" and var in state:
+                    params[var] = state[var]
+        
+        # Create LLM input with proper message handling
+        llm_input = create_llm_input_with_messages(self.prompt, messages, params)
+        
+        # Get the LLM client, potentially with tools bound
+        llm_client = self.client
+        
+        if len(self.tool_names or []) > 0:
+            filtered_tools = self.get_filtered_tools()
+            if filtered_tools:
+                logger.info(f"Binding {len(filtered_tools)} tools to LLM: {[t.name for t in filtered_tools]}")
+                llm_client = self.client.bind_tools(filtered_tools)
+            else:
+                logger.warning("No tools to bind to LLM")
+        
         try:
-            if self.structured_output and len(self.output_variables) > 0:
+            if self.structured_output and self.output_variables:
+                # Handle structured output
                 struct_params = {
                     key: {
                         "type": 'list[str]' if 'list' in value else value,
@@ -48,27 +150,144 @@ class LLMNode(BaseTool):
                     }
                     for key, value in (self.structured_output_dict or {}).items()
                 }
-                stuct_model = create_pydantic_model(f"LLMOutput", struct_params)
-                llm = self.client.with_structured_output(stuct_model)
-                completion = llm.invoke(llm_input)
+                struct_model = create_pydantic_model(f"LLMOutput", struct_params)
+                llm = llm_client.with_structured_output(struct_model)
+                completion = llm.invoke(llm_input, config=config)
                 result = completion.model_dump()
+                
+                # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
+                
                 return result
             else:
-                completion = self.client.invoke(llm_input)
-                result = completion.content.strip()
-                response = _extract_json(result) or {}
-                response_data = {key: response[key] for key in response if key in self.output_variables}
-                if not response_data.get('messages'):
-                    response_data['messages'] = [
-                        {"role": "assistant", "content": response_data.get(self.response_key) or result}]
-                return response_data
-        except ValueError:
-            if self.output_variables:
-                return {self.output_variables[0]: result, "messages": [{"role": "assistant", "content": result}]}
-            else:
-                return {"messages": [{"role": "assistant", "content": result}]}
+                # Handle regular completion
+                completion = llm_client.invoke(llm_input, config=config)
+                logger.info(f"Initial completion: {completion}")
+                # Handle both tool-calling and regular responses
+                if hasattr(completion, 'tool_calls') and completion.tool_calls:
+                    # Handle iterative tool-calling and execution
+                    new_messages = messages + [completion]
+                    max_iterations = 15
+                    iteration = 0
+                    
+                    # Continue executing tools until no more tool calls or max iterations reached
+                    current_completion = completion
+                    while (hasattr(current_completion, 'tool_calls') and 
+                           current_completion.tool_calls and 
+                           iteration < max_iterations):
+                        
+                        iteration += 1
+                        logger.info(f"Tool execution iteration {iteration}/{max_iterations}")
+                        
+                        # Execute each tool call in the current completion
+                        tool_calls = current_completion.tool_calls if hasattr(current_completion.tool_calls, '__iter__') else []
+                        
+                        for tool_call in tool_calls:
+                            tool_name = tool_call.get('name', '') if isinstance(tool_call, dict) else getattr(tool_call, 'name', '')
+                            tool_args = tool_call.get('args', {}) if isinstance(tool_call, dict) else getattr(tool_call, 'args', {})
+                            tool_call_id = tool_call.get('id', '') if isinstance(tool_call, dict) else getattr(tool_call, 'id', '')
+                            
+                            # Find the tool in filtered tools
+                            filtered_tools = self.get_filtered_tools()
+                            tool_to_execute = None
+                            for tool in filtered_tools:
+                                if tool.name == tool_name:
+                                    tool_to_execute = tool
+                                    break
+                            
+                            if tool_to_execute:
+                                try:
+                                    logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
+                                    tool_result = tool_to_execute.invoke(tool_args)
+                                    
+                                    # Create tool message with result
+                                    from langchain_core.messages import ToolMessage
+                                    tool_message = ToolMessage(
+                                        content=str(tool_result),
+                                        tool_call_id=tool_call_id
+                                    )
+                                    new_messages.append(tool_message)
+                                    
+                                except Exception as e:
+                                    logger.error(f"Error executing tool '{tool_name}': {e}")
+                                    # Create error tool message
+                                    from langchain_core.messages import ToolMessage
+                                    tool_message = ToolMessage(
+                                        content=f"Error executing {tool_name}: {str(e)}",
+                                        tool_call_id=tool_call_id
+                                    )
+                                    new_messages.append(tool_message)
+                            else:
+                                logger.warning(f"Tool '{tool_name}' not found in available tools")
+                                # Create error tool message for missing tool
+                                from langchain_core.messages import ToolMessage
+                                tool_message = ToolMessage(
+                                    content=f"Tool '{tool_name}' not available",
+                                    tool_call_id=tool_call_id
+                                )
+                                new_messages.append(tool_message)
+                        
+                        # Call LLM again with tool results to get next response
+                        try:
+                            current_completion = llm_client.invoke(new_messages, config=config)
+                            new_messages.append(current_completion)
+                            
+                            # Check if we still have tool calls
+                            if hasattr(current_completion, 'tool_calls') and current_completion.tool_calls:
+                                logger.info(f"LLM requested {len(current_completion.tool_calls)} more tool calls")
+                            else:
+                                logger.info("LLM completed without requesting more tools")
+                                break
+                                
+                        except Exception as e:
+                            logger.error(f"Error in LLM call during iteration {iteration}: {e}")
+                            # Add error message and break the loop
+                            error_msg = f"Error processing tool results in iteration {iteration}: {str(e)}"
+                            new_messages.append(AIMessage(content=error_msg))
+                            break
+                    
+                    # Log completion status
+                    if iteration >= max_iterations:
+                        logger.warning(f"Reached maximum iterations ({max_iterations}) for tool execution")
+                        # Add a warning message to the chat
+                        warning_msg = f"Maximum tool execution iterations ({max_iterations}) reached. Stopping tool execution."
+                        new_messages.append(AIMessage(content=warning_msg))
+                    else:
+                        logger.info(f"Tool execution completed after {iteration} iterations")
+                    
+                    return {"messages": new_messages}
+                else:
+                    # Regular text response
+                    content = completion.content.strip() if hasattr(completion, 'content') else str(completion)
+                    
+                    # Try to extract JSON if output variables are specified (but exclude 'messages' which is handled separately)
+                    json_output_vars = [var for var in (self.output_variables or []) if var != 'messages']
+                    if json_output_vars:
+                        try:
+                            response = _extract_json(content) or {}
+                            response_data = {key: response.get(key) for key in json_output_vars if key in response}
+                            
+                            # Always add the messages to the response
+                            new_messages = messages + [AIMessage(content=content)]
+                            response_data['messages'] = new_messages
+                            
+                            return response_data
+                        except (ValueError, json.JSONDecodeError) as e:
+                            # LLM returned non-JSON content, treat as plain text
+                            logger.warning(f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
+                            # Fall through to plain text handling
+                    
+                    # Simple text response (either no output variables or JSON parsing failed)
+                    new_messages = messages + [AIMessage(content=content)]
+                    return {"messages": new_messages}
+                        
         except Exception as e:
             logger.error(f"Error in LLM Node: {format_exc()}")
-            return {"messages": [{"role": "assistant", "content": f"Error: {e}"}]}
+            error_msg = f"Error: {e}"
+            new_messages = messages + [AIMessage(content=error_msg)]
+            return {"messages": new_messages}
+
+    def _run(self, *args, **kwargs):
+        # Legacy support for old interface
+        return self.invoke(kwargs, **kwargs)

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -35,6 +35,21 @@ class McpServerTool(BaseTool):
                 field_type = float
             elif field_type == 'boolean':
                 field_type = bool
+            elif field_type == 'object':#Dict[str, Any]
+                nested_model = McpServerTool.create_pydantic_model_from_schema(field_info)
+                field_type = nested_model
+            elif field_type == 'array':
+                item_schema = field_info['items']
+                item_type = McpServerTool.create_pydantic_model_from_schema(item_schema) if item_schema['type'] == 'object' else (
+                    str if item_schema['type'] == 'string' else
+                    int if item_schema['type'] == 'integer' else
+                    float if item_schema['type'] == 'number' else
+                    bool if item_schema['type'] == 'boolean' else
+                    None
+                )
+                if item_type is None:
+                    raise ValueError(f"Unsupported array item type: {item_schema['type']}")
+                field_type = list[item_type]
             else:
                 raise ValueError(f"Unsupported field type: {field_type}")