beamlit 0.0.55rc103__py3-none-any.whl → 0.0.56rc105__py3-none-any.whl

beamlit/api/knowledgebases/update_knowledgebase.py

@@ -10,7 +10,7 @@ from ...types import Response
 
 
 def _get_kwargs(
-    knowledgebase_id: str,
+    knowledgebase_name: str,
     *,
     body: Knowledgebase,
 ) -> dict[str, Any]:
@@ -18,7 +18,7 @@ def _get_kwargs(
 
     _kwargs: dict[str, Any] = {
         "method": "put",
-        "url": f"/knowledgebases/{knowledgebase_id}",
+        "url": f"/knowledgebases/{knowledgebase_name}",
     }
 
     _body = body.to_dict()
@@ -51,7 +51,7 @@ def _build_response(*, client: Union[AuthenticatedClient, Client], response: htt
 
 
 def sync_detailed(
-    knowledgebase_id: str,
+    knowledgebase_name: str,
     *,
     client: AuthenticatedClient,
     body: Knowledgebase,
@@ -61,7 +61,7 @@ def sync_detailed(
      Updates an knowledgebase.
 
     Args:
-        knowledgebase_id (str):
+        knowledgebase_name (str):
         body (Knowledgebase): Knowledgebase
 
     Raises:
@@ -73,7 +73,7 @@ def sync_detailed(
     """
 
     kwargs = _get_kwargs(
-        knowledgebase_id=knowledgebase_id,
+        knowledgebase_name=knowledgebase_name,
         body=body,
     )
 
@@ -85,7 +85,7 @@ def sync_detailed(
 
 
 def sync(
-    knowledgebase_id: str,
+    knowledgebase_name: str,
     *,
     client: AuthenticatedClient,
     body: Knowledgebase,
@@ -95,7 +95,7 @@ def sync(
      Updates an knowledgebase.
 
     Args:
-        knowledgebase_id (str):
+        knowledgebase_name (str):
         body (Knowledgebase): Knowledgebase
 
     Raises:
@@ -107,14 +107,14 @@ def sync(
     """
 
     return sync_detailed(
-        knowledgebase_id=knowledgebase_id,
+        knowledgebase_name=knowledgebase_name,
         client=client,
         body=body,
     ).parsed
 
 
 async def asyncio_detailed(
-    knowledgebase_id: str,
+    knowledgebase_name: str,
     *,
     client: AuthenticatedClient,
     body: Knowledgebase,
@@ -124,7 +124,7 @@ async def asyncio_detailed(
      Updates an knowledgebase.
 
     Args:
-        knowledgebase_id (str):
+        knowledgebase_name (str):
         body (Knowledgebase): Knowledgebase
 
     Raises:
@@ -136,7 +136,7 @@ async def asyncio_detailed(
     """
 
     kwargs = _get_kwargs(
-        knowledgebase_id=knowledgebase_id,
+        knowledgebase_name=knowledgebase_name,
         body=body,
     )
 
@@ -146,7 +146,7 @@ async def asyncio_detailed(
 
 
 async def asyncio(
-    knowledgebase_id: str,
+    knowledgebase_name: str,
     *,
     client: AuthenticatedClient,
     body: Knowledgebase,
@@ -156,7 +156,7 @@ async def asyncio(
      Updates an knowledgebase.
 
     Args:
-        knowledgebase_id (str):
+        knowledgebase_name (str):
         body (Knowledgebase): Knowledgebase
 
     Raises:
@@ -169,7 +169,7 @@ async def asyncio(
 
     return (
         await asyncio_detailed(
-            knowledgebase_id=knowledgebase_id,
+            knowledgebase_name=knowledgebase_name,
             client=client,
             body=body,
         )

beamlit/common/settings.py

@@ -83,9 +83,11 @@ class Settings(BaseSettings):
     base_url: str = Field(default="https://api.beamlit.com/v0")
     app_url: str = Field(default="https://app.beamlit.com")
     run_url: str = Field(default="https://run.beamlit.com")
+    run_internal_hostname: str = Field(default="internal.run.beamlit.com")
     registry_url: str = Field(default="https://us.registry.beamlit.com")
     log_level: str = Field(default="INFO")
     enable_opentelemetry: bool = Field(default=False)
+    cloud: bool = Field(default=False)
     agent: SettingsAgent = SettingsAgent()
     server: SettingsServer = SettingsServer()
     authentication: SettingsAuthentication = SettingsAuthentication()

beamlit/deploy/deploy.py

@@ -59,6 +59,7 @@ def set_default_values(resource: Resource, deployment: Agent | Function):
     return deployment
 
 def get_beamlit_deployment_from_resource(
+    settings: Settings,
     resource: Resource,
 ) -> Agent | Function:
     """
@@ -75,6 +76,7 @@ def get_beamlit_deployment_from_resource(
             if isinstance(arg.value, ast.Dict):
                 value = arg_to_dict(arg.value)
                 metadata = EnvironmentMetadata(**value.get("metadata", {}))
+                metadata.environment = settings.environment
                 spec = AgentSpec(**value.get("spec", {}))
                 agent = Agent(metadata=metadata, spec=spec)
                 if not agent.spec.prompt:
@@ -84,6 +86,7 @@ def get_beamlit_deployment_from_resource(
             if isinstance(arg.value, ast.Dict):
                 value = arg_to_dict(arg.value)
                 metadata = EnvironmentMetadata(**value.get("metadata", {}))
+                metadata.environment = settings.environment
                 spec = FunctionSpec(**value.get("spec", {}))
                 func = Function(metadata=metadata, spec=spec)
                 if not func.spec.parameters:
@@ -265,13 +268,13 @@ def generate_beamlit_deployment(directory: str, name: str):
     functions: list[tuple[Resource, Function]] = []
     agents: list[tuple[Resource, Agent]] = []
     for resource in get_resources("agent", settings.server.directory):
-        agent = get_beamlit_deployment_from_resource(resource)
+        agent = get_beamlit_deployment_from_resource(settings, resource)
         if name and agent.metadata.name != name:
             agent.metadata.name = slugify(name)
         if agent:
             agents.append((resource, agent))
     for resource in get_resources("function", settings.server.directory):
-        function = get_beamlit_deployment_from_resource(resource)
+        function = get_beamlit_deployment_from_resource(settings, resource)
         if function:
             functions.append((resource, function))
 

beamlit/functions/common.py

@@ -28,6 +28,7 @@ from beamlit.authentication import new_client
 from beamlit.client import AuthenticatedClient
 from beamlit.common import slugify
 from beamlit.common.settings import get_settings
+from beamlit.functions.local.local import LocalToolKit
 from beamlit.functions.remote.remote import RemoteToolkit
 from beamlit.models import AgentChain
 
@@ -35,10 +36,12 @@ logger = getLogger(__name__)
 
 def get_functions(
     remote_functions: Union[list[str], None] = None,
+    local_functions: Union[list[dict], None] = None,
     client: Union[AuthenticatedClient, None] = None,
     dir: Union[str, None] = None,
     chain: Union[list[AgentChain], None] = None,
     remote_functions_empty: bool = True,
+    local_functions_empty: bool = True,
     from_decorator: str = "function",
     warning: bool = True,
 ):
@@ -140,6 +143,7 @@ def get_functions(
                                             client=client,
                                             dir=os.path.join(root),
                                             remote_functions_empty=remote_functions_empty,
+                                            local_functions_empty=local_functions_empty,
                                             from_decorator="kit",
                                         )
                                         functions.extend(kit_functions)
@@ -187,6 +191,18 @@ def get_functions(
                     f"Traceback:\n{traceback.format_exc()}"
                 )
                 logger.warn(f"Failed to initialize remote function {function}: {e!s}")
+    if local_functions:
+        for function in local_functions:
+            try:
+                toolkit = LocalToolKit(client, function)
+                toolkit.initialize()
+                functions.extend(toolkit.get_tools())
+            except Exception as e:
+                logger.debug(
+                    f"Failed to initialize local function {function}: {e!s}\n"
+                    f"Traceback:\n{traceback.format_exc()}"
+                )
+                logger.warn(f"Failed to initialize local function {function}: {e!s}")
 
     if chain:
         toolkit = ChainToolkit(client, chain)

beamlit/functions/local/local.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+import pydantic
+from langchain_core.tools.base import BaseTool
+
+from beamlit.authentication.authentication import AuthenticatedClient
+from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
+from beamlit.models import Function
+
+
+@dataclass
+class LocalToolKit:
+    """
+    Toolkit for managing local tools.
+
+    Attributes:
+        client (AuthenticatedClient): The authenticated client instance.
+        function (str): The name of the local function to integrate.
+        _function (Function | None): Cached Function object after initialization.
+    """
+    client: AuthenticatedClient
+    local_function: dict
+    _function: Function | None = None
+    model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
+
+    def initialize(self) -> None:
+        """Initialize the session and retrieve the local function details."""
+        if self._function is None:
+            try:
+                # For local functions, we directly create the Function object
+                # based on the local function name
+                self._function = Function(
+                    metadata={"name": self.local_function['name']},
+                    spec={
+                        "configurations": {
+                            "url": self.local_function['url'],
+                            "sse": self.local_function['sse'],
+                        },
+                        "description": self.local_function['description'] or "",
+                    }
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to initialize local function: {e}")
+
+    def get_tools(self) -> list[BaseTool]:
+        mcp_client = MCPClient(self.client, self._function.spec["configurations"]["url"], sse=self._function.spec["configurations"]["sse"])
+        mcp_toolkit = MCPToolkit(client=mcp_client)
+        mcp_toolkit.initialize()
+        return mcp_toolkit.get_tools()

beamlit/functions/mcp/mcp.py

@@ -4,91 +4,87 @@ It includes classes for managing MCP clients, creating dynamic schemas, and inte
 """
 
 import asyncio
+import logging
 import warnings
-from typing import Any, Callable
+from typing import Any, AsyncIterator, Callable
 
 import pydantic
 import pydantic_core
 import requests
 import typing_extensions as t
 from langchain_core.tools.base import BaseTool, BaseToolkit, ToolException
+from mcp import ClientSession
+from mcp.client.sse import sse_client
 from mcp.types import CallToolResult, ListToolsResult
-from pydantic.json_schema import JsonSchemaValue
-from pydantic_core import core_schema as cs
 
 from beamlit.authentication.authentication import AuthenticatedClient
 from beamlit.common.settings import get_settings
 
-settings = get_settings()
+from .utils import create_schema_model
 
-TYPE_MAP = {
-    "integer": int,
-    "number": float,
-    "array": list,
-    "object": dict,
-    "boolean": bool,
-    "string": str,
-    "null": type(None),
-}
-
-FIELD_DEFAULTS = {
-    int: 0,
-    float: 0.0,
-    list: [],
-    bool: False,
-    str: "",
-    type(None): None,
-}
-
-def configure_field(name: str, type_: dict[str, t.Any], required: list[str]) -> tuple[type, t.Any]:
-    field_type = TYPE_MAP[type_["type"]]
-    default_ = FIELD_DEFAULTS.get(field_type) if name not in required else ...
-    return field_type, default_
-
-def create_schema_model(name: str, schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
-    # Create a new model class that returns our JSON schema.
-    # LangChain requires a BaseModel class.
-    class SchemaBase(pydantic.BaseModel):
-        model_config = pydantic.ConfigDict(extra="allow")
-
-        @t.override
-        @classmethod
-        def __get_pydantic_json_schema__(
-            cls, core_schema: cs.CoreSchema, handler: pydantic.GetJsonSchemaHandler
-        ) -> JsonSchemaValue:
-            return schema
-
-    # Since this langchain patch, we need to synthesize pydantic fields from the schema
-    # https://github.com/langchain-ai/langchain/commit/033ac417609297369eb0525794d8b48a425b8b33
-    required = schema.get("required", [])
-    fields: dict[str, t.Any] = {
-        name: configure_field(name, type_, required) for name, type_ in schema["properties"].items()
-    }
-
-    return pydantic.create_model(f"{name}Schema", __base__=SchemaBase, **fields)
+settings = get_settings()
 
+logger = logging.getLogger(__name__)
 
 
 class MCPClient:
     def __init__(self, client: AuthenticatedClient, url: str):
         self.client = client
         self.url = url
-
-    def list_tools(self) -> requests.Response:
-        client = self.client.get_httpx_client()
-        response = client.request("GET", f"{self.url}/tools/list")
-        response.raise_for_status()
-        return response
-
-    def call_tool(self, tool_name: str, arguments: dict[str, Any] = None) -> requests.Response:
-        client = self.client.get_httpx_client()
-        response = client.request(
-            "POST",
-            f"{self.url}/tools/call",
-            json={"name": tool_name, "arguments": arguments},
-        )
-        response.raise_for_status()
-        return response
+        self._sse = False
+
+    async def list_sse_tools(self) -> ListToolsResult:
+        # Create a new context for each SSE connection
+        try:
+            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    response = await session.list_tools()
+                    return response
+        except Exception:
+            self._sse = False
+            logger.info("SSE not available, trying HTTP")
+            return None  # Signal to list_tools() to try HTTP instead
+
+    def list_tools(self) -> ListToolsResult:
+        try:
+            loop = asyncio.get_event_loop()
+            result = loop.run_until_complete(self.list_sse_tools())
+            if result is None:  # SSE failed, try HTTP
+                raise Exception("SSE failed")
+            self._sse = True
+            return result
+        except Exception:  # Fallback to HTTP
+            client = self.client.get_httpx_client()
+            response = client.request("GET", f"{self.url}/tools/list")
+            response.raise_for_status()
+            return ListToolsResult(**response.json())
+
+    async def call_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any] = None,
+    ) -> requests.Response | AsyncIterator[CallToolResult]:
+        if self._sse:
+            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    response = await session.call_tool(tool_name, arguments or {})
+                    content = pydantic_core.to_json(response).decode()
+                    return content
+        else: # Fallback to HTTP
+            client = self.client.get_httpx_client()
+            response = client.request(
+                "POST",
+                f"{self.url}/tools/call",
+                json={"name": tool_name, "arguments": arguments},
+            )
+            response.raise_for_status()
+            result = CallToolResult(response.json())
+            if result.isError:
+                raise ToolException(result.content)
+            content = pydantic_core.to_json(result.content).decode()
+            return content
 
 class MCPTool(BaseTool):
     """
@@ -97,6 +93,7 @@ class MCPTool(BaseTool):
     Attributes:
         client (MCPClient): The MCP client instance.
         handle_tool_error (bool | str | Callable[[ToolException], str] | None): Error handling strategy.
+        sse (bool): Whether to use SSE streaming for responses.
     """
 
     client: MCPClient
@@ -112,13 +109,7 @@ class MCPTool(BaseTool):
 
     @t.override
     async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        result = self.client.call_tool(self.name, arguments=kwargs)
-        response = result.json()
-        result = CallToolResult(**response)
-        if result.isError:
-            raise ToolException(result.content)
-        content = pydantic_core.to_json(result.content).decode()
-        return content
+        return await self.client.call_tool(self.name, arguments=kwargs)
 
     @t.override
     @property
@@ -139,14 +130,13 @@ class MCPToolkit(BaseToolkit):
     """The MCP session used to obtain the tools"""
 
     _tools: ListToolsResult | None = None
-
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
     def initialize(self) -> None:
         """Initialize the session and retrieve tools list"""
         if self._tools is None:
             response = self.client.list_tools()
-            self._tools = ListToolsResult(**response.json())
+            self._tools = response
 
     @t.override
     def get_tools(self) -> list[BaseTool]:

beamlit/functions/mcp/utils.py

@@ -0,0 +1,56 @@
+"""
+This module provides functionalities to interact with MCP (Multi-Client Platform) servers.
+It includes classes for managing MCP clients, creating dynamic schemas, and integrating MCP tools into Beamlit.
+"""
+import pydantic
+import typing_extensions as t
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema as cs
+
+TYPE_MAP = {
+    "integer": int,
+    "number": float,
+    "array": list,
+    "object": dict,
+    "boolean": bool,
+    "string": str,
+    "null": type(None),
+}
+
+FIELD_DEFAULTS = {
+    int: 0,
+    float: 0.0,
+    list: [],
+    bool: False,
+    str: "",
+    type(None): None,
+}
+
+def configure_field(name: str, type_: dict[str, t.Any], required: list[str]) -> tuple[type, t.Any]:
+    field_type = TYPE_MAP[type_["type"]]
+    default_ = FIELD_DEFAULTS.get(field_type) if name not in required else ...
+    return field_type, default_
+
+def create_schema_model(name: str, schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
+    # Create a new model class that returns our JSON schema.
+    # LangChain requires a BaseModel class.
+    class SchemaBase(pydantic.BaseModel):
+        model_config = pydantic.ConfigDict(extra="allow")
+
+        @t.override
+        @classmethod
+        def __get_pydantic_json_schema__(
+            cls, core_schema: cs.CoreSchema, handler: pydantic.GetJsonSchemaHandler
+        ) -> JsonSchemaValue:
+            return schema
+
+    # Since this langchain patch, we need to synthesize pydantic fields from the schema
+    # https://github.com/langchain-ai/langchain/commit/033ac417609297369eb0525794d8b48a425b8b33
+    required = schema.get("required", [])
+    fields: dict[str, t.Any] = {
+        name: configure_field(name, type_, required) for name, type_ in schema["properties"].items()
+    }
+
+    return pydantic.create_model(f"{name}Schema", __base__=SchemaBase, **fields)
+
+

beamlit/functions/remote/remote.py

@@ -4,6 +4,7 @@ It includes classes for creating dynamic schemas based on function parameters an
 """
 
 import asyncio
+import os
 import warnings
 from dataclasses import dataclass
 from typing import Callable
@@ -67,7 +68,8 @@ class RemoteTool(BaseTool):
     resource_name: str
     kit: bool = False
     handle_tool_error: bool | str | Callable[[ToolException], str] | None = True
-
+    service_name: str | None = None
+    cloud: bool = False
     @t.override
     def _run(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
         warnings.warn(
@@ -87,7 +89,9 @@ class RemoteTool(BaseTool):
             self.resource_name,
             settings.environment,
             "POST",
-            json=body
+            cloud=self.cloud,
+            service_name=self.service_name,
+            json=body,
         )
         return result.text
 
@@ -110,6 +114,7 @@ class RemoteToolkit:
     client: AuthenticatedClient
     function: str
     _function: Function | None = None
+    _service_name: str | None = None
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
     def initialize(self) -> None:
@@ -117,6 +122,9 @@ class RemoteToolkit:
         if self._function is None:
             try:
                 response = get_function.sync_detailed(self.function, client=self.client)
+                function_name = self.function.upper().replace("-", "_")
+                if os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME"):
+                    self._service_name = os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME")
                 self._function = response.parsed
             except UnexpectedStatus as e:
                 settings = get_settings()
@@ -139,6 +147,8 @@ class RemoteToolkit:
 
         if self._function.spec.integration_connections:
             url = f"{settings.run_url}/{settings.workspace}/functions/{self._function.metadata.name}"
+            if self._service_name:
+                url = f"https://{self._service_name}.{settings.run_internal_hostname}"
             mcp_client = MCPClient(self.client, url)
             mcp_toolkit = MCPToolkit(client=mcp_client)
             mcp_toolkit.initialize()
@@ -153,6 +163,8 @@ class RemoteToolkit:
                     kit=True,
                     description=func.description or "",
                     args_schema=create_dynamic_schema(func.name, func.parameters),
+                    cloud=settings.cloud,
+                    service_name=self._service_name,
                 )
                 for func in self._function.spec.kit
             ]
@@ -167,5 +179,7 @@ class RemoteToolkit:
                     self._function.metadata.name,
                     self._function.spec.parameters
                 ),
+                cloud=settings.cloud,
+                service_name=self._service_name,
             )
         ]

beamlit/models/__init__.py

@@ -5,6 +5,8 @@ from .agent import Agent
 from .agent_chain import AgentChain
 from .agent_history import AgentHistory
 from .agent_history_event import AgentHistoryEvent
+from .agent_information_request import AgentInformationRequest
+from .agent_information_response import AgentInformationResponse
 from .agent_release import AgentRelease
 from .agent_spec import AgentSpec
 from .api_key import ApiKey
@@ -18,11 +20,17 @@ from .create_api_key_for_service_account_body import CreateApiKeyForServiceAccou
 from .create_workspace_service_account_body import CreateWorkspaceServiceAccountBody
 from .create_workspace_service_account_response_200 import CreateWorkspaceServiceAccountResponse200
 from .delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
+from .entrypoint import Entrypoint
+from .entrypoint_env import EntrypointEnv
 from .environment import Environment
 from .environment_metadata import EnvironmentMetadata
 from .environment_metrics import EnvironmentMetrics
 from .environment_spec import EnvironmentSpec
 from .flavor import Flavor
+from .form import Form
+from .form_config import FormConfig
+from .form_oauthomitempty import FormOauthomitempty
+from .form_secrets import FormSecrets
 from .function import Function
 from .function_kit import FunctionKit
 from .function_release import FunctionRelease
@@ -49,6 +57,12 @@ from .knowledgebase_spec_options import KnowledgebaseSpecOptions
 from .last_n_requests_metric import LastNRequestsMetric
 from .latency_metric import LatencyMetric
 from .location_response import LocationResponse
+from .mcp_definition import MCPDefinition
+from .mcp_definition_entrypoint import MCPDefinitionEntrypoint
+from .mcp_definition_form import MCPDefinitionForm
+from .mcp_hub_artifact import MCPHubArtifact
+from .mcp_hub_artifact_entrypoint import MCPHubArtifactEntrypoint
+from .mcp_hub_artifact_form import MCPHubArtifactForm
 from .metadata import Metadata
 from .metadata_labels import MetadataLabels
 from .metric import Metric
@@ -60,6 +74,7 @@ from .model import Model
 from .model_private_cluster import ModelPrivateCluster
 from .model_release import ModelRelease
 from .model_spec import ModelSpec
+from .o_auth import OAuth
 from .owner_fields import OwnerFields
 from .pending_invitation import PendingInvitation
 from .pending_invitation_accept import PendingInvitationAccept
@@ -125,6 +140,8 @@ __all__ = (
     "AgentChain",
     "AgentHistory",
     "AgentHistoryEvent",
+    "AgentInformationRequest",
+    "AgentInformationResponse",
     "AgentRelease",
     "AgentSpec",
     "ApiKey",
@@ -138,11 +155,17 @@ __all__ = (
     "CreateWorkspaceServiceAccountBody",
     "CreateWorkspaceServiceAccountResponse200",
     "DeleteWorkspaceServiceAccountResponse200",
+    "Entrypoint",
+    "EntrypointEnv",
     "Environment",
     "EnvironmentMetadata",
     "EnvironmentMetrics",
     "EnvironmentSpec",
     "Flavor",
+    "Form",
+    "FormConfig",
+    "FormOauthomitempty",
+    "FormSecrets",
     "Function",
     "FunctionKit",
     "FunctionRelease",
@@ -167,6 +190,12 @@ __all__ = (
     "LastNRequestsMetric",
     "LatencyMetric",
     "LocationResponse",
+    "MCPDefinition",
+    "MCPDefinitionEntrypoint",
+    "MCPDefinitionForm",
+    "MCPHubArtifact",
+    "MCPHubArtifactEntrypoint",
+    "MCPHubArtifactForm",
     "Metadata",
     "MetadataLabels",
     "Metric",
@@ -178,6 +207,7 @@ __all__ = (
     "ModelPrivateCluster",
     "ModelRelease",
     "ModelSpec",
+    "OAuth",
     "OwnerFields",
     "PendingInvitation",
     "PendingInvitationAccept",