hostel-protocol-python 0.1.0__tar.gz

hostel_protocol_python-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Lint
+        run: |
+          uv run ruff check src/ tests/
+          uv run black --check src/ tests/
+
+      - name: Typecheck
+        run: uv run mypy src/
+
+      - name: Test
+        run: uv run pytest --cov-report=xml
+
+      - name: Upload coverage
+        if: matrix.python-version == '3.12'
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage.xml

hostel_protocol_python-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,39 @@
+name: Publish to PyPI
+
+permissions:
+  actions: write       # Necessary to cancel workflow executions
+  checks: write        # Necessary to write reports
+  pull-requests: write # Necessary to comment on PRs
+  contents: read
+  packages: write
+
+on:
+  push:
+    tags: 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      actions: write       # Necessary to cancel workflow executions
+      checks: write        # Necessary to write reports
+      pull-requests: write # Necessary to comment on PRs
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

hostel_protocol_python-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing / Coverage
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+
+# mypy
+.mypy_cache/
+
+# ruff
+.ruff_cache/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# uv
+uv.lock

hostel_protocol_python-0.1.0/Makefile

@@ -0,0 +1,18 @@
+.PHONY: install format lint typecheck test
+
+install:
+	uv sync --all-extras
+
+format:
+	uv run black src/ tests/
+	uv run ruff check --fix src/ tests/
+
+lint:
+	uv run ruff check src/ tests/
+	uv run black --check src/ tests/
+
+typecheck:
+	uv run mypy src/
+
+test:
+	uv run pytest

hostel_protocol_python-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: hostel-protocol-python
+Version: 0.1.0
+Summary: Pydantic convenience layer for the Hostel protocol
+Requires-Python: >=3.12
+Requires-Dist: hostel-protocol>=0.1.0
+Requires-Dist: protobuf>=7.0
+Requires-Dist: pydantic>=2.5.0
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: types-protobuf; extra == 'dev'

