arcade-google-contacts 2.0.0__tar.gz

arcade_google_contacts-2.0.0/.gitignore

@@ -0,0 +1,175 @@
+.DS_Store
+credentials.yaml
+docker/credentials.yaml
+
+*.lock
+
+# example data
+examples/data
+scratch
+
+
+docs/source
+
+# From https://raw.githubusercontent.com/github/gitignore/main/Python.gitignore
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

arcade_google_contacts-2.0.0/.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+files: ^.*/google_contacts/.*
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: "v4.4.0"
+    hooks:
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.7
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

arcade_google_contacts-2.0.0/.ruff.toml

@@ -0,0 +1,46 @@
+target-version = "py310"
+line-length = 100
+fix = true
+
+[lint]
+select = [
+    # flake8-2020
+    "YTT",
+    # flake8-bandit
+    "S",
+    # flake8-bugbear
+    "B",
+    # flake8-builtins
+    "A",
+    # flake8-comprehensions
+    "C4",
+    # flake8-debugger
+    "T10",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # mccabe
+    "C90",
+    # pycodestyle
+    "E", "W",
+    # pyflakes
+    "F",
+    # pygrep-hooks
+    "PGH",
+    # pyupgrade
+    "UP",
+    # ruff
+    "RUF",
+    # tryceratops
+    "TRY",
+]
+
+[lint.per-file-ignores]
+"*" = ["TRY003", "B904"]
+"**/tests/*" = ["S101", "E501"]
+"**/evals/*" = ["S101", "E501"]
+
+[format]
+preview = true
+skip-magic-trailing-comma = false

arcade_google_contacts-2.0.0/Makefile

@@ -0,0 +1,55 @@
+.PHONY: help
+
+help:
+	@echo "🛠️ github Commands:\n"
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: install
+install: ## Install the uv environment and install all packages with dependencies
+	@echo "🚀 Creating virtual environment and installing all packages using uv"
+	@uv sync --active --all-extras --no-sources
+	@if [ -f .pre-commit-config.yaml ]; then uv run --no-sources pre-commit install; fi
+	@echo "✅ All packages and dependencies installed via uv"
+
+.PHONY: install-local
+install-local: ## Install the uv environment and install all packages with dependencies with local Arcade sources
+	@echo "🚀 Creating virtual environment and installing all packages using uv"
+	@uv sync --active --all-extras
+	@if [ -f .pre-commit-config.yaml ]; then uv run pre-commit install; fi
+	@echo "✅ All packages and dependencies installed via uv"
+
+.PHONY: build
+build: clean-build ## Build wheel file using poetry
+	@echo "🚀 Creating wheel file"
+	uv build
+
+.PHONY: clean-build
+clean-build: ## clean build artifacts
+	@echo "🗑️ Cleaning dist directory"
+	rm -rf dist
+
+.PHONY: test
+test: ## Test the code with pytest
+	@echo "🚀 Testing code: Running pytest"
+	@uv run --no-sources pytest -W ignore -v --cov --cov-config=pyproject.toml --cov-report=xml
+
+.PHONY: coverage
+coverage: ## Generate coverage report
+	@echo "coverage report"
+	@uv run --no-sources coverage report
+	@echo "Generating coverage report"
+	@uv run --no-sources coverage html
+
+.PHONY: bump-version
+bump-version: ## Bump the version in the pyproject.toml file by a patch version
+	@echo "🚀 Bumping version in pyproject.toml"
+	uv version --no-sources --bump patch
+
+.PHONY: check
+check: ## Run code quality tools.
+	@if [ -f .pre-commit-config.yaml ]; then\
+		echo "🚀 Linting code: Running pre-commit";\
+		uv run --no-sources pre-commit run -a;\
+	fi
+	@echo "🚀 Static type checking: Running mypy"
+	@uv run --no-sources mypy --config-file=pyproject.toml

