symphony-harness 0.0.1__tar.gz

symphony_harness-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sarthak Chauhan
+
+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.

symphony_harness-0.0.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: symphony-harness
+Version: 0.0.1
+Summary: Symphony agent harness: provider-agnostic tool loop, control-plane events, run limits, and compaction (import as core_harness)
+Author: Sarthak Chauhan
+Author-email: Sarthak Chauhan <sarthakchauhann@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: symphony-core
+Requires-Dist: pydantic>=2.0.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/Sarthakischauhan/symphony
+Project-URL: Documentation, https://github.com/Sarthakischauhan/symphony/blob/main/docs/packages/symphony-harness.md
+Project-URL: Source, https://github.com/Sarthakischauhan/symphony/tree/main/core_harness
+Description-Content-Type: text/markdown
+
+# symphony-harness
+
+A product-agnostic async agent loop for Python: model turns, callable tools, operational limits, and a typed event stream. Import it as `core_harness`.
+
+**Availability:** this package is not currently published on PyPI. Use it through the repository's uv workspace; start with the [source installation guide](../docs/getting-started/installation.md).
+
+## Minimal example
+
+```python
+import asyncio
+from core_ai import build_default_registry, default_model_id
+from core_harness import CoreHarness, Tool
+
+def read_file(path: str) -> str:
+    """Read a UTF-8 file."""
+    with open(path, encoding="utf-8") as file:
+        return file.read()
+
+async def main() -> None:
+    harness = CoreHarness(
+        registry=build_default_registry(),
+        registry=build_default_registry(),
+        model_id=default_model_id(registry),
+        system_prompt="Answer concisely and use tools when useful.",
+        tools=[Tool(read_file)],
+    )
+    result = await harness.run("Summarize README.md", session_id="example")
+    print(result.output_text)
+
+asyncio.run(main())
+```
+
+`CoreHarness` does not provide a filesystem boundary or default approval policy: attach only tools you intend to expose, and add product-level policy where needed. See [SECURITY.md](../SECURITY.md).
+
+## Build with the harness
+
+- [Harness guide](../docs/packages/symphony-harness.md): tools, runs, subagents, limits, and context.
+- [Extend the harness](../docs/developer-guide/extending.md): add-on hooks and child behavior.
+- [Event overview](../docs/developer-guide/events.md) and [detailed event catalog](docs/events.md).
+- [Background child lifecycle](docs/background-children.md).
+- [Architecture](../docs/developer-guide/architecture.md).

symphony_harness-0.0.1/README.md

@@ -0,0 +1,41 @@
+# symphony-harness
+
+A product-agnostic async agent loop for Python: model turns, callable tools, operational limits, and a typed event stream. Import it as `core_harness`.
+
+**Availability:** this package is not currently published on PyPI. Use it through the repository's uv workspace; start with the [source installation guide](../docs/getting-started/installation.md).
+
+## Minimal example
+
+```python
+import asyncio
+from core_ai import build_default_registry, default_model_id
+from core_harness import CoreHarness, Tool
+
+def read_file(path: str) -> str:
+    """Read a UTF-8 file."""
+    with open(path, encoding="utf-8") as file:
+        return file.read()
+
+async def main() -> None:
+    harness = CoreHarness(
+        registry=build_default_registry(),
+        registry=build_default_registry(),
+        model_id=default_model_id(registry),
+        system_prompt="Answer concisely and use tools when useful.",
+        tools=[Tool(read_file)],
+    )
+    result = await harness.run("Summarize README.md", session_id="example")
+    print(result.output_text)
+
+asyncio.run(main())
+```
+
+`CoreHarness` does not provide a filesystem boundary or default approval policy: attach only tools you intend to expose, and add product-level policy where needed. See [SECURITY.md](../SECURITY.md).
+
+## Build with the harness
+
+- [Harness guide](../docs/packages/symphony-harness.md): tools, runs, subagents, limits, and context.
+- [Extend the harness](../docs/developer-guide/extending.md): add-on hooks and child behavior.
+- [Event overview](../docs/developer-guide/events.md) and [detailed event catalog](docs/events.md).
+- [Background child lifecycle](docs/background-children.md).
+- [Architecture](../docs/developer-guide/architecture.md).

symphony_harness-0.0.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "symphony-harness"
+version = "0.0.1"
+description = "Symphony agent harness: provider-agnostic tool loop, control-plane events, run limits, and compaction (import as core_harness)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = [
+    "symphony-core",
+    "pydantic>=2.0.0",
+]
+
+[[project.authors]]
+name = "Sarthak Chauhan"
+email = "sarthakchauhann@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/Sarthakischauhan/symphony"
+Documentation = "https://github.com/Sarthakischauhan/symphony/blob/main/docs/packages/symphony-harness.md"
+Source = "https://github.com/Sarthakischauhan/symphony/tree/main/core_harness"
+
+[tool.uv.sources.symphony-core]
+workspace = true
+
+[tool.uv.build-backend]
+module-name = "core_harness"
+
+[dependency-groups]
+dev = ["pytest>=9.1.1"]
+
+[build-system]
+requires = ["uv_build>=0.9.8,<0.10.0"]
+build-backend = "uv_build"

