axio 0.7.0__tar.gz → 0.9.0__tar.gz

{axio-0.7.0 → axio-0.9.0}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.4
 Name: axio
-Version: 0.7.0
+Version: 0.9.0
 Summary: Minimal, streaming-first, protocol-driven foundation for LLM-powered agents
 Project-URL: Homepage, https://github.com/mosquito/axio-agent
 Project-URL: Repository, https://github.com/mosquito/axio-agent
 License: MIT
 License-File: LICENSE
-Keywords: agent,ai,async,llm,protocol,pydantic,streaming
+Keywords: agent,ai,async,llm,protocol,streaming
 Requires-Python: >=3.12
-Requires-Dist: pydantic>=2
 Description-Content-Type: text/markdown
 
 # axio
@@ -19,16 +18,16 @@ Description-Content-Type: text/markdown
 
 Minimal, streaming-first, protocol-driven foundation for LLM-powered agents.
 
-One dependency (`pydantic`). Three protocols. An agent loop that just works.
+No dependencies. Three protocols. An agent loop that just works.
 
 ## Features
 
-- **Streaming agent loop** — `run_stream()` yields typed events as they arrive; no buffering, no polling
-- **Three clean protocols** — `CompletionTransport`, `ContextStore`, `PermissionGuard`; swap any piece without touching the rest
-- **Concurrent tool dispatch** — all tool calls in a turn run via `asyncio.gather` automatically
-- **Context compaction** — `compact_context()` summarises old history to stay within token limits
-- **Testing helpers** — `StubTransport`, `make_tool_use_response()`, `make_echo_tool()` ship in `axio.testing`
-- **Plugin-ready** — entry-point groups (`axio.tools`, `axio.transport`, `axio.guards`) for drop-in extensions
+- **Streaming agent loop** - `run_stream()` yields typed events as they arrive; no buffering, no polling
+- **Three clean protocols** - `CompletionTransport`, `ContextStore`, `PermissionGuard`; swap any piece without touching the rest
+- **Concurrent tool dispatch** - all tool calls in a turn run via `asyncio.gather` automatically
+- **Context compaction** - `compact_context()` summarises old history to stay within token limits
+- **Testing helpers** - `StubTransport`, `make_tool_use_response()`, `make_echo_tool()` ship in `axio.testing`
+- **Plugin-ready** - entry-point groups (`axio.tools`, `axio.transport`, `axio.guards`) for drop-in extensions
 
 ## Installation
 
@@ -57,17 +56,14 @@ sys.modules["axio_transport_openai"] = _m
 import asyncio
 from axio.agent import Agent
 from axio.context import MemoryContextStore
-from axio.tool import Tool, ToolHandler
+from axio.tool import Tool
 
 # 1. Define a tool
-class Greet(ToolHandler):
+async def greet(name: str) -> str:
     """Return a greeting for the given name."""
-    name: str
-
-    async def __call__(self) -> str:
-        return f"Hello, {self.name}!"
+    return f"Hello, {name}!"
 
-greet_tool = Tool(name="greet", description="Greet someone by name", handler=Greet)
+greet_tool = Tool(name="greet", description="Greet someone by name", handler=greet)
 
 # 2. Wire up the agent (transport comes from an axio-transport-* package)
 from axio_transport_openai import OpenAITransport
@@ -144,9 +140,9 @@ class MyContextStore(ContextStore):
     async def get_history(self) -> list[Message]:
         return list(self._messages)
 
-    # Everything else — session_id, close(), fork(), clear(),
+    # Everything else - session_id, close(), fork(), clear(),
     # get/set_context_tokens(), add_context_tokens(), list_sessions()
-    # — has a default implementation.
+    # - has a default implementation.
 ```
 
 ### PermissionGuard
@@ -158,11 +154,12 @@ class MyContextStore(ContextStore):
 ```python
 from typing import Any
 from axio.permission import PermissionGuard
+from axio.tool import Tool
 
 class MyGuard(PermissionGuard):
