grasp_agents 0.4.7__py3-none-any.whl → 0.5.0__py3-none-any.whl

grasp_agents/utils.py

@@ -2,23 +2,22 @@ import ast
 import asyncio
 import json
 import re
-from collections.abc import Coroutine, Mapping
+from collections.abc import AsyncIterator, Coroutine, Mapping
 from datetime import UTC, datetime
 from logging import getLogger
 from pathlib import Path
-from typing import Annotated, Any, TypeVar, get_args, get_origin, overload
+from typing import Annotated, Any, TypeVar, get_args, get_origin
 
-from pydantic import TypeAdapter, ValidationError
+from pydantic import TypeAdapter
+from pydantic import ValidationError as PydanticValidationError
 from tqdm.autonotebook import tqdm
 
-from .errors import OutputValidationError, StringParsingError
+from .errors import JSONSchemaValidationError, PyJSONStringParsingError
 
 logger = getLogger(__name__)
 
 _JSON_START_RE = re.compile(r"[{\[]")
 
-T = TypeVar("T")
-
 
 def extract_json_substring(text: str) -> str | None:
     decoder = json.JSONDecoder()
@@ -34,112 +33,95 @@ def extract_json_substring(text: str) -> str | None:
 
 
 def parse_json_or_py_string(
-    s: str, return_none_on_failure: bool = False, strip_language_markdown: bool = True
+    s: str,
+    from_substring: bool = False,
+    return_none_on_failure: bool = False,
+    strip_language_markdown: bool = True,
 ) -> dict[str, Any] | list[Any] | None:
     s_orig = s
+
     if strip_language_markdown:
         s = re.sub(r"```[a-zA-Z0-9]*\n|```", "", s).strip()
+
+    if from_substring:
+        s = extract_json_substring(s) or ""
+
     try:
         return ast.literal_eval(s)
     except (ValueError, SyntaxError):
         try:
             return json.loads(s)
         except json.JSONDecodeError as exc:
+            err_message = (
+                "Both ast.literal_eval and json.loads "
+                f"failed to parse the following JSON/Python string:\n{s_orig}"
+            )
             if return_none_on_failure:
+                logger.warning(err_message)
                 return None
-            raise StringParsingError(
-                "Invalid JSON/Python string - Both ast.literal_eval and json.loads "
-                f"failed to parse the following response:\n{s_orig}"
-            ) from exc
+            raise PyJSONStringParsingError(s_orig, message=err_message) from exc
 
 
-def parse_json_or_py_substring(
-    json_str: str,
-    return_none_on_failure: bool = False,
-    strip_language_markdown: bool = True,
-) -> dict[str, Any] | list[Any] | None:
-    return parse_json_or_py_string(
-        extract_json_substring(json_str) or "",
-        return_none_on_failure=return_none_on_failure,
-        strip_language_markdown=strip_language_markdown,
-    )
-
+def is_str_type(t: Any) -> bool:
+    type_origin = get_origin(t)
+    type_args = get_args(t)
 
-@overload
-def validate_obj_from_json_or_py_string(
-    s: str,
-    adapter: TypeAdapter[T],
-    from_substring: bool = False,
-    strip_language_markdown: bool = True,
-) -> T: ...
+    return (t is str) or (
+        (type_origin is Annotated) and len(type_args) > 0 and type_args[0] is str
+    )
 
 
-@overload
 def validate_obj_from_json_or_py_string(
     s: str,
-    adapter: Mapping[str, TypeAdapter[T]],
+    schema: Any,
     from_substring: bool = False,
     strip_language_markdown: bool = True,
-) -> T | str: ...
-
-
-def validate_obj_from_json_or_py_string(
+) -> Any:
+    try:
+        if is_str_type(schema):
+            parsed = s
+        else:
+            parsed = parse_json_or_py_string(
+                s,
+                return_none_on_failure=True,
+                from_substring=from_substring,
+                strip_language_markdown=strip_language_markdown,
+            )
+        return TypeAdapter(schema).validate_python(parsed)
+    except PydanticValidationError as exc:
+        raise JSONSchemaValidationError(s, schema) from exc
+
+
+def validate_tagged_objs_from_json_or_py_string(
     s: str,
-    adapter: TypeAdapter[T] | Mapping[str, TypeAdapter[T]],
+    schema_by_xml_tag: Mapping[str, Any],
     from_substring: bool = False,
     strip_language_markdown: bool = True,
-) -> T | str:
-    _selected_adapter: TypeAdapter[T] | None = None
-    _selected_tag: str | None = None
-    s_orig = s
+) -> Mapping[str, Any]:
+    validated_obj_per_tag: dict[str, Any] = {}
+    _schema: Any = None
+    _tag: str | None = None
 
