pattern-agentic-messaging 0.8.1__tar.gz

pattern_agentic_messaging-0.8.1/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:raw.githubusercontent.com)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

pattern_agentic_messaging-0.8.1/.gitignore

@@ -0,0 +1,3 @@
+*~
+**/#*
+__pycache__

pattern_agentic_messaging-0.8.1/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright © 2025 Pattern Agentic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+“Software”), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pattern_agentic_messaging-0.8.1/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: pattern_agentic_messaging
+Version: 0.8.1
+Summary: SLIM-powered messaging
+Author-email: Amos Joshua <amos@patternagentic.ai>
+License-File: LICENSE.md
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: slim-bindings<0.7.0,>=0.6.3
+Description-Content-Type: text/markdown
+
+# Pattern Agentic Messaging
+
+An async SLIM wrapper with a FastAPI-like interface
+
+## Installation
+
+```bash
+pip install pattern_agentic_messaging
+```
+
+## Usage
+
+
+### Server
+
+Route messages to decorated methods based on a _discriminator_ field
+like `type`:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/server/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret",
+    message_discriminator="type"
+)
+
+app = PASlimApp(config)
+agent = None
+
+@app.on_session_connect
+async def on_connect(session):
+    agent = await create_agent(...)
+    session.context = {
+        "agent": agent
+    }
+    
+# expects {"type": "prompt", "question": "...."}
+@app.on_message('prompt')
+async def handle_prompt(session, msg):
+    agent = session.context.get("agent")
+    response = await agent.ask(msg["question"])
+    await session.send({"type": "response", "answer": response})
+
+# expects {"type": "status"}
+@app.on_message('status')
+async def handle_status(session, msg):
+    await session.send({"type": "status", "value": "ready"})
+
+@app.on_message
+async def handle_other(session, msg):
+    await session.send({"error": f"Unknown message type: {msg.get('type')}"})
+
+app.run()
+```
+
+Use `PASlimConfigGroup` to create a group channel. 
+
+
+### Client
+
+Connect to a specific peer:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/client/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async with await app.connect("org/ns/server/instance1") as session:
+        await session.send({"type": "prompt", "prompt": "Hello world!"})
+        async for msg in session:
+            print(f"RECEIVED: {msg}")
+```
+
+
+Alternatively to join a group channel:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/participant/p1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async with await app.join_channel() as session:
+        async for msg in session:
+            print(f"Channel message: {msg}")
+            await session.send({"type": "response", "msg": "received"})
+```
+
+
+## Low-level usage
+
+The API behind the decorator pattern can be used directly:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/server/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async for session, msg in app:
+        if not isinstance(msg, dict) or "prompt" not in msg:
+            await session.send({"error": "Invalid format"})
+            continue
+
+        result = await process(msg["prompt"])
+        await session.send({"result": result})
+```
+

pattern_agentic_messaging-0.8.1/README.md

