grasp_agents 0.1.5__py3-none-any.whl

grasp_agents/usage_tracker.py

@@ -0,0 +1,99 @@
+import logging
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, TypeAlias
+
+import yaml
+from pydantic import BaseModel, Field
+from termcolor import colored
+
+from .typing.message import AssistantMessage, Message, Usage
+
+logger = logging.getLogger(__name__)
+
+
+COSTS_DICT_PATH: Path = Path(__file__).parent / "costs_dict.yaml"
+
+ModelCostsDict: TypeAlias = dict[str, float]
+CostsDict: TypeAlias = dict[str, ModelCostsDict]
+
+
+class UsageTracker(BaseModel):
+    source_id: str
+    costs_dict_path: str | Path = COSTS_DICT_PATH
+    costs_dict: CostsDict | None = None
+    total_usage: Usage = Field(default_factory=Usage)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.costs_dict = self.load_costs_dict()
+
+    def load_costs_dict(self) -> CostsDict | None:
+        try:
+            with Path(self.costs_dict_path).open() as f:
+                return yaml.safe_load(f)["costs"]
+        except Exception:
+            logger.info(f"Failed to load cost dictionary from {self.costs_dict_path}")
+            return None
+
+    def _add_cost_to_usage(
+        self, usage: Usage, model_costs_dict: ModelCostsDict
+    ) -> None:
+        in_rate = model_costs_dict["input"]
+        out_rate = model_costs_dict["output"]
+        cached_discount = model_costs_dict.get("cached_discount")
+        input_cost = in_rate * usage.input_tokens
+        output_cost = out_rate * usage.output_tokens
+        reasoning_cost = (
+            out_rate * usage.reasoning_tokens
+            if usage.reasoning_tokens is not None
+            else 0.0
+        )
+        cached_cost: float = (
+            cached_discount * in_rate * usage.cached_tokens
+            if (usage.cached_tokens is not None) and (cached_discount is not None)
+            else 0.0
+        )
+        usage.cost = (input_cost + output_cost + reasoning_cost + cached_cost) / 1e6
+
+    def update(
+        self, messages: Sequence[Message], model_name: str | None = None
+    ) -> None:
+        if model_name is not None and self.costs_dict is not None:
+            model_costs_dict = self.costs_dict.get(model_name)
+        else:
+            model_costs_dict = None
+
+        for message in messages:
+            if isinstance(message, AssistantMessage) and message.usage is not None:
+                if model_costs_dict is not None:
+                    self._add_cost_to_usage(
+                        usage=message.usage, model_costs_dict=model_costs_dict
+                    )
+                self.total_usage += message.usage
+
+    def reset(self) -> None:
+        self.total_usage = Usage()
+
+    def print_usage(self) -> None:
+        usage = self.total_usage
+
+        logger.debug("\n-------------------")
+
+        token_usage_str = (
+            f"Total {self.source_id} I/O/(R)/(C) tokens: "
+            f"{usage.input_tokens}/{usage.output_tokens}"
+        )
+        if usage.reasoning_tokens is not None:
+            token_usage_str += f"/{usage.reasoning_tokens}"
+        if usage.cached_tokens is not None:
+            token_usage_str += f"/{usage.cached_tokens}"
+        logger.debug(colored(token_usage_str, "light_grey"))
+
+        if usage.cost is not None:
+            logger.debug(
+                colored(
+                    f"Total {self.source_id} cost: ${usage.cost:.4f}",
+                    "light_grey",
+                )
+            )

grasp_agents/utils.py

