grasp_agents 0.1.18__py3-none-any.whl → 0.2.1__py3-none-any.whl

grasp_agents/utils.py

@@ -1,85 +1,82 @@
 import ast
 import asyncio
-import functools
 import json
 import re
-from collections.abc import Callable, Coroutine
-from copy import deepcopy
+from collections.abc import Coroutine, Mapping
 from datetime import datetime
 from logging import getLogger
 from pathlib import Path
-from typing import Any, TypeVar, cast
+from typing import Any, TypeVar
 
-from pydantic import BaseModel, GetCoreSchemaHandler, TypeAdapter, create_model
-from pydantic.fields import FieldInfo
+from pydantic import (
+    GetCoreSchemaHandler,
+    TypeAdapter,
+    ValidationError,
+)
 from pydantic_core import core_schema
 from tqdm.autonotebook import tqdm
 
 logger = getLogger(__name__)
 
+_JSON_START_RE = re.compile(r"[{\[]")
 
-def merge_pydantic_models(*models: type[BaseModel]) -> type[BaseModel]:
-    fields_dict: dict[str, FieldInfo] = {}
-    for model in models:
-        for field_name, field_info in model.model_fields.items():
-            if field_name in fields_dict:
-                raise ValueError(
-                    f"Field conflict detected: '{field_name}' exists in multiple models"
-                )
-            fields_dict[field_name] = field_info
+T = TypeVar("T")
 
-    return create_model("MergedModel", __module__=__name__, **fields_dict)  # type: ignore
-
-
-def filter_fields(data: dict[str, Any], model: type[BaseModel]) -> dict[str, Any]:
-    return {key: data[key] for key in model.model_fields if key in data}
 
+def extract_json_substring(text: str) -> str | None:
+    decoder = json.JSONDecoder()
+    for match in _JSON_START_RE.finditer(text):
+        start = match.start()
+        try:
+            _, end = decoder.raw_decode(text, idx=start)
+            return text[start:end]
+        except ValueError:
+            continue
 
