versionhq 1.1.7.1__tar.gz → 1.1.7.3__tar.gz

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.1
+Version: 1.1.7.3
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -142,7 +142,7 @@ Multiple `agents` can form a `team` to complete complex tasks together.
       role="demo",
       goal="amazing project goal",
       skillsets=["skill_1", "skill_2", ],
-      llm="llm-of-choice"
+      llm="llm-of-your-choice"
    )
 
    task = Task(
@@ -153,20 +153,19 @@ Multiple `agents` can form a `team` to complete complex tasks together.
          ResponseField(title="test1", type=str, required=True),
          ResponseField(title="test2", type=list, required=True),
       ],
-      context=["amazing context",],
-      tools=["amazing tool"],
       callback=None,
    )
-
-   res = task.execute_sync(agent=agent)
-
+   res = task.execute_sync(agent=agent, context="amazing context to consider.")
    return res.to_dict()
-
    ```
 
-For more details:
+This will return a dictionary with keys defined in the `ResponseField`.
+
+   ```
+   { test1: "answer1", "test2": ["answer2-1", "answer2-2", "answer2-3",] }
+   ```
 
-[PyPi package](https://pypi.org/project/versionhq/)
+For more info: [PyPI package](https://pypi.org/project/versionhq/)
 
 <hr />
 

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/README.md

@@ -90,7 +90,7 @@ Multiple `agents` can form a `team` to complete complex tasks together.
       role="demo",
       goal="amazing project goal",
       skillsets=["skill_1", "skill_2", ],
-      llm="llm-of-choice"
+      llm="llm-of-your-choice"
    )
 
    task = Task(
@@ -101,20 +101,19 @@ Multiple `agents` can form a `team` to complete complex tasks together.
          ResponseField(title="test1", type=str, required=True),
          ResponseField(title="test2", type=list, required=True),
       ],
-      context=["amazing context",],
-      tools=["amazing tool"],
       callback=None,
    )
-
-   res = task.execute_sync(agent=agent)
-
+   res = task.execute_sync(agent=agent, context="amazing context to consider.")
    return res.to_dict()
-
    ```
 
-For more details:
+This will return a dictionary with keys defined in the `ResponseField`.
+
+   ```
+   { test1: "answer1", "test2": ["answer2-1", "answer2-2", "answer2-3",] }
+   ```
 