@@ -0,0 +1,123 @@
+# Pattern Agentic Messaging
+
+An async SLIM wrapper with a FastAPI-like interface
+
+## Installation
+
+```bash
+pip install pattern_agentic_messaging
+```
+
+## Usage
+
+
+### Server
+
+Route messages to decorated methods based on a _discriminator_ field
+like `type`:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/server/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret",
+    message_discriminator="type"
+)
+
+app = PASlimApp(config)
+agent = None
+
+@app.on_session_connect
+async def on_connect(session):
+    agent = await create_agent(...)
+    session.context = {
+        "agent": agent
+    }
+    
+# expects {"type": "prompt", "question": "...."}
+@app.on_message('prompt')
+async def handle_prompt(session, msg):
+    agent = session.context.get("agent")
+    response = await agent.ask(msg["question"])
+    await session.send({"type": "response", "answer": response})
+
+# expects {"type": "status"}
+@app.on_message('status')
+async def handle_status(session, msg):
+    await session.send({"type": "status", "value": "ready"})
+
+@app.on_message
+async def handle_other(session, msg):
+    await session.send({"error": f"Unknown message type: {msg.get('type')}"})
+
+app.run()
+```
+
+Use `PASlimConfigGroup` to create a group channel. 
+
+
+### Client
+
+Connect to a specific peer:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/client/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async with await app.connect("org/ns/server/instance1") as session:
+        await session.send({"type": "prompt", "prompt": "Hello world!"})
+        async for msg in session:
+            print(f"RECEIVED: {msg}")
+```
+
+
+Alternatively to join a group channel:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/participant/p1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async with await app.join_channel() as session:
+        async for msg in session:
+            print(f"Channel message: {msg}")
+            await session.send({"type": "response", "msg": "received"})
+```
+
+
+## Low-level usage
+
+The API behind the decorator pattern can be used directly:
+
+```python
+from pattern_agentic_messaging import PASlimApp, PASlimConfig
+
+config = PASlimConfig(
+    local_name="org/ns/server/instance1",
+    endpoint="https://slim.example.com",
+    auth_secret="shared-secret"
+)
+
+async with PASlimApp(config) as app:
+    async for session, msg in app:
+        if not isinstance(msg, dict) or "prompt" not in msg:
+            await session.send({"error": "Invalid format"})
+            continue
+
+        result = await process(msg["prompt"])
+        await session.send({"result": result})
+```
+

pattern_agentic_messaging-0.8.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pattern_agentic_messaging"
+version = "0.8.1"
+description = "SLIM-powered messaging"
+authors = [
+  { name="Amos Joshua", email="amos@patternagentic.ai" }
+]
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+  "slim-bindings>=0.6.3,<0.7.0"
+]
+
+[project.optional-dependencies]
+
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pattern_agentic_messaging"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.1",
+    "pytest-asyncio>=0.21.1",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/__init__.py

@@ -0,0 +1,29 @@
+from .config import PASlimConfig, PASlimP2PConfig, PASlimConfigGroup
+from .session import PASlimSession, PASlimP2PSession, PASlimGroupSession
+from .app import PASlimApp
+from .types import MessagePayload
+from .exceptions import (
+    PAMessagingError,
+    ConnectionError,
+    TimeoutError,
+    AuthenticationError,
+    SerializationError,
+    SessionClosedError
+)
+
+__all__ = [
+    "PASlimConfigBase",
+    "PASlimP2PConfig",
+    "PASlimGroupConfig",
+    "PASlimSession",
+    "PASlimP2PSession",
+    "PASlimGroupSession",
+    "PASlimApp",
+    "MessagePayload",
+    "PAMessagingError",
+    "ConnectionError",
+    "TimeoutError",
+    "AuthenticationError",
+    "SerializationError",
+    "SessionClosedError",
+]

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/app.py

@@ -0,0 +1,488 @@
+import asyncio
+import inspect
+import slim_bindings
+from typing import AsyncIterator, Optional, Literal, get_type_hints, get_origin, get_args
+from .config import PASlimConfig
+from .session import PASlimSession, PASlimP2PSession, PASlimGroupSession
+from .auth import create_shared_secret_auth
+from .types import MessagePayload
+from .exceptions import AuthenticationError
+
+try:
+    from pydantic import BaseModel, ValidationError
+    PYDANTIC_AVAILABLE = True
+except ImportError:
+    PYDANTIC_AVAILABLE = False
+    BaseModel = None
+    ValidationError = None
+
+
+def _extract_literal_value(model: type, field_name: str) -> Optional[str]:
+    """Extract Literal value from a Pydantic model field."""
+    try:
+        hints = get_type_hints(model)
+        field_type = hints.get(field_name)
+        if get_origin(field_type) is Literal:
+            args = get_args(field_type)
+            if args:
+                return args[0]
+    except Exception:
+        pass
+    return None
+
+
+def _get_pydantic_model_from_handler(func) -> Optional[type]:
+    """Extract Pydantic model type from handler's msg parameter, if present."""
+    if not PYDANTIC_AVAILABLE:
+        return None
+    try:
+        hints = get_type_hints(func)
+        msg_type = hints.get('msg')
+        if msg_type and isinstance(msg_type, type) and issubclass(msg_type, BaseModel):
+            return msg_type
+    except Exception:
+        pass
+    return None
+
+class PASlimApp:
+    def __init__(self, config: PASlimConfig):
+        self.config = config
+        self._app: Optional[slim_bindings.PyApp] = None
+        self._message_handlers = []
+        self._session_connect_handler = None
+        self._session_disconnect_handler = None
+        self._running = True
+
+    async def __aenter__(self):
+        if not self.config.auth_secret:
+            raise AuthenticationError("auth_secret is required")
+
+        auth_provider, auth_verifier = create_shared_secret_auth(
+            self.config.local_name,
+            self.config.auth_secret
+        )
+
+        parts = self.config.local_name.split('/')
+        if len(parts) == 3:
+            local_name = slim_bindings.PyName(*parts)
+        elif len(parts) == 4:
+            local_name = slim_bindings.PyName(parts[0], parts[1], parts[2])
+        else:
+            raise ValueError(f"local_name must be org/namespace/app or org/namespace/app/instance")
+
+        self._app = await slim_bindings.Slim.new(local_name, auth_provider, auth_verifier)
+
+        slim_config = {"endpoint": self.config.endpoint}
+        await self._app.connect(slim_config)
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def __aiter__(self):
+        return self.messages()
+
+    def on_message(self, discriminator=None, value=None):
+        """
+        Decorator to register a message handler with optional filtering.
+
+        Can be used as a direct decorator or with discriminator arguments.
+        Supports Pydantic model type hints for automatic parsing.
+
+        Examples:
+            # Catch-all handler (no filter)
+            @app.on_message
+            async def handler(session, msg):
+                await session.send(response)
+
+            # Filtered by value (requires message_discriminator in config)
+            @app.on_message('prompt')
+            async def handler(session, msg):
+                # Called when msg[config.message_discriminator] == 'prompt'
+                await session.send(response)
+
+            # Filtered by explicit field and value (legacy)
+            @app.on_message('type', 'prompt')
+            async def handler(session, msg):
+                # Only called when msg['type'] == 'prompt'
+                await session.send(response)
+
+            # Pydantic model handler (requires message_discriminator in config)
+            @app.on_message
+            async def handler(session, msg: PromptMessage):
+                # msg is automatically parsed as PromptMessage
+                await session.send(response)
+        """
+        def _register_handler(func, disc_field, disc_value):
+            model = _get_pydantic_model_from_handler(func)
+            model_disc_value = None
+
+            if model:
+                if not self.config.message_discriminator:
+                    raise ValueError(
+                        f"Handler '{func.__name__}' uses Pydantic type hint, "
+                        f"but config.message_discriminator is not set"
+                    )
+                model_disc_value = _extract_literal_value(
+                    model, self.config.message_discriminator
+                )
+
+            self._message_handlers.append({
+                'discriminator': disc_field,
+                'value': disc_value,
+                'handler': func,
+                'model': model,
+                'discriminator_value': model_disc_value,
+            })
+            return func
+
+        # Direct decoration: @app.on_message
+        if callable(discriminator):
+            func = discriminator
+            return _register_handler(func, None, None)
+
+        # Single argument: @app.on_message('prompt') - uses config.message_discriminator
+        if discriminator is not None and value is None:
+            if not self.config.message_discriminator:
+                raise ValueError(
+                    f"Single-argument @on_message('{discriminator}') requires "
+                    f"config.message_discriminator to be set"
+                )
+            return lambda func: _register_handler(func, self.config.message_discriminator, discriminator)
+
+        # Two arguments: @app.on_message('type', 'prompt')
+        return lambda func: _register_handler(func, discriminator, value)
+
+    def on_session_connect(self, func):
+        """
+        Decorator to register a session connect handler.
+
+        The handler will be called when a new session is established.
+
+        Example:
+            @app.on_session_connect
+            async def handler(session):
+                logger.info(f"Session {session.session_id} connected")
+        """
+        self._session_connect_handler = func
+        return func
+
+    def on_session_disconnect(self, func):
+        """
+        Decorator to register a session disconnect handler.
+
+        The handler will be called when a session ends.
+
+        Example:
+            @app.on_session_disconnect
+            async def handler(session):
+                logger.info(f"Session {session.session_id} disconnected")
+        """
+        self._session_disconnect_handler = func
+        return func
+
+    def stop(self):
+        """Stop the application gracefully."""
+        self._running = False
+
+    def run(self):
+        """
+        Run the application with automatic event loop and signal handling.
+
+        This is a synchronous method that sets up signal handlers,
+        creates an event loop, and runs the async message handling loop.
+
+        Example:
+            app = PASlimApp(config)
+
+            @app.on_message
+            async def handler(session, msg):
+                await session.send(response)
+
+            app.run()  # Blocks until stopped
+        """
+        import signal as sig
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        def signal_handler(signum, frame):
+            self.stop()
+
+        sig.signal(sig.SIGTERM, signal_handler)
+        sig.signal(sig.SIGINT, signal_handler)
+
+        try:
+            loop.run_until_complete(self._run_async())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            loop.close()
+
+    async def _run_async(self):
+        """Internal async runner for the decorator pattern."""
+        import logging
+
+        if not self._message_handlers:
+            raise ValueError("No message handlers registered. Use @app.on_message decorator.")
+
+        # Find catch-all handler (no discriminator and no model discriminator_value)
+        catch_all_info = None
+        for handler_info in self._message_handlers:
+            if handler_info['discriminator'] is None and handler_info.get('discriminator_value') is None:
+                catch_all_info = handler_info
+                break
+
+        logger = logging.getLogger(__name__)
+        disc_field = self.config.message_discriminator
+
+        async with self:
+            async for session, msg in self:
+                if not self._running:
+                    break
+
+                matched = False
+                for handler_info in self._message_handlers:
+                    disc = handler_info['discriminator']
+                    val = handler_info['value']
+                    handler = handler_info['handler']
+                    model = handler_info.get('model')
+                    model_disc_val = handler_info.get('discriminator_value')
+
+                    # Pydantic model handler
+                    if model and isinstance(msg, dict):
+                        # Check discriminator match (fast path)
+                        if model_disc_val is not None:
+                            if msg.get(disc_field) != model_disc_val:
+                                continue  # Fall through to next handler
+
+                        # Try to parse
+                        try:
+                            parsed = model.model_validate(msg)
+                            matched = True
+                            try:
+                                await handler(session, parsed)
+                            except Exception as exc:
+                                logger.error(f"Error in message handler: {exc}", exc_info=True)
+                            break
+                        except ValidationError as e:
+                            matched = True
+                            await session.send({
+                                "error": "validation_error",
+                                "details": e.errors()
+                            })
+                            break
+
+                    # Legacy dict-based handler (skip catch-all for now)
+                    elif disc is not None:
+                        if isinstance(msg, dict) and msg.get(disc) == val:
+                            matched = True
+                            try:
+                                await handler(session, msg)
+                            except Exception as exc:
+                                logger.error(f"Error in message handler: {exc}", exc_info=True)
+                            break
+
+                # Fall back to catch-all if no specific handler matched
+                if not matched and catch_all_info:
+                    handler = catch_all_info['handler']
+                    model = catch_all_info.get('model')
+                    try:
+                        if model and isinstance(msg, dict):
+                            parsed = model.model_validate(msg)
+                            await handler(session, parsed)
+                        else:
+                            await handler(session, msg)
+                    except ValidationError as e:
+                        await session.send({
+                            "error": "validation_error",
+                            "details": e.errors()
+                        })
+                    except Exception as exc:
+                        logger.error(f"Error in catch-all handler: {exc}", exc_info=True)
+                elif not matched:
+                    logger.warning(f"No handler for message: {msg}")
+
+    async def connect(self, peer_name: str) -> PASlimP2PSession:
+        """
+        Connect to a peer (P2P Active mode).
+
+        Args:
+            peer_name: Peer identifier (e.g., "org/namespace/app")
+
+        Returns:
+            PASlimP2PSession for communicating with the peer
+        """
+        parts = peer_name.split('/')
+        if len(parts) >= 3:
+            peer = slim_bindings.PyName(parts[0], parts[1], parts[2])
+        else:
+            raise ValueError(f"peer_name must be org/namespace/app or org/namespace/app/instance")
+
+        await self._app.set_route(peer)
+
+        session_config = slim_bindings.PySessionConfiguration.PointToPoint(
+            peer_name=peer,
+            max_retries=self.config.max_retries,
+            timeout=self.config.timeout,
+            mls_enabled=self.config.mls_enabled
+        )
+        slim_session = await self._app.create_session(session_config)
+        return PASlimP2PSession(slim_session)
+
+    async def accept(self) -> PASlimP2PSession:
+        """
+        Accept a single incoming P2P session (P2P Passive mode).
+
+        Returns:
+            PASlimP2PSession for the incoming connection
+        """
+        slim_session = await self._app.listen_for_session()
+        return PASlimP2PSession(slim_session)
+
+    async def create_channel(self, channel_name: str, invites: list[str] = None) -> PASlimGroupSession:
+        """
+        Create a group channel and invite participants (Group Moderator mode).
+
+        Args:
+            channel_name: Channel identifier (e.g., "org/namespace/channel")
+            invites: List of participant names to invite
+
+        Returns:
+            PASlimGroupSession for the channel
+        """
+        if invites is None:
+            invites = []
+
+        parts = channel_name.split('/')
+        if len(parts) >= 3:
+            channel = slim_bindings.PyName(parts[0], parts[1], parts[2])
+        else:
+            raise ValueError(f"channel_name must be org/namespace/channel")
+
+        session_config = slim_bindings.PySessionConfiguration.Group(
+            channel_name=channel,
+            max_retries=self.config.max_retries,
+            timeout=self.config.timeout,
+            mls_enabled=self.config.mls_enabled
+        )
+        slim_session = await self._app.create_session(session_config)
+        session = PASlimGroupSession(slim_session)
+
+        for invite in invites:
+            parts = invite.split('/')
+            if len(parts) >= 3:
+                participant = slim_bindings.PyName(parts[0], parts[1], parts[2])
+            else:
+                raise ValueError(f"invite name must be org/namespace/app")
+            await self._app.set_route(participant)
+            await session.invite(invite)
+
+        return session
+
+    async def join_channel(self) -> PASlimGroupSession:
+        """
+        Join a group channel by accepting an invite (Group Participant mode).
+
+        Returns:
+            PASlimGroupSession for the channel
+        """
+        slim_session = await self._app.listen_for_session()
+        return PASlimGroupSession(slim_session)
+
+    async def listen(self) -> AsyncIterator[PASlimP2PSession]:
+        """
+        Listen for incoming P2P sessions (P2P Passive mode).
+
+        Yields:
+            PASlimP2PSession for each incoming connection
+        """
+        while True:
+            slim_session = await self._app.listen_for_session()
+            yield PASlimP2PSession(slim_session)
+
+    async def messages(self) -> AsyncIterator[tuple[PASlimSession, MessagePayload]]:
+        """
+        Iterate over messages from all incoming sessions.
+
+        Yields (session, message) tuples from all active sessions.
+        Automatically manages session lifecycle - listens for new sessions,
+        starts their message loops, and multiplexes messages into a single stream.
+
+        Designed for servers handling multiple concurrent clients.
+
+        Example:
+            async with PASlimApp(config) as app:
+                async for session, msg in app:
+                    await session.send(response)
+        """
+        message_queue: asyncio.Queue = asyncio.Queue()
+        session_tasks: set[asyncio.Task] = set()
+        listener_task: Optional[asyncio.Task] = None
+
+        async def session_reader(session: PASlimSession):
+            """Read messages from a session and forward to queue."""
+            try:
+                # Call session connect handler if registered
+                if self._session_connect_handler:
+                    try:
+                        await self._session_connect_handler(session)
+                    except Exception:
+                        pass  # Don't let handler errors prevent session
+
+                async with session:
+                    async for msg in session:
+                        await message_queue.put((session, msg))
+            except Exception:
+                pass  # Session ended or errored - normal behavior
+            finally:
+                # Call session disconnect handler if registered
+                if self._session_disconnect_handler:
+                    try:
+                        await self._session_disconnect_handler(session)
+                    except Exception:
+                        pass  # Don't let handler errors prevent cleanup
+
+        async def session_listener():
+            """Listen for new sessions and spawn reader tasks."""
+            async for session in self.listen():
+                task = asyncio.create_task(session_reader(session))
+                session_tasks.add(task)
+                task.add_done_callback(session_tasks.discard)
+
+        try:
+            listener_task = asyncio.create_task(session_listener())
+
+            while True:
+                # Check if listener crashed
+                if listener_task.done():
+                    exc = listener_task.exception()
+                    if exc:
+                        raise exc
+                    break  # Listener ended (shouldn't happen)
+
+                # Get next message with timeout to periodically check listener health
+                try:
+                    session, msg = await asyncio.wait_for(
+                        message_queue.get(),
+                        timeout=0.1
+                    )
+                    yield (session, msg)
+                except asyncio.TimeoutError:
+                    continue  # No message yet, loop back
+
+        finally:
+            # Cleanup: cancel all tasks
+            if listener_task and not listener_task.done():
+                listener_task.cancel()
+                try:
+                    await listener_task
+                except asyncio.CancelledError:
+                    pass
+
+            for task in list(session_tasks):
+                task.cancel()
+
+            if session_tasks:
+                await asyncio.gather(*session_tasks, return_exceptions=True)

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/auth.py

@@ -0,0 +1,23 @@
+import slim_bindings
+from typing import Tuple
+
+def create_shared_secret_auth(identity: str, secret: str) -> Tuple[slim_bindings.PyIdentityProvider, slim_bindings.PyIdentityVerifier]:
+    provider = slim_bindings.PyIdentityProvider.SharedSecret(
+        identity=identity,
+        shared_secret=secret
+    )
+    verifier = slim_bindings.PyIdentityVerifier.SharedSecret(
+        identity=identity,
+        shared_secret=secret
+    )
+    return provider, verifier
+
+def create_jwt_auth(jwt_path: str, iss: str, sub: str, aud: str, public_key: slim_bindings.PyKey) -> Tuple[slim_bindings.PyIdentityProvider, slim_bindings.PyIdentityVerifier]:
+    provider = slim_bindings.PyIdentityProvider.StaticJwt(path=jwt_path)
+    verifier = slim_bindings.PyIdentityVerifier.Jwt(
+        public_key=public_key,
+        issuer=iss,
+        audience=[aud],
+        subject=sub
+    )
+    return provider, verifier

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/config.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Optional
+
+
+@dataclass
+class PASlimConfig:
+    local_name: str
+    endpoint: str
+    auth_secret: Optional[str] = None
+    max_retries: int = 5
+    timeout: timedelta = field(default_factory=lambda: timedelta(seconds=5))
+    mls_enabled: bool = True
+    message_discriminator: Optional[str] = None
+
+
+@dataclass
+class PASlimConfigP2P(PASlimConfig):
+    peer_name: Optional[str] = None
+
+
+@dataclass
+class PASlimConfigGroup(PASlimConfig):
+    channel_name: Optional[str] = None
+    invites: list[str] = field(default_factory=list)

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/exceptions.py

@@ -0,0 +1,17 @@
+class PAMessagingError(Exception):
+    pass
+
+class ConnectionError(PAMessagingError):
+    pass
+
+class TimeoutError(PAMessagingError):
+    pass
+
+class AuthenticationError(PAMessagingError):
+    pass
+
+class SerializationError(PAMessagingError):
+    pass
+
+class SessionClosedError(PAMessagingError):
+    pass

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/messages.py

@@ -0,0 +1,28 @@
+import json
+from typing import Union
+from .types import MessagePayload
+from .exceptions import SerializationError
+
+def encode_message(payload: MessagePayload) -> bytes:
+    if isinstance(payload, bytes):
+        return payload
+    if isinstance(payload, str):
+        return payload.encode('utf-8')
+    if isinstance(payload, dict):
+        try:
+            return json.dumps(payload).encode('utf-8')
+        except (TypeError, ValueError) as e:
+            raise SerializationError(f"Failed to encode dict: {e}")
+    raise SerializationError(f"Unsupported payload type: {type(payload)}")
+
+def decode_message(data: bytes) -> Union[dict, str, bytes]:
+    try:
+        text = data.decode('utf-8', errors='strict')
+        if '\x00' in text:
+            return data
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            return text
+    except UnicodeDecodeError:
+        return data

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/session.py

@@ -0,0 +1,130 @@
+import asyncio
+import uuid
+from typing import Optional, Callable, Any, Dict
+from datetime import timedelta
+from .types import MessagePayload
+from .messages import encode_message, decode_message
+from .exceptions import SessionClosedError, TimeoutError as PATimeoutError
+
+class PASlimSession:
+    def __init__(self, slim_session):
+        self._session = slim_session
+        self._session_id = str(uuid.uuid4())
+        self.context: Dict[str, Any] = {}
+        self._queue: asyncio.Queue = asyncio.Queue()
+        self._read_task: Optional[asyncio.Task] = None
+        self._callbacks: list[Callable] = []
+        self._pending_requests: dict[str, asyncio.Future] = {}
+        self._closed = False
+
+    @property
+    def session_id(self) -> str:
+        """Unique identifier for this session instance."""
+        return self._session_id
+
+    async def _read_loop(self):
+        while not self._closed:
+            try:
+                msg_ctx, payload = await self._session.get_message()
+                decoded = decode_message(payload)
+
+                if isinstance(decoded, dict) and "_request_id" in decoded:
+                    request_id = decoded["_request_id"]
+                    if request_id in self._pending_requests:
+                        self._pending_requests[request_id].set_result(decoded)
+                        continue
+
+                for callback in self._callbacks:
+                    try:
+                        if asyncio.iscoroutinefunction(callback):
+                            await callback(decoded)
+                        else:
+                            callback(decoded)
+                    except Exception:
+                        pass
+
+                await self._queue.put((msg_ctx, decoded))
+            except Exception:
+                if not self._closed:
+                    break
+
+    async def __aenter__(self):
+        self._read_task = asyncio.create_task(self._read_loop())
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self._closed = True
+        if self._read_task:
+            self._read_task.cancel()
+            try:
+                await self._read_task
+            except asyncio.CancelledError:
+                pass
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if self._closed:
+            raise StopAsyncIteration
+        try:
+            _, msg = await self._queue.get()
+            return msg
+        except asyncio.CancelledError:
+            raise StopAsyncIteration
+
+    async def send(self, payload: MessagePayload):
+        if self._closed:
+            raise SessionClosedError("Session is closed")
+        data = encode_message(payload)
+        await self._session.publish(data)
+
+    def on_message(self, callback: Callable[[Any], None]):
+        self._callbacks.append(callback)
+
+    async def request(self, payload: MessagePayload, timeout: Optional[float] = None) -> Any:
+        if self._closed:
+            raise SessionClosedError("Session is closed")
+
+        request_id = str(uuid.uuid4())
+        future = asyncio.Future()
+        self._pending_requests[request_id] = future
+
+        if isinstance(payload, dict):
+            payload["_request_id"] = request_id
+        else:
+            payload = {"_request_id": request_id, "data": payload}
+
+        await self.send(payload)
+
+        try:
+            if timeout:
+                return await asyncio.wait_for(future, timeout=timeout)
+            else:
+                return await future
+        except asyncio.TimeoutError:
+            raise PATimeoutError(f"Request timed out after {timeout}s")
+        finally:
+            self._pending_requests.pop(request_id, None)
+
+class PASlimP2PSession(PASlimSession):
+    pass
+
+class PASlimGroupSession(PASlimSession):
+    async def invite(self, participant_name: str):
+        import slim_bindings
+        parts = participant_name.split('/')
+        if len(parts) >= 3:
+            name = slim_bindings.PyName(parts[0], parts[1], parts[2])
+        else:
+            raise ValueError(f"participant_name must be org/namespace/app")
+        await self._session.invite(name)
+
+    async def remove(self, participant_name: str):
+        import slim_bindings
+        parts = participant_name.split('/')
+        if len(parts) >= 3:
+            name = slim_bindings.PyName(parts[0], parts[1], parts[2])
+        else:
+            raise ValueError(f"participant_name must be org/namespace/app")
+        await self._session.remove(name)

pattern_agentic_messaging-0.8.1/src/pattern_agentic_messaging/types.py

@@ -0,0 +1,3 @@
+from typing import Union
+
+MessagePayload = Union[bytes, str, dict]

pattern_agentic_messaging-0.8.1/tests/test_config.py

@@ -0,0 +1,23 @@
+from datetime import timedelta
+from pattern_agentic_messaging import PASlimConfigP2P, PASlimConfigGroup, SessionMode, GroupMode
+
+def test_p2p_config_defaults():
+    config = PASlimConfigP2P(
+        local_name="org/ns/app/inst",
+        endpoint="https://example.com",
+        auth_secret="secret123"
+    )
+    assert config.max_retries == 5
+    assert config.timeout == timedelta(seconds=5)
+    assert config.mls_enabled is True
+    assert config.mode == SessionMode.ACTIVE
+
+def test_group_config_defaults():
+    config = PASlimConfigGroup(
+        local_name="org/ns/app/inst",
+        endpoint="https://example.com",
+        auth_secret="secret123",
+        channel_name="org/ns/channel"
+    )
+    assert config.mode == GroupMode.MODERATOR
+    assert config.invites == []

pattern_agentic_messaging-0.8.1/tests/test_messages.py

@@ -0,0 +1,33 @@
+import pytest
+from pattern_agentic_messaging.messages import encode_message, decode_message
+from pattern_agentic_messaging.exceptions import SerializationError
+
+def test_encode_bytes():
+    data = b"raw bytes"
+    assert encode_message(data) == data
+
+def test_encode_str():
+    assert encode_message("hello") == b"hello"
+
+def test_encode_dict():
+    result = encode_message({"type": "ping"})
+    assert result == b'{"type": "ping"}'
+
+def test_encode_invalid():
+    with pytest.raises(SerializationError):
+        encode_message(123)
+
+def test_decode_json():
+    data = b'{"type": "pong"}'
+    result = decode_message(data)
+    assert result == {"type": "pong"}
+
+def test_decode_string():
+    data = b"plain text"
+    result = decode_message(data)
+    assert result == "plain text"
+
+def test_decode_binary():
+    data = b"\x00\x01\x02"
+    result = decode_message(data)
+    assert result == data

pattern_agentic_messaging-0.8.1/uv.lock

@@ -0,0 +1,132 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pattern-agentic-messaging"
+version = "0.8.0"
+source = { editable = "." }
+dependencies = [
+    { name = "slim-bindings" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "slim-bindings", specifier = ">=0.6.3" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=9.0.1" },
+    { name = "pytest-asyncio", specifier = ">=0.21.1" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125, upload-time = "2025-11-12T13:05:09.333Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668, upload-time = "2025-11-12T13:05:07.379Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "slim-bindings"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/09/0b33770d5389000151c032d96b61c6957ad90331179ad02601c57e8686c8/slim_bindings-0.6.3.tar.gz", hash = "sha256:bd9e272640527c7ef51e90e69c4268cd5712fa65b2fe1d9deb4f7de29122916e", size = 394752, upload-time = "2025-10-31T16:16:32.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/ed/9ace6f64460dd8d381b4ff7ce58fc063853c6a7571d598f26db70b901585/slim_bindings-0.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:01d04a307c8befdd6667262f74c85e1f8e69c36187f5772ed6822718d3b6a647", size = 8242169, upload-time = "2025-10-31T16:15:45.396Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cb/52bee40860d13dcc158b8e98c099768276383b94450404948459d49a36ee/slim_bindings-0.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cbd3d21bb140ce6837a99145ab4c4336efed658e624bec8710471c237ed082dd", size = 7912501, upload-time = "2025-10-31T16:15:47.598Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/23/8dfa1489fef922ded4d9855ecb8caca7f1e17041a690055b3bab15b8cb09/slim_bindings-0.6.3-cp311-cp311-manylinux_2_34_aarch64.whl", hash = "sha256:89e026a28a84318dc3cb1e7526d81915ad069e9d89a35e462d9e466b92170008", size = 8744989, upload-time = "2025-10-31T16:15:49.686Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cf/5d5a27c10b0a4c04e05fa5a6a19f4cf663a3b4e90fc506e078b1358977a1/slim_bindings-0.6.3-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:50c0d8427f99a558b0ff980f19a17390876076119f12c91d3e23cd0e4bca7c55", size = 8882953, upload-time = "2025-10-31T16:15:51.524Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/43/517f2144a9fc5d248571d14ff81f93f3a9a15de2362058c5471c77bca41a/slim_bindings-0.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:72281ef20250d3ba85af547888f5c1f9831a422a5ede1bb7c878d3b2b537d2fd", size = 7292432, upload-time = "2025-10-31T16:15:53.787Z" },
+    { url = "https://files.pythonhosted.org/packages/05/62/74ca0c91c3379bc8e072ffec8ee012105f3e47bc5c84549cac346c83760b/slim_bindings-0.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a8af60585e2488434a50a8dfc46a0f7e32a858925cd6eb25329248b6d3c02fe5", size = 8237044, upload-time = "2025-10-31T16:16:01.952Z" },
+    { url = "https://files.pythonhosted.org/packages/20/64/b9264200cd5bfbaa5077953fc406232fd8bc9e26aa3bc8bf5dd96de6e6fa/slim_bindings-0.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d7eaeb154294744ae0c087d1bda235f6794bb351108448a38bf5ffe18d5f8fd0", size = 7905819, upload-time = "2025-10-31T16:16:04.911Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/6b/e701bc4a44e9ba5292557baee205d453890ab989225c9842b05b3440ddf8/slim_bindings-0.6.3-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:dac66eb1d6e619d8dba7d8ea75781883457a40cc85159eaac4401d044c9934d2", size = 8756849, upload-time = "2025-10-31T16:16:07.403Z" },
+    { url = "https://files.pythonhosted.org/packages/05/2a/6197e2cfb9c2ff55ade9ef1a545cb006171296e474ccfc52e909cf8055ca/slim_bindings-0.6.3-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:bd7ee891a08da0dd1c96c8fa825ae60eab99356c052870cbd490f52bef0147ac", size = 8891589, upload-time = "2025-10-31T16:16:09.139Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/32/e1dbb223a7ed65c6e28fe714f888dff725a16a42eecdde993999d281665a/slim_bindings-0.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:1e3cde1d33db1e3bace6c5b80d79f3031f9a8cce0896495873a481b80372882c", size = 7302666, upload-time = "2025-10-31T16:16:10.812Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f5/69737a3d263396a18eb84a70483f924f3356be3f81b6660710e84e2ae04d/slim_bindings-0.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e24a2ff9ef307790ec114f4bfa158c49dfe0c988ec70c1fe315b4733c672cf69", size = 8237490, upload-time = "2025-10-31T16:16:12.433Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ff/cab83e16d0595c6ff3a0bbc3e42eaf69a328b183dc5197a150c599c25468/slim_bindings-0.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b55894c30ea608d44eaa5f008ccd016428e2fbdf3b161b073889cd9dbc9c12d5", size = 7906161, upload-time = "2025-10-31T16:16:14.002Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/16/2cbdedab433e9349ef58263db5843e864554de4d203b993ebe1930d7ce44/slim_bindings-0.6.3-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:d73069dfdbff0ac0e651ba9b5b76cb6932e633d652467bec66e8e22ec79a7228", size = 8756685, upload-time = "2025-10-31T16:16:15.72Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ef/bc746c42162f8611309dab09c11f3d5d063a2f664c27826c8775e6503d5a/slim_bindings-0.6.3-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:27c6bd7b18128eb449d01c92ac0f2c5c28dde83c8173c6cb55950fe921834790", size = 8891357, upload-time = "2025-10-31T16:16:17.517Z" },
+    { url = "https://files.pythonhosted.org/packages/62/4c/3d2a141c56440b5c065106cf6a57f44f22ed8543dba35d06c766c8ff01a2/slim_bindings-0.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:0e928d4cac235f942794ebace44245de4384c3fe9fc74f4889846964707ebc90", size = 7302378, upload-time = "2025-10-31T16:16:20.009Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]