pybotchi 3.4.3__tar.gz → 3.5.0__tar.gz

{pybotchi-3.4.3 → pybotchi-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybotchi
-Version: 3.4.3
+Version: 3.5.0
 Summary: A deterministic, intent-based AI agent builder.
 License-File: LICENSE
 Author: Alexie (Boyong) Madolid
@@ -15,8 +15,8 @@ Provides-Extra: mcp
 Requires-Dist: aiofiles (>=25.1.0) ; extra == "grpc"
 Requires-Dist: click (>=8.3.1) ; extra == "grpc"
 Requires-Dist: datamodel-code-generator[ruff] (>=0.31.2) ; extra == "mcp" or extra == "grpc"
-Requires-Dist: grpcio (>=1.76.0) ; extra == "grpc"
-Requires-Dist: grpcio-tools (>=1.76.0) ; extra == "grpc"
+Requires-Dist: grpcio (>=1.80.0) ; extra == "grpc"
+Requires-Dist: grpcio-tools (>=1.80.0) ; extra == "grpc"
 Requires-Dist: langchain-core (>=0.3.15)
 Requires-Dist: mcp (>=1.15.0) ; extra == "mcp"
 Requires-Dist: orjson (>=3.9.11)

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/action.py

@@ -26,8 +26,8 @@ if TYPE_CHECKING:
     from .context import Context
 
 
-DEFAULT_ACTION = getenv("DEFAULT_ACTION", "DefaultAction")
-DEFAULT_TOOL_CALL_PROMPT = getenv(
+DEFAULT_ACTION: str = getenv("DEFAULT_ACTION", "DefaultAction")
+DEFAULT_TOOL_CALL_PROMPT: str = getenv(
     "DEFAULT_TOOL_CALL_PROMPT",
     """
 You are an AI assistant expert in function calling.
@@ -47,7 +47,7 @@ ${system}
 ${addons}
 """.strip(),
 )
-DEFAULT_MAX_ITERATION_PROMPT = getenv(
+DEFAULT_MAX_ITERATION_PROMPT: str = getenv(
     "DEFAULT_MAX_ITERATION_PROMPT",
     """
 You are an AI assistant responsible for delivering the final response to the user.

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/common.py

@@ -182,7 +182,7 @@ class ConcurrentBreakPoint(Exception):  # noqa: N818
 
     def __init__(self, action_return: ActionReturn) -> None:
         """Initialize ConcurrentBreakPoint Exception."""
-        self.action_return = action_return
+        self.action_return: ActionReturn = action_return
         super().__init__(action_return)
 
 

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/action.py

@@ -1,14 +1,14 @@
 """Pybotchi GRPC Classes."""
 
 from asyncio import Queue
-from collections.abc import AsyncGenerator, Awaitable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable
 from contextlib import AsyncExitStack, asynccontextmanager
 from inspect import getmembers
 from itertools import islice
 from typing import Any, Generic
 
 from datamodel_code_generator import DataModelType, Formatter, PythonVersion
-from datamodel_code_generator.model import get_data_model_types
+from datamodel_code_generator.model import DataModelSet, get_data_model_types
 from datamodel_code_generator.parser.jsonschema import (
     JsonSchemaParser,
 )
@@ -36,7 +36,7 @@ from ..action import Action, ChildActions
 from ..common import ActionReturn, Graph
 from ..utils import unwrap_exceptions
 
-DMT = get_data_model_types(
+DMT: DataModelSet = get_data_model_types(
     DataModelType.PydanticV2BaseModel,
     target_python_version=PythonVersion.PY_313,
 )
@@ -56,13 +56,13 @@ class GRPCClient:
         exclude_unset: bool,
     ) -> None:
         """Build GRPC Client."""
-        self.stub = stub
-        self.name = name
-        self.config = config
-        self.manual_enable = manual_enable
-        self.allowed_actions = allowed_actions
-        self.remote_action_class = remote_action_class or GRPCRemoteAction
-        self.exclude_unset = exclude_unset
+        self.stub: PyBotchiGRPCStub = stub
+        self.name: str = name
+        self.config: GRPCConfigLoaded = config
+        self.manual_enable: bool = manual_enable
+        self.allowed_actions: dict[str, bool] = allowed_actions
+        self.remote_action_class: type["GRPCRemoteAction"] = remote_action_class or GRPCRemoteAction
+        self.exclude_unset: bool = exclude_unset
 
     def build_action(self, agent_id: str, action_schema: ActionSchema) -> tuple[str, type["GRPCRemoteAction"]]:
         """Build GRPCToolAction."""
@@ -143,7 +143,7 @@ class GRPCClient:
         return actions
 
 
-class GRPCAction(Action[TContext], Generic[TContext]):
+class GRPCAction(Action[TContext]):
     """GRPC Action."""
 
     __grpc_clients__: dict[str, GRPCClient]
@@ -178,7 +178,7 @@ class GRPCAction(Action[TContext], Generic[TContext]):
 
     async def execute(self, context: TContext, parent: Action | None = None, append: bool = True) -> ActionReturn:
         """Execute main process."""
-        self._parent = parent
+        self._parent: Action | None = parent
         parent_context = context
         try:
             if parent and append:
@@ -441,7 +441,7 @@ async def multi_grpc_clients(
     integrations: dict[str, GRPCIntegration],
     connections: list[GRPCConnection],
     bypass: bool = False,
-) -> AsyncGenerator[dict[str, GRPCClient], None]:
+) -> AsyncIterator[dict[str, GRPCClient]]:
     """Connect to multiple grpc clients."""
     async with AsyncExitStack() as stack:
         clients: dict[str, GRPCClient] = {}

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/cli.py

@@ -234,7 +234,7 @@ def compile() -> None:
             f"--python_out={current_dir}",
             f"--pyi_out={current_dir}",
             f"--grpc_python_out={current_dir}",
-            "pybotchi.proto",  # must be relative to --proto_path
+            "pybotchi.proto",
         ]
     )
 

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/common.py

@@ -81,23 +81,23 @@ class GRPCConnection:
         require_integration: bool = True,
     ) -> None:
         """Build GRPC Connection."""
-        self.name = name
-        self.url = url
-        self.groups = [] if groups is None else groups
-        self.secure = secure
-        self.root_certificates = root_certificates
-        self.private_key = private_key
-        self.certificate_chain = certificate_chain
-        self.options = options
-        self.compression = compression
-        self.interceptors = interceptors
-        self.metadata = metadata
-        self.allow_exec = allow_exec
-        self.manual_enable = manual_enable
-        self.allowed_actions = {} if allowed_actions is None else allowed_actions
-        self.remote_action_class = remote_action_class
-        self.exclude_unset = exclude_unset
-        self.require_integration = require_integration
+        self.name: str = name
+        self.url: str = url
+        self.groups: list[str] = [] if groups is None else groups
+        self.secure: bool = secure
+        self.root_certificates: str | bytes | None = root_certificates
+        self.private_key: str | bytes | None = private_key
+        self.certificate_chain: str | bytes | None = certificate_chain
+        self.options: list[tuple[str, Any]] | None = options
+        self.compression: GRPCCompression | None = compression
+        self.interceptors: Sequence[ClientInterceptor] | None = interceptors
+        self.metadata: dict[str, Any] | None = metadata
+        self.allow_exec: bool = allow_exec
+        self.manual_enable: bool = manual_enable
+        self.allowed_actions: dict[str, bool] = {} if allowed_actions is None else allowed_actions
+        self.remote_action_class: type["GRPCRemoteAction"] | None = remote_action_class
+        self.exclude_unset: bool = exclude_unset
+        self.require_integration: bool = require_integration
 
     async def get_config(self, override: GRPCConfig | None) -> GRPCConfigLoaded:
         """Generate config."""

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/exception.py

@@ -6,11 +6,11 @@ class GRPCRemoteError(Exception):
 
     def __init__(self, cls: str, alias: str, type: str, message: str, tracebacks: list[str]) -> None:
         """Initialize Error."""
-        self.cls = cls
-        self.alias = alias
-        self.type = type
-        self.message = message
-        self.tracebacks = tracebacks
+        self.cls: str = cls
+        self.alias: str = alias
+        self.type: str = type
+        self.message: str = message
+        self.tracebacks: list[str] = tracebacks
 
         super().__init__(cls, alias, type, message, tracebacks)
 

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/handler.py

@@ -1,7 +1,7 @@
 """PyBotchi GRPC Handler."""
 
 from asyncio import Queue, create_task
-from collections.abc import AsyncGenerator, Awaitable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable
 from itertools import islice
 from sys import exc_info
 from traceback import format_exception
@@ -39,16 +39,16 @@ class PyBotchiGRPC(PyBotchiGRPCServicer, Generic[TContext]):
 
     def __init__(self, id: str, module: str, groups: dict[str, dict[str, type[Action]]]) -> None:
         """Initialize Handler."""
-        self.id = id
-        self.module = module
-        self.groups = groups
-        self.__has_validate_metadata__ = self.__class__.validate_metadata is not PyBotchiGRPC.validate_metadata
+        self.id: str = id
+        self.module: str = module
+        self.groups: dict[str, dict[str, type[Action]]] = groups
+        self.__has_validate_metadata__: bool = self.__class__.validate_metadata is not PyBotchiGRPC.validate_metadata
 
     async def validate_metadata(self, metadata: Metadata | None) -> None:
         """Validate invocation metadata."""
         pass
 
-    async def consume(self, context: TContext, groups: list[str], events: AsyncGenerator[Event, None]) -> None:
+    async def consume(self, context: TContext, groups: list[str], events: AsyncIterator[Event]) -> None:
         """Consume event."""
         try:
             async for event in events:
@@ -133,7 +133,7 @@ class PyBotchiGRPC(PyBotchiGRPCServicer, Generic[TContext]):
                 if isinstance(ret, Awaitable):
                     await ret
 
-    async def accept(self, events: AsyncGenerator[Event, None], context: ServicerContext) -> Queue[Event]:
+    async def accept(self, events: AsyncIterator[Event], context: ServicerContext) -> Queue[Event]:
         """Accept connect execution."""
         event = await anext(events)
         if event.name != "init" or not event.data:
@@ -156,7 +156,7 @@ class PyBotchiGRPC(PyBotchiGRPCServicer, Generic[TContext]):
     ##############################################################################################
 
     async def execute_connect(
-        self, request_iterator: AsyncGenerator[Event, None], context: ServicerContext
+        self, request_iterator: AsyncIterator[Event], context: ServicerContext
     ) -> AsyncGenerator[Event, None]:
         """Execute `connect` method."""
         queue = await self.accept(request_iterator, context)
@@ -172,7 +172,7 @@ class PyBotchiGRPC(PyBotchiGRPCServicer, Generic[TContext]):
     ##############################################################################################
 
     async def connect(
-        self, request_iterator: AsyncGenerator[Event, None], context: ServicerContext
+        self, request_iterator: AsyncIterator[Event], context: ServicerContext
     ) -> AsyncGenerator[Event, None]:
         """Consume `connect` method."""
         if self.__has_validate_metadata__ and self.validate_metadata(context.invocation_metadata()):

pybotchi-3.5.0/pybotchi/grpc/pybotchi_pb2.pyi

@@ -0,0 +1,165 @@
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Event(_message.Message):
+    __slots__ = ("name", "data")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    data: _struct_pb2.Struct
+    def __init__(self, name: _Optional[str] = ..., data: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class ActionListRequest(_message.Message):
+    __slots__ = ("groups", "allowed_actions")
+    class AllowedActionsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bool
+        def __init__(self, key: _Optional[str] = ..., value: bool = ...) -> None: ...
+    GROUPS_FIELD_NUMBER: _ClassVar[int]
+    ALLOWED_ACTIONS_FIELD_NUMBER: _ClassVar[int]
+    groups: _containers.RepeatedScalarFieldContainer[str]
+    allowed_actions: _containers.ScalarMap[str, bool]
+    def __init__(self, groups: _Optional[_Iterable[str]] = ..., allowed_actions: _Optional[_Mapping[str, bool]] = ...) -> None: ...
+
+class ActionListResponse(_message.Message):
+    __slots__ = ("agent_id", "actions")
+    AGENT_ID_FIELD_NUMBER: _ClassVar[int]
+    ACTIONS_FIELD_NUMBER: _ClassVar[int]
+    agent_id: str
+    actions: _containers.RepeatedCompositeFieldContainer[ActionSchema]
+    def __init__(self, agent_id: _Optional[str] = ..., actions: _Optional[_Iterable[_Union[ActionSchema, _Mapping]]] = ...) -> None: ...
+
+class ActionSchema(_message.Message):
+    __slots__ = ("concurrent", "group", "schema")
+    CONCURRENT_FIELD_NUMBER: _ClassVar[int]
+    GROUP_FIELD_NUMBER: _ClassVar[int]
+    SCHEMA_FIELD_NUMBER: _ClassVar[int]
+    concurrent: bool
+    group: str
+    schema: JSONSchema
+    def __init__(self, concurrent: bool = ..., group: _Optional[str] = ..., schema: _Optional[_Union[JSONSchema, _Mapping]] = ...) -> None: ...
+
+class JSONSchema(_message.Message):
+    __slots__ = ("schema", "id", "title", "description", "type", "properties", "required", "additional_properties", "items", "min_items", "max_items", "min_length", "max_length", "pattern", "format", "minimum", "maximum", "multiple_of", "enum", "default_value", "definitions", "ref", "all_of", "any_of", "one_of")
+    class PropertiesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: JSONSchema
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[JSONSchema, _Mapping]] = ...) -> None: ...
+    class DefinitionsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: JSONSchema
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[JSONSchema, _Mapping]] = ...) -> None: ...
+    SCHEMA_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    TITLE_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    PROPERTIES_FIELD_NUMBER: _ClassVar[int]
+    REQUIRED_FIELD_NUMBER: _ClassVar[int]
+    ADDITIONAL_PROPERTIES_FIELD_NUMBER: _ClassVar[int]
+    ITEMS_FIELD_NUMBER: _ClassVar[int]
+    MIN_ITEMS_FIELD_NUMBER: _ClassVar[int]
+    MAX_ITEMS_FIELD_NUMBER: _ClassVar[int]
+    MIN_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    MAX_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    PATTERN_FIELD_NUMBER: _ClassVar[int]
+    FORMAT_FIELD_NUMBER: _ClassVar[int]
+    MINIMUM_FIELD_NUMBER: _ClassVar[int]
+    MAXIMUM_FIELD_NUMBER: _ClassVar[int]
+    MULTIPLE_OF_FIELD_NUMBER: _ClassVar[int]
+    ENUM_FIELD_NUMBER: _ClassVar[int]
+    DEFAULT_VALUE_FIELD_NUMBER: _ClassVar[int]
+    DEFINITIONS_FIELD_NUMBER: _ClassVar[int]
+    REF_FIELD_NUMBER: _ClassVar[int]
+    ALL_OF_FIELD_NUMBER: _ClassVar[int]
+    ANY_OF_FIELD_NUMBER: _ClassVar[int]
+    ONE_OF_FIELD_NUMBER: _ClassVar[int]
+    NOT_FIELD_NUMBER: _ClassVar[int]
+    schema: str
+    id: str
+    title: str
+    description: str
+    type: str
+    properties: _containers.MessageMap[str, JSONSchema]
+    required: _containers.RepeatedScalarFieldContainer[str]
+    additional_properties: bool
+    items: JSONSchema
+    min_items: int
+    max_items: int
+    min_length: int
+    max_length: int
+    pattern: str
+    format: str
+    minimum: float
+    maximum: float
+    multiple_of: float
+    enum: _containers.RepeatedScalarFieldContainer[str]
+    default_value: str
+    definitions: _containers.MessageMap[str, JSONSchema]
+    ref: str
+    all_of: _containers.RepeatedCompositeFieldContainer[JSONSchema]
+    any_of: _containers.RepeatedCompositeFieldContainer[JSONSchema]
+    one_of: _containers.RepeatedCompositeFieldContainer[JSONSchema]
+    def __init__(self, schema: _Optional[str] = ..., id: _Optional[str] = ..., title: _Optional[str] = ..., description: _Optional[str] = ..., type: _Optional[str] = ..., properties: _Optional[_Mapping[str, JSONSchema]] = ..., required: _Optional[_Iterable[str]] = ..., additional_properties: bool = ..., items: _Optional[_Union[JSONSchema, _Mapping]] = ..., min_items: _Optional[int] = ..., max_items: _Optional[int] = ..., min_length: _Optional[int] = ..., max_length: _Optional[int] = ..., pattern: _Optional[str] = ..., format: _Optional[str] = ..., minimum: _Optional[float] = ..., maximum: _Optional[float] = ..., multiple_of: _Optional[float] = ..., enum: _Optional[_Iterable[str]] = ..., default_value: _Optional[str] = ..., definitions: _Optional[_Mapping[str, JSONSchema]] = ..., ref: _Optional[str] = ..., all_of: _Optional[_Iterable[_Union[JSONSchema, _Mapping]]] = ..., any_of: _Optional[_Iterable[_Union[JSONSchema, _Mapping]]] = ..., one_of: _Optional[_Iterable[_Union[JSONSchema, _Mapping]]] = ..., **kwargs) -> None: ...
+
+class TraverseRequest(_message.Message):
+    __slots__ = ("nodes", "alias", "groups", "name", "allowed_actions", "integrations", "bypass")
+    class AllowedActionsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bool
+        def __init__(self, key: _Optional[str] = ..., value: bool = ...) -> None: ...
+    NODES_FIELD_NUMBER: _ClassVar[int]
+    ALIAS_FIELD_NUMBER: _ClassVar[int]
+    GROUPS_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    ALLOWED_ACTIONS_FIELD_NUMBER: _ClassVar[int]
+    INTEGRATIONS_FIELD_NUMBER: _ClassVar[int]
+    BYPASS_FIELD_NUMBER: _ClassVar[int]
+    nodes: _containers.RepeatedScalarFieldContainer[str]
+    alias: str
+    groups: _containers.RepeatedScalarFieldContainer[str]
+    name: str
+    allowed_actions: _containers.ScalarMap[str, bool]
+    integrations: _struct_pb2.Struct
+    bypass: bool
+    def __init__(self, nodes: _Optional[_Iterable[str]] = ..., alias: _Optional[str] = ..., groups: _Optional[_Iterable[str]] = ..., name: _Optional[str] = ..., allowed_actions: _Optional[_Mapping[str, bool]] = ..., integrations: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., bypass: bool = ...) -> None: ...
+
+class TraverseGraph(_message.Message):
+    __slots__ = ("origin", "nodes", "edges")
+    ORIGIN_FIELD_NUMBER: _ClassVar[int]
+    NODES_FIELD_NUMBER: _ClassVar[int]
+    EDGES_FIELD_NUMBER: _ClassVar[int]
+    origin: str
+    nodes: _containers.RepeatedScalarFieldContainer[str]
+    edges: _containers.RepeatedCompositeFieldContainer[Edge]
+    def __init__(self, origin: _Optional[str] = ..., nodes: _Optional[_Iterable[str]] = ..., edges: _Optional[_Iterable[_Union[Edge, _Mapping]]] = ...) -> None: ...
+
+class Edge(_message.Message):
+    __slots__ = ("source", "target", "concurrent", "name")
+    SOURCE_FIELD_NUMBER: _ClassVar[int]
+    TARGET_FIELD_NUMBER: _ClassVar[int]
+    CONCURRENT_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    source: str
+    target: str
+    concurrent: bool
+    name: str
+    def __init__(self, source: _Optional[str] = ..., target: _Optional[str] = ..., concurrent: bool = ..., name: _Optional[str] = ...) -> None: ...

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/grpc/pybotchi_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from . import pybotchi_pb2 as pybotchi__pb2
 
-GRPC_GENERATED_VERSION = '1.76.0'
+GRPC_GENERATED_VERSION = '1.80.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/mcp/action.py

@@ -1,6 +1,6 @@
 """Pybotchi MCP Classes."""
 
-from collections.abc import AsyncGenerator, Awaitable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable
 from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from inspect import getdoc, getmembers
 from itertools import islice
@@ -8,7 +8,7 @@ from os import getenv
 from typing import Any, Callable, Generic, Literal
 
 from datamodel_code_generator import DataModelType, Formatter, PythonVersion
-from datamodel_code_generator.model import get_data_model_types
+from datamodel_code_generator.model import DataModelSet, get_data_model_types
 from datamodel_code_generator.parser.base import title_to_class_name
 from datamodel_code_generator.parser.jsonschema import (
     JsonSchemaParser,
@@ -42,7 +42,7 @@ from ..action import Action, ChildActions
 from ..common import ActionReturn, ChatRole, Graph
 from ..utils import is_camel_case, unwrap_exceptions
 
-DMT = get_data_model_types(
+DMT: DataModelSet = get_data_model_types(
     DataModelType.PydanticV2BaseModel,
     target_python_version=PythonVersion.PY_313,
 )
@@ -62,13 +62,13 @@ class MCPClient:
         exclude_unset: bool,
     ) -> None:
         """Build MCP Client."""
-        self.session = session
-        self.name = name
-        self.config = config
-        self.manual_enable = manual_enable
-        self.allowed_tools = allowed_tools
-        self.tool_action_class = tool_action_class or MCPToolAction
-        self.exclude_unset = exclude_unset
+        self.session: ClientSession = session
+        self.name: str = name
+        self.config: MCPConfig = config
+        self.manual_enable: bool = manual_enable
+        self.allowed_tools: dict[str, bool] = allowed_tools
+        self.tool_action_class: type["MCPToolAction"] = tool_action_class or MCPToolAction
+        self.exclude_unset: bool = exclude_unset
 
     def build_tool(self, tool: Tool) -> tuple[str, type["MCPToolAction"]]:
         """Build MCPToolAction."""
@@ -142,7 +142,7 @@ class MCPClient:
         return actions
 
 
-class MCPAction(Action[TContext], Generic[TContext]):
+class MCPAction(Action[TContext]):
     """MCP Action."""
 
     __mcp_servers__: dict[str, FastMCP] = {}
@@ -179,7 +179,7 @@ class MCPAction(Action[TContext], Generic[TContext]):
 
     async def execute(self, context: TContext, parent: Action | None = None, append: bool = True) -> ActionReturn:
         """Execute main process."""
-        self._parent = parent
+        self._parent: Action | None = parent
         parent_context = context
         try:
             if parent and append:
@@ -367,7 +367,7 @@ async def multi_mcp_clients(
     integrations: dict[str, MCPIntegration],
     connections: list[MCPConnection],
     bypass: bool = False,
-) -> AsyncGenerator[dict[str, MCPClient], None]:
+) -> AsyncIterator[dict[str, MCPClient]]:
     """Connect to multiple mcp clients."""
     async with AsyncExitStack() as stack:
         clients: dict[str, MCPClient] = {}

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/mcp/common.py

@@ -91,22 +91,22 @@ class MCPConnection:
         require_integration: bool = True,
     ) -> None:
         """Build MCP Connection."""
-        self.name = name
-        self.mode = mode
-        self.url = url
-        self.headers = headers
-        self.timeout = timeout
-        self.sse_read_timeout = sse_read_timeout
-        self.terminate_on_close = terminate_on_close
-        self.httpx_client_factory = httpx_client_factory
-        self.auth = auth
-        self.on_session_created = on_session_created
+        self.name: str = name
+        self.mode: MCPMode | Literal["SSE", "SHTTP"] = mode
+        self.url: str = url
+        self.headers: dict[str, str] | None = headers
+        self.timeout: float = timeout
+        self.sse_read_timeout: float = sse_read_timeout
+        self.terminate_on_close: bool = terminate_on_close
+        self.httpx_client_factory: McpHttpClientFactory = httpx_client_factory
+        self.auth: Auth | None = auth
+        self.on_session_created: Callable[[str], None] | None = on_session_created
         self.async_client_args: AsyncClientArgs = {} if async_client_args is None else async_client_args
-        self.manual_enable = manual_enable
-        self.allowed_tools = {} if allowed_tools is None else allowed_tools
-        self.tool_action_class = tool_action_class
-        self.exclude_unset = exclude_unset
-        self.require_integration = require_integration
+        self.manual_enable: bool = manual_enable
+        self.allowed_tools: dict[str, bool] = {} if allowed_tools is None else allowed_tools
+        self.tool_action_class: type["MCPToolAction"] | None = tool_action_class
+        self.exclude_unset: bool = exclude_unset
+        self.require_integration: bool = require_integration
 
     def get_config(self, override: MCPConfig | None) -> MCPConfig:
         """Generate config."""

{pybotchi-3.4.3 → pybotchi-3.5.0}/pybotchi/utils.py

@@ -4,14 +4,14 @@ from collections import deque
 from collections.abc import Generator
 from contextlib import suppress
 from importlib import import_module
-from re import compile
+from re import Pattern, compile
 from typing import Any, Callable
 from uuid import UUID
 
 from orjson import loads
 
-PLACEHOLDERS = compile(r"(\${\s*([^:\s]+)\s*(?:\:\s*([\S\s]*?))?\s*})")
-CAMEL_CASE = compile(r"^[a-z]+(?:[A-Z][a-z0-9]*)*$")
+PLACEHOLDERS: Pattern = compile(r"(\${\s*([^:\s]+)\s*(?:\:\s*([\S\s]*?))?\s*})")
+CAMEL_CASE: Pattern = compile(r"^[a-z]+(?:[A-Z][a-z0-9]*)*$")
 
 
 def apply_placeholders(target: str, **placeholders: Any) -> str:

{pybotchi-3.4.3 → pybotchi-3.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybotchi"
-version = "3.4.3"
+version = "3.5.0"
 description = "A deterministic, intent-based AI agent builder."
 authors = ["Alexie (Boyong) Madolid <madolid.alexie@gmail.com>"]
 readme = "README.md"
@@ -26,8 +26,8 @@ mcp = { version = ">=1.15.0", optional = true }
 
 # GRPC optional
 click = { version = ">=8.3.1", optional = true }
-grpcio = { version = ">=1.76.0", optional = true }
-grpcio-tools = { version = ">=1.76.0", optional = true }
+grpcio = { version = ">=1.80.0", optional = true }
+grpcio-tools = { version = ">=1.80.0", optional = true }
 aiofiles = { version = ">=25.1.0", optional = true }
 
 [tool.poetry.group.dev.dependencies]

pybotchi-3.4.3/pybotchi/__init__.pyi

@@ -1,6 +0,0 @@
-from .action import Action as Action, DEFAULT_ACTION as DEFAULT_ACTION, all_agents as all_agents, graph as graph
-from .common import ActionReturn as ActionReturn, ChatRole as ChatRole, Groups as Groups, UsageMetadata as UsageMetadata
-from .context import Context as Context
-from .llm import LLM as LLM
-
-__all__ = ['Action', 'DEFAULT_ACTION', 'all_agents', 'graph', 'ActionReturn', 'ChatRole', 'Groups', 'UsageMetadata', 'Context', 'LLM']