hyperforge-static-string 1.0.0.post22__tar.gz

hyperforge_static_string-1.0.0.post22/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: hyperforge_static_string
+Version: 1.0.0.post22
+Summary: A Hyperforge agent that always returns a fixed string
+License: MIT License
+Project-URL: Homepage, https://progress.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Requires-Dist: hyperforge

hyperforge_static_string-1.0.0.post22/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+dependencies = ["hyperforge"]
+
+name = "hyperforge_static_string"
+version = "1.0.0.post22"
+authors = []
+description = "A Hyperforge agent that always returns a fixed string"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+license = { text = "MIT License" }
+
+[tool.uv]
+required-version = ">=0.10"
+managed = true
+default-groups = "all"
+keyring-provider = "subprocess"
+package = true
+
+[project.urls]
+Homepage = "https://progress.com"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-asyncio",
+]

hyperforge_static_string-1.0.0.post22/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string/__init__.py

@@ -0,0 +1,3 @@
+from .agent import StaticStringAgent
+
+AGENTS = {"static_string": StaticStringAgent}

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string/agent.py

@@ -0,0 +1,78 @@
+from time import time
+from typing import Any, ClassVar, Dict, Optional
+
+from hyperforge.agent import Agent
+from hyperforge.configure import agent
+from hyperforge.context.agent import ContextAgent
+from hyperforge.context.config import ContextAgentConfig
+from hyperforge.definition import FunctionDefinition
+from hyperforge.manager import Manager
+from hyperforge.memory import Chunk, Context, QuestionMemory
+from pydantic import Field
+
+
+class StaticStringAgentConfig(ContextAgentConfig):
+    context: str = Field(description="Data to add to the context")
+
+
+@agent(
+    id="static_string",
+    agent_type="context",
+    title="Static String",
+    description="Use a static string to provide context for answering questions.",
+    config_schema=StaticStringAgentConfig,
+)
+class StaticStringAgent(ContextAgent, Agent[StaticStringAgentConfig]):
+    __published_functions__: ClassVar[Dict[str, FunctionDefinition]] = {
+        "static_string": FunctionDefinition(
+            name="static_string",
+            description="Returns a static string to provide context for answering questions.",
+            parameters={},
+        )
+    }
+
+    def static_string(self) -> str:
+        return self.config.context
+
+    async def _get_question_context(
+        self,
+        memory: QuestionMemory,
+        manager: Manager,
+        question_uuid: str,
+        question: str,
+        flow_id: str,
+        extra_context: Optional[Dict[str, Any]] = None,
+    ) -> list[tuple[str, str]]:
+        error = None
+        t0 = time()
+        missing = await self.save_ctx_and_return_missing(
+            memory=memory,
+            context=Context(
+                original_question_uuid=memory.original_question_uuid,
+                actual_question_uuid=question_uuid,
+                question=question,
+                chunks=[
+                    Chunk(
+                        chunk_id="static_string",
+                        text=self.static_string(),
+                        origin_agent=self.config.module,
+                    )
+                ],
+                source=f"/context/{self.agent_id}",
+                agent=self.config.module,
+            ),
+            question=question,
+            manager=manager,
+            flow_id=flow_id,
+        )
+        await memory.add_step(
+            step_module=self.config.module,
+            step_title=self.step_title("Search results"),
+            step_agent_path=f"/context/{self.agent_id}",
+            step_value="String done",
+            timeit=time() - t0,
+            input_nuclia_tokens=0.5,
+            output_nuclia_tokens=0.5,
+            error=error,
+        )
+        return [missing] if missing is not None else []

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: hyperforge_static_string
+Version: 1.0.0.post22
+Summary: A Hyperforge agent that always returns a fixed string
+License: MIT License
+Project-URL: Homepage, https://progress.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Requires-Dist: hyperforge

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+src/hyperforge_static_string/__init__.py
+src/hyperforge_static_string/agent.py
+src/hyperforge_static_string/py.typed
+src/hyperforge_static_string.egg-info/PKG-INFO
+src/hyperforge_static_string.egg-info/SOURCES.txt
+src/hyperforge_static_string.egg-info/dependency_links.txt
+src/hyperforge_static_string.egg-info/requires.txt
+src/hyperforge_static_string.egg-info/top_level.txt
+tests/test_static_string.py

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string.egg-info/requires.txt

@@ -0,0 +1 @@
+hyperforge