-[PyPi package](https://pypi.org/project/versionhq/)
+For more info: [PyPI package](https://pypi.org/project/versionhq/)
 
 <hr />
 

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__"]
 
 [project]
 name = "versionhq"
-version = "1.1.7.1"
+version = "1.1.7.3"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows"
 readme = "README.md"

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq/__init__.py

@@ -10,20 +10,23 @@ warnings.filterwarnings(
 from versionhq.agent.model import Agent
 from versionhq.clients.customer.model import Customer
 from versionhq.clients.product.model import Product, ProductProvider
-from versionhq.clients.workflow.model import MessagingWorkflow
+from versionhq.clients.workflow.model import MessagingWorkflow, MessagingComponent, Score, ScoreFormat
 from versionhq.llm.model import LLM
 from versionhq.task.model import Task, TaskOutput
 from versionhq.team.model import Team, TeamOutput
 from versionhq.tool.model import Tool
 
 
-__version__ = "1.1.7.1"
+__version__ = "1.1.7.3"
 __all__ = [
     "Agent",
     "Customer",
     "Product",
     "ProductProvider",
     "MessagingWorkflow",
+    "MessagingComponent",
+    "Score",
+    "ScoreFormat",
     "LLM",
     "Task",
     "TaskOutput",

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq/agent/model.py

@@ -95,7 +95,7 @@ class Agent(ABC, BaseModel):
     role: str = Field(description="role of the agent - used in summary and logs")
     goal: str = Field(description="concise goal of the agent (details are set in the Task instance)")
     backstory: Optional[str] = Field(default=None, description="system context passed to the LLM")
-    knowledge: Optional[str] = Field(default=None)
+    knowledge: Optional[str] = Field(default=None, description="external knowledge fed to the agent")
     skillsets: Optional[List[str]] = Field(default_factory=list)
 
     # tools
@@ -358,7 +358,7 @@ class Agent(ABC, BaseModel):
         return {"output": response.output if hasattr(response, "output") else response}
 
 
-    def execute_task(self, task, context: Optional[str] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None, tools: Optional[str] = None) -> str:
         """
         Execute the task and return the output in string.
         To simplify, the tools are cascaded from the `tools_called` under the `task` Task instance if any.
@@ -367,7 +367,7 @@ class Agent(ABC, BaseModel):
         """
 
         task_prompt = task.prompt()
-        if context:
+        if context is not task.prompt_context:  # as `task.prompt()` includes adding `task.prompt_context` to the prompt.
             task_prompt += context
 
         tool_results = []

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq/clients/product/model.py

@@ -1,15 +1,6 @@
 import uuid
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
-from pydantic import (
-    UUID4,
-    InstanceOf,
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-    model_validator,
-)
+from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 
@@ -23,24 +14,16 @@ class ProductProvider(BaseModel):
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None, description="client name")
-    region: Optional[str] = Field(
-        default=None, description="region of client's main business operation"
-    )
-    data_pipeline: Optional[List[str]] = Field(
-        default=None, description="store the data pipelines that the client is using"
-    )
-    destinations: Optional[List[str]] = Field(
-        default=None,
-        description="store the destination services that the client is using",
-    )
+    region: Optional[str] = Field(default=None, description="region of client's main business operation")
+    data_pipeline: Optional[List[str]] = Field(default=None, description="store the data pipelines that the client is using")
+    destinations: Optional[List[str]] = Field(default=None,description="store the destination services that the client is using")
 
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "This field is not to be set by the user.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
 
 
 class Product(BaseModel):
@@ -51,24 +34,16 @@ class Product(BaseModel):
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None, description="product name")
     description: Optional[str] = Field(
-        default=None,
-        max_length=256,
-        description="product description scraped from landing url or client input. cascade to the agent",
-    )
+        default=None,max_length=256,description="product description scraped from landing url or client input. cascade to the agent")
     provider: Optional[ProductProvider] = Field(default=None)
     audience: Optional[str] = Field(default=None, description="target audience")
     usp: Optional[str] = Field(default=None)
-    landing_url: Optional[str] = Field(
-        default=None, description="marketing url of the product if any"
-    )
-    cohort_timeframe: Optional[int] = Field(
-        default=30, description="ideal cohort timeframe of the product in days"
-    )
+    landing_url: Optional[str] = Field(default=None, description="marketing url of the product if any")
+    cohort_timeframe: Optional[int] = Field(default=30, description="ideal cohort timeframe of the product in days")
+
 
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "This field is not to be set by the user.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})

versionhq-1.1.7.3/src/versionhq/clients/workflow/model.py

@@ -0,0 +1,158 @@
+import uuid
+from abc import ABC
+from datetime import date, datetime, time, timedelta
+from typing import Any, Dict, List, Union, Callable, Type, Optional, get_args, get_origin
+from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
+from pydantic_core import PydanticCustomError
+
+from versionhq.clients.product.model import Product
+from versionhq.clients.customer.model import Customer
+from versionhq.agent.model import Agent
+from versionhq.team.model import Team
+
+
+class ScoreFormat:
+    def __init__(self, rate: Union[float, int] = 0, weight: int = 1):
+        self.rate = rate
+        self.weight = weight
+        self.aggregate = rate * weight
+
+
+class Score:
+    """
+    Evaluate the score on 0 (no performance) to 1 scale.
+    `rate`: Any float from 0.0 to 1.0 given by an agent.
+    `weight`: Importance of each factor to the aggregated score.
+    """
+
+    def __init__(
+        self,
+        brand_tone: ScoreFormat = ScoreFormat(0, 0),
+        audience: ScoreFormat = ScoreFormat(0, 0),
+        track_record: ScoreFormat = ScoreFormat(0, 0),
+        **kwargs: Optional[Dict[str, ScoreFormat]],
+    ):
+        self.brand_tone = brand_tone
+        self.audience = audience
+        self.track_record = track_record
+        self.kwargs = kwargs
+
+
+    def result(self) -> int:
+        aggregate_score = self.brand_tone.aggregate + self.audience.aggregate + self.track_record.aggregate
+        denominator = self.brand_tone.weight + self.audience.weight + self.track_record.weight
+
+        for k, v in self.kwargs.items():
+            aggregate_score += v.aggregate
+            denominator += v.weight
+
+        if denominator == 0:
+            return 0
+
+        return round(aggregate_score / denominator, 2)
+
+
+
+class MessagingComponent(ABC, BaseModel):
+    layer_id: int = Field(default=0, description="add id of the layer: 0, 1, 2")
+    message: str = Field(default=None, max_length=1024, description="text message content to be sent")
+    interval: Optional[str] = Field(
+        default=None,description="interval to move on to the next layer. if this is the last layer, set as `None`")
+    score: Union[float, InstanceOf[Score]] = Field(default=None)
+
+
+    def store_scoring_result(self, scoring_subject: str, score: Union[int, Score, ScoreFormat] = None):
+        """
+        Set up the `score` field
+        """
+
+        if isinstance(score, Score):
+            setattr(self, "score", score)
+
+        elif isinstance(score, ScoreFormat):
+            score_instance = Score()
+            setattr(score_instance, scoring_subject, score)
+            setattr(self, "score", score_instance)
+
+        elif isinstance(score, int) or isinstance(score, float):
+            score_instance, score_format_instance = Score(), ScoreFormat(rate=score, weight=1)
+            setattr(score_instance, "kwargs", { scoring_subject: score_format_instance })
+            setattr(self, "score", score_instance)
+
+        else:
+            pass
+
+        return self
+
+
+
+class MessagingWorkflow(ABC, BaseModel):
+    """
+    Store 3 layers of messaging workflow sent to `customer` on the `product`
+    """
+
+    _created_at: Optional[datetime]
+    _updated_at: Optional[datetime]
+
+    model_config = ConfigDict()
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
+
+    # responsible tean or agents
+    team: Optional[Team] = Field(default=None, description="store `Team` instance responsibile for autopiloting this workflow")
+    agents: Optional[List[Agent]] = Field(
+        default=None, description="store `Agent` instances responsible for autopiloting this workflow. if the team exsits, this field remains as `None`")
+
+    # metrics
+    destination: Optional[str] = Field( default=None, description="destination service to launch this workflow")
+    product: InstanceOf[Product] = Field(default=None)
+    customer: InstanceOf[Customer] = Field(default=None)
+
+    metrics: Union[List[Dict[str, Any]], List[str]] = Field(
+        default=None, max_length=256, description="store metrics that used to predict and track the performance of this workflow.")
+
+
+    @property
+    def name(self):
+        if self.customer.id:
+            return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
+        else:
+            return f"Workflow ID: {self.id} - on {self.product.id}"
+
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
+
+    @model_validator(mode="after")
+    def set_up_destination(self):
+        """
+        Set up the destination service when self.destination is None.
+        Prioritize customer's destination to the product provider's destination list.
+        """
+        if self.destination is None:
+            if self.customer is not None:
+                self.destination = self.customer.on
+
+            else:
+                destination_list = self.product.provider.destinations
+                if destination_list:
+                    self.destination = destination_list[0]
+        return self
+
+
+    def reassign_agent_or_team(self, agents: List[Agent] = None, team: Team = None) -> None:
+        """
+        Fire unresponsible agents/team and assign new one.
+        """
+
+        if not agents and not team:
+            raise ValueError("Need to add at least 1 agent or team.")
+
+        self.agents = agents
+        self.team = team
+        self.updated_at = datetime.datetime.now()

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq/task/model.py

@@ -151,9 +151,10 @@ class Task(BaseModel):
     # task setup
     context: Optional[List["Task"]] = Field(default=None, description="other tasks whose outputs should be used as context")
     tools_called: Optional[List[ToolCalled]] = Field(default_factory=list, description="tools that the agent can use for this task")
-    take_tool_res_as_final: bool = Field(default=False,description="when set True, tools res will be stored in the `TaskOutput`")
+    take_tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
+    allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
 
-    prompt_context: Optional[str] = None
+    prompt_context: Optional[str] = Field(default=None)
     async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
     config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
     callback: Optional[Any] = Field(default=None, description="callback to be executed after the task is completed.")
@@ -278,17 +279,20 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         When we have cusotmer/product info, add them to the prompt.
         """
 
-        task_slices = [self.description, f"{self.output_prompt}"]
+        task_slices = [self.description, f"{self.output_prompt}", f"Take the following context into consideration: "]
 
         if self.context:
             context_outputs = "\n".join([task.output.context_prompting() if hasattr(task, "output") else "" for task in self.context])
-            task_slices.insert(1,  f"Take the following context into consideration: {context_outputs}")
+            task_slices.insert(len(task_slices),  context_outputs)
 
         if customer:
-            task_slices.insert(1,  f"customer overview: {customer}")
+            task_slices.insert(len(task_slices),  f"Customer overview: {customer}")
 
         if product_overview:
-            task_slices.insert(1, f"Product overview: {product_overview}")
+            task_slices.insert(len(task_slices), f"Product overview: {product_overview}")
+
+        if self.prompt_context:
+            task_slices.insert(len(task_slices), self.prompt_context)
 
         return "\n".join(task_slices)
 
@@ -367,7 +371,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
 
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
+    def execute_sync(self, agent, context: Optional[str] = None, callback_kwargs: Dict[str, Any] = None) -> TaskOutput:
         """
         Execute the task synchronously.
         When the task has context, make sure we have executed all the tasks in the context first.
@@ -376,12 +380,12 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         if self.context:
             for task in self.context:
                 if task.output is None:
-                    task._execute_core(agent, context)
+                    task._execute_core(agent, context, callback_kwargs)
 
         return self._execute_core(agent, context)
 
 
-    def execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
+    def execute_async(self, agent, context: Optional[str] = None, callback_kwargs: Dict[str, Any] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
@@ -390,26 +394,36 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         threading.Thread(
             daemon=True,
             target=self._execute_task_async,
-            args=(agent, context, future),
+            args=(agent, context, callback_kwargs, future),
         ).start()
         return future
 
 
-    def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
-        """Execute the task asynchronously with context handling."""
-        result = self._execute_core(agent, context)
+    def _execute_task_async(self, agent, context: Optional[str], callback_kwargs: Dict[str, Any], future: Future[TaskOutput]) -> None:
+        """
+        Execute the task asynchronously with context handling.
+        """
+
+        result = self._execute_core(agent, context, callback_kwargs)
         future.set_result(result)
 
 
-    def _execute_core(self, agent, context: Optional[str]) -> TaskOutput:
+    def _execute_core(self, agent, context: Optional[str], callback_kwargs: Optional[Dict[str, Any]] = None) -> TaskOutput:
         """
         Run the core execution logic of the task.
+        To speed up the process, when the format is not expected to return, we will skip the conversion process.
         """
+        from versionhq.agent.model import Agent
 
         self.prompt_context = context
+
+        if self.allow_delegation:
+            agent = Agent(role="delegated_agent", goal=agent.goal, llm=agent.llm) #! REFINEME - logic to pick up the high performer
+            self.delegations += 1
+
         output_raw = agent.execute_task(task=self, context=context)
-        output_json_dict = self.create_json_output(raw_result=output_raw)
-        output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict)
+        output_json_dict = self.create_json_output(raw_result=output_raw) if self.expected_output_json is True else None
+        output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict) if self.expected_output_pydantic else None
         task_output = TaskOutput(
             task_id=self.id,
             raw=output_raw,
@@ -422,7 +436,10 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         # self._set_end_execution_time(start_time)
 
         if self.callback:
-            self.callback(self.output)
+            if isinstance(self.callback, Callable):
+                self.callback(**callback_kwargs)
+            else:
+                self.callback(self.output)
 
         # if self._execution_span:
         #     # self._telemetry.task_ended(self._execution_span, self, agent.team)

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq/team/model.py

@@ -7,17 +7,9 @@ from dotenv import load_dotenv
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, TYPE_CHECKING, Callable, Optional, Tuple, Union
-from pydantic import (
-    UUID4,
-    InstanceOf,
-    Json,
-    BaseModel,
-    Field,
-    PrivateAttr,
-    field_validator,
-    model_validator,
-)
-from pydantic_core import PydanticCustomError
+from pydantic import UUID4, InstanceOf, Json, BaseModel, Field, PrivateAttr, field_validator, model_validator
+from pydantic._internal._generate_schema import GenerateSchema
+from pydantic_core import PydanticCustomError, core_schema
 
 from versionhq.agent.model import Agent
 from versionhq.task.model import Task, TaskOutput, ConditionalTask, TaskOutputFormat
@@ -27,9 +19,6 @@ from versionhq._utils.logger import Logger
 from versionhq._utils.usage_metrics import UsageMetrics
 
 
-from pydantic._internal._generate_schema import GenerateSchema
-from pydantic_core import core_schema
-
 initial_match_type = GenerateSchema.match_type
 
 
@@ -301,10 +290,8 @@ class Team(BaseModel):
 
     # task execution
     def _process_async_tasks(
-        self,
-        futures: List[Tuple[Task, Future[TaskOutput], int]],
-        was_replayed: bool = False,
-    ) -> List[TaskOutput]:
+            self, futures: List[Tuple[Task, Future[TaskOutput], int]], was_replayed: bool = False
+        ) -> List[TaskOutput]:
         task_outputs: List[TaskOutput] = []
         for future_task, future, task_index in futures:
             task_output = future.result()