-def read_txt(file_path: str) -> str:
-    return Path(file_path).read_text()
+    return None
 
 
-def format_json_string(text: str) -> str:
-    decoder = json.JSONDecoder()
-    text = text.replace("\n", "")
-    length = len(text)
-    i = 0
-    while i < length:
-        ch = text[i]
-        if ch in "{[":
-            try:
-                _, end = decoder.raw_decode(text[i:])
-                return text[i : i + end]
-            except ValueError:
-                pass
-        i += 1
-
-    return text
-
-
-def read_json_string(
-    json_str: str, return_none_on_failure: bool = False
+def parse_json_or_py_string(
+    s: str, return_none_on_failure: bool = False
 ) -> dict[str, Any] | list[Any] | None:
+    s_fmt = re.sub(r"```[a-zA-Z0-9]*\n|```", "", s).strip()
     try:
-        json_response = ast.literal_eval(json_str)
+        return ast.literal_eval(s_fmt)
     except (ValueError, SyntaxError):
         try:
-            json_response = json.loads(json_str)
+            return json.loads(s_fmt)
         except json.JSONDecodeError as exc:
             if return_none_on_failure:
                 return None
             raise ValueError(
-                "Invalid JSON - Both ast.literal_eval and json.loads "
-                f"failed to parse the following response:\n{json_str}"
+                "Invalid JSON/Python string - Both ast.literal_eval and json.loads "
+                f"failed to parse the following response:\n{s}"
             ) from exc
 
-    return json_response
 
-
-def extract_json(
+def parse_json_or_py_substring(
     json_str: str, return_none_on_failure: bool = False
 ) -> dict[str, Any] | list[Any] | None:
-    return read_json_string(format_json_string(json_str), return_none_on_failure)
+    return parse_json_or_py_string(
+        extract_json_substring(json_str) or "", return_none_on_failure
+    )
+
+
+def validate_obj_from_json_or_py_string(
+    s: str, adapter: TypeAdapter[T], from_substring: bool = False
+) -> T:
+    try:
+        if from_substring:
+            parsed = parse_json_or_py_substring(s, return_none_on_failure=True)
+        else:
+            parsed = parse_json_or_py_string(s, return_none_on_failure=True)
+        if parsed is None:
+            parsed = s
+        return adapter.validate_python(parsed)
+    except (json.JSONDecodeError, ValidationError) as exc:
+        raise ValueError(
+            f"Invalid JSON or Python string:\n{s}\nExpected type: {adapter._type}",  # type: ignore[arg-type]
+        ) from exc
 
 
 def extract_xml_list(text: str) -> list[str]:
@@ -92,16 +89,26 @@ def extract_xml_list(text: str) -> list[str]:
     return chunks
 
 
-def make_conditional_parsed_output_type(
-    response_format: type, marker: str = "<DONE>"
+def build_marker_json_parser_type(
+    marker_to_model: Mapping[str, type],
 ) -> type:
-    class ParsedOutput:
-        """
-        * Accepts any **str**.
-        * If the string contains `marker`, it must contain a valid JSON for
-        `response_format` → we return that a response_format instance.
-        * Otherwise we leave the string untouched.
-        """
+    """
+    Return a Pydantic-compatible *type* that, when given a **str**, searches for
+    the first marker substring and validates the JSON that follows with the
+    corresponding Pydantic model.
+
+    If no marker is found, the raw string is returned unchanged.
+
+    Example:
+    -------
+    >>> Todo = build_marker_json_parser_type({'```json': MyModel})
+    >>> Todo.validate('```json {"a": 1}')
+    MyModel(a=1)
+
+    """
+
+    class MarkerParsedOutput:
+        """String → (Model | str) parser generated by build_marker_json_parser_type."""
 
         @classmethod
         def __get_pydantic_core_schema__(
@@ -109,58 +116,49 @@ def make_conditional_parsed_output_type(
             _source_type: Any,
             _handler: GetCoreSchemaHandler,
         ) -> core_schema.CoreSchema:
-            def validator(v: Any) -> Any:
-                if isinstance(v, str) and marker in v:
-                    v_json_str = format_json_string(v)
-                    response_format_adapter = TypeAdapter[Any](response_format)
+            def _validate(value: Any) -> Any:
+                if not isinstance(value, str):
+                    raise TypeError("MarkerParsedOutput expects a string")
 
-                    return response_format_adapter.validate_json(v_json_str)
+                for marker, model in marker_to_model.items():
+                    if marker in value:
+                        adapter = TypeAdapter[Any](model)
+                        return validate_obj_from_json_or_py_string(
+                            value, adapter=adapter, from_substring=True
+                        )
 
-                return v
+                return value
 
             return core_schema.no_info_after_validator_function(
-                validator, core_schema.any_schema()
+                _validate, core_schema.any_schema()
             )
 
         @classmethod
         def __get_pydantic_json_schema__(
-            cls, core_schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler
+            cls,
+            schema: core_schema.CoreSchema,
+            handler: GetCoreSchemaHandler,
         ):
-            return handler(core_schema)
+            return handler(schema)
 
-    return ParsedOutput
+    unique_suffix = "_".join(sorted(marker_to_model))[:40]
+    MarkerParsedOutput.__name__ = f"MarkerParsedOutput_{unique_suffix}"
 
+    return MarkerParsedOutput
 
-T = TypeVar("T", bound=Callable[..., Any])
 
-
-def forbid_state_change(method: T) -> T:
-    @functools.wraps(method)
-    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-        before = deepcopy(self.__dict__)
-        result = method(self, *args, **kwargs)
-        after = self.__dict__
-        if before != after:
-            raise RuntimeError(
-                f"Method '{method.__name__}' modified the instance state."
-            )
-        return result
-
-    return cast("T", wrapper)
+def read_txt(file_path: str | Path, encoding: str = "utf-8") -> str:
+    return Path(file_path).read_text(encoding=encoding)
 
 
 def read_contents_from_file(
     file_path: str | Path,
     binary_mode: bool = False,
 ) -> str | bytes:
-    """Reads and returns contents of file"""
     try:
         if binary_mode:
-            with open(file_path, "rb") as file:
-                return file.read()
-        else:
-            with open(file_path) as file:
-                return file.read()
+            return Path(file_path).read_bytes()
+        return Path(file_path).read_text()
     except FileNotFoundError:
         logger.error(f"File {file_path} not found.")
         return ""
@@ -168,13 +166,9 @@ def read_contents_from_file(
 
 def get_prompt(prompt_text: str | None, prompt_path: str | Path | None) -> str | None:
     if prompt_text is None:
-        prompt = (
-            read_contents_from_file(prompt_path) if prompt_path is not None else None
-        )
-    else:
-        prompt = prompt_text
+        return read_contents_from_file(prompt_path) if prompt_path is not None else None  # type: ignore[arg-type]
 
-    return prompt  # type: ignore[assignment]
+    return prompt_text
 
 
 async def asyncio_gather_with_pbar(

grasp_agents/workflow/looped_agent.py

@@ -1,16 +1,16 @@
 from collections.abc import Sequence
 from logging import getLogger
-from typing import Any, Generic, Protocol, TypeVar, cast, final
+from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast, final
 
 from ..agent_message_pool import AgentMessage, AgentMessagePool
 from ..comm_agent import CommunicatingAgent
 from ..run_context import CtxT, RunContextWrapper
-from ..typing.io import AgentID, AgentPayload, AgentState, InT, OutT
+from ..typing.io import AgentID, AgentState, InT, OutT
 from .workflow_agent import WorkflowAgent
 
 logger = getLogger(__name__)
 
-_EH_OutT = TypeVar("_EH_OutT", bound=AgentPayload, contravariant=True)  # noqa: PLC0105
+_EH_OutT = TypeVar("_EH_OutT", contravariant=True)  # noqa: PLC0105
 
 
 class WorkflowLoopExitHandler(Protocol[_EH_OutT, CtxT]):
@@ -23,13 +23,16 @@ class WorkflowLoopExitHandler(Protocol[_EH_OutT, CtxT]):
 
 
 class LoopedWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, CtxT]):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
     def __init__(
         self,
         agent_id: AgentID,
-        subagents: Sequence[
-            CommunicatingAgent[AgentPayload, AgentPayload, AgentState, CtxT]
-        ],
-        exit_agent: CommunicatingAgent[AgentPayload, OutT, AgentState, CtxT],
+        subagents: Sequence[CommunicatingAgent[Any, Any, AgentState, CtxT]],
+        exit_agent: CommunicatingAgent[Any, OutT, AgentState, CtxT],
         message_pool: AgentMessagePool[CtxT] | None = None,
         recipient_ids: list[AgentID] | None = None,
         dynamic_routing: bool = False,
@@ -61,7 +64,7 @@ class LoopedWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, Ctx
 
         return func
 
-    def _workflow_loop_exit(
+    def _exit_workflow_loop(
         self,
         output_message: AgentMessage[OutT, AgentState],
         ctx: RunContextWrapper[CtxT] | None,
@@ -101,7 +104,7 @@ class LoopedWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, Ctx
                 if subagent is self._end_agent:
                     num_iterations += 1
                     exit_message = cast("AgentMessage[OutT, AgentState]", agent_message)
-                    if self._workflow_loop_exit(exit_message, ctx=ctx):
+                    if self._exit_workflow_loop(exit_message, ctx=ctx):
                         return exit_message
                     if num_iterations >= self._max_iterations:
                         logger.info(

grasp_agents/workflow/sequential_agent.py

@@ -1,20 +1,23 @@
 from collections.abc import Sequence
-from typing import Any, Generic, cast, final
+from typing import Any, ClassVar, Generic, cast, final
 
 from ..agent_message_pool import AgentMessage, AgentMessagePool
 from ..comm_agent import CommunicatingAgent
 from ..run_context import CtxT, RunContextWrapper
-from ..typing.io import AgentID, AgentPayload, AgentState, InT, OutT
+from ..typing.io import AgentID, AgentState, InT, OutT
 from .workflow_agent import WorkflowAgent
 
 
 class SequentialWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, CtxT]):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
     def __init__(
         self,
         agent_id: AgentID,
-        subagents: Sequence[
-            CommunicatingAgent[AgentPayload, AgentPayload, AgentState, CtxT]
-        ],
+        subagents: Sequence[CommunicatingAgent[Any, Any, AgentState, CtxT]],
         message_pool: AgentMessagePool[CtxT] | None = None,
         recipient_ids: list[AgentID] | None = None,
         dynamic_routing: bool = False,
@@ -23,7 +26,7 @@ class SequentialWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT,
         super().__init__(
             subagents=subagents,
             start_agent=subagents[0],
-            end_agent=subagents[-1],  # type: ignore[assignment]
+            end_agent=subagents[-1],
             agent_id=agent_id,
             message_pool=message_pool,
             recipient_ids=recipient_ids,

grasp_agents/workflow/workflow_agent.py

@@ -1,11 +1,11 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Any, Generic
+from typing import Any, ClassVar, Generic
 
 from ..agent_message_pool import AgentMessage, AgentMessagePool
 from ..comm_agent import CommunicatingAgent
 from ..run_context import CtxT, RunContextWrapper
-from ..typing.io import AgentID, AgentPayload, AgentState, InT, OutT
+from ..typing.io import AgentID, AgentState, InT, OutT
 
 
 class WorkflowAgent(
@@ -13,14 +13,17 @@ class WorkflowAgent(
     ABC,
     Generic[InT, OutT, CtxT],
 ):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
     def __init__(
         self,
         agent_id: AgentID,
-        subagents: Sequence[
-            CommunicatingAgent[AgentPayload, AgentPayload, AgentState, CtxT]
-        ],
-        start_agent: CommunicatingAgent[InT, AgentPayload, AgentState, CtxT],
-        end_agent: CommunicatingAgent[AgentPayload, OutT, AgentState, CtxT],
+        subagents: Sequence[CommunicatingAgent[Any, Any, AgentState, CtxT]],
+        start_agent: CommunicatingAgent[InT, Any, AgentState, CtxT],
+        end_agent: CommunicatingAgent[Any, OutT, AgentState, CtxT],
         message_pool: AgentMessagePool[CtxT] | None = None,
         recipient_ids: list[AgentID] | None = None,
         dynamic_routing: bool = False,
@@ -28,6 +31,10 @@ class WorkflowAgent(
     ) -> None:
         if not subagents:
             raise ValueError("At least one step is required")
+        if start_agent not in subagents:
+            raise ValueError("Start agent must be in the subagents list")
+        if end_agent not in subagents:
+            raise ValueError("End agent must be in the subagents list")
 
         self.subagents = subagents
 
@@ -36,8 +43,6 @@ class WorkflowAgent(
 
         super().__init__(
             agent_id=agent_id,
-            out_schema=end_agent.out_schema,
-            rcv_args_schema=start_agent.rcv_args_schema,
             message_pool=message_pool,
             recipient_ids=recipient_ids,
             dynamic_routing=dynamic_routing,
@@ -48,11 +53,11 @@ class WorkflowAgent(
             )
 
     @property
-    def start_agent(self) -> CommunicatingAgent[InT, AgentPayload, AgentState, CtxT]:
+    def start_agent(self) -> CommunicatingAgent[InT, Any, AgentState, CtxT]:
         return self._start_agent
 
     @property
-    def end_agent(self) -> CommunicatingAgent[AgentPayload, OutT, AgentState, CtxT]:
+    def end_agent(self) -> CommunicatingAgent[Any, OutT, AgentState, CtxT]:
         return self._end_agent
 
     @abstractmethod

{grasp_agents-0.1.18.dist-info → grasp_agents-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.1.18
+Version: 0.2.1
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4
@@ -17,7 +17,10 @@ Description-Content-Type: text/markdown
 # Grasp Agents
 
 <br/>
-<img src="./.assets/grasp.svg" alt="Grasp Agents" width="320" />
+<picture>
+  <source srcset="./.assets/grasp-dark.svg" media="(prefers-color-scheme: dark)">
+  <img src="./.assets/grasp.svg" alt="Grasp Agents"/>
+</picture>
 <br/>
 <br/>
 
@@ -34,14 +37,14 @@ Description-Content-Type: text/markdown
 ## Features
 
 - Clean formulation of agents as generic entities over:
-    * I/O schemas
-    * Agent state
-    * Shared context
+  - I/O schemas
+  - Agent state
+  - Shared context
 - Transparent implementation of common agentic patterns:
     * Single-agent loops with an optional "ReAct mode" to enforce reasoning between the tool calls
     * Workflows (static communication topology), including loops
     * Agents-as-tools for task delegation
-    * Freeform A2A communication via in-process Actor model
+    * Freeform A2A communication via the in-process actor model
 - Batch processing support outside of agentic loops
 - Simple logging and usage/cost tracking
 
@@ -54,7 +57,7 @@ Description-Content-Type: text/markdown
 - `prompt_builder.py`: Tools for constructing prompts.
 - `workflow/`: Modules for defining and managing agent workflows.
 - `cloud_llm.py`, `llm.py`: LLM integration and base LLM functionalities.
-- `openai/`: Modules specific to OpenAI API integration.    
+- `openai/`: Modules specific to OpenAI API integration.
 - `memory.py`: Memory management for agents (currently only message history).
 - `run_context.py`: Context management for agent runs.
 - `usage_tracker.py`: Tracking of API usage and costs.
@@ -107,18 +110,20 @@ GOOGLE_AI_STUDIO_API_KEY=your_google_ai_studio_api_key
 Create a script, e.g., `problem_recommender.py`:
 
 ```python
+import asyncio
 import re
-from typing import Any
 from pathlib import Path
-from pydantic import BaseModel, Field
+from typing import Any
+
 from dotenv import load_dotenv
-from grasp_agents.typing.tool import BaseTool
-from grasp_agents.typing.io import AgentPayload
-from grasp_agents.run_context import RunContextWrapper
-from grasp_agents.openai.openai_llm import OpenAILLM, OpenAILLMSettings
-from grasp_agents.llm_agent import LLMAgent
+from pydantic import BaseModel, Field
+
 from grasp_agents.grasp_logging import setup_logging
+from grasp_agents.llm_agent import LLMAgent
+from grasp_agents.openai.openai_llm import OpenAILLM, OpenAILLMSettings
+from grasp_agents.run_context import RunContextWrapper
 from grasp_agents.typing.message import Conversation
+from grasp_agents.typing.tool import BaseTool
 
 load_dotenv()
 
@@ -130,8 +135,8 @@ setup_logging(
 )
 
 sys_prompt_react = """
-Your task is to suggest an exciting stats problem to a student. 
-Ask the student about their education, interests, and preferences, then suggest a problem tailored to them. 
+Your task is to suggest an exciting stats problem to a student.
+Ask the student about their education, interests, and preferences, then suggest a problem tailored to them.
 
 # Instructions
 * Ask questions one by one.
@@ -143,14 +148,13 @@ Ask the student about their education, interests, and preferences, then suggest
 class TeacherQuestion(BaseModel):
     question: str = Field(..., description="The question to ask the student.")
 
+
 StudentReply = str
 
 
 class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, Any]):
     name: str = "ask_student_tool"
     description: str = "Ask the student a question and get their reply."
-    in_schema: type[TeacherQuestion] = TeacherQuestion
-    out_schema: type[StudentReply] = StudentReply
 
     async def run(
         self, inp: TeacherQuestion, ctx: RunContextWrapper[Any] | None = None
@@ -158,11 +162,10 @@ class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, Any]):
         return input(inp.question)
 
 
-class FinalResponse(AgentPayload):
-    problem: str
+Problem = str
 
 
-teacher = LLMAgent[Any, FinalResponse, None](
+teacher = LLMAgent[Any, Problem, None](
     agent_id="teacher",
     llm=OpenAILLM(
         model_name="gpt-4.1",
@@ -173,30 +176,31 @@ teacher = LLMAgent[Any, FinalResponse, None](
     max_turns=20,
     react_mode=True,
     sys_prompt=sys_prompt_react,
-    out_schema=FinalResponse,
     set_state_strategy="reset",
 )
 
 
-@teacher.tool_call_loop_exit_handler
-def exit_tool_call_loop(conversation: Conversation, ctx, **kwargs) -> None:
-    message_text = conversation[-1].content
-
-    return re.search(r"<PROBLEM>", message_text)
+@teacher.exit_tool_call_loop_handler
+def exit_tool_call_loop(
+    conversation: Conversation, ctx: RunContextWrapper[Any] | None, **kwargs: Any
+) -> bool:
+    return r"<PROBLEM>" in str(conversation[-1].content)
 
 
 @teacher.parse_output_handler
-def parse_output(conversation: Conversation, ctx, **kwargs) -> FinalResponse:
-    message_text = conversation[-1].content
-    matches = re.findall(r"<PROBLEM>(.*?)</PROBLEM>", message_text, re.DOTALL)
+def parse_output(
+    conversation: Conversation, ctx: RunContextWrapper[Any] | None, **kwargs: Any
+) -> Problem:
+    message = str(conversation[-1].content)
+    matches = re.findall(r"<PROBLEM>(.*?)</PROBLEM>", message, re.DOTALL)
 
-    return FinalResponse(problem=matches[0])
+    return matches[0]
 
 
 async def main():
-    ctx = RunContextWrapper(print_messages=True)
+    ctx = RunContextWrapper[None](print_messages=True)
     out = await teacher.run(ctx=ctx)
-    print(out.payloads[0].problem)
+    print(out.payloads[0])
     print(ctx.usage_tracker.total_usage)
 
 

grasp_agents-0.2.1.dist-info/RECORD

@@ -0,0 +1,45 @@
+grasp_agents/agent_message.py,sha256=eJV5n44t8EIE6M3jl48Ld7pmaW9dDhBX_FWm_u9yGWE,877
+grasp_agents/agent_message_pool.py,sha256=OKTXNEo9LAJTQJkzxmJ3TQgWw7WJKOzrKCJjeHpln6o,3158
+grasp_agents/base_agent.py,sha256=BOLYxS_cSisOR4qupUYIVn2FW15svit3jbNNfjw_cT8,1347
+grasp_agents/cloud_llm.py,sha256=D3iWYb0F-6cG4rXgVoP4bWm2u2RtnEh_xG3MufFaFDo,13157
+grasp_agents/comm_agent.py,sha256=e2IsatGLxdDkSZpPxQm6s1ha6w0Z9XAzRU1L4qb9wNY,7280
+grasp_agents/costs_dict.yaml,sha256=EW6XxRXLZobMwQEEiUNYALbDzfbZFb2zEVCaTSAqYjw,2334
+grasp_agents/generics_utils.py,sha256=kw4Odte6Nvl4c9U7-mKPgXCavWZXo009zYDHAA0BR3g,6234
+grasp_agents/grasp_logging.py,sha256=H1GYhXdQvVkmauFDZ-KDwvVmPQHZUUm9sRqX_ObK2xI,1111
+grasp_agents/http_client.py,sha256=KZva2MjJjuI5ohUeU8RdTAImUnQYaqBrV2jDH8smbJw,738
+grasp_agents/llm.py,sha256=n67lXbB8spr_i3Xz0Plw7oeykfjQmVHHkSiveqBB5Lw,3150
+grasp_agents/llm_agent.py,sha256=C57T2UlsGSebkLIdk96si06b1h5IVIGj1ZIUxV2tX2I,14989
+grasp_agents/llm_agent_state.py,sha256=lLdYni2f3TA5zJLf_jqR5DSWqVI_zP2YfNrwEGqZnvg,2402
+grasp_agents/memory.py,sha256=X1YtVX8XxP5KnGPMW8BqjID8QK4hTG2obxoyhnnZ4pU,5575
+grasp_agents/printer.py,sha256=Jk6OJExio53gbKBod5Dd8Y3CWYrVb4K5q4UJ8i9cQvo,5024
+grasp_agents/prompt_builder.py,sha256=JQ269tvRokWBdibJIkv1ZBkEYNR-AWppZpj2Fx7c9VY,8208
+grasp_agents/run_context.py,sha256=M4w_HXl5aiz-18CDlfNCRNZm3m5UIQMrjKkhurFTtkY,2229
+grasp_agents/tool_orchestrator.py,sha256=--E-ue7Z8nK6NwqGbWeCQWfTjWIbPxEe5X54bjPe62M,6107
+grasp_agents/usage_tracker.py,sha256=5YuN6hpg6HASdg-hOylgWzhCiORmDMnZuQtbISfhm_4,3378
+grasp_agents/utils.py,sha256=gKUtJ6__HB7yHBUPWY5tkdSAfgj3_R3--s2J5B5fBPE,5739
+grasp_agents/openai/__init__.py,sha256=qN8HMAatSJKOsA6v-JwakMYguwkswCVHqrmK1gFy9wI,3096
+grasp_agents/openai/completion_converters.py,sha256=lX9h1kaGAo5ttsl-4V7l4x8IpjxJaJJtyU2cKu3-EOc,1871
+grasp_agents/openai/content_converters.py,sha256=6GI0D7xJalzsiawAJOyCUzTJTo0NQdpv87YKmfN0LYQ,2631
+grasp_agents/openai/converters.py,sha256=DBXBxow9oRG6pc8inpZBLiuUqHzVfpscmHFpN9bAdvc,5276
+grasp_agents/openai/message_converters.py,sha256=KjF6FbXzwlWdM-1YT3cswUV-74sjiwOhLFPMY4sJ5Xk,4593
+grasp_agents/openai/openai_llm.py,sha256=dscGlVhH4v1yAw4NRPgJdww9toOoMRpIqA6HD4IGWOs,6132
+grasp_agents/openai/tool_converters.py,sha256=KhWRETkjhjocISUo_HBZ8QfBiyTOoC5WurPNAR4BYxc,1027
+grasp_agents/rate_limiting/__init__.py,sha256=KRgtF_E7R3YfA2cpYcFcZ7wycV0pWVJ0xRQC7YhiIEQ,158
+grasp_agents/rate_limiting/rate_limiter_chunked.py,sha256=BPgkUXvhmZhTpZs2T6uujNFuxH_kYHiISuf6_-eNhUc,5544
+grasp_agents/rate_limiting/types.py,sha256=PbnNhEAcYedQdIpPJWud8HUVcxa_xZS2RDZu4c5jr40,1003
+grasp_agents/rate_limiting/utils.py,sha256=oEDWDNHYMUdxOOG49PlAJochkZq8nnVBCo6JxPc1iSo,2007
+grasp_agents/typing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/typing/completion.py,sha256=_KDLx3Gtz7o-pEZrvAFgCZwDmkr2oQkxrL-2LSXHHsw,657
+grasp_agents/typing/content.py,sha256=VdnHdW8PHDCtX_ffvcwQz-7ypPUQNSGqHa3txFE_72Y,3676
+grasp_agents/typing/converters.py,sha256=yORIljRsVoKz7oj38pHLD6luIelM1RcYL_PqG_D4nWM,3086
+grasp_agents/typing/io.py,sha256=uxSvbD05UK5nIhPfDvXIoGuU6xRMW4USZq_4IgBeGCY,609
+grasp_agents/typing/message.py,sha256=XgPjXeh47e2GG1AYslhxaNw1Ax6Ozatga_7X2SFFKMA,3826
+grasp_agents/typing/tool.py,sha256=e0pTMnRcpMpGNVQ8muE9wnh7LdIgh92AqXDo9hMDxf0,1960
+grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/workflow/looped_agent.py,sha256=8NVy6dAwEs7f6JgYHZUI1h-N8SabpND4n-3rSy5mh70,3945
+grasp_agents/workflow/sequential_agent.py,sha256=Ral6Bvsl5-NdO-uKMGiWuz5EE9rNcYb1lXhY8CcQw4w,2054
+grasp_agents/workflow/workflow_agent.py,sha256=LadvEJTsV6YEGRb_eaYgu5r7k1aa8N-2FHXMYJpbBVU,2460
+grasp_agents-0.2.1.dist-info/METADATA,sha256=UY4lcgpBi7u0wqNU1Ep5Wp_13azdTzcFXsncASIdYXA,6889
+grasp_agents-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.2.1.dist-info/licenses/LICENSE.md,sha256=-nNNdWqGB8gJ2O-peFQ2Irshv5tW5pHKyTcYkwvH7CE,1201
+grasp_agents-0.2.1.dist-info/RECORD,,

{grasp_agents-0.1.18.dist-info → grasp_agents-0.2.1.dist-info}/licenses/LICENSE.md

@@ -8,6 +8,6 @@ Package production dependencies are licensed under the following terms:
 | dotenv    | 0.9.9   | BSD-3-Clause license                              | https://github.com/pedroburon/dotenv    |
 | httpx     | 0.28.1  | BSD License                                       | https://github.com/encode/httpx         |
 | openai    | 1.77.0  | Apache Software License                           | https://github.com/openai/openai-python |
-| tenacity  | 9.1.2   | Apache Software License                           | https://github.com/jd/tenacity          |
+| tenacity  | 8.5.0   | Apache Software License                           | https://github.com/jd/tenacity          |
 | termcolor | 2.5.0   | MIT License                                       | https://github.com/termcolor/termcolor  |
 | tqdm      | 4.67.1  | MIT License; Mozilla Public License 2.0 (MPL 2.0) | https://tqdm.github.io                  |