hostel_protocol_python-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hostel-protocol-python"
+version = "0.1.0"
+description = "Pydantic convenience layer for the Hostel protocol"
+requires-python = ">=3.12"
+dependencies = [
+    "hostel-protocol>=0.1.0",
+    "pydantic>=2.5.0",
+    "protobuf>=7.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "black",
+    "ruff",
+    "mypy",
+    "types-protobuf",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hostel_protocol"]
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+plugins = ["pydantic.mypy"]
+
+[[tool.mypy.overrides]]
+module = "hostel.protocol.v1.*"
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=hostel_protocol --cov-report=term-missing"
+
+[tool.uv]
+constraint-dependencies = ["protobuf>=7.0"]
+override-dependencies = ["protobuf>=7.0"]

hostel_protocol_python-0.1.0/src/hostel_protocol/__init__.py

@@ -0,0 +1,76 @@
+"""hostel_protocol — Pydantic convenience layer for the Hostel protocol."""
+
+from hostel_protocol.converter import proto_to_pydantic, pydantic_to_proto
+from hostel_protocol.models import (
+    AIChatMessage,
+    ChatMessage,
+    ChatRequest,
+    ChatResponse,
+    CreateComponentRequest,
+    CreateComponentResponse,
+    CreateTaskRequest,
+    CreateTaskResponse,
+    DeleteComponentRequest,
+    DeleteComponentResponse,
+    DeleteTaskRequest,
+    DeleteTaskResponse,
+    GetComponentRequest,
+    GetComponentResponse,
+    GetTaskRequest,
+    GetTaskResponse,
+    HostelMessage,
+    HumanChatMessage,
+    ListAgentsRequest,
+    ListAgentsResponse,
+    ListComponentsRequest,
+    ListComponentsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    TaskData,
+    ToolChatMessage,
+    UpdateComponentRequest,
+    UpdateComponentResponse,
+    UpdateTaskRequest,
+    UpdateTaskResponse,
+)
+
+__all__ = [
+    # Converter
+    "pydantic_to_proto",
+    "proto_to_pydantic",
+    # Chat
+    "HumanChatMessage",
+    "AIChatMessage",
+    "ToolChatMessage",
+    "ChatMessage",
+    "ChatRequest",
+    "ChatResponse",
+    # Agent
+    "ListAgentsRequest",
+    "ListAgentsResponse",
+    # Component
+    "CreateComponentRequest",
+    "CreateComponentResponse",
+    "GetComponentRequest",
+    "GetComponentResponse",
+    "ListComponentsRequest",
+    "ListComponentsResponse",
+    "UpdateComponentRequest",
+    "UpdateComponentResponse",
+    "DeleteComponentRequest",
+    "DeleteComponentResponse",
+    # Task
+    "TaskData",
+    "CreateTaskRequest",
+    "CreateTaskResponse",
+    "ListTasksRequest",
+    "ListTasksResponse",
+    "GetTaskRequest",
+    "GetTaskResponse",
+    "UpdateTaskRequest",
+    "UpdateTaskResponse",
+    "DeleteTaskRequest",
+    "DeleteTaskResponse",
+    # Envelope
+    "HostelMessage",
+]

hostel_protocol_python-0.1.0/src/hostel_protocol/converter.py

@@ -0,0 +1,368 @@
+"""Bidirectional converter between Pydantic models and Protobuf messages."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from google.protobuf import struct_pb2, wrappers_pb2
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.message import Message
+from hostel.protocol.v1 import (
+    agent_pb2,
+    chat_pb2,
+    component_pb2,
+    message_pb2,
+    task_pb2,
+)
+from pydantic import BaseModel
+
+from hostel_protocol import models
+
+# ---------------------------------------------------------------------------
+# Registry: Pydantic model class  <->  Protobuf message class
+# ---------------------------------------------------------------------------
+
+_PYDANTIC_TO_PROTO: dict[type[BaseModel], type[Message]] = {
+    # Chat
+    models.HumanChatMessage: chat_pb2.HumanChatMessage,
+    models.AIChatMessage: chat_pb2.AIChatMessage,
+    models.ToolChatMessage: chat_pb2.ToolChatMessage,
+    models.ChatMessage: chat_pb2.ChatMessage,
+    models.ChatRequest: chat_pb2.ChatRequest,
+    models.ChatResponse: chat_pb2.ChatResponse,
+    # Agent
+    models.ListAgentsRequest: agent_pb2.ListAgentsRequest,
+    models.ListAgentsResponse: agent_pb2.ListAgentsResponse,
+    # Component
+    models.CreateComponentRequest: component_pb2.CreateComponentRequest,
+    models.CreateComponentResponse: component_pb2.CreateComponentResponse,
+    models.GetComponentRequest: component_pb2.GetComponentRequest,
+    models.GetComponentResponse: component_pb2.GetComponentResponse,
+    models.ListComponentsRequest: component_pb2.ListComponentsRequest,
+    models.ListComponentsResponse: component_pb2.ListComponentsResponse,
+    models.UpdateComponentRequest: component_pb2.UpdateComponentRequest,
+    models.UpdateComponentResponse: component_pb2.UpdateComponentResponse,
+    models.DeleteComponentRequest: component_pb2.DeleteComponentRequest,
+    models.DeleteComponentResponse: component_pb2.DeleteComponentResponse,
+    # Task
+    models.TaskData: task_pb2.TaskData,
+    models.CreateTaskRequest: task_pb2.CreateTaskRequest,
+    models.CreateTaskResponse: task_pb2.CreateTaskResponse,
+    models.ListTasksRequest: task_pb2.ListTasksRequest,
+    models.ListTasksResponse: task_pb2.ListTasksResponse,
+    models.GetTaskRequest: task_pb2.GetTaskRequest,
+    models.GetTaskResponse: task_pb2.GetTaskResponse,
+    models.UpdateTaskRequest: task_pb2.UpdateTaskRequest,
+    models.UpdateTaskResponse: task_pb2.UpdateTaskResponse,
+    models.DeleteTaskRequest: task_pb2.DeleteTaskRequest,
+    models.DeleteTaskResponse: task_pb2.DeleteTaskResponse,
+    # Envelope
+    models.HostelMessage: message_pb2.HostelMessage,
+}
+
+_PROTO_TO_PYDANTIC: dict[type[Message], type[BaseModel]] = {v: k for k, v in _PYDANTIC_TO_PROTO.items()}
+
+# Fields in each proto that use google.protobuf.StringValue (nullable strings)
+_STRING_VALUE_FIELDS: dict[type[Message], set[str]] = {
+    task_pb2.TaskData: {"webhook_url", "status", "response", "created_at", "updated_at", "executed_at"},
+    task_pb2.CreateTaskRequest: {"webhook_url"},
+    task_pb2.UpdateTaskRequest: {"agent_name", "prompt", "start_datetime", "webhook_url", "status"},
+}
+
+# Fields that hold google.protobuf.Struct (dict[str, Any])
+_STRUCT_FIELDS: dict[type[Message], set[str]] = {
+    chat_pb2.ChatResponse: {"content"},
+    component_pb2.CreateComponentRequest: {"data"},
+    component_pb2.GetComponentResponse: {"data"},
+    component_pb2.UpdateComponentRequest: {"data"},
+    message_pb2.HostelMessage: {"meta", "system_payload", "generic_payload"},
+}
+
+# Fields that hold google.protobuf.Value
+_VALUE_FIELDS: dict[type[Message], set[str]] = {
+    chat_pb2.ChatResponse: {"content"},
+}
+
+# Fields that hold repeated sub-messages
+_REPEATED_MSG_FIELDS: dict[type[Message], dict[str, type[Message]]] = {
+    agent_pb2.ListAgentsResponse: {"agents": struct_pb2.Struct},
+    chat_pb2.ChatRequest: {"messages": chat_pb2.ChatMessage},
+    component_pb2.ListComponentsResponse: {"components": struct_pb2.Struct},
+    task_pb2.ListTasksResponse: {"tasks": task_pb2.TaskData},
+}
+
+# Fields that hold a single sub-message (non-oneof)
+_SUB_MSG_FIELDS: dict[type[Message], dict[str, type[Message]]] = {
+    task_pb2.CreateTaskResponse: {"task": task_pb2.TaskData},
+    task_pb2.GetTaskResponse: {"task": task_pb2.TaskData},
+    task_pb2.UpdateTaskResponse: {"task": task_pb2.TaskData},
+}
+
+# oneof groups: proto class -> {field_name: proto sub-message class}
+_ONEOF_FIELDS: dict[type[Message], dict[str, type[Message]]] = {
+    chat_pb2.ChatMessage: {
+        "human": chat_pb2.HumanChatMessage,
+        "ai": chat_pb2.AIChatMessage,
+        "tool": chat_pb2.ToolChatMessage,
+    },
+}
+
+# HostelMessage payload oneof (special handling due to breadth)
+_HOSTEL_MESSAGE_PAYLOAD_FIELDS: dict[str, type[Message]] = {
+    "agent_list_request": agent_pb2.ListAgentsRequest,
+    "agent_list_response": agent_pb2.ListAgentsResponse,
+    "system_payload": struct_pb2.Struct,
+    "chat_request": chat_pb2.ChatRequest,
+    "chat_response_chunk": chat_pb2.ChatResponse,
+    "task_create": task_pb2.CreateTaskRequest,
+    "task_create_response": task_pb2.CreateTaskResponse,
+    "task_list": task_pb2.ListTasksRequest,
+    "task_list_response": task_pb2.ListTasksResponse,
+    "task_get": task_pb2.GetTaskRequest,
+    "task_get_response": task_pb2.GetTaskResponse,
+    "task_update": task_pb2.UpdateTaskRequest,
+    "task_update_response": task_pb2.UpdateTaskResponse,
+    "task_delete": task_pb2.DeleteTaskRequest,
+    "task_delete_response": task_pb2.DeleteTaskResponse,
+    "component_create": component_pb2.CreateComponentRequest,
+    "component_create_response": component_pb2.CreateComponentResponse,
+    "component_get": component_pb2.GetComponentRequest,
+    "component_get_response": component_pb2.GetComponentResponse,
+    "component_list": component_pb2.ListComponentsRequest,
+    "component_list_response": component_pb2.ListComponentsResponse,
+    "component_update": component_pb2.UpdateComponentRequest,
+    "component_update_response": component_pb2.UpdateComponentResponse,
+    "component_delete": component_pb2.DeleteComponentRequest,
+    "component_delete_response": component_pb2.DeleteComponentResponse,
+    "generic_payload": struct_pb2.Struct,
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _struct_to_dict(s: struct_pb2.Struct) -> dict[str, Any]:
+    return dict(MessageToDict(s))
+
+
+def _dict_to_struct(d: dict[str, Any]) -> struct_pb2.Struct:
+    s = struct_pb2.Struct()
+    s.update(d)
+    return s
+
+
+def _value_to_python(v: struct_pb2.Value) -> Any:
+    return MessageToDict(v)
+
+
+def _python_to_value(v: Any) -> struct_pb2.Value:
+    val = struct_pb2.Value()
+    if v is None:
+        val.null_value = 0  # type: ignore[assignment]
+    elif isinstance(v, bool):
+        val.bool_value = v
+    elif isinstance(v, (int, float)):
+        val.number_value = float(v)
+    elif isinstance(v, str):
+        val.string_value = v
+    elif isinstance(v, dict):
+        ParseDict(v, val.struct_value)
+    elif isinstance(v, list):
+        for item in v:
+            val.list_value.values.append(_python_to_value(item))
+    return val
+
+
+# ---------------------------------------------------------------------------
+# Pydantic  →  Protobuf
+# ---------------------------------------------------------------------------
+
+
+def pydantic_to_proto(model: BaseModel) -> Message:
+    """Convert a Pydantic model instance to the corresponding Protobuf message."""
+    proto_cls = _PYDANTIC_TO_PROTO.get(type(model))
+    if proto_cls is None:
+        raise TypeError(f"No protobuf mapping registered for {type(model).__name__}")
+    return _pydantic_to_proto_inner(model, proto_cls)
+
+
+def _pydantic_to_proto_inner(model: BaseModel, proto_cls: type[Message]) -> Message:
+    proto = proto_cls()
+    string_value_fields = _STRING_VALUE_FIELDS.get(proto_cls, set())
+    struct_fields = _STRUCT_FIELDS.get(proto_cls, set())
+    value_fields = _VALUE_FIELDS.get(proto_cls, set())
+    repeated_fields = _REPEATED_MSG_FIELDS.get(proto_cls, {})
+    sub_msg_fields = _SUB_MSG_FIELDS.get(proto_cls, {})
+    oneof_fields = _ONEOF_FIELDS.get(proto_cls, {})
+
+    # Special handling for HostelMessage payload oneof
+    is_envelope = proto_cls is message_pb2.HostelMessage
+
+    for field_name, value in model:
+        if value is None:
+            continue
+
+        # StringValue wrapper fields
+        if field_name in string_value_fields:
+            wrapper = wrappers_pb2.StringValue(value=value)
+            getattr(proto, field_name).CopyFrom(wrapper)
+
+        # google.protobuf.Value fields
+        elif field_name in value_fields:
+            getattr(proto, field_name).CopyFrom(_python_to_value(value))
+
+        # Struct fields (dict)
+        elif field_name in struct_fields:
+            if isinstance(value, dict):
+                getattr(proto, field_name).CopyFrom(_dict_to_struct(value))
+            # repeated Struct handled below
+
+        # Repeated Struct (list[dict])
+        elif field_name in repeated_fields and repeated_fields[field_name] is struct_pb2.Struct:
+            for item in value:
+                getattr(proto, field_name).append(_dict_to_struct(item))
+
+        # Repeated sub-messages
+        elif field_name in repeated_fields:
+            child_proto_cls = repeated_fields[field_name]
+            child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+            for item in value:
+                if child_pydantic_cls and isinstance(item, child_pydantic_cls):
+                    getattr(proto, field_name).append(_pydantic_to_proto_inner(item, child_proto_cls))
+
+        # Single sub-message fields
+        elif field_name in sub_msg_fields:
+            child_proto_cls = sub_msg_fields[field_name]
+            getattr(proto, field_name).CopyFrom(_pydantic_to_proto_inner(value, child_proto_cls))
+
+        # Oneof sub-message fields
+        elif field_name in oneof_fields:
+            child_proto_cls = oneof_fields[field_name]
+            getattr(proto, field_name).CopyFrom(_pydantic_to_proto_inner(value, child_proto_cls))
+
+        # HostelMessage payload oneof
+        elif is_envelope and field_name in _HOSTEL_MESSAGE_PAYLOAD_FIELDS:
+            child_proto_cls = _HOSTEL_MESSAGE_PAYLOAD_FIELDS[field_name]
+            if child_proto_cls is struct_pb2.Struct:
+                getattr(proto, field_name).CopyFrom(_dict_to_struct(value))
+            else:
+                child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+                if child_pydantic_cls and isinstance(value, child_pydantic_cls):
+                    getattr(proto, field_name).CopyFrom(_pydantic_to_proto_inner(value, child_proto_cls))
+
+        # Scalar fields
+        else:
+            setattr(proto, field_name, value)
+
+    return proto
+
+
+# ---------------------------------------------------------------------------
+# Protobuf  →  Pydantic
+# ---------------------------------------------------------------------------
+
+
+def proto_to_pydantic(proto: Message) -> BaseModel:
+    """Convert a Protobuf message to the corresponding Pydantic model."""
+    pydantic_cls = _PROTO_TO_PYDANTIC.get(type(proto))
+    if pydantic_cls is None:
+        raise TypeError(f"No pydantic mapping registered for {type(proto).__name__}")
+    return _proto_to_pydantic_inner(proto, pydantic_cls)
+
+
+def _proto_to_pydantic_inner(proto: Message, pydantic_cls: type[BaseModel]) -> BaseModel:
+    proto_cls = type(proto)
+    string_value_fields = _STRING_VALUE_FIELDS.get(proto_cls, set())
+    struct_fields = _STRUCT_FIELDS.get(proto_cls, set())
+    value_fields = _VALUE_FIELDS.get(proto_cls, set())
+    repeated_fields = _REPEATED_MSG_FIELDS.get(proto_cls, {})
+    sub_msg_fields = _SUB_MSG_FIELDS.get(proto_cls, {})
+    oneof_fields = _ONEOF_FIELDS.get(proto_cls, {})
+
+    is_envelope = proto_cls is message_pb2.HostelMessage
+
+    kwargs: dict[str, Any] = {}
+
+    for field_desc in proto.DESCRIPTOR.fields:
+        field_name = field_desc.name
+
+        # StringValue wrapper fields
+        if field_name in string_value_fields:
+            if proto.HasField(field_name):
+                kwargs[field_name] = getattr(proto, field_name).value
+            else:
+                kwargs[field_name] = None
+
+        # google.protobuf.Value fields
+        elif field_name in value_fields:
+            if proto.HasField(field_name):
+                kwargs[field_name] = _value_to_python(getattr(proto, field_name))
+            else:
+                kwargs[field_name] = None
+
+        # Struct fields (dict)
+        elif field_name in struct_fields and field_name not in repeated_fields:
+            if is_envelope and field_name in {"system_payload", "generic_payload"}:
+                # These are oneof payload members
+                if proto.HasField(field_name):
+                    kwargs[field_name] = _struct_to_dict(getattr(proto, field_name))
+                else:
+                    kwargs[field_name] = None
+            elif proto.HasField(field_name):
+                kwargs[field_name] = _struct_to_dict(getattr(proto, field_name))
+            else:
+                kwargs[field_name] = {}
+
+        # Repeated Struct (list[dict])
+        elif field_name in repeated_fields and repeated_fields[field_name] is struct_pb2.Struct:
+            kwargs[field_name] = [_struct_to_dict(item) for item in getattr(proto, field_name)]
+
+        # Repeated sub-messages
+        elif field_name in repeated_fields:
+            child_proto_cls = repeated_fields[field_name]
+            child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+            if child_pydantic_cls:
+                kwargs[field_name] = [
+                    _proto_to_pydantic_inner(item, child_pydantic_cls) for item in getattr(proto, field_name)
+                ]
+
+        # Single sub-message fields
+        elif field_name in sub_msg_fields:
+            if proto.HasField(field_name):
+                child_proto_cls = sub_msg_fields[field_name]
+                child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+                if child_pydantic_cls:
+                    kwargs[field_name] = _proto_to_pydantic_inner(getattr(proto, field_name), child_pydantic_cls)
+            else:
+                kwargs[field_name] = None
+
+        # Oneof sub-message fields
+        elif field_name in oneof_fields:
+            if proto.HasField(field_name):
+                child_proto_cls = oneof_fields[field_name]
+                child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+                if child_pydantic_cls:
+                    kwargs[field_name] = _proto_to_pydantic_inner(getattr(proto, field_name), child_pydantic_cls)
+            else:
+                kwargs[field_name] = None
+
+        # HostelMessage payload oneof
+        elif is_envelope and field_name in _HOSTEL_MESSAGE_PAYLOAD_FIELDS:
+            if proto.HasField(field_name):
+                child_proto_cls = _HOSTEL_MESSAGE_PAYLOAD_FIELDS[field_name]
+                if child_proto_cls is struct_pb2.Struct:
+                    kwargs[field_name] = _struct_to_dict(getattr(proto, field_name))
+                else:
+                    child_pydantic_cls = _PROTO_TO_PYDANTIC.get(child_proto_cls)
+                    if child_pydantic_cls:
+                        kwargs[field_name] = _proto_to_pydantic_inner(getattr(proto, field_name), child_pydantic_cls)
+            else:
+                kwargs[field_name] = None
+
+        # Scalar fields
+        else:
+            kwargs[field_name] = getattr(proto, field_name)
+
+    return pydantic_cls(**kwargs)