@@ -315,6 +302,7 @@ class Team(BaseModel):
             )
         return task_outputs
 
+
     def _handle_conditional_task(
         self,
         task: ConditionalTask,
@@ -323,6 +311,7 @@ class Team(BaseModel):
         task_index: int,
         was_replayed: bool,
     ) -> Optional[TaskOutput]:
+
         if futures:
             task_outputs = self._process_async_tasks(futures, was_replayed)
             futures.clear()
@@ -347,6 +336,7 @@ class Team(BaseModel):
         Take the output of the first task or the lead task output as the team output `raw` value.
         Note that `tasks` are already sorted by the importance.
         """
+
         if len(task_outputs) < 1:
             raise ValueError("Something went wrong. Kickoff should return only one task output.")
 

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.1
+Version: 1.1.7.3
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -142,7 +142,7 @@ Multiple `agents` can form a `team` to complete complex tasks together.
       role="demo",
       goal="amazing project goal",
       skillsets=["skill_1", "skill_2", ],
-      llm="llm-of-choice"
+      llm="llm-of-your-choice"
    )
 
    task = Task(
@@ -153,20 +153,19 @@ Multiple `agents` can form a `team` to complete complex tasks together.
          ResponseField(title="test1", type=str, required=True),
          ResponseField(title="test2", type=list, required=True),
       ],
-      context=["amazing context",],
-      tools=["amazing tool"],
       callback=None,
    )
-
-   res = task.execute_sync(agent=agent)
-
+   res = task.execute_sync(agent=agent, context="amazing context to consider.")
    return res.to_dict()
-
    ```
 
-For more details:
+This will return a dictionary with keys defined in the `ResponseField`.
+
+   ```
+   { test1: "answer1", "test2": ["answer2-1", "answer2-2", "answer2-3",] }
+   ```
 
-[PyPi package](https://pypi.org/project/versionhq/)
+For more info: [PyPI package](https://pypi.org/project/versionhq/)
 
 <hr />
 

{versionhq-1.1.7.1 → versionhq-1.1.7.3}/src/versionhq.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/conftest.py
 tests/agent/__init__.py
 tests/agent/agent_test.py
 tests/cli/__init__.py
+tests/clients/workflow_test.py
 tests/task/__init__.py
 tests/task/task_test.py
 tests/team/__init__.py

versionhq-1.1.7.3/tests/clients/workflow_test.py

@@ -0,0 +1,21 @@
+import os
+import pytest
+from versionhq.agent.model import Agent
+from versionhq.llm.model import LLM
+from versionhq.clients.workflow.model import Score, ScoreFormat, MessagingWorkflow, MessagingComponent
+
+MODEL_NAME = os.environ.get("LITELLM_MODEL_NAME", "gpt-3.5-turbo")
+LITELLM_API_KEY = os.environ.get("LITELLM_API_KEY")
+
+
+def test_store_scores():
+    """
+    Test if the final result will be calcurated using a random subject
+    """
+
+    messaging_component = MessagingComponent(message="demo")
+    score_raw = 15
+    messaging_component.store_scoring_result("demo", score=score_raw)
+
+    assert messaging_component.score is not None
+    assert messaging_component.score.result() is not None