arcade_google_contacts-2.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: arcade_google_contacts
+Version: 2.0.0
+Summary: Arcade.dev LLM tools for Google Contacts
+Author-email: Arcade <dev@arcade.dev>
+Requires-Python: >=3.10
+Requires-Dist: arcade-tdk<3.0.0,>=2.0.0
+Requires-Dist: google-api-core<3.0.0,>=2.19.1
+Requires-Dist: google-api-python-client<3.0.0,>=2.137.0
+Requires-Dist: google-auth-httplib2<1.0.0,>=0.2.0
+Requires-Dist: google-auth<3.0.0,>=2.32.0
+Requires-Dist: googleapis-common-protos<2.0.0,>=1.63.2
+Provides-Extra: dev
+Requires-Dist: arcade-ai[evals]<3.0.0,>=2.0.0; extra == 'dev'
+Requires-Dist: arcade-serve<3.0.0,>=2.0.0; extra == 'dev'
+Requires-Dist: mypy<1.6.0,>=1.5.1; extra == 'dev'
+Requires-Dist: pre-commit<3.5.0,>=3.4.0; extra == 'dev'
+Requires-Dist: pytest-asyncio<0.25.0,>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov<4.1.0,>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock<3.12.0,>=3.11.1; extra == 'dev'
+Requires-Dist: pytest<8.4.0,>=8.3.0; extra == 'dev'
+Requires-Dist: ruff<0.8.0,>=0.7.4; extra == 'dev'
+Requires-Dist: tox<4.12.0,>=4.11.1; extra == 'dev'

arcade_google_contacts-2.0.0/arcade_google_contacts/__init__.py

@@ -0,0 +1,7 @@
+from arcade_google_contacts.tools import (
+    create_contact,
+    search_contacts_by_email,
+    search_contacts_by_name,
+)
+
+__all__ = ["create_contact", "search_contacts_by_email", "search_contacts_by_name"]

arcade_google_contacts-2.0.0/arcade_google_contacts/constants.py

@@ -0,0 +1 @@
+DEFAULT_SEARCH_CONTACTS_LIMIT = 30

arcade_google_contacts-2.0.0/arcade_google_contacts/tools/__init__.py

@@ -0,0 +1,7 @@
+from arcade_google_contacts.tools.contacts import (
+    create_contact,
+    search_contacts_by_email,
+    search_contacts_by_name,
+)
+
+__all__ = ["create_contact", "search_contacts_by_email", "search_contacts_by_name"]

arcade_google_contacts-2.0.0/arcade_google_contacts/tools/contacts.py