-    if isinstance(adapter, Mapping):
-        for _tag, _adapter in adapter.items():
+    try:
+        for _tag, _schema in schema_by_xml_tag.items():
             match = re.search(rf"<{_tag}>\s*(.*?)\s*</{_tag}>", s, re.DOTALL)
             if not match:
                 continue
-            s = match.group(1).strip()
-            _selected_adapter = _adapter
-            _selected_tag = _tag
-            break
-        if _selected_adapter is None:
-            return s
-    else:
-        _selected_adapter = adapter
-
-    _type = _selected_adapter._type  # type: ignore[attr-defined]
-    type_origin = get_origin(_type)
-    type_args = get_args(_type)
-    is_str_type = (_type is str) or (
-        type_origin is Annotated and type_args and type_args[0] is str
-    )
-
-    try:
-        if not is_str_type:
-            if from_substring:
-                parsed = parse_json_or_py_substring(
-                    s,
-                    return_none_on_failure=True,
-                    strip_language_markdown=strip_language_markdown,
-                )
-            else:
-                parsed = parse_json_or_py_string(
-                    s,
-                    return_none_on_failure=True,
-                    strip_language_markdown=strip_language_markdown,
-                )
-            if parsed is None:
-                parsed = s
-        else:
-            parsed = s
-        return _selected_adapter.validate_python(parsed)
-    except ValidationError as exc:
-        err_message = f"Invalid JSON or Python string:\n{s_orig}"
-        if _selected_tag:
-            err_message += f"\nExpected type {_type} within tag <{_selected_tag}>"
-        else:
-            err_message += f"\nExpected type {_type}"
-        raise OutputValidationError(err_message) from exc
+            tagged_substring = match.group(1).strip()
+            validated_obj_per_tag[_tag] = validate_obj_from_json_or_py_string(
+                tagged_substring,  # type: ignore[assignment]
+                schema=_schema,
+                from_substring=from_substring,
+                strip_language_markdown=strip_language_markdown,
+            )
+    except JSONSchemaValidationError as exc:
+        err_message = (
+            f"Failed to validate substring within tag <{_tag}> against JSON schema:"
+            f"\n{s}\nExpected type: {_schema}"
+        )
+        raise JSONSchemaValidationError(s, _schema, message=err_message) from exc
+
+    return validated_obj_per_tag
 
 
 def extract_xml_list(text: str) -> list[str]:
