test

Author: heyitsaamir

packages/ai/src/microsoft/teams/ai/chat_prompt.py

@@ -5,7 +5,7 @@
 
 from dataclasses import dataclass
 from inspect import isawaitable
-from typing import Any, Awaitable, Callable, TypeVar
+from typing import Any, Awaitable, Callable, Self, TypeVar
 
 from pydantic import BaseModel
 
@@ -35,11 +35,11 @@ def __init__(
         self.functions: dict[str, Function[Any]] = {func.name: func for func in functions} if functions else {}
         self.plugins: list[AIPluginProtocol] = plugins or []
 
-    def with_function(self, function: Function[T]) -> "ChatPrompt":
+    def with_function(self, function: Function[T]) -> Self:
         self.functions[function.name] = function
         return self
 
-    def with_plugin(self, plugin: AIPluginProtocol) -> "ChatPrompt":
+    def with_plugin(self, plugin: AIPluginProtocol) -> Self:
         """Add a plugin to the chat prompt."""
         self.plugins.append(plugin)
         return self
@@ -82,15 +82,14 @@ async def send(
                 )
 
         # Allow plugins to modify the functions before sending to model
-        if wrapped_functions:
-            functions_list = list(wrapped_functions.values())
-            for plugin in self.plugins:
-                plugin_result = await plugin.on_build_functions(functions_list)
-                if plugin_result is not None:
-                    functions_list = plugin_result
+        functions_list = list(wrapped_functions.values()) if wrapped_functions else []
+        for plugin in self.plugins:
+            plugin_result = await plugin.on_build_functions(functions_list)
+            if plugin_result is not None:
+                functions_list = plugin_result
 
-            # Convert back to dict for model
-            wrapped_functions = {func.name: func for func in functions_list}
+        # Convert back to dict for model
+        wrapped_functions = {func.name: func for func in functions_list}
 
         response = await self.model.generate_text(
             current_input, memory=memory, functions=wrapped_functions, on_chunk=on_chunk

packages/ai/src/microsoft/teams/ai/function.py

@@ -4,7 +4,7 @@
 """
 
 from dataclasses import dataclass
-from typing import Any, Awaitable, Generic, Protocol, TypeVar, Union
+from typing import Any, Awaitable, Dict, Generic, Protocol, TypeVar, Union
 
 from pydantic import BaseModel
 
@@ -19,7 +19,7 @@ def __call__(self, params: Params) -> Union[str, Awaitable[str]]: ...
 class Function(Generic[Params]):
     name: str
     description: str
-    parameter_schema: type[Params]
+    parameter_schema: Union[type[Params], Dict[str, Any]]
     handler: FunctionHandler[Params]
 
 

packages/mcp/src/microsoft/teams/mcp/ai_plugin.py

@@ -75,7 +75,7 @@ def __init__(
 
         self._version = version
         self._cache: Dict[str, McpCachedValue] = cache or {}
-        self._logger = logger or ConsoleLogger().create_logger(self.name)
+        self._logger = logger.getChild(self.name) if logger else ConsoleLogger().create_logger(self.name)
         self._refetch_timeout_ms = refetch_timeout_ms
 
         # Track MCP server URLs and their parameters
@@ -170,26 +170,26 @@ async def _fetch_tools_if_needed(self) -> None:
                     self._logger.debug(f"Cached {len(result)} tools for {url}")
 
     def _create_function_from_tool(
-        self, url: str, tool: Union[McpToolDetails, Dict[str, Any]], plugin_params: McpClientPluginParams
+        self, url: str, tool: McpToolDetails, plugin_params: McpClientPluginParams
     ) -> Function[BaseModel]:
         """Create a Teams AI function from an MCP tool."""
-        if isinstance(tool, dict):
-            tool_name = tool["name"]
-            tool_description = tool["description"]
-        else:
-            tool_name = tool.name
-            tool_description = tool.description
+        tool_name = tool.name
+        tool_description = tool.description
 
         async def handler(params: BaseModel) -> str:
             """Handle MCP tool call."""
             try:
+                self._logger.debug(f"Making call to {url} tool-name={tool_name}")
                 result = await self._call_mcp_tool(url, tool_name, params.model_dump(), plugin_params)
+                self._logger.debug("Successfully received result for mcp call")
                 return str(result)
             except Exception as e:
                 self._logger.error(f"Error calling tool {tool_name} on {url}: {e}")
                 raise
 
-        return Function(name=tool_name, description=tool_description, parameter_schema=BaseModel, handler=handler)
+        return Function(
+            name=tool_name, description=tool_description, parameter_schema=tool.input_schema, handler=handler
+        )
 
     async def _fetch_tools_from_server(self, url: str, params: McpClientPluginParams) -> List[McpToolDetails]:
         """Fetch tools from a specific MCP server."""
@@ -212,6 +212,7 @@ async def _fetch_tools_from_server(self, url: str, params: McpClientPluginParams
                         )
                     )
 
+                self._logger.debug(f"Got {len(tools)} tools for {url}")
                 return tools
 
     async def _call_mcp_tool(

packages/openai_ai_model/src/microsoft/teams/openai_ai_model/completions_model.py

@@ -37,6 +37,8 @@
 )
 from pydantic import BaseModel
 
+from .function_utils import get_function_schema, parse_function_arguments
+
 
 class _ToolCallData(TypedDict):
     id: str
@@ -127,8 +129,8 @@ async def _execute_functions(
                 if functions and call.name in functions:
                     function = functions[call.name]
                     try:
-                        # Parse arguments into Pydantic model
-                        parsed_args = function.parameter_schema(**call.arguments)
+                        # Parse arguments using utility function
+                        parsed_args = parse_function_arguments(function, call.arguments)
 
                         # Handle both sync and async function handlers
                         result = function.handler(parsed_args)
@@ -258,7 +260,7 @@ def _convert_functions(self, functions: dict[str, Function[BaseModel]]) -> list[
                 "function": {
                     "name": func.name,
                     "description": func.description,
-                    "parameters": func.parameter_schema.model_json_schema(),
+                    "parameters": get_function_schema(func),
                 },
             }
             for func in functions.values()

packages/openai_ai_model/src/microsoft/teams/openai_ai_model/function_utils.py

@@ -0,0 +1,38 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from typing import Any, Dict
+
+from microsoft.teams.ai import Function
+from pydantic import BaseModel, create_model
+
+
+def get_function_schema(func: Function[BaseModel]) -> Dict[str, Any]:
+    """
+    Get JSON schema from a Function's parameter_schema.
+
+    Handles both dict schemas and Pydantic model classes.
+    """
+    if isinstance(func.parameter_schema, dict):
+        # Raw JSON schema - use as-is
+        return func.parameter_schema.copy()
+    else:
+        # Pydantic model - convert to JSON schema
+        return func.parameter_schema.model_json_schema()
+
+
+def parse_function_arguments(func: Function[BaseModel], arguments: Dict[str, Any]) -> BaseModel:
+    """
+    Parse function arguments into a BaseModel instance.
+
+    Handles both dict schemas and Pydantic model classes.
+    """
+    if isinstance(func.parameter_schema, dict):
+        # For dict schemas, create a simple BaseModel dynamically
+        DynamicModel = create_model("DynamicParams")
+        return DynamicModel(**arguments)
+    else:
+        # For Pydantic model schemas, parse normally
+        return func.parameter_schema(**arguments)

packages/openai_ai_model/src/microsoft/teams/openai_ai_model/responses_chat_model.py

@@ -22,6 +22,10 @@
 )
 from microsoft.teams.openai_ai_model.common import OpenAIBaseModel
 from openai import NOT_GIVEN
+from openai.lib._pydantic import (
+    _ensure_strict_json_schema,  # pyright: ignore [reportPrivateUsage]
+    to_strict_json_schema,
+)
 from openai.types.responses import (
     EasyInputMessageParam,
     FunctionToolParam,
@@ -33,6 +37,8 @@
 )
 from pydantic import BaseModel
 
+from .function_utils import get_function_schema, parse_function_arguments
+
 
 @dataclass
 class OpenAIResponsesAIModel(OpenAIBaseModel, AIModel):
@@ -217,8 +223,8 @@ async def _execute_functions(
                 if functions and call.name in functions:
                     function = functions[call.name]
                     try:
-                        # Parse arguments into Pydantic model
-                        parsed_args = function.parameter_schema(**call.arguments)
+                        # Parse arguments using utility function
+                        parsed_args = parse_function_arguments(function, call.arguments)
 
                         # Handle both sync and async function handlers
                         result = function.handler(parsed_args)
@@ -301,9 +307,14 @@ def _convert_functions_to_tools(self, functions: dict[str, Function[BaseModel]])
         tools: list[ToolParam] = []
 
         for func in functions.values():
-            # Get schema and ensure additionalProperties is false for Responses API
-            schema = func.parameter_schema.model_json_schema()
-            schema["additionalProperties"] = False
+            # Get strict schema for Responses API using OpenAI's transformations
+            if isinstance(func.parameter_schema, dict):
+                # For raw JSON schemas, use OpenAI's strict transformation
+                schema = get_function_schema(func)
+                schema = _ensure_strict_json_schema(schema, path=(), root=schema)
+            else:
+                # Use OpenAI's official strict schema transformation for Pydantic models
+                schema = to_strict_json_schema(func.parameter_schema)
 
             tools.append(
                 FunctionToolParam(

tests/mcp/src/main.py

@@ -10,6 +10,7 @@
 from microsoft.teams.ai import Agent
 from microsoft.teams.ai.memory import ListMemory
 from microsoft.teams.api import MessageActivity
+from microsoft.teams.api.activities.typing import TypingActivityInput
 from microsoft.teams.apps import ActivityContext, App
 from microsoft.teams.apps.options import AppOptions
 from microsoft.teams.devtools import DevToolsPlugin
@@ -51,6 +52,7 @@ async def handle_message(ctx: ActivityContext[MessageActivity]):
     """Handle message activities using the new generated handler system."""
     print(f"[GENERATED onMessage] Message received: {ctx.activity.text}")
     print(f"[GENERATED onMessage] From: {ctx.activity.from_}")
+    await ctx.send(TypingActivityInput())
 
     result = await responses_agent.send(ctx.activity.text)
     if result.response.content: