matimo-microsoft 0.1.0__tar.gz

matimo_microsoft-0.1.0/.gitignore

@@ -0,0 +1,63 @@
+# Dependencies
+**/node_modules/
+package-lock.json
+yarn.lock
+
+# Build output
+**/dist/
+*.tsbuildinfo
+
+# Python compiled / build
+**/__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+**/build/
+**/.eggs/
+**/.venv/
+**/.mypy_cache/
+**/.ruff_cache/
+**/.pytest_cache/
+
+# Test coverage
+**/coverage/
+**/.nyc_output/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+typescript/examples/mcp/matimo-tools/.matimo-approvals.json
+typescript/examples/mcp/matimo-tools/fetch-weather/definition.yaml
+typescript/examples/mcp/matimo-tools/npm_downloads/definition.yaml
+typescript/examples/mcp/matimo-tools/skills/ecosystem-health/SKILL.md
+typescript/examples/mcp/matimo-tools/skills/matimo-health-check/SKILL.md
+typescript/examples/mcp/matimo-tools/skills/moltbook-identity/SKILL.md
+typescript/packages/cli/.matimo/certs/server.crt
+typescript/packages/cli/.matimo/certs/server.key
+typescript/examples/mcp/.matimo/certs/server.crt
+typescript/examples/mcp/.matimo/certs/server.key