@@ -198,3 +180,32 @@ async def asyncio_gather_with_pbar(
 
 def get_timestamp() -> str:
     return datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
+
+
+_T = TypeVar("_T")
+
+
+async def stream_concurrent(
+    generators: list[AsyncIterator[_T]],
+) -> AsyncIterator[tuple[int, _T]]:
+    queue: asyncio.Queue[tuple[int, _T] | None] = asyncio.Queue()
+    pumps_left = len(generators)
+
+    async def pump(gen: AsyncIterator[_T], idx: int) -> None:
+        nonlocal pumps_left
+        try:
+            async for item in gen:
+                await queue.put((idx, item))
+        finally:
+            pumps_left -= 1
+            if pumps_left == 0:
+                await queue.put(None)
+
+    for idx, gen in enumerate(generators):
+        asyncio.create_task(pump(gen, idx))
+
+    while True:
+        msg = await queue.get()
+        if msg is None:
+            break
+        yield msg

grasp_agents/workflow/looped_workflow.py

@@ -1,12 +1,13 @@
-from collections.abc import Sequence
+from collections.abc import AsyncIterator, Sequence
 from itertools import pairwise
 from logging import getLogger
-from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast, final
+from typing import Any, Generic, Protocol, TypeVar, cast, final
 
 from ..errors import WorkflowConstructionError
 from ..packet_pool import Packet, PacketPool
 from ..processor import Processor
 from ..run_context import CtxT, RunContext
+from ..typing.events import Event, ProcPacketOutputEvent, WorkflowResultEvent
 from ..typing.io import InT, OutT_co, ProcName
 from .workflow_processor import WorkflowProcessor
 
@@ -27,11 +28,6 @@ class ExitWorkflowLoopHandler(Protocol[_OutT_contra, CtxT]):
 class LoopedWorkflow(
     WorkflowProcessor[InT, OutT_co, CtxT], Generic[InT, OutT_co, CtxT]
 ):
-    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
-        0: "_in_type",
-        1: "_out_type",
-    }
-
     def __init__(
         self,
         name: ProcName,
@@ -39,7 +35,7 @@ class LoopedWorkflow(
         exit_proc: Processor[Any, OutT_co, Any, CtxT],
         packet_pool: PacketPool[CtxT] | None = None,
         recipients: list[ProcName] | None = None,
-        num_par_run_retries: int = 0,
+        max_retries: int = 0,
         max_iterations: int = 10,
     ) -> None:
         super().__init__(
@@ -49,7 +45,7 @@ class LoopedWorkflow(
             end_proc=exit_proc,
             packet_pool=packet_pool,
             recipients=recipients,
-            num_par_run_retries=num_par_run_retries,
+            max_retries=max_retries,
         )
 
         for prev_proc, proc in pairwise(subprocs):
@@ -102,10 +98,12 @@ class LoopedWorkflow(
         *,
         in_packet: Packet[InT] | None = None,
         in_args: InT | Sequence[InT] | None = None,
-        run_id: str | None = None,
+        call_id: str | None = None,
         forgetful: bool = False,
         ctx: RunContext[CtxT] | None = None,
     ) -> Packet[OutT_co]:
+        call_id = self._generate_call_id(call_id)
+
         packet = in_packet
         num_iterations = 0
         exit_packet: Packet[OutT_co] | None = None
@@ -117,7 +115,7 @@ class LoopedWorkflow(
                     in_packet=packet,
                     in_args=in_args,
                     forgetful=forgetful,
-                    run_id=self._generate_subproc_run_id(run_id, subproc=subproc),
+                    call_id=f"{call_id}/{subproc.name}",
                     ctx=ctx,
                 )
 
@@ -135,3 +133,54 @@ class LoopedWorkflow(
 
                 chat_inputs = None
                 in_args = None
+
+    @final
+    async def run_stream(  # type: ignore[override]
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | Sequence[InT] | None = None,
+        call_id: str | None = None,
+        forgetful: bool = False,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        call_id = self._generate_call_id(call_id)
+
+        packet = in_packet
+        num_iterations = 0
+        exit_packet: Packet[OutT_co] | None = None
+
+        for subproc in self.subprocs:
+            async for event in subproc.run_stream(
+                chat_inputs=chat_inputs,
+                in_packet=packet,
+                in_args=in_args,
+                forgetful=forgetful,
+                call_id=f"{call_id}/{subproc.name}",
+                ctx=ctx,
+            ):
+                if isinstance(event, ProcPacketOutputEvent):
+                    packet = event.data
+                yield event
+
+            if subproc is self._end_proc:
+                num_iterations += 1
+                exit_packet = cast("Packet[OutT_co]", packet)
+                if self._exit_workflow_loop(exit_packet, ctx=ctx):
+                    yield WorkflowResultEvent(
+                        data=exit_packet, proc_name=self.name, call_id=call_id
+                    )
+                    return
+                if num_iterations >= self._max_iterations:
+                    logger.info(
+                        f"Max iterations reached ({self._max_iterations}). "
+                        "Exiting loop."
+                    )
+                    yield WorkflowResultEvent(
+                        data=exit_packet, proc_name=self.name, call_id=call_id
+                    )
+                    return
+
+            chat_inputs = None
+            in_args = None

grasp_agents/workflow/sequential_workflow.py

@@ -1,11 +1,12 @@
-from collections.abc import Sequence
+from collections.abc import AsyncIterator, Sequence
 from itertools import pairwise
-from typing import Any, ClassVar, Generic, cast, final
+from typing import Any, Generic, cast, final
 
 from ..errors import WorkflowConstructionError
 from ..packet_pool import Packet, PacketPool
 from ..processor import Processor
 from ..run_context import CtxT, RunContext
+from ..typing.events import Event, ProcPacketOutputEvent, WorkflowResultEvent
 from ..typing.io import InT, OutT_co, ProcName
 from .workflow_processor import WorkflowProcessor
 
@@ -13,18 +14,13 @@ from .workflow_processor import WorkflowProcessor
 class SequentialWorkflow(
     WorkflowProcessor[InT, OutT_co, CtxT], Generic[InT, OutT_co, CtxT]
 ):
-    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
-        0: "_in_type",
-        1: "_out_type",
-    }
-
     def __init__(
         self,
         name: ProcName,
         subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
         packet_pool: PacketPool[CtxT] | None = None,
         recipients: list[ProcName] | None = None,
-        num_par_run_retries: int = 0,
+        max_retries: int = 0,
     ) -> None:
         super().__init__(
             subprocs=subprocs,
@@ -33,7 +29,7 @@ class SequentialWorkflow(
             name=name,
             packet_pool=packet_pool,
             recipients=recipients,
-            num_par_run_retries=num_par_run_retries,
+            max_retries=max_retries,
         )
 
         for prev_proc, proc in pairwise(subprocs):
@@ -52,9 +48,11 @@ class SequentialWorkflow(
         in_packet: Packet[InT] | None = None,
         in_args: InT | Sequence[InT] | None = None,
         forgetful: bool = False,
-        run_id: str | None = None,
+        call_id: str | None = None,
         ctx: RunContext[CtxT] | None = None,
     ) -> Packet[OutT_co]:
+        call_id = self._generate_call_id(call_id)
+
         packet = in_packet
         for subproc in self.subprocs:
             packet = await subproc.run(
@@ -62,10 +60,44 @@ class SequentialWorkflow(
                 in_packet=packet,
                 in_args=in_args,
                 forgetful=forgetful,
-                run_id=self._generate_subproc_run_id(run_id, subproc),
+                call_id=f"{call_id}/{subproc.name}",
                 ctx=ctx,
             )
             chat_inputs = None
             in_args = None
 
         return cast("Packet[OutT_co]", packet)
+
+    @final
+    async def run_stream(  # type: ignore[override]
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | Sequence[InT] | None = None,
+        forgetful: bool = False,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        call_id = self._generate_call_id(call_id)
+
+        packet = in_packet
+        for subproc in self.subprocs:
+            async for event in subproc.run_stream(
+                chat_inputs=chat_inputs,
+                in_packet=packet,
+                in_args=in_args,
+                forgetful=forgetful,
+                call_id=f"{call_id}/{subproc.name}",
+                ctx=ctx,
+            ):
+                if isinstance(event, ProcPacketOutputEvent):
+                    packet = event.data
+                yield event
+
+            chat_inputs = None
+            in_args = None
+
+        yield WorkflowResultEvent(
+            data=cast("Packet[OutT_co]", packet), proc_name=self.name, call_id=call_id
+        )

grasp_agents/workflow/workflow_processor.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
-from typing import Any, ClassVar, Generic
+from collections.abc import AsyncIterator, Sequence
+from typing import Any, Generic
 
 from ..comm_processor import CommProcessor
 from ..errors import WorkflowConstructionError
@@ -8,6 +8,7 @@ from ..packet import Packet
 from ..packet_pool import PacketPool
 from ..processor import Processor
 from ..run_context import CtxT, RunContext
+from ..typing.events import Event
 from ..typing.io import InT, OutT_co, ProcName
 
 
@@ -16,11 +17,6 @@ class WorkflowProcessor(
     ABC,
     Generic[InT, OutT_co, CtxT],
 ):
-    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
-        0: "_in_type",
-        1: "_out_type",
-    }
-
     def __init__(
         self,
         name: ProcName,
@@ -29,15 +25,18 @@ class WorkflowProcessor(
         end_proc: Processor[Any, OutT_co, Any, CtxT],
         packet_pool: PacketPool[CtxT] | None = None,
         recipients: list[ProcName] | None = None,
-        num_par_run_retries: int = 0,
+        max_retries: int = 0,
     ) -> None:
         super().__init__(
             name=name,
             packet_pool=packet_pool,
             recipients=recipients,
-            num_par_run_retries=num_par_run_retries,
+            max_retries=max_retries,
         )
 
+        self._in_type = start_proc.in_type
+        self._out_type = end_proc.out_type
+
         if len(subprocs) < 2:
             raise WorkflowConstructionError("At least two subprocessors are required")
         if start_proc not in subprocs:
@@ -49,17 +48,6 @@ class WorkflowProcessor(
                 "End subprocessor must be in the subprocessors list"
             )
 
-        if start_proc.in_type != self.in_type:
-            raise WorkflowConstructionError(
-                f"Start subprocessor's input type {start_proc.in_type} does not "
-                f"match workflow's input type {self._in_type}"
-            )
-        if end_proc.out_type != self.out_type:
-            raise WorkflowConstructionError(
-                f"End subprocessor's output type {end_proc.out_type} does not "
-                f"match workflow's output type {self._out_type}"
-            )
-
         self._subprocs = subprocs
         self._start_proc = start_proc
         self._end_proc = end_proc
@@ -76,10 +64,10 @@ class WorkflowProcessor(
     def end_proc(self) -> Processor[Any, OutT_co, Any, CtxT]:
         return self._end_proc
 
-    def _generate_subproc_run_id(
-        self, run_id: str | None, subproc: Processor[Any, Any, Any, CtxT]
+    def _generate_subproc_call_id(
+        self, call_id: str | None, subproc: Processor[Any, Any, Any, CtxT]
     ) -> str | None:
-        return f"{self._generate_run_id(run_id)}/{subproc.name}"
+        return f"{self._generate_call_id(call_id)}/{subproc.name}"
 
     @abstractmethod
     async def run(
@@ -90,6 +78,19 @@ class WorkflowProcessor(
         in_args: InT | Sequence[InT] | None = None,
         ctx: RunContext[CtxT] | None = None,
         forgetful: bool = False,
-        run_id: str | None = None,
+        call_id: str | None = None,
     ) -> Packet[OutT_co]:
         pass
+
+    @abstractmethod
+    async def run_stream(  # type: ignore[override]
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | Sequence[InT] | None = None,
+        ctx: RunContext[CtxT] | None = None,
+        forgetful: bool = False,
+        call_id: str | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        pass

{grasp_agents-0.4.7.dist-info → grasp_agents-0.5.0.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.4.7
+Version: 0.5.0
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: httpx<1,>=0.27.0
+Requires-Dist: litellm>=1.74.4
 Requires-Dist: openai<2,>=1.68.2
 Requires-Dist: pydantic>=2
 Requires-Dist: pyyaml>=6.0.2
@@ -103,7 +104,7 @@ Ensure you have a `.env` file with your OpenAI and Google AI Studio API keys set
 
 ```
 OPENAI_API_KEY=your_openai_api_key
-GOOGLE_AI_STUDIO_API_KEY=your_google_ai_studio_api_key
+GEMINI_API_KEY=your_gemini_api_key
 ```
 
 Create a script, e.g., `problem_recommender.py`:
@@ -117,7 +118,7 @@ from dotenv import load_dotenv
 from pydantic import BaseModel, Field
 
 from grasp_agents.grasp_logging import setup_logging
-from grasp_agents.openai import OpenAILLM, OpenAILLMSettings
+from grasp_agents.litellm import LiteLLM, LiteLLMSettings
 from grasp_agents import LLMAgent, BaseTool, RunContext
 
 load_dotenv()
@@ -178,9 +179,9 @@ class Problem(BaseModel):
 
 teacher = LLMAgent[None, Problem, None](
     name="teacher",
-    llm=OpenAILLM(
-        model_name="openai:gpt-4.1",
-        llm_settings=OpenAILLMSettings(temperature=0.5),
+    llm=LiteLLM(
+        model_name="gpt-4.1",
+        llm_settings=LiteLLMSettings(temperature=0.5),
     ),
     tools=[AskStudentTool()],
     react_mode=True,

grasp_agents-0.5.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+grasp_agents/__init__.py,sha256=CIsyUasb9HBC3M4olg6ATAwKXtVNmmtpyGJrt7hpZW4,947
+grasp_agents/cloud_llm.py,sha256=C6xrKYhiQb4tNXK_rFo2pNlVTXPS_gYd5uevAnpLFeE,13119
+grasp_agents/comm_processor.py,sha256=Tg6At2Ybow2WnJNvykOXKol4z5k3l8ED-GSesnA6aG0,6816
+grasp_agents/costs_dict.yaml,sha256=2MFNWtkv5W5WSCcv1Cj13B1iQLVv5Ot9pS_KW2Gu2DA,2510
+grasp_agents/errors.py,sha256=s4JRvccRroxmiM5d27f2KvUxw5yK8mkEZO4OCo98BKc,2531
+grasp_agents/generics_utils.py,sha256=5Pw3I9dlnKC2VGqYKC4ZZUO3Z_vTNT-NPFovNfPkl6I,6542
+grasp_agents/grasp_logging.py,sha256=H1GYhXdQvVkmauFDZ-KDwvVmPQHZUUm9sRqX_ObK2xI,1111
+grasp_agents/http_client.py,sha256=Es8NXGDkp4Nem7g24-jW0KFGA9Hp_o2Cv3cOvjup-iU,859
+grasp_agents/llm.py,sha256=YCzHlb2gdWVy77DmQpcu0dyEzGp4VQa3UMRJKodCYSs,6557
+grasp_agents/llm_agent.py,sha256=coXcYSd1G8UiYPqNpF1z5ESQcH2zhSHYO8QhQfRtqiE,14401
+grasp_agents/llm_agent_memory.py,sha256=GZ2Z66_JC_sR10vATvR53ui62xxY4lDDtL0XvL_AQNk,1846
+grasp_agents/llm_policy_executor.py,sha256=aWxXS2-7Twzaz8U07wslzR8zR9byl2bDha1ACKxUEvI,16734
+grasp_agents/memory.py,sha256=uRplf46uxHDmiNR3q7nk9fGSPv_BUtp8zJ-vzxUrXXg,783
+grasp_agents/packet.py,sha256=neJ139jgLKgZjLyXAwSe0lH08BftveYOsLFyri9MZ0w,785
+grasp_agents/packet_pool.py,sha256=doG7UpTO7cqJi4YT0UP_vfOnOebqiwzBUHfoxy1TkPY,3282
+grasp_agents/printer.py,sha256=JpEnal0wuI5dAVvg7IgzBSJsZgfydUVmfjXLGpEOE0I,10853
+grasp_agents/processor.py,sha256=WKtU5BleZ7IGSqDv0ZpO8RgBY04SInMU7JIjh3m34wg,15828
+grasp_agents/prompt_builder.py,sha256=3Ua-f-lRdoE2LomFWDiZILpKpfuQxAM-aHcY69hvv1U,7978
+grasp_agents/run_context.py,sha256=dUxwx1yM3gSk2KqMIAeDVVftysdk7v_1Ht0EcLk9jJI,1242
+grasp_agents/runner.py,sha256=yH1yUIhwpcAivLFFaq5pXJ9OQdFa4WjOs_uqJ4XTNQw,1456
+grasp_agents/usage_tracker.py,sha256=ZQfVUUpG0C89hyPWT_JgXnjQOxoYmumcQ9t-aCfcMo8,3561
+grasp_agents/utils.py,sha256=qKmGBwrQHw1-BgqRLuGTPKGs3J_zbrpk3nxnP1iZBiQ,6152
+grasp_agents/litellm/__init__.py,sha256=wD8RZBYokFDfbS9Cs7nO_zKb3w7RIVwEGj7g2D5CJH0,4510
+grasp_agents/litellm/completion_chunk_converters.py,sha256=J5PPxzoTBqkvKQnCoBxQxJo7Q8Xfl9cbv2GRZox8Cjo,2689
+grasp_agents/litellm/completion_converters.py,sha256=JQ7XvQwwc-biFqVMcRO61SL5VGs_SkUvAhUz1QD7EmU,2516
+grasp_agents/litellm/converters.py,sha256=3u648xjrphr9zPp12PO8fU13G4nI6_e9714Xcvh6SHc,4721
+grasp_agents/litellm/lite_llm.py,sha256=tJngUfZb2t59Rv9glQPCGNILlLKvy_6wNrQQFS8OZrY,8096
+grasp_agents/litellm/message_converters.py,sha256=PsGLIJEcAeEoluHIh-utEufJ_9WeMYzXkwnR-8jyULQ,2037
+grasp_agents/openai/__init__.py,sha256=xaRnblUskiLvypIhMe4NRp9dxCG-gNR7dPiugUbPbhE,4717
+grasp_agents/openai/completion_chunk_converters.py,sha256=3MnMskdlp7ycsggc1ok1XpCHaP4Us2rLYaxImPLw1eI,2573
+grasp_agents/openai/completion_converters.py,sha256=UlDeQSl0AEFUS-QI5e8rrjfmXZojSYksJGnrXA7DmIk,2528
+grasp_agents/openai/content_converters.py,sha256=sMsZhoatuL_8t0IdVaGWIVZLB4nyi1ajD61GewQmeY4,2503
+grasp_agents/openai/converters.py,sha256=CXHF2GehEHLEzjL45HywZ_1qaB3N29-lbac5oBDnLGA,4634
+grasp_agents/openai/message_converters.py,sha256=fhSN81uK51EGbLyM2-f0MvPX_UBrMy7SF3JQPo-dkXg,4686
+grasp_agents/openai/openai_llm.py,sha256=uJbbCytqpv8OCncKdzpiUdkVh3mJWgo95Y9Xetk_Ptg,10556
+grasp_agents/openai/tool_converters.py,sha256=IotZvpe3xMQcBfcjUTfAsn4LtZljj3zkU9bfpcoiqPw,1177
+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=PHJ01m7WI2KYQL8w7W2ti6hMsKEZnzYGaxbNcBCc_IE,2782
+grasp_agents/typing/completion_chunk.py,sha256=t6PvkDWQxRN5xA4efBdeou46RifMFodBmZc45Sx7qxQ,7610
+grasp_agents/typing/content.py,sha256=XFmLpNWkGhkw5JujO6UsYwhzTHkU67PfhzaXH2waLcQ,3659
+grasp_agents/typing/converters.py,sha256=kHlocHQS8QnduZOzNPbj3aRD8JpvJd53oudYqWdOxKE,2978
+grasp_agents/typing/events.py,sha256=XMwhEaVLq8vUBnusti5V02EOtx2TrlL1yUGbHVtiBdI,5130
+grasp_agents/typing/io.py,sha256=RtBnxOiEJkfCPz7bEu1T1JXU7o71MhHK3RkeedzWwX0,237
+grasp_agents/typing/message.py,sha256=o7bN84AgrC5Fm3Wx20gqL9ArAMcEtYvnHnXbb04ngCs,3224
+grasp_agents/typing/tool.py,sha256=4N-k_GvHVPAFyVyEq7z_LYKkA24iQlGoVYiWCzGTgT4,1786
+grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/workflow/looped_workflow.py,sha256=eA2V4ftAjXth1OqQS_jTNS3D5_hzLGGyWfn4Ju47FQ0,6338
+grasp_agents/workflow/sequential_workflow.py,sha256=wKlF6PvzLXkKDGlfvd8h-WI3AGNo6qyS2gkROzdPvWM,3421
+grasp_agents/workflow/workflow_processor.py,sha256=I0sTMfWGeTcx0y0oYssz8B85_PFhbatHXrSJ31woI6Q,3015
+grasp_agents-0.5.0.dist-info/METADATA,sha256=w21-UoIaSRaFmJe1KWfk4dQqQtvKmPfAQscIcMeMHjg,6865
+grasp_agents-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.5.0.dist-info/licenses/LICENSE.md,sha256=-nNNdWqGB8gJ2O-peFQ2Irshv5tW5pHKyTcYkwvH7CE,1201
+grasp_agents-0.5.0.dist-info/RECORD,,