-    async def check(self, handler: Any) -> Any:
-        # return handler to allow, raise GuardError to deny
-        return handler
+    async def check(self, tool: Tool[Any], **kwargs: Any) -> dict[str, Any]:
+        # return kwargs to allow, raise GuardError to deny
+        return kwargs
 ```
 
 ## Stream events
@@ -173,29 +170,25 @@ class MyGuard(PermissionGuard):
 | `ToolUseStart` | Tool call begins (name + id) |
 | `ToolInputDelta` | Streaming JSON fragment for tool arguments |
 | `ToolResult` | Tool execution result |
-| `IterationEnd` | One LLM round complete — carries `Usage` + `StopReason` |
+| `IterationEnd` | One LLM round complete - carries `Usage` + `StopReason` |
 | `Error` | Transport or tool exception |
-| `SessionEndEvent` | Agent loop finished — carries total `Usage` |
+| `SessionEndEvent` | Agent loop finished - carries total `Usage` |
 
 ## Tools
 
 <!-- name: test_readme_tools -->
 ```python
-from axio.tool import Tool, ToolHandler
+from axio.tool import Tool
 
-class Summarise(ToolHandler):
+async def summarise(text: str, max_words: int = 20) -> str:
     """Summarise the given text in one sentence."""
-    text: str
-    max_words: int = 20
-
-    async def __call__(self) -> str:
-        # your implementation
-        return "..."
+    # your implementation
+    return "..."
 
 tool = Tool(
     name="summarise",
     description="Summarise text",   # overrides docstring if set
-    handler=Summarise,
+    handler=summarise,
     concurrency=4,                   # max parallel executions
 )
 ```

{axio-0.7.0 → axio-0.9.0}/README.md

@@ -6,16 +6,16 @@
 
 Minimal, streaming-first, protocol-driven foundation for LLM-powered agents.
 
-One dependency (`pydantic`). Three protocols. An agent loop that just works.
+No dependencies. Three protocols. An agent loop that just works.
 
 ## Features
 
-- **Streaming agent loop** — `run_stream()` yields typed events as they arrive; no buffering, no polling
-- **Three clean protocols** — `CompletionTransport`, `ContextStore`, `PermissionGuard`; swap any piece without touching the rest
-- **Concurrent tool dispatch** — all tool calls in a turn run via `asyncio.gather` automatically
-- **Context compaction** — `compact_context()` summarises old history to stay within token limits
-- **Testing helpers** — `StubTransport`, `make_tool_use_response()`, `make_echo_tool()` ship in `axio.testing`
-- **Plugin-ready** — entry-point groups (`axio.tools`, `axio.transport`, `axio.guards`) for drop-in extensions
+- **Streaming agent loop** - `run_stream()` yields typed events as they arrive; no buffering, no polling
+- **Three clean protocols** - `CompletionTransport`, `ContextStore`, `PermissionGuard`; swap any piece without touching the rest
+- **Concurrent tool dispatch** - all tool calls in a turn run via `asyncio.gather` automatically
+- **Context compaction** - `compact_context()` summarises old history to stay within token limits
+- **Testing helpers** - `StubTransport`, `make_tool_use_response()`, `make_echo_tool()` ship in `axio.testing`
+- **Plugin-ready** - entry-point groups (`axio.tools`, `axio.transport`, `axio.guards`) for drop-in extensions
 
 ## Installation
 
@@ -44,17 +44,14 @@ sys.modules["axio_transport_openai"] = _m
 import asyncio
 from axio.agent import Agent
 from axio.context import MemoryContextStore
-from axio.tool import Tool, ToolHandler
+from axio.tool import Tool
 
 # 1. Define a tool
-class Greet(ToolHandler):
+async def greet(name: str) -> str:
     """Return a greeting for the given name."""
-    name: str
-
-    async def __call__(self) -> str:
-        return f"Hello, {self.name}!"
+    return f"Hello, {name}!"
 
-greet_tool = Tool(name="greet", description="Greet someone by name", handler=Greet)
+greet_tool = Tool(name="greet", description="Greet someone by name", handler=greet)
 
 # 2. Wire up the agent (transport comes from an axio-transport-* package)
 from axio_transport_openai import OpenAITransport
@@ -131,9 +128,9 @@ class MyContextStore(ContextStore):
     async def get_history(self) -> list[Message]:
         return list(self._messages)
 
-    # Everything else — session_id, close(), fork(), clear(),
+    # Everything else - session_id, close(), fork(), clear(),
     # get/set_context_tokens(), add_context_tokens(), list_sessions()
-    # — has a default implementation.
+    # - has a default implementation.
 ```
 
 ### PermissionGuard
@@ -145,11 +142,12 @@ class MyContextStore(ContextStore):
 ```python
 from typing import Any
 from axio.permission import PermissionGuard
+from axio.tool import Tool
 
 class MyGuard(PermissionGuard):
-    async def check(self, handler: Any) -> Any:
-        # return handler to allow, raise GuardError to deny
-        return handler
+    async def check(self, tool: Tool[Any], **kwargs: Any) -> dict[str, Any]:
+        # return kwargs to allow, raise GuardError to deny
+        return kwargs
 ```
 
 ## Stream events