@@ -0,0 +1,96 @@
+import asyncio
+from typing import Annotated
+
+from arcade_tdk import ToolContext, tool
+from arcade_tdk.auth import Google
+
+from arcade_google_contacts.constants import DEFAULT_SEARCH_CONTACTS_LIMIT
+from arcade_google_contacts.utils import build_people_service, search_contacts
+
+
+async def _warmup_cache(service) -> None:  # type: ignore[no-untyped-def]
+    """
+    Warm-up the search cache for contacts by sending a request with an empty query.
+    This ensures that the lazy cache is updated for both primary contacts and other contacts.
+    This is unfortunately a real thing: https://developers.google.com/people/v1/contacts#search_the_users_contacts
+    """
+    service.people().searchContacts(query="", pageSize=1, readMask="names,emailAddresses").execute()
+    await asyncio.sleep(3)  # TODO experiment with this value
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts.readonly"]))
+async def search_contacts_by_email(
+    context: ToolContext,
+    email: Annotated[str, "The email address to search for"],
+    limit: Annotated[
+        int | None,
+        "The maximum number of contacts to return (30 is the max allowed by Google API)",
+    ] = DEFAULT_SEARCH_CONTACTS_LIMIT,
+) -> Annotated[dict, "A dictionary containing the list of matching contacts"]:
+    """
+    Search the user's contacts in Google Contacts by email address.
+    """
+    service = build_people_service(context.get_auth_token_or_empty())
+    # Warm-up the cache before performing search.
+    # TODO: Ideally we should warmup only if this user (or google domain?) hasn't warmed up recently
+    await _warmup_cache(service)
+
+    return {"contacts": search_contacts(service, email, limit)}
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts.readonly"]))
+async def search_contacts_by_name(
+    context: ToolContext,
+    name: Annotated[str, "The full name to search for"],
+    limit: Annotated[
+        int | None,
+        "The maximum number of contacts to return (30 is the max allowed by Google API)",
+    ] = DEFAULT_SEARCH_CONTACTS_LIMIT,
+) -> Annotated[dict, "A dictionary containing the list of matching contacts"]:
+    """
+    Search the user's contacts in Google Contacts by name.
+    """
+    service = build_people_service(context.get_auth_token_or_empty())
+    # Warm-up the cache before performing search.
+    # TODO: Ideally we should warmup only if this user (or google domain?) hasn't warmed up recently
+    await _warmup_cache(service)
+    return {"contacts": search_contacts(service, name, limit)}
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts"]))
+async def create_contact(
+    context: ToolContext,
+    given_name: Annotated[str, "The given name of the contact"],
+    family_name: Annotated[str | None, "The optional family name of the contact"],
+    email: Annotated[str | None, "The optional email address of the contact"],
+) -> Annotated[dict, "A dictionary containing the details of the created contact"]:
+    """
+    Create a new contact record in Google Contacts.
+
+    Examples:
+    ```
+    create_contact(given_name="Alice")
+    create_contact(given_name="Alice", family_name="Smith")
+    create_contact(given_name="Alice", email="alice@example.com")
+    ```
+    """
+    # Build the People API service
+    service = build_people_service(context.get_auth_token_or_empty())
+
+    # Construct the person payload with the specified names
+    name_body = {"givenName": given_name}
+    if family_name:
+        name_body["familyName"] = family_name
+    contact_body = {"names": [name_body]}
+    if email:
+        contact_body["emailAddresses"] = [{"value": email, "type": "work"}]
+
+    # Create the contact. The personFields parameter specifies what information
+    # should be returned. Here, we return names and emailAddresses.
+    created_contact = (
+        service.people()
+        .createContact(body=contact_body, personFields="names,emailAddresses")
+        .execute()
+    )
+
+    return {"contact": created_contact}

arcade_google_contacts-2.0.0/arcade_google_contacts/utils.py

@@ -0,0 +1,49 @@
+import logging
+from typing import Any, cast
+
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import Resource, build
+
+from arcade_google_contacts.constants import DEFAULT_SEARCH_CONTACTS_LIMIT
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+logger = logging.getLogger(__name__)
+
+
+def build_people_service(auth_token: str | None) -> Resource:  # type: ignore[no-any-unimported]
+    """
+    Build a People service object.
+    """
+    auth_token = auth_token or ""
+    return build("people", "v1", credentials=Credentials(auth_token))
+
+
+def search_contacts(service: Any, query: str, limit: int | None) -> list[dict[str, Any]]:
+    """
+    Search the user's contacts in Google Contacts.
+    """
+    response = (
+        service.people()
+        .searchContacts(
+            query=query,
+            pageSize=limit or DEFAULT_SEARCH_CONTACTS_LIMIT,
+            readMask=",".join([
+                "names",
+                "nicknames",
+                "emailAddresses",
+                "phoneNumbers",
+                "addresses",
+                "organizations",
+                "biographies",
+                "urls",
+                "userDefined",
+            ]),
+        )
+        .execute()
+    )
+
+    return cast(list[dict[str, Any]], response.get("results", []))

arcade_google_contacts-2.0.0/evals/eval_google_contacts.py