matimo_microsoft-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: matimo-microsoft
+Version: 0.1.0
+Summary: Matimo provider — Microsoft Graph tools (mail, calendar, Teams, files, SharePoint)
+License: MIT
+Keywords: agents,ai,graph,matimo,microsoft,outlook,sharepoint,teams,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Requires-Dist: matimo-core<0.2.0,>=0.1.0
+Description-Content-Type: text/markdown
+
+# matimo-microsoft
+
+> Microsoft Graph tools for [Matimo](https://matimo.dev) — search, OneDrive/SharePoint
+> files, Outlook mail, Microsoft Teams, calendar, and SharePoint publishing.
+
+[![PyPI](https://img.shields.io/pypi/v/matimo-microsoft)](https://pypi.org/project/matimo-microsoft/)
+[![Docs](https://img.shields.io/badge/docs-matimo.dev-blue)](https://matimo.dev/docs)
+
+---
+
+## Installation
+
+```bash
+pip install matimo matimo-microsoft
+```
+
+---
+
+## Available Tools (9 Total)
+
+| Tool | Description | Risk | Graph endpoint |
+|------|-------------|------|----------------|
+| `ms_search_knowledge` | Search SharePoint sites, OneDrive/SharePoint files, and list items | low | `POST /search/query` |
+| `ms_read_file` | Read a OneDrive/SharePoint file's contents (plain-text formats only) | low | `GET /drives/{id}/items/{id}/content` |
+| `ms_list_files` | List the children of a OneDrive/SharePoint folder | low | `GET /drives/{id}/items/{id}/children` |
+| `ms_get_email` | List messages in the signed-in user's mailbox | low | `GET /me/messages` |
+| `ms_send_email` | Send an email as the signed-in user | **high** (approval) | `POST /me/messages` + `/send` |
+| `ms_send_teams_message` | Post (or reply to) a message in a Teams channel | medium | `POST /teams/{id}/channels/{id}/messages` |
+| `ms_create_document` | Upload a small file to OneDrive/SharePoint (≤4 MB) | medium | `PUT /drives/{id}/items/{id}:/{name}:/content` |
+| `ms_create_calendar_event` | Create a calendar event, optionally as a Teams meeting | medium | `POST /me/events` |
+| `ms_publish_to_sharepoint` | Create and publish a SharePoint site page | **high** (approval) | `POST /sites/{id}/pages` + `/publish` |
+
+---
+
+## Quick Start
+
+```python
+from matimo import MatimoInstance
+
+matimo = await MatimoInstance.init(auto_discover=True)
+
+# Search across SharePoint and OneDrive
+search = await matimo.execute("ms_search_knowledge", {"query": "Q3 budget filetype:xlsx", "top": 5})
+
+# List messages in the signed-in user's mailbox
+inbox = await matimo.execute("ms_get_email", {"top": 5, "filter": "isRead eq false"})
+
+# Send an email (requires_approval: true — routed through HITL)
+await matimo.execute(
+    "ms_send_email",
+    {"to": ["alice@contoso.com"], "subject": "Weekly status update", "body": "Here is the summary..."},
+)
+```
+
+---
+
+## Authentication
+
+Microsoft Graph tools use delegated OAuth2 access tokens. Matimo never performs the
+OAuth code exchange itself — connect Microsoft through your Matimo deployment (Nova),
+then provide the resulting token at execution time:
+
+```bash
+export MICROSOFT_GRAPH_ACCESS_TOKEN="eyJ0eXAiOiJKV1Qi..."
+```
+
+or pass it through per-call credentials:
+
+```python
+await matimo.execute(
+    "ms_get_email",
+    {"top": 5},
+    credentials={"MICROSOFT_GRAPH_ACCESS_TOKEN": token},
+)
+```
+
+---
+
+## Risk & Approval
+
+`ms_send_email` and `ms_publish_to_sharepoint` are marked `risk: high` and
+`requires_approval: true` — Matimo routes them through the human-in-the-loop approval
+flow before they execute, since they send mail and publish content visible to others
+on the user's behalf. `ms_send_teams_message`, `ms_create_document`, and
+`ms_create_calendar_event` are `risk: medium` (external writes, narrower blast radius).
+The remaining read-only tools are `risk: low`.
+
+---
+
+## Documentation
+
+- [Microsoft Graph API overview](https://learn.microsoft.com/en-us/graph/overview)
+- [Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer)
+- [Python Examples — Direct SDK](https://github.com/tallclub/matimo/tree/main/python/examples/native/microsoft)
+- [Python Examples — LangChain agent](https://github.com/tallclub/matimo/tree/main/python/examples/langchain/microsoft)
+- [Python Examples — CrewAI crew](https://github.com/tallclub/matimo/tree/main/python/examples/crewai/microsoft)
+
+---
+
+## Links
+
+- **PyPI:** https://pypi.org/project/matimo-microsoft/
+- **GitHub:** https://github.com/tallclub/matimo
+- **Microsoft Graph API Docs:** https://learn.microsoft.com/en-us/graph/overview
+- **Matimo documentation:** https://matimo.dev/docs

matimo_microsoft-0.1.0/README.md

@@ -0,0 +1,105 @@
+# matimo-microsoft
+
+> Microsoft Graph tools for [Matimo](https://matimo.dev) — search, OneDrive/SharePoint
+> files, Outlook mail, Microsoft Teams, calendar, and SharePoint publishing.
+
+[![PyPI](https://img.shields.io/pypi/v/matimo-microsoft)](https://pypi.org/project/matimo-microsoft/)
+[![Docs](https://img.shields.io/badge/docs-matimo.dev-blue)](https://matimo.dev/docs)
+
+---
+
+## Installation
+
+```bash
+pip install matimo matimo-microsoft
+```
+
+---
+
+## Available Tools (9 Total)
+
+| Tool | Description | Risk | Graph endpoint |
+|------|-------------|------|----------------|
+| `ms_search_knowledge` | Search SharePoint sites, OneDrive/SharePoint files, and list items | low | `POST /search/query` |
+| `ms_read_file` | Read a OneDrive/SharePoint file's contents (plain-text formats only) | low | `GET /drives/{id}/items/{id}/content` |
+| `ms_list_files` | List the children of a OneDrive/SharePoint folder | low | `GET /drives/{id}/items/{id}/children` |
+| `ms_get_email` | List messages in the signed-in user's mailbox | low | `GET /me/messages` |
+| `ms_send_email` | Send an email as the signed-in user | **high** (approval) | `POST /me/messages` + `/send` |
+| `ms_send_teams_message` | Post (or reply to) a message in a Teams channel | medium | `POST /teams/{id}/channels/{id}/messages` |
+| `ms_create_document` | Upload a small file to OneDrive/SharePoint (≤4 MB) | medium | `PUT /drives/{id}/items/{id}:/{name}:/content` |
+| `ms_create_calendar_event` | Create a calendar event, optionally as a Teams meeting | medium | `POST /me/events` |
+| `ms_publish_to_sharepoint` | Create and publish a SharePoint site page | **high** (approval) | `POST /sites/{id}/pages` + `/publish` |
+
+---
+
+## Quick Start
+
+```python
+from matimo import MatimoInstance
+
+matimo = await MatimoInstance.init(auto_discover=True)
+
+# Search across SharePoint and OneDrive
+search = await matimo.execute("ms_search_knowledge", {"query": "Q3 budget filetype:xlsx", "top": 5})
+
+# List messages in the signed-in user's mailbox
+inbox = await matimo.execute("ms_get_email", {"top": 5, "filter": "isRead eq false"})
+
+# Send an email (requires_approval: true — routed through HITL)
+await matimo.execute(
+    "ms_send_email",
+    {"to": ["alice@contoso.com"], "subject": "Weekly status update", "body": "Here is the summary..."},
+)
+```
+
+---
+
+## Authentication
+
+Microsoft Graph tools use delegated OAuth2 access tokens. Matimo never performs the
+OAuth code exchange itself — connect Microsoft through your Matimo deployment (Nova),
+then provide the resulting token at execution time:
+
+```bash
+export MICROSOFT_GRAPH_ACCESS_TOKEN="eyJ0eXAiOiJKV1Qi..."
+```
+
+or pass it through per-call credentials:
+
+```python
+await matimo.execute(
+    "ms_get_email",
+    {"top": 5},
+    credentials={"MICROSOFT_GRAPH_ACCESS_TOKEN": token},
+)
+```
+
+---
+
+## Risk & Approval
+
+`ms_send_email` and `ms_publish_to_sharepoint` are marked `risk: high` and
+`requires_approval: true` — Matimo routes them through the human-in-the-loop approval
+flow before they execute, since they send mail and publish content visible to others
+on the user's behalf. `ms_send_teams_message`, `ms_create_document`, and
+`ms_create_calendar_event` are `risk: medium` (external writes, narrower blast radius).
+The remaining read-only tools are `risk: low`.
+
+---
+
+## Documentation
+
+- [Microsoft Graph API overview](https://learn.microsoft.com/en-us/graph/overview)
+- [Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer)
+- [Python Examples — Direct SDK](https://github.com/tallclub/matimo/tree/main/python/examples/native/microsoft)
+- [Python Examples — LangChain agent](https://github.com/tallclub/matimo/tree/main/python/examples/langchain/microsoft)
+- [Python Examples — CrewAI crew](https://github.com/tallclub/matimo/tree/main/python/examples/crewai/microsoft)
+
+---
+
+## Links
+
+- **PyPI:** https://pypi.org/project/matimo-microsoft/
+- **GitHub:** https://github.com/tallclub/matimo
+- **Microsoft Graph API Docs:** https://learn.microsoft.com/en-us/graph/overview
+- **Matimo documentation:** https://matimo.dev/docs

matimo_microsoft-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "matimo-microsoft"
+version = "0.1.0"
+description = "Matimo provider — Microsoft Graph tools (mail, calendar, Teams, files, SharePoint)"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["ai", "tools", "agents", "matimo", "microsoft", "graph", "outlook", "teams", "sharepoint"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "matimo-core>=0.1.0,<0.2.0",
+]
+
+[project.entry-points."matimo.providers"]
+microsoft = "matimo_microsoft:get_tools_path"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/matimo_microsoft"]

matimo_microsoft-0.1.0/src/matimo_microsoft/__init__.py

@@ -0,0 +1,17 @@
+"""Matimo microsoft provider — exposes the path to YAML tool definitions."""
+from __future__ import annotations
+
+import importlib.resources
+from pathlib import Path
+
+
+def get_tools_path() -> str:
+    """Return the absolute path to the bundled microsoft tool definitions."""
+    try:
+        ref = importlib.resources.files("matimo_microsoft") / "tools"
+        return str(ref)
+    except Exception:
+        return str(Path(__file__).parent / "tools")
+
+
+__all__ = ["get_tools_path"]

matimo_microsoft-0.1.0/src/matimo_microsoft/graph_client.py

@@ -0,0 +1,236 @@
+"""
+Shared Microsoft Graph helpers for all 'type: function' tools in this package.
+Mirrors: typescript/packages/microsoft/tools/graph-client.ts
+
+Conventions (mirrors matimo-slack and matimo-gmail):
+- Tools NEVER perform OAuth token exchange. A delegated Graph access token is
+  injected at execution time via params['MICROSOFT_GRAPH_ACCESS_TOKEN'] (merged
+  from credentials by the function executor) or the MICROSOFT_GRAPH_ACCESS_TOKEN
+  environment variable as a fallback.
+- Every Graph error is normalized into a MatimoError with the closest matching
+  ErrorCode (Matimo has no per-provider error classes — see matimo.errors).
+- Unlike the TypeScript executor, Python's MatimoInstance.execute() re-raises
+  MatimoError rather than converting it to {success: False} — every failure path
+  here raises directly.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any, Literal
+
+import httpx
+
+from matimo.errors import ErrorCode, MatimoError
+
+GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0"
+
+_RETRYABLE_STATUS_CODES = {429, 500, 503}
+_MAX_RETRIES = 3
+_INITIAL_BACKOFF_S = 0.5
+
+HttpMethod = Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+ResponseType = Literal["json", "bytes"]
+
+
+def get_access_token(params: dict[str, Any]) -> str:
+    """
+    Resolve the delegated Graph access token. Matimo never exchanges OAuth codes —
+    the token must already be present in the merged params (credentials) or the
+    environment.
+    """
+    token = params.get("MICROSOFT_GRAPH_ACCESS_TOKEN") or os.environ.get(
+        "MICROSOFT_GRAPH_ACCESS_TOKEN"
+    )
+
+    if not token:
+        raise MatimoError(
+            "Microsoft Graph access token is missing. Provide it via "
+            "credentials.MICROSOFT_GRAPH_ACCESS_TOKEN or the MICROSOFT_GRAPH_ACCESS_TOKEN "
+            "environment variable. Matimo never performs the OAuth exchange itself — "
+            "connect Microsoft in Nova first.",
+            ErrorCode.AUTH_FAILED,
+            {"provider": "microsoft", "placeholder": "MICROSOFT_GRAPH_ACCESS_TOKEN"},
+        )
+
+    return str(token)
+
+
+def require_params(params: dict[str, Any], required: list[str], tool_name: str) -> None:
+    """
+    Validate required parameters BEFORE any network call, mirroring the
+    "ValidationError before any API call" requirement. Raises VALIDATION_FAILED.
+    """
+    missing = [name for name in required if params.get(name) in (None, "")]
+
+    if missing:
+        raise MatimoError(
+            f"{tool_name}: missing required parameter(s): {', '.join(missing)}",
+            ErrorCode.VALIDATION_FAILED,
+            {"toolName": tool_name, "missingParams": missing},
+        )
+
+
+def _parse_retry_after_seconds(retry_after_header: str | None) -> float | None:
+    """
+    Parse a `Retry-After` header into delta-seconds, returning None when it's
+    absent or not a numeric delay. Per RFC 9110 §10.2.3, `Retry-After` MAY be
+    an HTTP-date instead of delta-seconds — float() raises ValueError on that
+    (unlike JS's Number(), which yields NaN), so the conversion must be guarded
+    to avoid crashing error mapping for 429 responses.
+    """
+    if retry_after_header is None:
+        return None
+    try:
+        return float(retry_after_header)
+    except (TypeError, ValueError):
+        return None
+
+
+def map_graph_error(
+    status: int,
+    data: Any,
+    headers: httpx.Headers | dict[str, str] | None,
+    resource_type: str,
+) -> MatimoError:
+    """
+    Map a Microsoft Graph HTTP error response onto a MatimoError using the closest
+    matching ErrorCode (Matimo has no CredentialError/NotFoundError/ProviderError
+    classes — see matimo.errors):
+      401/403 -> AUTH_FAILED         ("Microsoft Graph access denied. Check connection status in Nova.")
+      404     -> FILE_NOT_FOUND      (details.resourceType identifies what was missing)
+      429     -> RATE_LIMIT_EXCEEDED (details.retryAfterSeconds carries Retry-After)
+      500/503 -> EXECUTION_FAILED    (retryable)
+      other   -> EXECUTION_FAILED
+    """
+    graph_error = data.get("error") if isinstance(data, dict) else None
+    details: dict[str, Any] = {"statusCode": status, "graphError": graph_error, "resourceType": resource_type}
+
+    if status in (401, 403):
+        return MatimoError(
+            "Microsoft Graph access denied. Check connection status in Nova.",
+            ErrorCode.AUTH_FAILED,
+            details,
+        )
+
+    if status == 404:
+        return MatimoError(f"{resource_type} not found.", ErrorCode.FILE_NOT_FOUND, details)
+
+    if status == 429:
+        retry_after_header = None
+        if headers is not None:
+            retry_after_header = headers.get("retry-after") or headers.get("Retry-After")
+        retry_after_seconds = _parse_retry_after_seconds(retry_after_header)
+        return MatimoError(
+            "Microsoft Graph rate limit exceeded. Respect Retry-After before retrying.",
+            ErrorCode.RATE_LIMIT_EXCEEDED,
+            {**details, "retryAfterSeconds": retry_after_seconds},
+        )
+
+    if status in (500, 503):
+        return MatimoError(
+            "Microsoft Graph service is temporarily unavailable. Please retry shortly.",
+            ErrorCode.EXECUTION_FAILED,
+            details,
+        )
+
+    return MatimoError(
+        f"Microsoft Graph request failed with status {status}.",
+        ErrorCode.EXECUTION_FAILED,
+        details,
+    )
+
+
+async def graph_request(
+    *,
+    method: HttpMethod,
+    path: str,
+    token: str,
+    query: dict[str, Any] | None = None,
+    body: Any = None,
+    headers: dict[str, str] | None = None,
+    resource_type: str = "Resource",
+    response_type: ResponseType = "json",
+    allow_empty_response: bool = False,
+) -> Any:
+    """
+    Perform an authenticated Microsoft Graph request with retry-on-429/5xx
+    (respecting Retry-After, exponential backoff, max 3 retries) and normalized
+    MatimoError mapping for every other failure.
+
+    Args:
+        path: Path relative to https://graph.microsoft.com/v1.0, e.g. '/me/messages'
+        response_type: 'bytes' for binary downloads (e.g. file content)
+        allow_empty_response: Treat a 204/empty body as success and return None
+            (e.g. publish, sendMail)
+    """
+    url = f"{GRAPH_BASE_URL}{path}"
+
+    is_json_body = body is not None and not isinstance(body, (bytes, bytearray))
+    request_headers: dict[str, str] = {
+        "Authorization": f"Bearer {token}",
+        **({"Accept": "application/json"} if response_type == "json" else {}),
+        **({"Content-Type": "application/json"} if is_json_body else {}),
+        **(headers or {}),
+    }
+
+    request_kwargs: dict[str, Any] = {}
+    if isinstance(body, (bytes, bytearray)):
+        request_kwargs["content"] = bytes(body)
+    elif body is not None:
+        request_kwargs["json"] = body
+
+    filtered_query = {
+        key: value
+        for key, value in (query or {}).items()
+        if value is not None and value != ""
+    }
+
+    attempt = 0
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        while True:
+            try:
+                response = await client.request(
+                    method,
+                    url,
+                    params=filtered_query or None,
+                    headers=request_headers,
+                    **request_kwargs,
+                )
+            except httpx.HTTPError as exc:
+                raise MatimoError(
+                    "Microsoft Graph request failed before a response was received (network error).",
+                    ErrorCode.NETWORK_ERROR,
+                    {"path": path, "originalError": str(exc)},
+                    cause=exc,
+                ) from exc
+
+            if 200 <= response.status_code < 300:
+                if allow_empty_response and (response.status_code == 204 or not response.content):
+                    return None
+                if response_type == "bytes":
+                    return response.content
+                if not response.content:
+                    return None
+                return response.json()
+
+            try:
+                error_body: Any = response.json()
+            except ValueError:
+                error_body = None
+
+            error = map_graph_error(response.status_code, error_body, response.headers, resource_type)
+
+            is_retryable = response.status_code in _RETRYABLE_STATUS_CODES and attempt < _MAX_RETRIES
+            if not is_retryable:
+                raise error
+
+            retry_after_seconds = error.details.get("retryAfterSeconds") if error.details else None
+            delay_s = (
+                retry_after_seconds
+                if isinstance(retry_after_seconds, (int, float))
+                else _INITIAL_BACKOFF_S * (2**attempt)
+            )
+
+            attempt += 1
+            await asyncio.sleep(delay_s)

matimo_microsoft-0.1.0/src/matimo_microsoft/tools/ms_create_calendar_event/definition.yaml

@@ -0,0 +1,100 @@
+name: ms_create_calendar_event
+description: |
+  Create an event on the signed-in user's default calendar (POST /me/events).
+  Supports attendees, location, a single IANA/Windows time zone for both start and
+  end, and Microsoft Teams online meetings (isOnlineMeeting), returning the meeting's
+  join URL when one is created.
+version: '1.0.0'
+status: approved
+risk: medium
+
+parameters:
+  subject:
+    type: string
+    description: Title of the event
+    required: true
+
+  body:
+    type: string
+    description: Description / agenda for the event (plain text)
+    required: false
+
+  start:
+    type: string
+    description: 'Start date and time, e.g. "2026-06-15T09:00:00"'
+    required: true
+
+  end:
+    type: string
+    description: 'End date and time, e.g. "2026-06-15T09:30:00"'
+    required: true
+
+  timezone:
+    type: string
+    description: 'IANA or Windows time zone applied to both `start` and `end`, e.g. "America/Los_Angeles"'
+    required: false
+    default: UTC
+
+  attendees:
+    type: array
+    description: Email addresses of attendees to invite
+    required: false
+
+  location:
+    type: string
+    description: Free-text location / room name for the event
+    required: false
+
+  is_online_meeting:
+    type: boolean
+    description: When true, Microsoft Teams creates an online meeting for this event
+    required: false
+    default: false
+
+execution:
+  type: function
+  code: ./ms_create_calendar_event.py
+  timeout: 25000
+
+authentication:
+  type: oauth2
+  provider: microsoft
+  scopes:
+    - https://graph.microsoft.com/Calendars.ReadWrite
+
+output_schema:
+  type: object
+  properties:
+    success:
+      type: boolean
+    event_id:
+      type: string
+    web_link:
+      type: string
+    join_url:
+      type: string
+      description: Microsoft Teams meeting join URL — present only when is_online_meeting is true
+
+error_handling:
+  retry: 1
+  backoff_type: exponential
+  initial_delay_ms: 1000
+
+tags: [microsoft, graph, calendar, outlook, teams, write]
+
+examples:
+  - name: Schedule a 30-minute internal sync
+    params:
+      subject: 'Sprint planning'
+      start: '2026-06-15T09:00:00'
+      end: '2026-06-15T09:30:00'
+      timezone: 'America/Los_Angeles'
+      attendees: ['alice@contoso.com', 'bob@contoso.com']
+  - name: Schedule an online Teams meeting with a location fallback
+    params:
+      subject: 'All-hands'
+      start: '2026-06-20T17:00:00'
+      end: '2026-06-20T18:00:00'
+      timezone: UTC
+      location: 'Building 4, Room 200'
+      is_online_meeting: true