@@ -160,29 +158,25 @@ class MyGuard(PermissionGuard):
 | `ToolUseStart` | Tool call begins (name + id) |
 | `ToolInputDelta` | Streaming JSON fragment for tool arguments |
 | `ToolResult` | Tool execution result |
-| `IterationEnd` | One LLM round complete — carries `Usage` + `StopReason` |
+| `IterationEnd` | One LLM round complete - carries `Usage` + `StopReason` |
 | `Error` | Transport or tool exception |
-| `SessionEndEvent` | Agent loop finished — carries total `Usage` |
+| `SessionEndEvent` | Agent loop finished - carries total `Usage` |
 
 ## Tools
 
 <!-- name: test_readme_tools -->
 ```python
-from axio.tool import Tool, ToolHandler
+from axio.tool import Tool
 
-class Summarise(ToolHandler):
+async def summarise(text: str, max_words: int = 20) -> str:
     """Summarise the given text in one sentence."""
-    text: str
-    max_words: int = 20
-
-    async def __call__(self) -> str:
-        # your implementation
-        return "..."
+    # your implementation
+    return "..."
 
 tool = Tool(
     name="summarise",
     description="Summarise text",   # overrides docstring if set
-    handler=Summarise,
+    handler=summarise,
     concurrency=4,                   # max parallel executions
 )
 ```