@@ -0,0 +1,135 @@
+from arcade_evals import (
+    BinaryCritic,
+    EvalRubric,
+    EvalSuite,
+    ExpectedToolCall,
+    tool_eval,
+)
+from arcade_tdk import ToolCatalog
+
+import arcade_google_contacts
+from arcade_google_contacts.tools import (
+    create_contact,
+    search_contacts_by_email,
+    search_contacts_by_name,
+)
+
+# Evaluation rubric
+rubric = EvalRubric(
+    fail_threshold=0.9,
+    warn_threshold=0.95,
+)
+
+catalog = ToolCatalog()
+catalog.add_module(arcade_google_contacts)
+
+
+@tool_eval()
+def contacts_eval_suite() -> EvalSuite:
+    """Create an evaluation suite for Google Contacts tools."""
+    suite = EvalSuite(
+        name="Google Contacts Tools Evaluation",
+        system_message="You are an AI assistant that can manage Google Contacts using the provided tools.",
+        catalog=catalog,
+        rubric=rubric,
+    )
+
+    suite.add_case(
+        name="Search contacts by name",
+        user_message="Find my contact Bob",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=search_contacts_by_name,
+                args={
+                    "name": "Bob",
+                },
+            )
+        ],
+    )
+
+    suite.add_case(
+        name="Search contacts by email",
+        user_message="Find my contact alice@example.com",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=search_contacts_by_email,
+                args={
+                    "email": "alice@example.com",
+                },
+            )
+        ],
+    )
+
+    suite.add_case(
+        name="Search contacts with query and limit",
+        user_message="Find 5 contacts whose names include 'Alice'",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=search_contacts_by_name,
+                args={
+                    "name": "Alice",
+                    "limit": 5,
+                },
+            )
+        ],
+        critics=[
+            BinaryCritic(critic_field="query", weight=0.5),
+            BinaryCritic(critic_field="limit", weight=0.5),
+        ],
+    )
+
+    suite.add_case(
+        name="Create new contact with only given name",
+        user_message="Create a new contact for Alice",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=create_contact,
+                args={
+                    "given_name": "Alice",
+                },
+            )
+        ],
+        critics=[
+            BinaryCritic(critic_field="given_name", weight=1.0),
+        ],
+    )
+
+    suite.add_case(
+        name="Create new contact with only email (infer name from email)",
+        user_message="Create a new contact for alice@example.com",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=create_contact,
+                args={
+                    "given_name": "Alice",
+                    "email": "alice@example.com",
+                },
+            )
+        ],
+        critics=[
+            BinaryCritic(critic_field="email", weight=0.5),
+            BinaryCritic(critic_field="given_name", weight=0.5),
+        ],
+    )
+
+    suite.add_case(
+        name="Create new contact with full name and email",
+        user_message="Create a contact for Bob Smith (bob.smith@example.com)",
+        expected_tool_calls=[
+            ExpectedToolCall(
+                func=create_contact,
+                args={
+                    "given_name": "Bob",
+                    "family_name": "Smith",
+                    "email": "bob.smith@example.com",
+                },
+            )
+        ],
+        critics=[
+            BinaryCritic(critic_field="given_name", weight=0.33),
+            BinaryCritic(critic_field="family_name", weight=0.33),
+            BinaryCritic(critic_field="email", weight=0.34),
+        ],
+    )
+
+    return suite

arcade_google_contacts-2.0.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = [ "hatchling",]
+build-backend = "hatchling.build"
+
+[project]
+name = "arcade_google_contacts"
+version = "2.0.0"
+description = "Arcade.dev LLM tools for Google Contacts"
+requires-python = ">=3.10"
+dependencies = [
+    "arcade-tdk>=2.0.0,<3.0.0",
+    "google-api-core>=2.19.1,<3.0.0",
+    "google-api-python-client>=2.137.0,<3.0.0",
+    "google-auth>=2.32.0,<3.0.0",
+    "google-auth-httplib2>=0.2.0,<1.0.0",
+    "googleapis-common-protos>=1.63.2,<2.0.0",
+]
+[[project.authors]]
+name = "Arcade"
+email = "dev@arcade.dev"
+
+
+[project.optional-dependencies]
+dev = [
+    "arcade-ai[evals]>=2.0.0,<3.0.0",
+    "arcade-serve>=2.0.0,<3.0.0",
+    "pytest>=8.3.0,<8.4.0",
+    "pytest-cov>=4.0.0,<4.1.0",
+    "pytest-mock>=3.11.1,<3.12.0",
+    "pytest-asyncio>=0.24.0,<0.25.0",
+    "mypy>=1.5.1,<1.6.0",
+    "pre-commit>=3.4.0,<3.5.0",
+    "tox>=4.11.1,<4.12.0",
+    "ruff>=0.7.4,<0.8.0",
+]
+
+# Use local path sources for arcade libs when working locally
+[tool.uv.sources]
+arcade-ai = { path = "../../", editable = true }
+arcade-serve = { path = "../../libs/arcade-serve/", editable = true }
+arcade-tdk = { path = "../../libs/arcade-tdk/", editable = true }
+
+
+[tool.mypy]
+files = [ "arcade_google_contacts/**/*.py",]
+python_version = "3.10"
+disallow_untyped_defs = "True"
+disallow_any_unimported = "True"
+no_implicit_optional = "True"
+check_untyped_defs = "True"
+warn_return_any = "True"
+warn_unused_ignores = "True"
+show_error_codes = "True"
+ignore_missing_imports = "True"
+
+[tool.pytest.ini_options]
+testpaths = [ "tests",]
+
+[tool.coverage.report]
+skip_empty = true
+
+[tool.hatch.build.targets.wheel]
+packages = [ "arcade_google_contacts",]