symphony_harness-0.0.1/pyproject.toml.orig

@@ -0,0 +1,35 @@
+[project]
+name = "symphony-harness"
+version = "0.0.1"
+description = "Symphony agent harness: provider-agnostic tool loop, control-plane events, run limits, and compaction (import as core_harness)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Sarthak Chauhan", email = "sarthakchauhann@gmail.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "symphony-core",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Sarthakischauhan/symphony"
+Documentation = "https://github.com/Sarthakischauhan/symphony/blob/main/docs/packages/symphony-harness.md"
+Source = "https://github.com/Sarthakischauhan/symphony/tree/main/core_harness"
+
+[tool.uv.sources]
+symphony-core = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.8,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "core_harness"

symphony_harness-0.0.1/src/core_harness/__init__.py

@@ -0,0 +1,88 @@
+from core_harness.addons import (
+    Addon,
+    ChildConfig,
+    ChildIdentity,
+    CompactionAddon,
+    Compactor,
+    KeepDropPlan,
+    KeepSystemRecentCompactor,
+    PersistenceAddon,
+    SubagentAddon,
+    compaction_from_config,
+    plan_keep_drop,
+)
+from core_harness.addons.persistence import (
+    Checkpoint,
+    NullPersistence,
+    Persistence,
+)
+from core_harness.context import (
+    ContextReport,
+    bound_tool_result,
+    build_context_report,
+)
+from core_harness.config import (
+    HarnessConfig,
+    load_harness_config,
+    resolve_harness_config,
+)
+from core_harness.events import EventLog, EventSink, HumanInteraction, InteractionPort
+from core_harness.ops import Answer, Interrupt, Op, UserInput
+from core_harness.errors import HarnessCancelled, HarnessLimitExceeded
+from core_harness.harness import CoreHarness
+from core_harness.models import (
+    ControlPlaneEvent,
+    ControlPlaneEventType,
+    EVENT_SCHEMA_VERSION,
+    HarnessResult,
+    PendingToolCall,
+    RunLimits,
+    ToolCall,
+    ToolResult,
+    UsageTotals,
+)
+from core_harness.tools import Tool
+
+__all__ = [
+    "Answer",
+    "Addon",
+    "Checkpoint",
+    "ChildConfig",
+    "ChildIdentity",
+    "CompactionAddon",
+    "Compactor",
+    "ContextReport",
+    "ControlPlaneEvent",
+    "ControlPlaneEventType",
+    "CoreHarness",
+    "EVENT_SCHEMA_VERSION",
+    "EventLog",
+    "EventSink",
+    "HumanInteraction",
+    "InteractionPort",
+    "Interrupt",
+    "Op",
+    "UserInput",
+    "HarnessCancelled",
+    "HarnessLimitExceeded",
+    "HarnessResult",
+    "HarnessConfig",
+    "KeepDropPlan",
+    "KeepSystemRecentCompactor",
+    "NullPersistence",
+    "PendingToolCall",
+    "Persistence",
+    "PersistenceAddon",
+    "RunLimits",
+    "SubagentAddon",
+    "Tool",
+    "ToolCall",
+    "ToolResult",
+    "UsageTotals",
+    "bound_tool_result",
+    "build_context_report",
+    "compaction_from_config",
+    "load_harness_config",
+    "resolve_harness_config",
+    "plan_keep_drop",
+]

symphony_harness-0.0.1/src/core_harness/addons/__init__.py

@@ -0,0 +1,45 @@
+"""Opt-in harness add-ons.
+
+``CoreHarness`` is an extension surface. Pass ``addons=[...]`` at construction
+or call ``register_addon``. There is no directory discovery and no skill
+loader; skills can hang off this same attach path later.
+"""
+
+from __future__ import annotations
+
+from core_harness.addons.addon import Addon
+from core_harness.addons.compaction import (
+    CompactionAddon,
+    Compactor,
+    KeepDropPlan,
+    KeepSystemRecentCompactor,
+    compaction_from_config,
+    plan_keep_drop,
+)
+from core_harness.addons.persistence import (
+    Checkpoint,
+    CheckpointStatus,
+    NullPersistence,
+    Persistence,
+    PersistenceAddon,
+)
+from core_harness.addons.subagent import ChildConfig, ChildIdentity, SubagentAddon
+
+
+__all__ = [
+    "Addon",
+    "Checkpoint",
+    "CheckpointStatus",
+    "ChildConfig",
+    "ChildIdentity",
+    "CompactionAddon",
+    "Compactor",
+    "KeepDropPlan",
+    "KeepSystemRecentCompactor",
+    "NullPersistence",
+    "Persistence",
+    "PersistenceAddon",
+    "SubagentAddon",
+    "compaction_from_config",
+    "plan_keep_drop",
+]