{axio-0.7.0 → axio-0.9.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "axio"
-version = "0.7.0"
+version = "0.9.0"  # bumped to the git tag by CI on publish
 description = "Minimal, streaming-first, protocol-driven foundation for LLM-powered agents"
 readme = "README.md"
 requires-python = ">=3.12"
 license = {text = "MIT"}
-keywords = ["llm", "agent", "ai", "async", "streaming", "pydantic", "protocol"]
-dependencies = ["pydantic>=2"]
+keywords = ["llm", "agent", "ai", "async", "streaming", "protocol"]
+dependencies = []
 
 
 [project.urls]
@@ -34,6 +34,7 @@ select = ["E", "F", "I", "UP"]
 strict = true
 python_version = "3.12"
 
+
 [dependency-groups]
 dev = [
     "pytest>=8",

axio-0.9.0/src/axio/__init__.py

@@ -0,0 +1,52 @@
+"""axio - public API."""
+
+from .agent import Agent
+from .blocks import TextBlock, ToolResultBlock, ToolUseBlock
+from .context import ContextStore, MemoryContextStore
+from .events import IterationEnd, StreamEvent, TextDelta, ToolInputDelta, ToolResult, ToolUseStart
+from .exceptions import GuardError, HandlerError
+from .field import Field, FieldInfo, StrictStr
+from .messages import Message
+from .permission import ConcurrentGuard, PermissionGuard
+from .selector import ToolSelector
+from .stream import AgentStream
+from .tool import CONTEXT, Tool
+from .transport import CompletionTransport
+from .types import StopReason, Usage
+
+__all__ = [
+    # core
+    "Agent",
+    "Tool",
+    "CONTEXT",
+    "ContextStore",
+    "MemoryContextStore",
+    "CompletionTransport",
+    # events
+    "StreamEvent",
+    "TextDelta",
+    "IterationEnd",
+    "ToolUseStart",
+    "ToolInputDelta",
+    "ToolResult",
+    # messages & blocks
+    "Message",
+    "TextBlock",
+    "ToolUseBlock",
+    "ToolResultBlock",
+    # types & errors
+    "StopReason",
+    "Usage",
+    "GuardError",
+    "HandlerError",
+    # permissions
+    "PermissionGuard",
+    "ConcurrentGuard",
+    # field annotations
+    "Field",
+    "FieldInfo",
+    "StrictStr",
+    # advanced
+    "ToolSelector",
+    "AgentStream",
+]

{axio-0.7.0 → axio-0.9.0}/src/axio/agent.py

@@ -85,7 +85,7 @@ class Agent:
 
     @staticmethod
     def _accumulate_text(content: list[TextBlock | ToolUseBlock], delta: str) -> None:
-        """Append text delta — merge into last TextBlock or start a new one."""
+        """Append text delta - merge into last TextBlock or start a new one."""
         if content and isinstance(content[-1], TextBlock):
             content[-1] = TextBlock(text=content[-1].text + delta)
         else:
@@ -190,7 +190,7 @@ class Agent:
                             stop_reason,
                         )
 
-                    # Dispatch tools BEFORE appending to context — cancellation
+                    # Dispatch tools BEFORE appending to context - cancellation
                     # between here and the two appends below cannot leave orphan
                     # ToolUseBlocks in the persistent context store.
                     valid = [b for b in tool_blocks if b.id not in malformed]

{axio-0.7.0 → axio-0.9.0}/src/axio/agent_loader.py

@@ -46,7 +46,7 @@ are comma-separated.
 
 Custom sources
 --------------
-Subclass :class:`AgentLoader` and implement :meth:`~AgentLoader.load` — the
+Subclass :class:`AgentLoader` and implement :meth:`~AgentLoader.load` - the
 base :meth:`~AgentLoader.load_file` will handle reading the file and calling
 your implementation automatically::
 
@@ -68,12 +68,11 @@ from pathlib import Path
 from types import MappingProxyType
 from typing import Annotated, Any, TypedDict
 
-from pydantic import Field
-
 from .agent import Agent
 from .context import ContextStore, MemoryContextStore
 from .events import StreamEvent, TextDelta
-from .tool import Tool, ToolHandler
+from .field import Field
+from .tool import CONTEXT, Tool
 from .transport import CompletionTransport, DummyCompletionTransport
 
 
@@ -91,7 +90,7 @@ class AgentSpec:
     def to_agent(self, toolbox: Mapping[str, Tool[Any]] = MappingProxyType({})) -> Agent:
         """Return a prototype Agent with *toolbox* tools attached.
 
-        The agent uses :class:`~axio.transport.DummyCompletionTransport` —
+        The agent uses :class:`~axio.transport.DummyCompletionTransport` -
         call ``agent.copy(transport=real_transport)`` before running it.
 
         Raises :exc:`KeyError` if any name in ``self.tools`` is absent from
@@ -114,7 +113,7 @@ class AgentLoader:
     """Base class for format-specific agent loaders.
 
     Subclasses implement :meth:`load` to parse a raw string.  The source of
-    that string is entirely up to the caller — files, databases, HTTP, etc.
+    that string is entirely up to the caller - files, databases, HTTP, etc.
     :meth:`load_file` is provided on the base class and calls :meth:`load`
     automatically.
     """
@@ -276,7 +275,7 @@ def load_agents(
 ) -> dict[str, tuple[str, Agent]]:
     """Scan *directory* for ``.toml``, ``.json``, and ``.ini`` agent files.
 
-    Returns ``dict[name, (description, agent)]`` — same shape as the
+    Returns ``dict[name, (description, agent)]`` - same shape as the
     ``AGENTS`` registry used in ``agent_swarm`` and similar examples.
 
     Example::
@@ -300,25 +299,19 @@ class AgentContext(TypedDict):
     on_event: Callable[[str, StreamEvent], None] | None
 
 
-class AgentTool(ToolHandler[AgentContext]):
-    """Handler for a single delegate agent — receives runtime deps via Tool.context."""
-
-    task: Annotated[str, Field(description="Full task instructions.")]
-
-    async def __call__(
-        self,
-        context: AgentContext,
-    ) -> str:
-        agent = context["proto"].copy(transport=context["transport"])
-        ctx = context["context_factory"]()
-        if context["on_event"] is None:
-            return await agent.run(self.task, ctx)
-        parts: list[str] = []
-        async for event in agent.run_stream(self.task, ctx):
-            context["on_event"](context["agent_name"], event)
-            if isinstance(event, TextDelta):
-                parts.append(event.delta)
-        return "".join(parts)
+async def agent_tool(task: Annotated[str, Field(description="Full task instructions.")]) -> str:
+    """Delegate a task to a sub-agent."""
+    context: AgentContext = CONTEXT.get()
+    agent = context["proto"].copy(transport=context["transport"])
+    ctx = context["context_factory"]()
+    if context["on_event"] is None:
+        return await agent.run(task, ctx)
+    parts: list[str] = []
+    async for event in agent.run_stream(task, ctx):
+        context["on_event"](context["agent_name"], event)
+        if isinstance(event, TextDelta):
+            parts.append(event.delta)
+    return "".join(parts)
 
 
 def make_agent_tools(
@@ -337,7 +330,7 @@ def make_agent_tools(
     Parameters
     ----------
     agents:
-        ``dict[name, (description, prototype_agent)]`` — e.g. the value
+        ``dict[name, (description, prototype_agent)]`` - e.g. the value
         returned by :func:`load_agents`.
     transport:
         Transport assigned to the selected agent via ``agent.copy()``.
@@ -364,7 +357,7 @@ def make_agent_tools(
         tool = Tool(
             name=f"{agent_name_prefix}{agent_name}",
             description=desc,
-            handler=AgentTool,
+            handler=agent_tool,
             context=AgentContext(
                 proto=proto,
                 transport=transport,

{axio-0.7.0 → axio-0.9.0}/src/axio/compaction.py

@@ -70,14 +70,14 @@ def _find_safe_boundary(history: list[Message], keep_recent: int) -> int:
 class AutoCompactStore(ContextStore):
     """Delegating ``ContextStore`` wrapper that auto-compacts the inner store
     when token usage exceeds a threshold.  Works with any ``ContextStore``
-    backend — ``MemoryContextStore``, ``SQLiteContextStore``, etc.
+    backend - ``MemoryContextStore``, ``SQLiteContextStore``, etc.
 
     The threshold defaults to 75 % of ``transport.model.context_window``
     (read via ``getattr``; falls back to 128 000 if the transport has no
     ``model`` attribute).  Pass ``max_tokens`` explicitly to override.
 
     Compaction fires from :meth:`add_context_tokens`, which the agent loop
-    calls immediately after ``IterationEnd`` — ``input_tokens`` there equals
+    calls immediately after ``IterationEnd`` - ``input_tokens`` there equals
     the real context size sent to the model in that iteration.
 
     Internally, :meth:`_do_compact` forks the inner store before calling

axio-0.9.0/src/axio/field.py

@@ -0,0 +1,179 @@
+"""Field metadata for tool handler functions - lightweight replacement for pydantic.Field."""
+
+from __future__ import annotations
+
+import types
+import typing
+from dataclasses import dataclass
+from typing import Annotated, Any, Final, Literal, get_args, get_origin
+
+# Types for which basic isinstance checks are applied in non-strict mode.
+PRIMITIVE_TYPES: frozenset[type] = frozenset({str, int, float, bool, list, dict})
+
+
+def unwrap_hint(hint: Any) -> tuple[Any, bool]:
+    """Strip ``Annotated`` and ``Optional`` wrappers.
+
+    Returns ``(inner_type, is_optional)`` where *inner_type* has no Annotated or
+    Union-with-None wrappers and *is_optional* is True when ``None`` was one of
+    the Union members.
+    """
+    inner = get_args(hint)[0] if get_origin(hint) is typing.Annotated else hint
+    origin = get_origin(inner)
+    if origin is types.UnionType or origin is typing.Union:
+        inner_args = get_args(inner)
+        non_none = [a for a in inner_args if a is not type(None)]
+        is_optional = len(non_none) < len(inner_args)
+        inner = non_none[0] if len(non_none) == 1 else inner
+        return inner, is_optional
+    return inner, False
+
+
+def check_scalar(value: Any, name: str, b: type, strict: bool) -> None:
+    """Raise TypeError when *value* does not satisfy the scalar type *b*."""
+    if strict:
+        if not isinstance(value, b):
+            raise TypeError(f"Field '{name}' requires {b.__name__}, got {type(value).__name__}")
+    elif b is float and isinstance(value, int):
+        pass  # int is a valid JSON "number"
+    elif b in PRIMITIVE_TYPES and value is not None and not isinstance(value, b):
+        raise TypeError(f"Field '{name}' requires {b.__name__}, got {type(value).__name__}")
+
+
+def check_list_items(value: list[Any], name: str, inner: Any) -> None:
+    """Raise TypeError when any list element violates the generic item type."""
+    item_args = get_args(inner)
+    if not item_args:
+        return
+    item_hint = item_args[0]
+    item_b = bare_type(item_hint)
+    if item_b not in PRIMITIVE_TYPES:
+        return
+    for idx, elem in enumerate(value):
+        try:
+            check_type(elem, name, item_hint, strict=False)
+        except (TypeError, ValueError):
+            raise TypeError(f"Field '{name}' element {idx} requires {item_b.__name__}, got {type(elem).__name__}")
+
+
+def check_type(value: Any, name: str, inner: Any, *, strict: bool) -> None:
+    """Dispatch type validation for *value* against *inner* (already unwrapped)."""
+    origin = get_origin(inner)
+    b = bare_type(inner)
+
+    # Multi-branch union (e.g. str | int): value must satisfy at least one branch.
+    # unwrap_hint already stripped Optional (| None), so non-None multi-unions land here.
+    if b is object and (origin is types.UnionType or origin is typing.Union):
+        branches = [br for br in get_args(inner) if br is not type(None)]
+        for branch in branches:
+            try:
+                check_type(value, name, branch, strict=strict)
+                return
+            except (TypeError, ValueError):
+                continue
+        branch_names = " | ".join(getattr(bare_type(br), "__name__", str(br)) for br in branches)
+        raise TypeError(f"Field '{name}' requires {branch_names}, got {type(value).__name__}")
+
+    # bool is an int subclass - reject it for non-bool hints before numeric dispatch.
+    if isinstance(value, bool) and b is not bool:
+        raise TypeError(f"Field '{name}' requires {b.__name__}, got bool")
+
+    if origin is Literal:
+        allowed = get_args(inner)
+        if value not in allowed:
+            raise ValueError(f"Field '{name}' must be one of {list(allowed)!r}, got {value!r}")
+        return
+
+    check_scalar(value, name, b, strict)
+
+    if origin is list and isinstance(value, list):
+        check_list_items(value, name, inner)
+
+
+class MissingSentinel:
+    """Singleton sentinel - distinguishes 'no default' from ``None``."""
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "MISSING"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+#: Sentinel value meaning "this field has no default and is required".
+MISSING: Final[MissingSentinel] = MissingSentinel()
+
+
+@dataclass(frozen=True)
+class FieldInfo:
+    """Metadata attached to a handler parameter via ``Annotated[T, FieldInfo(...)]``."""
+
+    description: str = ""
+    default: Any = MISSING
+    ge: int | float | None = None  # minimum (≥)
+    le: int | float | None = None  # maximum (≤)
+    strict: bool = False  # reject implicit type coercion
+
+    def validate(self, value: Any, name: str, hint: Any) -> None:
+        """Validate *value* against this FieldInfo's constraints, raising if invalid."""
+        inner, is_optional = unwrap_hint(hint)
+        if value is None and is_optional:
+            return
+        check_type(value, name, inner, strict=self.strict)
+        if self.ge is not None and value < self.ge:
+            raise ValueError(f"Field '{name}' must be >= {self.ge}")
+        if self.le is not None and value > self.le:
+            raise ValueError(f"Field '{name}' must be <= {self.le}")
+
+
+# noinspection PyPep8Naming
+def Field(
+    description: str = "",
+    default: Any = MISSING,
+    ge: int | float | None = None,
+    le: int | float | None = None,
+) -> FieldInfo:
+    """Annotate a handler parameter with metadata (description, default, constraints).
+
+    Usage::
+
+        async def search(
+            query: Annotated[str, Field(description="Search query")],
+            limit: Annotated[int, Field(default=10, ge=1, le=100)],
+        ) -> str: ...
+    """
+    return FieldInfo(description=description, default=default, ge=ge, le=le)
+
+
+#: Drop-in replacement for ``from pydantic import StrictStr``.
+#: Rejects non-string values (e.g. integers) without coercion.
+StrictStr = Annotated[str, FieldInfo(strict=True)]
+
+
+def is_classvar(annotation: Any) -> bool:
+    """Return True if *annotation* is ``ClassVar`` or ``ClassVar[X]``."""
+    return get_origin(annotation) is typing.ClassVar or annotation is typing.ClassVar
+
+
+def get_field_info(annotation: Any) -> FieldInfo | None:
+    """Extract a ``FieldInfo`` from an ``Annotated`` annotation, or return ``None``."""
+    if get_origin(annotation) is not typing.Annotated:
+        return None
+    return next((a for a in get_args(annotation)[1:] if isinstance(a, FieldInfo)), None)
+
+
+def bare_type(hint: Any) -> type:
+    """Return the base Python type, stripping ``Annotated``, ``Optional``, and generic wrappers."""
+    origin = get_origin(hint)
+    args = get_args(hint)
+    if origin is typing.Annotated:
+        return bare_type(args[0])
+    if origin is types.UnionType or origin is typing.Union:
+        non_none = [a for a in args if a is not type(None)]
+        return bare_type(non_none[0]) if len(non_none) == 1 else object
+    if origin is not None:
+        # Generic alias: list[int] → list, dict[str, Any] → dict, etc.
+        return origin if isinstance(origin, type) else object
+    return hint if isinstance(hint, type) else object