@@ -0,0 +1,151 @@
+import ast
+import asyncio
+from datetime import datetime
+import functools
+import json
+import re
+from collections.abc import Callable, Coroutine
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, TypeVar, cast
+
+from pydantic import BaseModel, create_model
+from pydantic.fields import FieldInfo
+from tqdm.autonotebook import tqdm
+
+
+def read_contents_from_file(
+    file_path: str | Path,
+    binary_mode: bool = False,
+) -> str:
+    """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()
+    except FileNotFoundError:
+        print(f"File {file_path} not found.")
+        return ""
+
+
+async def asyncio_gather_with_pbar(
+    *corouts: Coroutine[Any, Any, Any],
+    no_tqdm: bool = False,
+    desc: str | None = None,
+) -> list[Any]:
+    pbar = tqdm(total=len(corouts), desc=desc, disable=no_tqdm)
+
+    async def run_and_update(coro: Coroutine[Any, Any, Any]) -> Any:
+        result = await coro
+        pbar.update(1)
+        return result
+
+    wrapped_tasks = [run_and_update(c) for c in corouts]
+    results = await asyncio.gather(*wrapped_tasks)
+    pbar.close()
+
+    return results
+
+
+def get_timestamp() -> str:
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def read_txt(file_path: str) -> str:
+    return Path(file_path).read_text()
+
+
+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 ""
+
+
+def read_json_string(json_str: str) -> dict[str, Any] | list[Any]:
+    try:
+        json_response = ast.literal_eval(json_str)
+    except (ValueError, SyntaxError):
+        try:
+            json_response = json.loads(json_str)
+        except json.JSONDecodeError as exc:
+            raise ValueError(
+                "Invalid JSON - Both ast.literal_eval and json.loads "
+                f"failed to parse the following response:\n{json_str}"
+            ) from exc
+
+    return json_response  # type: ignore
+
+
+def extract_json(json_str: str) -> dict[str, Any] | list[Any]:
+    return read_json_string(format_json_string(json_str))
+
+
+def extract_xml_list(text: str) -> list[str]:
+    pattern = re.compile(r"<(chunk_\d+)>(.*?)</\1>", re.DOTALL)
+
+    chunks: list[str] = []
+    for match in pattern.finditer(text):
+        content = match.group(2).strip()
+        chunks.append(content)
+    return chunks
+
+
+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 prompt
+
+
+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
+
+    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}
+
+
+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)

grasp_agents/workflow/looped_agent.py

@@ -0,0 +1,113 @@
+from collections.abc import Sequence
+from logging import getLogger
+from typing import Any, 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 .workflow_agent import WorkflowAgent
+
+logger = getLogger(__name__)
+
+_EH_OutT = TypeVar("_EH_OutT", bound=AgentPayload, contravariant=True)  # noqa: PLC0105
+
+
+class WorkflowLoopExitHandler(Protocol[_EH_OutT, CtxT]):
+    def __call__(
+        self,
+        output_message: AgentMessage[_EH_OutT, AgentState],
+        ctx: RunContextWrapper[CtxT] | None,
+        **kwargs: Any,
+    ) -> bool: ...
+
+
+class LoopedWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, CtxT]):
+    def __init__(
+        self,
+        agent_id: AgentID,
+        subagents: Sequence[
+            CommunicatingAgent[AgentPayload, AgentPayload, AgentState, CtxT]
+        ],
+        exit_agent: CommunicatingAgent[AgentPayload, OutT, AgentState, CtxT],
+        message_pool: AgentMessagePool[CtxT] | None = None,
+        recipient_ids: list[AgentID] | None = None,
+        dynamic_routing: bool = False,
+        max_iterations: int = 10,
+        **kwargs: Any,  # noqa: ARG002
+    ) -> None:
+        super().__init__(
+            subagents=subagents,
+            agent_id=agent_id,
+            start_agent=subagents[0],
+            end_agent=exit_agent,
+            message_pool=message_pool,
+            recipient_ids=recipient_ids,
+            dynamic_routing=dynamic_routing,
+        )
+
+        self._max_iterations = max_iterations
+
+        self._workflow_loop_exit_impl: WorkflowLoopExitHandler[OutT, CtxT] | None = None
+
+    @property
+    def max_iterations(self) -> int:
+        return self._max_iterations
+
+    def workflow_loop_exit_handler(
+        self, func: WorkflowLoopExitHandler[OutT, CtxT]
+    ) -> WorkflowLoopExitHandler[OutT, CtxT]:
+        self._workflow_loop_exit_impl = func
+
+        return func
+
+    def _workflow_loop_exit(
+        self,
+        output_message: AgentMessage[OutT, AgentState],
+        ctx: RunContextWrapper[CtxT] | None,
+        **kwargs: Any,
+    ) -> bool:
+        if self._workflow_loop_exit_impl:
+            return self._workflow_loop_exit_impl(output_message, ctx=ctx, **kwargs)
+
+        return False
+
+    @final
+    async def run(
+        self,
+        inp_items: Any | None = None,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+        rcv_message: AgentMessage[InT, AgentState] | None = None,
+        entry_point: bool = False,
+        forbid_state_change: bool = False,
+        **kwargs: Any,
+    ) -> AgentMessage[OutT, AgentState]:
+        agent_message = rcv_message
+        num_iterations = 0
+        exit_message: AgentMessage[OutT, AgentState] | None = None
+
+        while True:
+            for subagent in self.subagents:
+                agent_message = await subagent.run(
+                    inp_items=inp_items,
+                    rcv_message=agent_message,
+                    entry_point=entry_point,
+                    forbid_state_change=forbid_state_change,
+                    ctx=ctx,
+                    **kwargs,
+                )
+
+                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):
+                        return exit_message
+                    if num_iterations >= self._max_iterations:
+                        logger.info(
+                            f"Max iterations reached ({self._max_iterations}). Exiting loop."
+                        )
+                        return exit_message
+
+                inp_items = None
+                entry_point = False

grasp_agents/workflow/sequential_agent.py

@@ -0,0 +1,57 @@
+from collections.abc import Sequence
+from typing import Any, 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 .workflow_agent import WorkflowAgent
+
+
+class SequentialWorkflowAgent(WorkflowAgent[InT, OutT, CtxT], Generic[InT, OutT, CtxT]):
+    def __init__(
+        self,
+        agent_id: AgentID,
+        subagents: Sequence[
+            CommunicatingAgent[AgentPayload, AgentPayload, AgentState, CtxT]
+        ],
+        message_pool: AgentMessagePool[CtxT] | None = None,
+        recipient_ids: list[AgentID] | None = None,
+        dynamic_routing: bool = False,
+        **kwargs: Any,  # noqa: ARG002
+    ) -> None:
+        super().__init__(
+            subagents=subagents,
+            start_agent=subagents[0],
+            end_agent=subagents[-1],  # type: ignore[assignment]
+            agent_id=agent_id,
+            message_pool=message_pool,
+            recipient_ids=recipient_ids,
+            dynamic_routing=dynamic_routing,
+        )
+
+    @final
+    async def run(
+        self,
+        inp_items: Any | None = None,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+        rcv_message: AgentMessage[InT, AgentState] | None = None,
+        entry_point: bool = False,
+        forbid_state_change: bool = False,
+        **kwargs: Any,
+    ) -> AgentMessage[OutT, AgentState]:
+        agent_message = rcv_message
+        for subagent in self.subagents:
+            agent_message = await subagent.run(
+                inp_items=inp_items,
+                rcv_message=agent_message,
+                entry_point=entry_point,
+                forbid_state_change=forbid_state_change,
+                ctx=ctx,
+                **kwargs,
+            )
+            inp_items = None
+            entry_point = False
+
+        return cast("AgentMessage[OutT, AgentState]", agent_message)

grasp_agents/workflow/workflow_agent.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Any, 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
+
+
+class WorkflowAgent(
+    CommunicatingAgent[InT, OutT, AgentState, CtxT],
+    ABC,
+    Generic[InT, OutT, CtxT],
+):
+    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],
+        message_pool: AgentMessagePool[CtxT] | None = None,
+        recipient_ids: list[AgentID] | None = None,
+        dynamic_routing: bool = False,
+        **kwargs: Any,  # noqa: ARG002
+    ) -> None:
+        if not subagents:
+            raise ValueError("At least one step is required")
+
+        self.subagents = subagents
+
+        self._start_agent = start_agent
+        self._end_agent = end_agent
+
+        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,
+        )
+        for subagent in subagents:
+            assert not subagent.recipient_ids, (
+                "Subagents must not have recipient_ids set."
+            )
+
+    @property
+    def start_agent(self) -> CommunicatingAgent[InT, AgentPayload, AgentState, CtxT]:
+        return self._start_agent
+
+    @property
+    def end_agent(self) -> CommunicatingAgent[AgentPayload, OutT, AgentState, CtxT]:
+        return self._end_agent
+
+    @abstractmethod
+    async def run(
+        self,
+        inp_items: Any | None = None,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+        rcv_message: AgentMessage[InT, AgentState] | None = None,
+        entry_point: bool = False,
+        forbid_state_change: bool = False,
+        **generation_kwargs: Any,
+    ) -> AgentMessage[OutT, AgentState]:
+        pass

grasp_agents-0.1.5.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: grasp_agents
+Version: 0.1.5
+Summary: Add your description here
+License-File: LICENSE
+Requires-Python: <3.12,>=3.11.4
+Requires-Dist: httpx<1,>=0.27.0
+Requires-Dist: openai<2,>=1.68.2
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: termcolor<3,>=2.4.0
+Requires-Dist: tqdm<5,>=4.66.2
+Description-Content-Type: text/markdown
+
+# grasp-agents

grasp_agents-0.1.5.dist-info/RECORD

@@ -0,0 +1,44 @@
+grasp_agents/agent_message.py,sha256=atYrmIVT-1wkLUM79YnqcRVy_J7Vwsj-9KCXFEoI0tc,944
+grasp_agents/agent_message_pool.py,sha256=4O4xz-aZ_I5m3iLAUiMAQcVn5AGRP4daUM8XME03Xsw,3250
+grasp_agents/base_agent.py,sha256=Zf7lL-0iYse1hKTfgWYCCO8Va-8wKliougW6Nmd2RG4,1876
+grasp_agents/cloud_llm.py,sha256=V1TN_xGTQ1uN4RVn_6bfYBEjnhxRCBHac60FFtCSawI,11677
+grasp_agents/comm_agent.py,sha256=x1x6lE23F4iitofKlDgmXTT-aNt6L-sR8wC5L9DRCag,7748
+grasp_agents/costs_dict.yaml,sha256=EW6XxRXLZobMwQEEiUNYALbDzfbZFb2zEVCaTSAqYjw,2334
+grasp_agents/grasp_logging.py,sha256=H1GYhXdQvVkmauFDZ-KDwvVmPQHZUUm9sRqX_ObK2xI,1111
+grasp_agents/http_client.py,sha256=KZva2MjJjuI5ohUeU8RdTAImUnQYaqBrV2jDH8smbJw,738
+grasp_agents/llm.py,sha256=fks_mGkg2vgPGsJGr6rD6mN-IMgbYab_nA2qj3A3ADQ,2987
+grasp_agents/llm_agent.py,sha256=9Z8qxOM4Y7oTBEi53zt8BqmAJIBqtwCGNxUfru458Xk,11997
+grasp_agents/llm_agent_state.py,sha256=91K1-8Uodbe-t_I6nu0xBzHfQjssZYCHjMuDbu5aCr0,2327
+grasp_agents/memory.py,sha256=7YkZKQHuXAfQlGqLoXdt6YZmgSj3EWVtT72s_v84ixc,5808
+grasp_agents/printer.py,sha256=Jk6OJExio53gbKBod5Dd8Y3CWYrVb4K5q4UJ8i9cQvo,5024
+grasp_agents/prompt_builder.py,sha256=rYVIY4adJwBitjrTYvpEh5x8C7cLbIiXxT1F-vQuvEM,7393
+grasp_agents/run_context.py,sha256=hyETO3-p0azPFws75kX6rrUDLf58Ar6jmyt6TQ5Po78,2589
+grasp_agents/tool_orchestrator.py,sha256=d7gOVqcki3qNC_UFvAyLO8iirGwrfzs50bQQrUF-43E,5513
+grasp_agents/usage_tracker.py,sha256=5YuN6hpg6HASdg-hOylgWzhCiORmDMnZuQtbISfhm_4,3378
+grasp_agents/utils.py,sha256=9newohaDSRuoUwSdrlox8RX3bI40MRTJyjT2S1MZzmE,4246
+grasp_agents/data_retrieval/__init__.py,sha256=KRgtF_E7R3YfA2cpYcFcZ7wycV0pWVJ0xRQC7YhiIEQ,158
+grasp_agents/data_retrieval/rate_limiter_chunked.py,sha256=NPqYrWwKTx1lim_zlhWar5wDwFz1cA-b6JOzT10kOtE,5843
+grasp_agents/data_retrieval/types.py,sha256=JbLYJC-gmzcHH_4-YNTz9IcIwVpcpDyDGvljxNznf5k,1389
+grasp_agents/data_retrieval/utils.py,sha256=D3Bkq6-9gF7ubearjZwZaTt_u2-sM3JDlGQD9HmJ3rQ,1917
+grasp_agents/openai/__init__.py,sha256=qN8HMAatSJKOsA6v-JwakMYguwkswCVHqrmK1gFy9wI,3096
+grasp_agents/openai/completion_converters.py,sha256=YvborvhN3_tACBBKXfOkx2NsTo6vqvNoPse_PqOSKUo,1774
+grasp_agents/openai/content_converters.py,sha256=6GI0D7xJalzsiawAJOyCUzTJTo0NQdpv87YKmfN0LYQ,2631
+grasp_agents/openai/converters.py,sha256=7O_K4MAW1CxwrF0vnA_MhrqwSeBx5eri8zADr-rzNuM,5346
+grasp_agents/openai/message_converters.py,sha256=IJwt7nd_YRe_Cw0mk8Szi6_Ys30KVgCFSFv_pp60SQk,4714
+grasp_agents/openai/openai_llm.py,sha256=A7ubei4pCR0g3mUk-0k-Anu5KBPmvNJnI3FSgIuKggk,6212
+grasp_agents/openai/tool_converters.py,sha256=MKprfNMorVNNUVorFe77yWNSOcYtMauUJtpXpeF4AH4,1033
+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=13nLNZqZgtpo9sM0vCRQmZ4bQjjZqUSElMQOwjL7bO8,3651
+grasp_agents/typing/converters.py,sha256=VM_kVEf11qYzTg_3Z9Tbu8o-xndt3Cb90BjE3Daehes,3117
+grasp_agents/typing/io.py,sha256=w2J71_-AaRFh1F3OEPXzAeMyHOKgG4l34A_scqU4GCg,813
+grasp_agents/typing/message.py,sha256=1-QF14NZcPcDive_oVM6u12QHlt8q7NHuCY4kuFULbY,3725
+grasp_agents/typing/tool.py,sha256=rLw8W8RIGQ5Hk9B0Yk9I8dN3wU2-D1lL54z_qiOlPRQ,1362
+grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/workflow/looped_agent.py,sha256=YBOgOIvy3_NwKvEoGgzQJ2fY9SNG66MQk6obSBGWvCc,3896
+grasp_agents/workflow/sequential_agent.py,sha256=yDt2nA-b1leVByD8jsKrWD6bHe0o9z33jrOJGOLwbyk,2004
+grasp_agents/workflow/workflow_agent.py,sha256=9U94IQ39Vb1W_5u8aoqHb65ikdarEhEJkexDz8xwHD4,2294
+grasp_agents-0.1.5.dist-info/METADATA,sha256=3AG9RAi-4U0LzWtpcvZFzK5eBGYVRfARDyRQMDtculM,362
+grasp_agents-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.1.5.dist-info/licenses/LICENSE,sha256=GRDob7--af0SOT8BRgu7Ds1NqhunPyxGjyETcCk-o7s,1062
+grasp_agents-0.1.5.dist-info/RECORD,,

grasp_agents-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

grasp_agents-0.1.5.dist-info/licenses/LICENSE

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