symphony_harness-0.0.1/src/core_harness/addons/addon.py

@@ -0,0 +1,67 @@
+"""Attachable harness extensions.
+
+Subclass :class:`Addon` and override hooks to opt in.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class Addon:
+    """Harness extension. Hooks are no-ops until overridden.
+
+    Public seams (override to opt in): ``before_run``, ``before_turn``,
+    ``before_tool``, ``after_turn``, ``after_run``, ``on_tool``,
+    ``on_compact``. ``before_tool`` may return a deny reason; the others
+    observe. Inherit on spawn by implementing :meth:`fork_for_child`.
+    """
+
+    name: str = ""
+
+    def attach(self, harness: Any) -> None:
+        """Mount this add-on onto a harness. Called once from ``register_addon``."""
+        del harness
+        return None
+
+    def fork_for_child(self, parent_harness: Any) -> Optional[Addon]:
+        """Child inherit policy: return an instance to inherit, or ``None`` to skip.
+
+        The default skips, so children do not receive this instance.
+        ``ChildConfig.addons`` / ``addon_factory`` replace this path when set.
+        """
+        del parent_harness
+        return None
+
+    async def before_run(self, **payload: Any) -> None:
+        del payload
+        return None
+
+    async def before_turn(self, **payload: Any) -> None:
+        del payload
+        return None
+
+    async def before_tool(self, **payload: Any) -> Optional[str]:
+        """Return a deny reason to skip the tool, or ``None`` to allow it."""
+        del payload
+        return None
+
+    async def after_turn(self, **payload: Any) -> None:
+        del payload
+        return None
+
+    async def after_run(self, **payload: Any) -> None:
+        """Called after a successful run, before ``CoreHarness.run`` returns."""
+        del payload
+        return None
+
+    async def on_tool(self, **payload: Any) -> None:
+        del payload
+        return None
+
+    async def on_compact(self, **payload: Any) -> None:
+        del payload
+        return None
+
+
+__all__ = ["Addon"]

symphony_harness-0.0.1/src/core_harness/addons/compaction/__init__.py

@@ -0,0 +1,76 @@
+"""Compaction add-on: mount a ``Compactor`` onto the harness."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from core_harness.addons.addon import Addon
+from core_harness.addons.compaction.policy import (
+    COMPACTION_CONTINUATION,
+    Compactor,
+    KeepDropPlan,
+    KeepSystemRecentCompactor,
+    compaction_header,
+    compaction_target,
+    dropped_turn_facts,
+    plan_keep_drop,
+    summarize_dropped_turns,
+)
+from core_harness.config import HarnessConfig
+
+
+class CompactionAddon(Addon):
+    """Mount a ``Compactor`` onto ``CoreHarness.state``."""
+
+    name = "compaction"
+
+    def __init__(
+        self,
+        compactor: Compactor | None = None,
+        *,
+        keep_recent_tools: int = 32,
+        target_tokens: Optional[int] = None,
+    ) -> None:
+        self.compactor = compactor or KeepSystemRecentCompactor(
+            keep_recent_tools=keep_recent_tools,
+            target_tokens=target_tokens,
+        )
+        if isinstance(self.compactor, KeepSystemRecentCompactor):
+            keep_recent_tools = self.compactor.keep_recent_tools
+            target_tokens = self.compactor.target_tokens
+        self.keep_recent_tools = keep_recent_tools
+        self.target_tokens = target_tokens
+
+    def attach(self, harness: Any) -> None:
+        harness.state.compactor = self.compactor
+
+    def fork_for_child(self, parent_harness: Any) -> CompactionAddon:
+        """New add-on with a fresh compactor using the same settings."""
+        del parent_harness
+        return CompactionAddon(
+            keep_recent_tools=self.keep_recent_tools,
+            target_tokens=self.target_tokens,
+        )
+
+
+def compaction_from_config(config: HarnessConfig) -> CompactionAddon:
+    """Build the keep-system-recent add-on from harness settings."""
+    return CompactionAddon(
+        keep_recent_tools=config.compaction_keep_recent_tools,
+        target_tokens=config.context_target_tokens,
+    )
+
+
+__all__ = [
+    "COMPACTION_CONTINUATION",
+    "CompactionAddon",
+    "Compactor",
+    "KeepDropPlan",
+    "KeepSystemRecentCompactor",
+    "compaction_from_config",
+    "compaction_header",
+    "compaction_target",
+    "dropped_turn_facts",
+    "plan_keep_drop",
+    "summarize_dropped_turns",
+]