arcade_google_contacts-2.0.0/tests/test_contacts.py

@@ -0,0 +1,100 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from arcade_tdk import ToolContext
+
+from arcade_google_contacts.tools import create_contact
+
+
+@pytest.fixture
+def mock_context():
+    context = AsyncMock(spec=ToolContext)
+    context.authorization = MagicMock()
+    context.authorization.token = "mock_token"  # noqa: S105
+    return context
+
+
+@pytest.mark.asyncio
+async def test_create_contact_success(mock_context):
+    # Test create_contact with all parameters (given, family names and email)
+    created_contact_data = {"resourceName": "people/123", "etag": "abc"}
+
+    create_contact_call = MagicMock()
+    create_contact_call.execute.return_value = created_contact_data
+
+    people_mock = MagicMock()
+    people_mock.createContact.return_value = create_contact_call
+
+    service_mock = MagicMock()
+    service_mock.people.return_value = people_mock
+
+    with patch(
+        "arcade_google_contacts.tools.contacts.build_people_service", return_value=service_mock
+    ) as mock_build:
+        result = await create_contact(
+            mock_context,
+            given_name="Alice",
+            family_name="Smith",
+            email="alice@example.com",
+        )
+        assert "contact" in result
+        assert result["contact"] == created_contact_data
+
+        # Verify that the createContact API was called with the correct body contents.
+        expected_body = {
+            "names": [{"givenName": "Alice", "familyName": "Smith"}],
+            "emailAddresses": [{"value": "alice@example.com", "type": "work"}],
+        }
+        people_mock.createContact.assert_called_once_with(
+            body=expected_body, personFields="names,emailAddresses"
+        )
+        mock_build.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_create_contact_success_without_optional(mock_context):
+    # Test create_contact without optional parameters family_name and email.
+    created_contact_data = {"resourceName": "people/456", "etag": "def"}
+
+    create_contact_call = MagicMock()
+    create_contact_call.execute.return_value = created_contact_data
+
+    people_mock = MagicMock()
+    people_mock.createContact.return_value = create_contact_call
+
+    service_mock = MagicMock()
+    service_mock.people.return_value = people_mock
+
+    with patch(
+        "arcade_google_contacts.tools.contacts.build_people_service", return_value=service_mock
+    ):
+        result = await create_contact(mock_context, given_name="Bob", family_name=None, email=None)
+        assert "contact" in result
+        assert result["contact"] == created_contact_data
+
+        # Expected body should only include the givenName when family_name and email are omitted.
+        expected_body = {"names": [{"givenName": "Bob"}]}
+        people_mock.createContact.assert_called_once_with(
+            body=expected_body, personFields="names,emailAddresses"
+        )
+
+
+@pytest.mark.asyncio
+async def test_create_contact_error(mock_context):
+    # Simulate an error thrown by createContact
+    error_call = MagicMock()
+    error_call.execute.side_effect = Exception("Create error")
+
+    people_mock = MagicMock()
+    people_mock.createContact.return_value = error_call
+
+    service_mock = MagicMock()
+    service_mock.people.return_value = people_mock
+
+    with (
+        patch(
+            "arcade_google_contacts.tools.contacts.build_people_service", return_value=service_mock
+        ),
+        pytest.raises(Exception, match="Error in execution of CreateContact"),
+    ):
+        await create_contact(mock_context, given_name="Alice", family_name="Doe", email=None)