optimizely-opal.opal-tools-sdk 0.1.4.dev0__py3-none-any.whl → 0.1.10.dev0__py3-none-any.whl

opal_tools_sdk/__init__.py

@@ -2,6 +2,19 @@ from .service import ToolsService
 from .decorators import tool
 from .auth import requires_auth
 from .logging import register_logger_factory
+from .models import AuthData, AuthRequirement, Credentials, Environment, IslandConfig, IslandResponse
 
 __version__ = "0.1.0"
-__all__ = ["ToolsService", "tool", "requires_auth", "register_logger_factory"]
+__all__ = [
+    "ToolsService",
+    "tool",
+    "requires_auth",
+    "register_logger_factory",
+    # Models
+    "AuthData",
+    "AuthRequirement",
+    "Credentials",
+    "Environment",
+    "IslandConfig",
+    "IslandResponse",
+]

opal_tools_sdk/decorators.py

@@ -62,25 +62,48 @@ def tool(name: str, description: str, auth_requirements: Optional[List[Dict[str,
                 else:
                     field_type = str
 
+                # Check if the field is Optional (Union with None)
+                # Optional[X] is equivalent to Union[X, None]
+                type_args = getattr(field_type, '__args__', ())
+                is_optional = get_origin(field_type) is Union and type(None) in type_args
+
+                # Extract the actual type from Optional[T]
+                if is_optional and type_args:
+                    # Get the non-None type from Union[T, None]
+                    field_type = next(
+                        (arg for arg in type_args if arg is not type(None)),
+                        field_type,
+                    )
+
                 # Map Python type to Parameter type
                 param_type = ParameterType.string
-                if field_type == int:
+                if field_type is int:
                     param_type = ParameterType.integer
-                elif field_type == float:
+                elif field_type is float:
                     param_type = ParameterType.number
-                elif field_type == bool:
+                elif field_type is bool:
                     param_type = ParameterType.boolean
-                elif get_origin(field_type) is list:
+                elif field_type is list or get_origin(field_type) is list:
                     param_type = ParameterType.list
-                elif get_origin(field_type) is dict:
+                elif field_type is dict or get_origin(field_type) is dict:
                     param_type = ParameterType.dictionary
 
                 # Determine if required
                 field_info_extra = getattr(field_info, "json_schema_extra") or {}
                 if "required" in field_info_extra:
                     required = field_info_extra["required"]
+                # If the field is typed as Optional, it's not required (check this FIRST)
+                elif is_optional:
+                    required = False
+                # Check for Pydantic v2 is_required() method
+                elif hasattr(field_info, 'is_required'):
+                    required = field_info.is_required()
+                # Fall back to checking if default is ... (Pydantic v1/v2 compatibility)
+                elif hasattr(field_info, 'default'):
+                    required = field_info.default is ...
                 else:
-                    required = field_info.default is ... if hasattr(field_info, 'default') else True
+                    # If no default attribute at all, assume required
+                    required = True
 
                 # Get description
                 description_text = ""

opal_tools_sdk/models.py

@@ -1,9 +1,13 @@
 from enum import Enum
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Literal, TypedDict
 from dataclasses import dataclass
 
+from pydantic import BaseModel, Field
+
+
 class ParameterType(str, Enum):
     """Types of parameters supported by Opal tools."""
+
     string = "string"
     integer = "integer"
     number = "number"
@@ -11,9 +15,11 @@ class ParameterType(str, Enum):
     list = "array"  # Changed to match main service expectation
     dictionary = "object"  # Standard JSON schema type
 
+
 @dataclass
 class Parameter:
     """Parameter definition for an Opal tool."""
+
     name: str
     param_type: ParameterType
     description: str
@@ -21,31 +27,49 @@ class Parameter:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for the discovery endpoint."""
-        return {
-            "name": self.name,
-            "type": self.param_type.value,
-            "description": self.description,
-            "required": self.required
-        }
+        return {"name": self.name, "type": self.param_type.value, "description": self.description, "required": self.required}
+
 
 @dataclass
 class AuthRequirement:
     """Authentication requirements for an Opal tool."""
+
     provider: str  # e.g., "google", "microsoft"
     scope_bundle: str  # e.g., "calendar", "drive"
     required: bool = True
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for the discovery endpoint."""
-        return {
-            "provider": self.provider,
-            "scope_bundle": self.scope_bundle,
-            "required": self.required
-        }
+        return {"provider": self.provider, "scope_bundle": self.scope_bundle, "required": self.required}
+
+
+class Credentials(TypedDict):
+    """AuthData credentials."""
+
+    access_token: str
+    org_sso_id: Optional[str]
+    customer_id: str
+    instance_id: str
+    product_sku: str
+
+
+class AuthData(TypedDict):
+    """Authentication data for an Opal tool."""
+
+    provider: str
+    credentials: Credentials
+
+
+class Environment(TypedDict):
+    """Execution environment for an Opal tool. Interactive will provide interaction islands, while headless will not."""
+
+    execution_mode: Literal["headless", "interactive"]
+
 
 @dataclass
 class Function:
     """Function definition for an Opal tool."""
+
     name: str
     description: str
     parameters: List[Parameter]
@@ -60,10 +84,46 @@ class Function:
             "description": self.description,
             "parameters": [p.to_dict() for p in self.parameters],
             "endpoint": self.endpoint,
-            "http_method": self.http_method
+            "http_method": self.http_method,
         }
 
         if self.auth_requirements:
             result["auth_requirements"] = [auth.to_dict() for auth in self.auth_requirements]
 
         return result
+
+
+# Interaction island related classes
+class IslandConfig(BaseModel):
+    class Field(BaseModel):
+        name: str
+        label: str
+        type: Literal["string", "boolean", "json"]
+        value: str = Field(default="")
+        hidden: bool = Field(default=False)
+        options: list[str] = Field(default=[])
+
+    class Action(BaseModel):
+        name: str
+        label: str
+        type: str
+        endpoint: str
+        operation: str = Field(default="create")
+
+    fields: list[Field]
+    actions: list[Action]
+    type: Optional[str] = None
+    icon: Optional[str] = None
+
+
+class IslandResponse(BaseModel):
+    class ResponseConfig(BaseModel):
+        islands: list[IslandConfig]
+
+    type: Literal["island"]
+    config: ResponseConfig
+    message: Optional[str] = None
+
+    @classmethod
+    def create(cls, islands: list[IslandConfig], message: Optional[str] = None):
+        return cls(type="island", config=cls.ResponseConfig(islands=islands), message=message)

opal_tools_sdk/service.py

@@ -1,15 +1,16 @@
-from typing import Dict, List, Any, Callable, Type, Optional, get_type_hints
+from typing import Dict, List, Any, Callable, Optional, get_type_hints
 import inspect
 import logging
-from fastapi import FastAPI, APIRouter, Depends, Header, HTTPException, Request
+from fastapi import FastAPI, APIRouter, HTTPException, Request
 from fastapi.routing import APIRoute
-from pydantic import BaseModel, create_model
+from pydantic import BaseModel, ValidationError
 
-from .models import Function, Parameter, ParameterType, AuthRequirement
+from .models import Function, Parameter, AuthRequirement
 from . import _registry
 
 logger = logging.getLogger(__name__)
 
+
 class ToolsService:
     """Main class for managing Opal tools."""
 
@@ -33,15 +34,12 @@ class ToolsService:
             routes = []
             for route in app.routes:
                 if isinstance(route, APIRoute):
-                    routes.append({
-                        "path": route.path,
-                        "name": route.name,
-                        "methods": route.methods
-                    })
+                    routes.append({"path": route.path, "name": route.name, "methods": route.methods})
             return {"routes": routes}
 
     def _init_routes(self) -> None:
         """Initialize the discovery endpoint."""
+
         @self.router.get("/discovery")
         async def discovery() -> Dict[str, Any]:
             """Return the discovery information for this tools service."""
@@ -66,21 +64,23 @@ class ToolsService:
             # Auth requirements should always be a list
             if isinstance(handler.__auth_requirements__, list):
                 for req in handler.__auth_requirements__:
-                    auth_requirements.append(AuthRequirement(
-                        provider=req.get("provider", ""),
-                        scope_bundle=req.get("scope_bundle", ""),
-                        required=req.get("required", True)
-                    ))
+                    auth_requirements.append(
+                        AuthRequirement(
+                            provider=req.get("provider", ""), scope_bundle=req.get("scope_bundle", ""), required=req.get("required", True)
+                        )
+                    )
 
         return auth_requirements
 
-    def register_tool(self,
-                     name: str,
-                     description: str,
-                     handler: Callable,
-                     parameters: List[Parameter],
-                     endpoint: str,
-                     auth_requirements: Optional[List[AuthRequirement]] = None) -> None:
+    def register_tool(
+        self,
+        name: str,
+        description: str,
+        handler: Callable,
+        parameters: List[Parameter],
+        endpoint: str,
+        auth_requirements: Optional[List[AuthRequirement]] = None,
+    ) -> None:
         """Register a tool function.
 
         Args:
@@ -101,11 +101,7 @@ class ToolsService:
         final_auth_requirements = auth_requirements if auth_requirements else handler_auth_requirements
 
         function = Function(
-            name=name,
-            description=description,
-            parameters=parameters,
-            endpoint=endpoint,
-            auth_requirements=final_auth_requirements
+            name=name, description=description, parameters=parameters, endpoint=endpoint, auth_requirements=final_auth_requirements
         )
 
         self.functions.append(function)
@@ -144,7 +140,6 @@ class ToolsService:
                 param_name = list(sig.parameters.keys())[0]
                 param_type = get_type_hints(handler).get(param_name)
 
-
                 args = []
                 kwargs = {}
                 if param_type:
@@ -168,8 +163,12 @@ class ToolsService:
 
                 logger.info(f"Tool {name} returned: {result}")
                 return result
+            except ValidationError as e:
+                logger.warning(f"Invalid parameters predicted by LLM for tool {name}: {str(e)}")
+                raise HTTPException(status_code=400, detail=str(e))
             except Exception as e:
                 import traceback
+
                 logger.error(f"Error in tool {name}: {str(e)}")
                 logger.error(traceback.format_exc())
                 raise HTTPException(status_code=500, detail=str(e))

optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: optimizely-opal.opal-tools-sdk
+Version: 0.1.10.dev0
+Summary: SDK for creating Opal-compatible tools services
+Home-page: https://github.com/optimizely/opal-tools-sdk
+Author: Optimizely
+Author-email: Optimizely <opal-team@optimizely.com>
+License: MIT
+Project-URL: Homepage, https://github.com/optimizely/opal-tools-sdk
+Project-URL: Bug Tracker, https://github.com/optimizely/opal-tools-sdk/issues
+Keywords: opal,tools,sdk,ai,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.1
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Opal Tools SDK for Python
+
+This SDK simplifies the creation of tools services compatible with the Opal Tools Management Service.
+
+## Features
+
+- Easy definition of tool functions with decorators
+- Automatic generation of discovery endpoints
+- Parameter validation and type checking
+- Authentication helpers
+- FastAPI integration
+- Island components for interactive UI responses
+
+## Installation
+
+```bash
+pip install optimizely-opal.opal-tools-sdk
+```
+
+Note: While the package is installed as `optimizely-opal.opal-tools-sdk`, you'll still import it in your code as `opal_tools_sdk`:
+
+```python
+# Import using the package name
+from opal_tools_sdk import ToolsService, tool, IslandResponse, IslandConfig
+```
+
+## Usage
+
+```python
+from opal_tools_sdk import ToolsService, tool
+from pydantic import BaseModel
+from fastapi import FastAPI
+
+app = FastAPI()
+tools_service = ToolsService(app)
+
+class WeatherParameters(BaseModel):
+    location: str
+    units: str = "metric"
+
+@tool("get_weather", "Gets current weather for a location")
+async def get_weather(parameters: WeatherParameters):
+    # Implementation...
+    return {"temperature": 22, "condition": "sunny"}
+
+# Discovery endpoint is automatically created at /discovery
+```
+
+## Authentication
+
+The SDK provides two ways to require authentication for your tools:
+
+### 1. Using the `@requires_auth` decorator
+
+```python
+from opal_tools_sdk import ToolsService, tool, AuthData
+from opal_tools_sdk.auth import requires_auth
+from pydantic import BaseModel
+from fastapi import FastAPI
+from typing import Optional
+
+app = FastAPI()
+tools_service = ToolsService(app)
+
+class CalendarParameters(BaseModel):
+    date: str
+    timezone: str = "UTC"
+
+# Single authentication requirement
+@requires_auth(provider="google", scope_bundle="calendar", required=True)
+@tool("get_calendar_events", "Gets calendar events for a date")
+async def get_calendar_events(parameters: CalendarParameters, auth_data: Optional[AuthData] = None):
+    # The auth_data parameter contains authentication information
+    if auth_data:
+        token = auth_data["credentials"]["access_token"]
+
+    # Use the token to make authenticated requests
+    # ...
+
+    return {"events": ["Meeting at 10:00", "Lunch at 12:00"]}
+
+# Multiple authentication requirements (tool can work with either provider)
+@requires_auth(provider="google", scope_bundle="calendar", required=True)
+@requires_auth(provider="microsoft", scope_bundle="outlook", required=True)
+@tool("get_calendar_availability", "Check calendar availability")
+async def get_calendar_availability(parameters: CalendarParameters, auth_data: Optional[AuthData] = None):
+    provider = ""
+    token = ""
+    
+    if auth_data:
+        provider = auth_data["provider"]
+        token = auth_data["credentials"]["access_token"]
+
+        if provider == "google":
+            # Use Google Calendar API
+            pass
+        elif provider == "microsoft":
+            # Use Microsoft Outlook API
+            pass
+
+    return {"available": True, "provider_used": provider}
+```
+
+### 2. Specifying auth requirements in the `@tool` decorator
+
+```python
+@tool(
+    "get_email",
+    "Gets emails from the user's inbox",
+    auth_requirements=[
+        {"provider": "google", "scope_bundle": "gmail", "required": True}
+    ]
+)
+async def get_email(parameters: EmailParameters, auth_data: Optional[AuthData] = None):
+    # Implementation...
+    return {"emails": ["Email 1", "Email 2"]}
+```
+
+## Island Components
+
+The SDK includes Island components for creating interactive UI responses that allow users to input data and trigger actions.
+
+### Weather Tool with Interactive Island
+
+```python
+from opal_tools_sdk import ToolsService, tool, IslandResponse, IslandConfig
+from pydantic import BaseModel
+from fastapi import FastAPI
+
+app = FastAPI()
+tools_service = ToolsService(app)
+
+class WeatherParameters(BaseModel):
+    location: str
+    units: str = "metric"
+
+@tool("get_weather", "Gets current weather for a location")
+async def get_weather(parameters: WeatherParameters):
+    # Get weather data (implementation details omitted)
+    weather_data = {"temperature": 22, "condition": "sunny", "humidity": 65}
+    
+    # Create an interactive island for weather settings
+    island = IslandConfig(
+        fields=[
+            IslandConfig.Field(
+                name="location",
+                label="Location",
+                type="string",
+                value=parameters.location
+            ),
+            IslandConfig.Field(
+                name="units",
+                label="Temperature Units",
+                type="string",
+                value=parameters.units,
+                options=["metric", "imperial", "kelvin"]
+            ),
+            IslandConfig.Field(
+                name="current_temp",
+                label="Current Temperature",
+                type="string",
+                value=f"{weather_data['temperature']}°{'C' if parameters.units == 'metric' else 'F'}"
+            )
+        ],
+        actions=[
+            IslandConfig.Action(
+                name="refresh_weather",
+                label="Refresh Weather",
+                type="button",
+                endpoint="/tools/get_weather",
+                operation="update"
+            )
+        ]
+    )
+    
+    return IslandResponse.create([island])
+```
+
+### Island Components
+
+#### IslandConfig.Field
+Fields represent data inputs in the UI:
+- `name`: Programmatic field identifier
+- `label`: Human-readable label
+- `type`: Field type (`"string"`, `"boolean"`, `"json"`)
+- `value`: Current field value (optional)
+- `hidden`: Whether to hide from user (optional, default: False)
+- `options`: Available options for selection (optional)
+
+#### IslandConfig.Action
+Actions represent buttons or operations:
+- `name`: Programmatic action identifier
+- `label`: Human-readable button label
+- `type`: UI element type (typically `"button"`)
+- `endpoint`: API endpoint to call
+- `operation`: Operation type (default: `"create"`)
+
+#### IslandConfig
+Contains the complete island configuration:
+- `fields`: List of IslandConfig.Field objects
+- `actions`: List of IslandConfig.Action objects
+- `type`: Island type for UI rendering (optional, default: `None`)
+- `icon`: Icon to display in the island (optional, default: `None`)
+
+#### IslandResponse
+The response wrapper for islands:
+- Use `IslandResponse.create([islands])` to create responses
+- Supports multiple islands per response
+
+## Type Definitions
+
+The SDK provides several TypedDict and dataclass definitions for better type safety:
+
+### Authentication Types
+- `AuthData`: TypedDict containing provider and credentials information
+- `Credentials`: TypedDict with access_token, org_sso_id, customer_id, instance_id, and product_sku
+- `AuthRequirement`: Dataclass for specifying authentication requirements
+
+### Execution Environment
+- `Environment`: TypedDict specifying execution mode (`"headless"` or `"interactive"`)
+
+### Parameter Types
+- `ParameterType`: Enum for supported parameter types (string, integer, number, boolean, list, dictionary)
+- `Parameter`: Dataclass for tool parameter definitions
+- `Function`: Dataclass for complete tool function definitions
+
+These types are automatically imported when you import from `opal_tools_sdk` and provide better IDE support and type checking.
+
+## Documentation
+
+See full documentation for more examples and configuration options.

optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/RECORD

@@ -0,0 +1,11 @@
+opal_tools_sdk/__init__.py,sha256=0B0c53fyCRMuI_zOfwiePzQk5ion1BSKCqGLVsY0TVk,495
+opal_tools_sdk/_registry.py,sha256=YE3eD4kcS09QDe4RccBYAzXPo9znEU7fblrsB-g3o-Y,67
+opal_tools_sdk/auth.py,sha256=9aMiZv6n6_iu7hQA0sKg4hgNr5DzYFFuP0SWUoZf_Vw,1520
+opal_tools_sdk/decorators.py,sha256=DuSDb1Dd1DSIlOC0ZBS4iE8Go3O93xqtPS43S5HwKBw,6526
+opal_tools_sdk/logging.py,sha256=krvkhdql2GWh0aCWj5gfqyn5plsyLJ773WzIirK7tkU,1325
+opal_tools_sdk/models.py,sha256=X25qtorUkQKQAd2zHBJjlBSGeIo0gIJVJ7d0QJsPPko,3546
+opal_tools_sdk/service.py,sha256=a5ZC-J1GF5y1-FdWCXdilCy7p5hG63MTTn6frBBCo4Y,6939
+optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/METADATA,sha256=AJEYAccTQUy-Tk9YgB_iZuJmp5LpqvCf0-ZkeiVPIBo,8221
+optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/top_level.txt,sha256=nCJ5PxF0rgoV6yNJvvuUaZPx4D3EWkl7gpu-6xafH1E,15
+optimizely_opal_opal_tools_sdk-0.1.10.dev0.dist-info/RECORD,,

optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/METADATA

@@ -1,138 +0,0 @@
-Metadata-Version: 2.4
-Name: optimizely-opal.opal-tools-sdk
-Version: 0.1.4.dev0
-Summary: SDK for creating Opal-compatible tools services
-Home-page: https://github.com/optimizely/opal-tools-sdk
-Author: Optimizely
-Author-email: Optimizely <opal-team@optimizely.com>
-License: MIT
-Project-URL: Homepage, https://github.com/optimizely/opal-tools-sdk
-Project-URL: Bug Tracker, https://github.com/optimizely/opal-tools-sdk/issues
-Keywords: opal,tools,sdk,ai,llm
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.10
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: fastapi>=0.100.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: httpx>=0.24.1
-Dynamic: author
-Dynamic: home-page
-Dynamic: requires-python
-
-# Opal Tools SDK for Python
-
-This SDK simplifies the creation of tools services compatible with the Opal Tools Management Service.
-
-## Features
-
-- Easy definition of tool functions with decorators
-- Automatic generation of discovery endpoints
-- Parameter validation and type checking
-- Authentication helpers
-- FastAPI integration
-
-## Installation
-
-```bash
-pip install optimizely-opal.opal-tools-sdk
-```
-
-Note: While the package is installed as `optimizely-opal.opal-tools-sdk`, you'll still import it in your code as `opal_tools_sdk`:
-
-```python
-# Import using the package name
-from opal_tools_sdk import ToolsService, tool
-```
-
-## Usage
-
-```python
-from opal_tools_sdk import ToolsService, tool
-from pydantic import BaseModel
-from fastapi import FastAPI
-
-app = FastAPI()
-tools_service = ToolsService(app)
-
-class WeatherParameters(BaseModel):
-    location: str
-    units: str = "metric"
-
-@tool("get_weather", "Gets current weather for a location")
-async def get_weather(parameters: WeatherParameters):
-    # Implementation...
-    return {"temperature": 22, "condition": "sunny"}
-
-# Discovery endpoint is automatically created at /discovery
-```
-
-## Authentication
-
-The SDK provides two ways to require authentication for your tools:
-
-### 1. Using the `@requires_auth` decorator
-
-```python
-from opal_tools_sdk import ToolsService, tool
-from opal_tools_sdk.auth import requires_auth
-from pydantic import BaseModel
-from fastapi import FastAPI
-
-app = FastAPI()
-tools_service = ToolsService(app)
-
-class CalendarParameters(BaseModel):
-    date: str
-    timezone: str = "UTC"
-
-# Single authentication requirement
-@requires_auth(provider="google", scope_bundle="calendar", required=True)
-@tool("get_calendar_events", "Gets calendar events for a date")
-async def get_calendar_events(parameters: CalendarParameters, auth_data=None):
-    # The auth_data parameter contains authentication information
-    token = auth_data.get("credentials", {}).get("token", "")
-
-    # Use the token to make authenticated requests
-    # ...
-
-    return {"events": ["Meeting at 10:00", "Lunch at 12:00"]}
-
-# Multiple authentication requirements (tool can work with either provider)
-@requires_auth(provider="google", scope_bundle="calendar", required=True)
-@requires_auth(provider="microsoft", scope_bundle="outlook", required=True)
-@tool("get_calendar_availability", "Check calendar availability")
-async def get_calendar_availability(parameters: CalendarParameters, auth_data=None):
-    provider = auth_data.get("provider", "")
-    token = auth_data.get("credentials", {}).get("token", "")
-
-    if provider == "google":
-        # Use Google Calendar API
-        pass
-    elif provider == "microsoft":
-        # Use Microsoft Outlook API
-        pass
-
-    return {"available": True, "provider_used": provider}
-```
-
-### 2. Specifying auth requirements in the `@tool` decorator
-
-```python
-@tool(
-    "get_email",
-    "Gets emails from the user's inbox",
-    auth_requirements=[
-        {"provider": "google", "scope_bundle": "gmail", "required": True}
-    ]
-)
-async def get_email(parameters: EmailParameters, auth_data=None):
-    # Implementation...
-    return {"emails": ["Email 1", "Email 2"]}
-```
-
-## Documentation
-
-See full documentation for more examples and configuration options.

optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/RECORD

@@ -1,11 +0,0 @@
-opal_tools_sdk/__init__.py,sha256=riYZkv0C1Pgwd3SpE9Zwxs3a1eXa26wrGfY1N1Tdjb4,242
-opal_tools_sdk/_registry.py,sha256=YE3eD4kcS09QDe4RccBYAzXPo9znEU7fblrsB-g3o-Y,67
-opal_tools_sdk/auth.py,sha256=9aMiZv6n6_iu7hQA0sKg4hgNr5DzYFFuP0SWUoZf_Vw,1520
-opal_tools_sdk/decorators.py,sha256=iHal7RElOSCWjqKHIK-Hc4GKOsjuGyUg0_lsQKVQShg,5315
-opal_tools_sdk/logging.py,sha256=krvkhdql2GWh0aCWj5gfqyn5plsyLJ773WzIirK7tkU,1325
-opal_tools_sdk/models.py,sha256=lVumBjEWbKtkRBzwXt7m5uagqinJ6Y96K9a5Uw39yaM,2092
-opal_tools_sdk/service.py,sha256=wVYe40zEZc1ynIkvowD9APU8BFHQ5fdy3j8qlsdZB1U,6965
-optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/METADATA,sha256=3uy9B3LYQM6kJj-D_mtfrTYqCmpogXeKT-cMWE8IySU,4115
-optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/top_level.txt,sha256=nCJ5PxF0rgoV6yNJvvuUaZPx4D3EWkl7gpu-6xafH1E,15
-optimizely_opal_opal_tools_sdk-0.1.4.dev0.dist-info/RECORD,,