grasp_agents 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

grasp_agents/openai/openai_llm.py

@@ -3,9 +3,9 @@ import logging
 import os
 from collections.abc import AsyncIterator, Iterable, Mapping
 from copy import deepcopy
+from dataclasses import dataclass, field
 from typing import Any, Literal
 
-import httpx
 from openai import AsyncOpenAI, AsyncStream
 from openai._types import NOT_GIVEN  # type: ignore[import]
 from openai.lib.streaming.chat import (
@@ -15,8 +15,7 @@ from openai.lib.streaming.chat import ChatCompletionStreamState
 from openai.lib.streaming.chat import ChunkEvent as OpenAIChunkEvent
 from pydantic import BaseModel
 
-from ..cloud_llm import APIProvider, CloudLLM, CloudLLMSettings, LLMRateLimiter
-from ..http_client import AsyncHTTPClientParams
+from ..cloud_llm import APIProvider, CloudLLM, CloudLLMSettings
 from ..typing.tool import BaseTool
 from . import (
     OpenAICompletion,
@@ -90,105 +89,75 @@ class OpenAILLMSettings(CloudLLMSettings, total=False):
     # TODO: support audio
 
 
+@dataclass(frozen=True)
 class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
-    def __init__(
-        self,
-        # Base LLM args
-        model_name: str,
-        llm_settings: OpenAILLMSettings | None = None,
-        tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
-        response_schema: Any | None = None,
-        response_schema_by_xml_tag: Mapping[str, Any] | None = None,
-        apply_response_schema_via_provider: bool = False,
-        model_id: str | None = None,
-        # Custom LLM provider
-        api_provider: APIProvider | None = None,
-        # Connection settings
-        max_client_retries: int = 2,
-        async_http_client: httpx.AsyncClient | None = None,
-        async_http_client_params: (
-            dict[str, Any] | AsyncHTTPClientParams | None
-        ) = None,
-        async_openai_client_params: dict[str, Any] | None = None,
-        # Rate limiting
-        rate_limiter: LLMRateLimiter | None = None,
-        # LLM response retries: try to regenerate to pass validation
-        max_response_retries: int = 1,
-    ) -> None:
+    converters: OpenAIConverters = field(default_factory=OpenAIConverters)
+    async_openai_client_params: dict[str, Any] | None = None
+    client: AsyncOpenAI = field(init=False)
+
+    def __post_init__(self):
+        super().__post_init__()
+
         openai_compatible_providers = get_openai_compatible_providers()
 
-        model_name_parts = model_name.split("/", 1)
-        if api_provider is not None:
-            provider_model_name = model_name
+        _api_provider = self.api_provider
+
+        model_name_parts = self.model_name.split("/", 1)
+        if _api_provider is not None:
+            _model_name = self.model_name
         elif len(model_name_parts) == 2:
             compat_providers_map = {
                 provider["name"]: provider for provider in openai_compatible_providers
             }
-            provider_name, provider_model_name = model_name_parts
+            provider_name, _model_name = model_name_parts
             if provider_name not in compat_providers_map:
                 raise ValueError(
                     f"API provider '{provider_name}' is not a supported OpenAI "
                     f"compatible provider. Supported providers are: "
                     f"{', '.join(compat_providers_map.keys())}"
                 )
-            api_provider = compat_providers_map[provider_name]
+            _api_provider = compat_providers_map[provider_name]
         else:
             raise ValueError(
                 "Model name must be in the format 'provider/model_name' or "
                 "you must provide an 'api_provider' argument."
             )
 
-        if llm_settings is not None:
-            stream_options = llm_settings.get("stream_options") or {}
+        if self.llm_settings is not None:
+            stream_options = self.llm_settings.get("stream_options") or {}
             stream_options["include_usage"] = True
-            _llm_settings = deepcopy(llm_settings)
+            _llm_settings = deepcopy(self.llm_settings)
             _llm_settings["stream_options"] = stream_options
         else:
             _llm_settings = OpenAILLMSettings(stream_options={"include_usage": True})
 
-        super().__init__(
-            model_name=provider_model_name,
-            model_id=model_id,
-            llm_settings=_llm_settings,
-            converters=OpenAIConverters(),
-            tools=tools,
-            response_schema=response_schema,
-            response_schema_by_xml_tag=response_schema_by_xml_tag,
-            apply_response_schema_via_provider=apply_response_schema_via_provider,
-            api_provider=api_provider,
-            async_http_client=async_http_client,
-            async_http_client_params=async_http_client_params,
-            rate_limiter=rate_limiter,
-            max_client_retries=max_client_retries,
-            max_response_retries=max_response_retries,
-        )
-
         response_schema_support: bool = any(
-            fnmatch.fnmatch(self._model_name, pat)
-            for pat in api_provider.get("response_schema_support") or []
+            fnmatch.fnmatch(_model_name, pat)
+            for pat in _api_provider.get("response_schema_support") or []
         )
-        if apply_response_schema_via_provider:
-            if self._tools:
-                for tool in self._tools.values():
-                    tool.strict = True
-            if not response_schema_support:
-                raise ValueError(
-                    "Native response schema validation is not supported for model "
-                    f"'{self._model_name}' by the API provider. Please set "
-                    "apply_response_schema_via_provider=False."
-                )
+        if self.apply_response_schema_via_provider and not response_schema_support:
+            raise ValueError(
+                "Native response schema validation is not supported for model "
+                f"'{_model_name}' by the API provider. Please set "
+                "apply_response_schema_via_provider=False."
+            )
 
-        _async_openai_client_params = deepcopy(async_openai_client_params or {})
-        if self._async_http_client is not None:
-            _async_openai_client_params["http_client"] = self._async_http_client
+        _async_openai_client_params = deepcopy(self.async_openai_client_params or {})
+        if self.async_http_client is not None:
+            _async_openai_client_params["http_client"] = self.async_http_client
 
-        self._client: AsyncOpenAI = AsyncOpenAI(
-            base_url=self.api_provider.get("base_url"),
-            api_key=self.api_provider.get("api_key"),
-            max_retries=max_client_retries,
+        _client = AsyncOpenAI(
+            base_url=_api_provider.get("base_url"),
+            api_key=_api_provider.get("api_key"),
+            max_retries=self.max_client_retries,
             **_async_openai_client_params,
         )
 
+        object.__setattr__(self, "model_name", _model_name)
+        object.__setattr__(self, "api_provider", _api_provider)
+        object.__setattr__(self, "llm_settings", _llm_settings)
+        object.__setattr__(self, "client", _client)
+
     async def _get_completion(
         self,
         api_messages: Iterable[OpenAIMessageParam],
@@ -203,9 +172,9 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
         response_format = api_response_schema or NOT_GIVEN
         n = n_choices or NOT_GIVEN
 
-        if self._apply_response_schema_via_provider:
-            return await self._client.beta.chat.completions.parse(
-                model=self._model_name,
+        if self.apply_response_schema_via_provider:
+            return await self.client.beta.chat.completions.parse(
+                model=self.model_name,
                 messages=api_messages,
                 tools=tools,
                 tool_choice=tool_choice,
@@ -214,8 +183,8 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
                 **api_llm_settings,
             )
 
-        return await self._client.chat.completions.create(
-            model=self._model_name,
+        return await self.client.chat.completions.create(
+            model=self.model_name,
             messages=api_messages,
             tools=tools,
             tool_choice=tool_choice,
@@ -238,10 +207,10 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
         response_format = api_response_schema or NOT_GIVEN
         n = n_choices or NOT_GIVEN
 
-        if self._apply_response_schema_via_provider:
+        if self.apply_response_schema_via_provider:
             stream_manager: OpenAIAsyncChatCompletionStreamManager[Any] = (
-                self._client.beta.chat.completions.stream(
-                    model=self._model_name,
+                self.client.beta.chat.completions.stream(
+                    model=self.model_name,
                     messages=api_messages,
                     tools=tools,
                     tool_choice=tool_choice,
@@ -257,8 +226,8 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
         else:
             stream_generator: AsyncStream[
                 OpenAICompletionChunk
-            ] = await self._client.chat.completions.create(
-                model=self._model_name,
+            ] = await self.client.chat.completions.create(
+                model=self.model_name,
                 messages=api_messages,
                 tools=tools,
                 tool_choice=tool_choice,
@@ -271,16 +240,20 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
                     yield completion_chunk
 
     def combine_completion_chunks(
-        self, completion_chunks: list[OpenAICompletionChunk]
+        self,
+        completion_chunks: list[OpenAICompletionChunk],
+        response_schema: Any | None = None,
+        tools: Mapping[str, BaseTool[BaseModel, Any, Any]] | None = None,
     ) -> OpenAICompletion:
         response_format = NOT_GIVEN
         input_tools = NOT_GIVEN
-        if self._apply_response_schema_via_provider:
-            if self._response_schema:
-                response_format = self._response_schema
-            if self._tools:
+        if self.apply_response_schema_via_provider:
+            if response_schema:
+                response_format = response_schema
+            if tools:
                 input_tools = [
-                    self._converters.to_tool(tool) for tool in self._tools.values()
+                    self.converters.to_tool(tool, strict=True)
+                    for tool in tools.values()
                 ]
         state = ChatCompletionStreamState[Any](
             input_tools=input_tools, response_format=response_format

grasp_agents/openai/tool_converters.py

@@ -13,8 +13,10 @@ from . import (
 )
 
 
-def to_api_tool(tool: BaseTool[BaseModel, Any, Any]) -> OpenAIToolParam:
-    if tool.strict:
+def to_api_tool(
+    tool: BaseTool[BaseModel, Any, Any], strict: bool | None = None
+) -> OpenAIToolParam:
+    if strict:
         return pydantic_function_tool(
             model=tool.in_type, name=tool.name, description=tool.description
         )
@@ -23,9 +25,9 @@ def to_api_tool(tool: BaseTool[BaseModel, Any, Any]) -> OpenAIToolParam:
         name=tool.name,
         description=tool.description,
         parameters=tool.in_type.model_json_schema(),
-        strict=tool.strict,
+        strict=strict,
     )
-    if tool.strict is None:
+    if strict is None:
         function.pop("strict")
 
     return OpenAIToolParam(type="function", function=function)

grasp_agents/processors/base_processor.py

@@ -1,6 +1,6 @@
 import logging
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Callable, Coroutine
+from collections.abc import AsyncIterator, Callable, Coroutine, Sequence
 from functools import wraps
 from typing import (
     Any,
@@ -37,7 +37,6 @@ from ..typing.tool import BaseTool
 
 logger = logging.getLogger(__name__)
 
-_OutT_contra = TypeVar("_OutT_contra", contravariant=True)
 
 F = TypeVar("F", bound=Callable[..., Coroutine[Any, Any, Packet[Any]]])
 F_stream = TypeVar("F_stream", bound=Callable[..., AsyncIterator[Event[Any]]])
@@ -102,10 +101,13 @@ def with_retry_stream(func: F_stream) -> F_stream:
     return cast("F_stream", wrapper)
 
 
+_OutT_contra = TypeVar("_OutT_contra", contravariant=True)
+
+
 class RecipientSelector(Protocol[_OutT_contra, CtxT]):
     def __call__(
-        self, output: _OutT_contra, ctx: RunContext[CtxT] | None
-    ) -> list[ProcName] | None: ...
+        self, output: _OutT_contra, ctx: RunContext[CtxT]
+    ) -> Sequence[ProcName] | None: ...
 
 
 class BaseProcessor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]):
@@ -118,7 +120,7 @@ class BaseProcessor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, C
         self,
         name: ProcName,
         max_retries: int = 0,
-        recipients: list[ProcName] | None = None,
+        recipients: Sequence[ProcName] | None = None,
         **kwargs: Any,
     ) -> None:
         self._in_type: type[InT]
@@ -239,7 +241,7 @@ class BaseProcessor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, C
             ) from err
 
     def _validate_recipients(
-        self, recipients: list[ProcName] | None, call_id: str
+        self, recipients: Sequence[ProcName] | None, call_id: str
     ) -> None:
         for r in recipients or []:
             if r not in (self.recipients or []):
@@ -252,8 +254,8 @@ class BaseProcessor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, C
 
     @final
     def _select_recipients(
-        self, output: OutT, ctx: RunContext[CtxT] | None = None
-    ) -> list[ProcName] | None:
+        self, output: OutT, ctx: RunContext[CtxT]
+    ) -> Sequence[ProcName] | None:
         if self.recipient_selector:
             return self.recipient_selector(output=output, ctx=ctx)
 
@@ -310,9 +312,15 @@ class BaseProcessor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, C
             name: str = tool_name
             description: str = tool_description
 
-            async def run(self, inp: InT, ctx: RunContext[CtxT] | None = None) -> OutT:
+            async def run(
+                self,
+                inp: InT,
+                *,
+                call_id: str | None = None,
+                ctx: RunContext[CtxT] | None = None,
+            ) -> OutT:
                 result = await processor_instance.run(
-                    in_args=inp, forgetful=True, ctx=ctx
+                    in_args=inp, forgetful=True, call_id=call_id, ctx=ctx
                 )
 
                 return result.payloads[0]

grasp_agents/processors/parallel_processor.py

@@ -30,7 +30,7 @@ class ParallelProcessor(
         in_args: InT | None = None,
         memory: MemT,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> OutT:
         return cast("OutT", in_args)
 
@@ -41,7 +41,7 @@ class ParallelProcessor(
         in_args: InT | None = None,
         memory: MemT,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> AsyncIterator[Event[Any]]:
         output = cast("OutT", in_args)
         yield ProcPayloadOutputEvent(data=output, proc_name=self.name, call_id=call_id)
@@ -67,7 +67,7 @@ class ParallelProcessor(
         in_args: InT | None = None,
         forgetful: bool = False,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> Packet[OutT]:
         memory = self.memory.model_copy(deep=True) if forgetful else self.memory
 
@@ -86,7 +86,7 @@ class ParallelProcessor(
         return Packet(payloads=[val_output], sender=self.name, recipients=recipients)
 
     async def _run_parallel(
-        self, in_args: list[InT], call_id: str, ctx: RunContext[CtxT] | None = None
+        self, in_args: list[InT], call_id: str, ctx: RunContext[CtxT]
     ) -> Packet[OutT]:
         tasks = [
             self._run_single(
@@ -114,6 +114,7 @@ class ParallelProcessor(
         ctx: RunContext[CtxT] | None = None,
     ) -> Packet[OutT]:
         call_id = self._generate_call_id(call_id)
+        ctx = RunContext[CtxT](state=None) if ctx is None else ctx  # type: ignore
 
         val_in_args = self._validate_inputs(
             call_id=call_id,
@@ -143,7 +144,7 @@ class ParallelProcessor(
         in_args: InT | None = None,
         forgetful: bool = False,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> AsyncIterator[Event[Any]]:
         memory = self.memory.model_copy(deep=True) if forgetful else self.memory
 
@@ -178,7 +179,7 @@ class ParallelProcessor(
         self,
         in_args: list[InT],
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> AsyncIterator[Event[Any]]:
         streams = [
             self._run_single_stream(
@@ -222,6 +223,7 @@ class ParallelProcessor(
         ctx: RunContext[CtxT] | None = None,
     ) -> AsyncIterator[Event[Any]]:
         call_id = self._generate_call_id(call_id)
+        ctx = RunContext[CtxT](state=None) if ctx is None else ctx  # type: ignore
 
         val_in_args = self._validate_inputs(
             call_id=call_id,

grasp_agents/processors/processor.py

@@ -1,5 +1,5 @@
 import logging
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Sequence
 from typing import Any, ClassVar, Generic, cast
 
 from ..memory import MemT
@@ -25,7 +25,7 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         in_args: list[InT] | None = None,
         memory: MemT,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> list[OutT]:
         return cast("list[OutT]", in_args)
 
@@ -36,7 +36,7 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         in_args: list[InT] | None = None,
         memory: MemT,
         call_id: str,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> AsyncIterator[Event[Any]]:
         outputs = await self._process(
             chat_inputs=chat_inputs,
@@ -58,7 +58,7 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         in_args: InT | list[InT] | None = None,
         forgetful: bool = False,
         call_id: str | None = None,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> tuple[list[InT] | None, MemT, str]:
         call_id = self._generate_call_id(call_id)
 
@@ -74,10 +74,10 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         return val_in_args, memory, call_id
 
     def _postprocess(
-        self, outputs: list[OutT], call_id: str, ctx: RunContext[CtxT] | None = None
+        self, outputs: list[OutT], call_id: str, ctx: RunContext[CtxT]
     ) -> Packet[OutT]:
         payloads: list[OutT] = []
-        routing: dict[int, list[ProcName] | None] = {}
+        routing: dict[int, Sequence[ProcName] | None] = {}
         for idx, output in enumerate(outputs):
             val_output = self._validate_output(output, call_id=call_id)
             recipients = self._select_recipients(output=val_output, ctx=ctx)
@@ -105,6 +105,8 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         call_id: str | None = None,
         ctx: RunContext[CtxT] | None = None,
     ) -> Packet[OutT]:
+        ctx = RunContext[CtxT](state=None) if ctx is None else ctx  # type: ignore
+
         val_in_args, memory, call_id = self._preprocess(
             chat_inputs=chat_inputs,
             in_packet=in_packet,
@@ -134,6 +136,8 @@ class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, C
         call_id: str | None = None,
         ctx: RunContext[CtxT] | None = None,
     ) -> AsyncIterator[Event[Any]]:
+        ctx = RunContext[CtxT](state=None) if ctx is None else ctx  # type: ignore
+
         val_in_args, memory, call_id = self._preprocess(
             chat_inputs=chat_inputs,
             in_packet=in_packet,

grasp_agents/prompt_builder.py

@@ -1,6 +1,6 @@
 import json
 from collections.abc import Sequence
-from typing import ClassVar, Generic, Protocol, TypeAlias, TypeVar, final
+from typing import ClassVar, Generic, Protocol, TypeAlias, TypeVar, cast, final
 
 from pydantic import BaseModel, TypeAdapter
 
@@ -15,13 +15,11 @@ _InT_contra = TypeVar("_InT_contra", contravariant=True)
 
 
 class SystemPromptBuilder(Protocol[CtxT]):
-    def __call__(self, ctx: RunContext[CtxT] | None) -> str | None: ...
+    def __call__(self, ctx: RunContext[CtxT]) -> str | None: ...
 
 
 class InputContentBuilder(Protocol[_InT_contra, CtxT]):
-    def __call__(
-        self, in_args: _InT_contra | None, *, ctx: RunContext[CtxT] | None
-    ) -> Content: ...
+    def __call__(self, in_args: _InT_contra, ctx: RunContext[CtxT]) -> Content: ...
 
 
 PromptArgumentType: TypeAlias = str | bool | int | ImageData
@@ -45,7 +43,7 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         self._in_args_type_adapter: TypeAdapter[InT] = TypeAdapter(self._in_type)
 
     @final
-    def build_system_prompt(self, ctx: RunContext[CtxT] | None = None) -> str | None:
+    def build_system_prompt(self, ctx: RunContext[CtxT]) -> str | None:
         if self.system_prompt_builder:
             return self.system_prompt_builder(ctx=ctx)
 
@@ -73,23 +71,19 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
 
     @final
     def _build_input_content(
-        self,
-        in_args: InT | None = None,
-        ctx: RunContext[CtxT] | None = None,
+        self, in_args: InT | None, ctx: RunContext[CtxT]
     ) -> Content:
-        val_in_args = in_args
-        if in_args is not None:
-            val_in_args = self._validate_input_args(in_args=in_args)
-
-        if self.input_content_builder:
-            return self.input_content_builder(in_args=val_in_args, ctx=ctx)
-
-        if val_in_args is None:
+        if in_args is None and self._in_type is not type(None):
             raise InputPromptBuilderError(
                 proc_name=self._agent_name,
-                message="Input arguments are not provided, "
-                f"but input content is required [agent_name={self._agent_name}]",
+                message="Either chat inputs or input arguments must be provided "
+                f"when input type is not None [agent_name={self._agent_name}]",
             )
+        in_args = cast("InT", in_args)
+
+        val_in_args = self._validate_input_args(in_args)
+        if self.input_content_builder:
+            return self.input_content_builder(in_args=val_in_args, ctx=ctx)
 
         if issubclass(self._in_type, BaseModel) and isinstance(val_in_args, BaseModel):
             val_in_args_map = self._format_pydantic_prompt_args(val_in_args)
@@ -106,17 +100,17 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
     def build_input_message(
         self,
         chat_inputs: LLMPrompt | Sequence[str | ImageData] | None = None,
+        *,
         in_args: InT | None = None,
-        ctx: RunContext[CtxT] | None = None,
+        ctx: RunContext[CtxT],
     ) -> UserMessage | None:
-        if chat_inputs is not None and in_args is not None:
-            raise InputPromptBuilderError(
-                proc_name=self._agent_name,
-                message="Cannot use both chat inputs and input arguments "
-                f"at the same time [agent_name={self._agent_name}]",
-            )
-
-        if chat_inputs:
+        if chat_inputs is not None:
+            if in_args is not None:
+                raise InputPromptBuilderError(
+                    proc_name=self._agent_name,
+                    message="Cannot use both chat inputs and input arguments "
+                    f"at the same time [agent_name={self._agent_name}]",
+                )
             if isinstance(chat_inputs, LLMPrompt):
                 return UserMessage.from_text(chat_inputs, name=self._agent_name)
             return UserMessage.from_content_parts(chat_inputs, name=self._agent_name)

grasp_agents/run_context.py

@@ -13,7 +13,7 @@ CtxT = TypeVar("CtxT")
 
 
 class RunContext(BaseModel, Generic[CtxT]):
-    state: CtxT | None = None
+    state: CtxT = None  # type: ignore
 
     completions: dict[ProcName, list[Completion]] = Field(
         default_factory=lambda: defaultdict(list)

grasp_agents/runner.py

@@ -33,7 +33,7 @@ class Runner(Generic[OutT, CtxT]):
 
         self._entry_proc = entry_proc
         self._procs = procs
-        self._ctx = ctx or RunContext[CtxT]()
+        self._ctx = ctx or RunContext[CtxT](state=None)  # type: ignore
 
     @property
     def ctx(self) -> RunContext[CtxT]:

grasp_agents/typing/converters.py

@@ -69,7 +69,9 @@ class Converters(ABC):
 
     @staticmethod
     @abstractmethod
-    def to_tool(tool: BaseTool[BaseModel, Any, Any], **kwargs: Any) -> Any:
+    def to_tool(
+        tool: BaseTool[BaseModel, Any, Any], strict: bool | None = None, **kwargs: Any
+    ) -> Any:
         pass
 
     @staticmethod

grasp_agents/typing/tool.py

@@ -48,8 +48,6 @@ class BaseTool(
     name: str
     description: str
 
-    strict: bool | None = None
-
     _in_type: type[_InT] = PrivateAttr()
     _out_type: type[_OutT_co] = PrivateAttr()
 
@@ -62,14 +60,24 @@ class BaseTool(
         return self._out_type
 
     @abstractmethod
-    async def run(self, inp: _InT, ctx: RunContext[CtxT] | None = None) -> _OutT_co:
+    async def run(
+        self,
+        inp: _InT,
+        *,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> _OutT_co:
         pass
 
     async def __call__(
-        self, ctx: RunContext[CtxT] | None = None, **kwargs: Any
+        self,
+        *,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+        **kwargs: Any,
     ) -> _OutT_co:
         input_args = TypeAdapter(self._in_type).validate_python(kwargs)
-        output = await self.run(input_args, ctx=ctx)
+        output = await self.run(input_args, call_id=call_id, ctx=ctx)
 
         return TypeAdapter(self._out_type).validate_python(output)
 

grasp_agents/workflow/workflow_processor.py

@@ -21,7 +21,7 @@ class WorkflowProcessor(
         subprocs: Sequence[BaseProcessor[Any, Any, Any, CtxT]],
         start_proc: BaseProcessor[InT, Any, Any, CtxT],
         end_proc: BaseProcessor[Any, OutT, Any, CtxT],
-        recipients: list[ProcName] | None = None,
+        recipients: Sequence[ProcName] | None = None,
         max_retries: int = 0,
     ) -> None:
         super().__init__(name=name, recipients=recipients, max_retries=max_retries)
@@ -57,11 +57,11 @@ class WorkflowProcessor(
         return func
 
     @property
-    def recipients(self) -> list[ProcName] | None:
+    def recipients(self) -> Sequence[ProcName] | None:
         return self._end_proc.recipients
 
     @recipients.setter
-    def recipients(self, value: list[ProcName] | None) -> None:
+    def recipients(self, value: Sequence[ProcName] | None) -> None:
         if hasattr(self, "_end_proc"):
             self._end_proc.recipients = value
 
@@ -96,7 +96,7 @@ class WorkflowProcessor(
         pass
 
     @abstractmethod
-    async def run_stream(  # type: ignore[override]
+    async def run_stream(
         self,
         chat_inputs: Any | None = None,
         *,