hyperforge_static_string-1.0.0.post22/src/hyperforge_static_string.egg-info/top_level.txt

@@ -0,0 +1 @@
+hyperforge_static_string

hyperforge_static_string-1.0.0.post22/tests/test_static_string.py

@@ -0,0 +1,115 @@
+from unittest.mock import MagicMock
+from uuid import uuid4
+
+import pytest
+from hyperforge.manager import Manager
+from hyperforge.memory.memory import EphemeralSessionMemory
+from hyperforge.models import MemoryConfig, Rules
+from hyperforge_static_string.agent import StaticStringAgent, StaticStringAgentConfig
+
+pytestmark = pytest.mark.asyncio
+
+
+def make_config(**kwargs) -> StaticStringAgentConfig:
+    """Helper to create a StaticStringAgentConfig with sensible test defaults."""
+    defaults = dict(
+        id="test-static-string",
+        title="Static String",
+        module="static_string",
+        prune_context=False,  # Disable validation so no LLM calls are needed
+    )
+    defaults.update(kwargs)
+    return StaticStringAgentConfig(**defaults)
+
+
+def make_session() -> EphemeralSessionMemory:
+    session = EphemeralSessionMemory.from_config(
+        config=MemoryConfig(), agent_id="test", workflow_id="test", rules=Rules()
+    )
+    session.init("test-session")
+    return session
+
+
+async def test_static_string_returns_context_string():
+    """static_string() returns exactly the configured context string."""
+    config = make_config(context="Hello, world!")
+    agent = StaticStringAgent(config=config)
+    assert agent.static_string() == "Hello, world!"
+
+
+async def test_get_question_context_saves_context_to_memory():
+    """_get_question_context saves a Context with the correct chunk to memory."""
+    manager = MagicMock(spec=Manager)
+    config = make_config(context="Some static context text.")
+    agent = StaticStringAgent(config=config)
+
+    memory = make_session().start_question("What is the answer?")
+    flow_id = uuid4().hex
+
+    missing = await agent._get_question_context(
+        memory=memory,
+        manager=manager,
+        question_uuid=memory.original_question_uuid,
+        question="What is the answer?",
+        flow_id=flow_id,
+    )
+
+    # No missing context — everything was provided
+    assert missing == []
+
+    # Context was saved with the correct chunk.
+    # Note: StaticStringAgent does not set agent_id on the Context object,
+    # so contexts are stored under the empty-string key.
+    saved = memory.get_agent_contexts(flow_id=flow_id, agent_id="")
+    assert len(saved) == 1
+    assert saved[0].chunks[0].chunk_id == "static_string"
+    assert saved[0].chunks[0].text == "Some static context text."
+    assert saved[0].chunks[0].origin_agent == config.module
+
+
+async def test_get_question_context_records_step():
+    """_get_question_context adds exactly one step with correct metadata."""
+    manager = MagicMock(spec=Manager)
+    config = make_config(context="Step test context.")
+    agent = StaticStringAgent(config=config)
+
+    memory = make_session().start_question("Any question?")
+    flow_id = uuid4().hex
+
+    await agent._get_question_context(
+        memory=memory,
+        manager=manager,
+        question_uuid=memory.original_question_uuid,
+        question="Any question?",
+        flow_id=flow_id,
+    )
+
+    assert len(memory.steps) == 1
+    step = memory.steps[0]
+    assert step.module == "static_string"
+    assert "Search results" in step.title
+    assert step.value == "String done"
+
+
+async def test_get_question_context_different_flow_ids():
+    """Contexts are scoped to their flow_id and do not bleed across flows."""
+    manager = MagicMock(spec=Manager)
+    config = make_config(context="Flow-isolated context.")
+    agent = StaticStringAgent(config=config)
+
+    memory = make_session().start_question("Question?")
+    flow_id_a = uuid4().hex
+    flow_id_b = uuid4().hex
+
+    await agent._get_question_context(
+        memory=memory,
+        manager=manager,
+        question_uuid=memory.original_question_uuid,
+        question="Question?",
+        flow_id=flow_id_a,
+    )
+
+    saved_a = memory.get_agent_contexts(flow_id=flow_id_a, agent_id="")
+    saved_b = memory.get_agent_contexts(flow_id=flow_id_b, agent_id="")
+    assert len(saved_a) == 1
+    assert len(saved_b) == 0