agentivium-core 0.2.0__py3-none-any.whl

agentivium_core/__init__.py

@@ -0,0 +1,50 @@
+"""Domain-neutral contracts for Agentivium systems."""
+
+from agentivium_core.eval import EvaluationRecord
+from agentivium_core.intent import IntentIR, IntentParser
+from agentivium_core.llm import (
+    LLMCallTrace,
+    LLMClient,
+    LLMMessage,
+    LLMRequest,
+    LLMResponse,
+    LLMUsage,
+    MockLLMClient,
+    PromptTemplate,
+    StructuredOutputParser,
+    StructuredOutputSpec,
+)
+from agentivium_core.planner import ActionPlan, Planner
+from agentivium_core.policy import (
+    PolicyValidator,
+    ValidationIssue,
+    ValidationResult,
+)
+from agentivium_core.tools import ToolAdapter
+from agentivium_core.trace import ExecutionTrace
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "ActionPlan",
+    "EvaluationRecord",
+    "ExecutionTrace",
+    "LLMCallTrace",
+    "LLMClient",
+    "LLMMessage",
+    "LLMRequest",
+    "LLMResponse",
+    "LLMUsage",
+    "IntentIR",
+    "IntentParser",
+    "MockLLMClient",
+    "Planner",
+    "PolicyValidator",
+    "PromptTemplate",
+    "StructuredOutputParser",
+    "StructuredOutputSpec",
+    "ToolAdapter",
+    "ValidationIssue",
+    "ValidationResult",
+    "__version__",
+]

agentivium_core/errors/__init__.py

@@ -0,0 +1,16 @@
+"""Agentivium Core exception hierarchy."""
+
+from agentivium_core.errors.base import (
+    AdapterExecutionError,
+    AgentiviumCoreError,
+    PolicyValidationError,
+    SchemaValidationError,
+)
+
+__all__ = [
+    "AdapterExecutionError",
+    "AgentiviumCoreError",
+    "PolicyValidationError",
+    "SchemaValidationError",
+]
+

agentivium_core/errors/base.py

@@ -0,0 +1,18 @@
+"""Base exceptions for system failures in core implementations."""
+
+
+class AgentiviumCoreError(Exception):
+    """Base exception for Agentivium Core system failures."""
+
+
+class SchemaValidationError(AgentiviumCoreError):
+    """Raised when a schema cannot be parsed or constructed."""
+
+
+class AdapterExecutionError(AgentiviumCoreError):
+    """Raised when a tool adapter fails to produce its output."""
+
+
+class PolicyValidationError(AgentiviumCoreError):
+    """Raised for validator system failures, not domain validation issues."""
+

agentivium_core/eval/__init__.py

@@ -0,0 +1,6 @@
+"""Evaluation schemas."""
+
+from agentivium_core.eval.record import EvaluationRecord
+
+__all__ = ["EvaluationRecord"]
+

agentivium_core/eval/record.py

@@ -0,0 +1,17 @@
+"""Structured evaluation record schema."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class EvaluationRecord(BaseModel):
+    """A normalized prediction, reference, and metrics record."""
+
+    sample_id: str
+    task: str
+    prediction: dict[str, Any]
+    gold: dict[str, Any] | None = None
+    metrics: dict[str, float] = Field(default_factory=dict)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+

agentivium_core/intent/__init__.py

@@ -0,0 +1,6 @@
+"""Intent schemas and parser contracts."""
+
+from agentivium_core.intent.base import IntentIR, IntentParser
+
+__all__ = ["IntentIR", "IntentParser"]
+

agentivium_core/intent/base.py

@@ -0,0 +1,28 @@
+"""Base intent representation and parser interface."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class IntentIR(BaseModel):
+    """Domain-neutral intermediate representation of a parsed request."""
+
+    ir_version: str = Field(default="0.1")
+    domain: str
+    raw_request: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class IntentParser(ABC):
+    """Contract implemented by domain-specific intent parsers."""
+
+    @abstractmethod
+    def parse(
+        self,
+        request: str,
+        context: dict[str, Any] | None = None,
+    ) -> IntentIR:
+        """Parse a raw request into a structured intent."""
+

agentivium_core/llm/__init__.py

@@ -0,0 +1,25 @@
+"""Provider-neutral LLM contracts."""
+
+from agentivium_core.llm.client import LLMClient, MockLLMClient
+from agentivium_core.llm.message import LLMMessage
+from agentivium_core.llm.prompt import PromptTemplate
+from agentivium_core.llm.request import LLMRequest
+from agentivium_core.llm.response import LLMResponse, LLMUsage
+from agentivium_core.llm.structured import (
+    StructuredOutputParser,
+    StructuredOutputSpec,
+)
+from agentivium_core.llm.trace import LLMCallTrace
+
+__all__ = [
+    "LLMCallTrace",
+    "LLMClient",
+    "LLMMessage",
+    "LLMRequest",
+    "LLMResponse",
+    "LLMUsage",
+    "MockLLMClient",
+    "PromptTemplate",
+    "StructuredOutputParser",
+    "StructuredOutputSpec",
+]

agentivium_core/llm/client.py

@@ -0,0 +1,30 @@
+"""Provider-neutral LLM client contract."""
+
+from abc import ABC, abstractmethod
+
+from agentivium_core.llm.request import LLMRequest
+from agentivium_core.llm.response import LLMResponse
+
+
+class LLMClient(ABC):
+    """Synchronous text-generation interface implemented outside core."""
+
+    @abstractmethod
+    def generate(self, request: LLMRequest) -> LLMResponse:
+        """Generate a normalized response for the given request."""
+        raise NotImplementedError
+
+
+class MockLLMClient(LLMClient):
+    """Testing/demo client that returns a fixed response."""
+
+    def __init__(self, response: str, model: str = "mock") -> None:
+        self.response = response
+        self.model = model
+
+    def generate(self, request: LLMRequest) -> LLMResponse:
+        return LLMResponse(
+            content=self.response,
+            model=self.model,
+            metadata={"mock": True},
+        )

agentivium_core/llm/message.py

@@ -0,0 +1,13 @@
+"""Provider-neutral LLM message schema."""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class LLMMessage(BaseModel):
+    """One normalized text message in an LLM request."""
+
+    role: Literal["system", "user", "assistant", "tool"]
+    content: str
+    metadata: dict[str, Any] = Field(default_factory=dict)

agentivium_core/llm/prompt.py

@@ -0,0 +1,27 @@
+"""Minimal prompt templating helpers."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from agentivium_core.llm.message import LLMMessage
+
+
+class PromptTemplate(BaseModel):
+    """System/user prompt template rendered with Python string formatting."""
+
+    name: str
+    version: str = "0.1"
+    system: str
+    user_template: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    def render(self, variables: dict[str, Any]) -> list[LLMMessage]:
+        """Render the template as system and user messages."""
+        return [
+            LLMMessage(role="system", content=self.system),
+            LLMMessage(
+                role="user",
+                content=self.user_template.format(**variables),
+            ),
+        ]

agentivium_core/llm/request.py

@@ -0,0 +1,19 @@
+"""Provider-neutral LLM request schema."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from agentivium_core.llm.message import LLMMessage
+
+
+class LLMRequest(BaseModel):
+    """Normalized request shape for provider/domain LLM clients."""
+
+    model: str | None = None
+    messages: list[LLMMessage]
+    temperature: float = 0.0
+    max_tokens: int | None = None
+    stop: list[str] | None = None
+    response_format: dict[str, Any] | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)

agentivium_core/llm/response.py

@@ -0,0 +1,24 @@
+"""Provider-neutral LLM response schemas."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class LLMUsage(BaseModel):
+    """Optional usage and timing data for an LLM call."""
+
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    total_tokens: int | None = None
+    latency_ms: float | None = None
+
+
+class LLMResponse(BaseModel):
+    """Normalized text response returned by an LLM client."""
+
+    content: str
+    model: str | None = None
+    usage: LLMUsage | None = None
+    raw: dict[str, Any] | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)

agentivium_core/llm/structured.py

@@ -0,0 +1,37 @@
+"""Structured-output contracts and minimal parsing utilities."""
+
+import json
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from agentivium_core.llm.response import LLMResponse
+
+
+class StructuredOutputSpec(BaseModel):
+    """Provider-neutral structured output requirement."""
+
+    name: str
+    output_schema: dict[str, Any] = Field(
+        alias="schema",
+        description="Provider-neutral schema",
+    )
+    strict: bool = True
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @property
+    def schema(self) -> dict[str, Any]:  # type: ignore[override]
+        """Return the provider-neutral schema."""
+        return self.output_schema
+
+
+class StructuredOutputParser:
+    """Minimal structured-output parser."""
+
+    def parse_json(self, response: LLMResponse) -> dict[str, Any]:
+        """Parse response content as a JSON object."""
+        data = json.loads(response.content)
+        if not isinstance(data, dict):
+            msg = "LLM response content must decode to a JSON object"
+            raise TypeError(msg)
+        return data

agentivium_core/llm/trace.py

@@ -0,0 +1,24 @@
+"""Provider-neutral LLM call tracing schema."""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class LLMCallTrace(BaseModel):
+    """Auditable record for one LLM call."""
+
+    trace_id: str
+    created_at: datetime = Field(default_factory=_utc_now)
+    provider: str | None = None
+    model: str | None = None
+    request: dict[str, Any]
+    response: dict[str, Any] | None = None
+    latency_ms: float | None = None
+    error: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)

agentivium_core/planner/__init__.py

@@ -0,0 +1,7 @@
+"""Action plan schemas and planner contracts."""
+
+from agentivium_core.planner.action import ActionPlan
+from agentivium_core.planner.base import Planner
+
+__all__ = ["ActionPlan", "Planner"]
+

agentivium_core/planner/action.py

@@ -0,0 +1,23 @@
+"""Structured next-action plans."""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+ActionType = Literal[
+    "execute",
+    "generate",
+    "ask_clarification",
+    "repair",
+    "reject",
+    "defer",
+]
+
+
+class ActionPlan(BaseModel):
+    """A structured decision describing what a system should do next."""
+
+    action: ActionType
+    reason: str | None = None
+    payload: dict[str, Any] = Field(default_factory=dict)
+

agentivium_core/planner/base.py

@@ -0,0 +1,20 @@
+"""Planner interface."""
+
+from abc import ABC, abstractmethod
+
+from agentivium_core.intent import IntentIR
+from agentivium_core.planner.action import ActionPlan
+from agentivium_core.policy import ValidationResult
+
+
+class Planner(ABC):
+    """Contract for choosing the next action from intent and validation."""
+
+    @abstractmethod
+    def plan(
+        self,
+        intent: IntentIR,
+        validation: ValidationResult,
+    ) -> ActionPlan:
+        """Return the system's next structured action."""
+

agentivium_core/policy/__init__.py

@@ -0,0 +1,7 @@
+"""Policy validation contracts and structured results."""
+
+from agentivium_core.policy.base import PolicyValidator
+from agentivium_core.policy.result import ValidationIssue, ValidationResult
+
+__all__ = ["PolicyValidator", "ValidationIssue", "ValidationResult"]
+

agentivium_core/policy/base.py

@@ -0,0 +1,20 @@
+"""Policy validator interface."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from agentivium_core.intent import IntentIR
+from agentivium_core.policy.result import ValidationResult
+
+
+class PolicyValidator(ABC):
+    """Contract implemented by domain-specific policy validators."""
+
+    @abstractmethod
+    def validate(
+        self,
+        intent: IntentIR,
+        policy: dict[str, Any] | None = None,
+    ) -> ValidationResult:
+        """Validate an intent against optional domain policy."""
+

agentivium_core/policy/result.py

@@ -0,0 +1,33 @@
+"""Structured policy validation results."""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+IssueSeverity = Literal["info", "warning", "blocking", "critical"]
+
+
+class ValidationIssue(BaseModel):
+    """A machine-readable issue found while validating an intent."""
+
+    code: str
+    severity: IssueSeverity
+    message: str
+    field: str | None = None
+    suggestion: str | None = None
+
+
+class ValidationResult(BaseModel):
+    """The complete structured output of policy validation."""
+
+    valid: bool
+    issues: list[ValidationIssue] = Field(default_factory=list)
+
+    @property
+    def blocking(self) -> bool:
+        """Whether any issue prevents execution."""
+
+        return any(
+            issue.severity in {"blocking", "critical"} for issue in self.issues
+        )
+

agentivium_core/py.typed

@@ -0,0 +1 @@
+

agentivium_core/tools/__init__.py

@@ -0,0 +1,6 @@
+"""Tool adapter contracts."""
+
+from agentivium_core.tools.base import ToolAdapter
+
+__all__ = ["ToolAdapter"]
+

agentivium_core/tools/base.py

@@ -0,0 +1,19 @@
+"""Tool adapter interface."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from agentivium_core.intent import IntentIR
+
+
+class ToolAdapter(ABC):
+    """Contract for translating a valid intent into tool-specific output."""
+
+    @abstractmethod
+    def generate(
+        self,
+        intent: IntentIR,
+        context: dict[str, Any] | None = None,
+    ) -> Any:
+        """Generate a tool-specific artifact or invocation."""
+

agentivium_core/trace/__init__.py

@@ -0,0 +1,6 @@
+"""Execution trace schemas."""
+
+from agentivium_core.trace.execution import ExecutionTrace
+
+__all__ = ["ExecutionTrace"]
+

agentivium_core/trace/execution.py

@@ -0,0 +1,28 @@
+"""Versioned execution trace schema."""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from agentivium_core.llm import LLMCallTrace
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class ExecutionTrace(BaseModel):
+    """Auditable record of the processing lifecycle for one request."""
+
+    trace_version: str = Field(default="0.1")
+    trace_id: str
+    created_at: datetime = Field(default_factory=_utc_now)
+    domain: str
+    raw_request: str | None = None
+    intent: dict[str, Any] | None = None
+    validation: dict[str, Any] | None = None
+    action_plan: dict[str, Any] | None = None
+    output: dict[str, Any] | None = None
+    llm_calls: list[LLMCallTrace] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)

agentivium_core-0.2.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: agentivium-core
+Version: 0.2.0
+Summary: Core abstractions for Agentivium agent-native systems.
+Author: Agentivium AI
+License: MIT License
+        
+        Copyright (c) 2026 Agentivium AI
+        
+        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.
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Agentivium Core
+
+`agentivium-core` defines the small, domain-neutral contracts shared by
+Agentivium agent-native systems. It provides typed schemas and abstract
+interfaces for intent parsing, policy validation, planning, tool adaptation,
+provider-neutral LLM calls, execution tracing, and evaluation.
+
+It is not an agent runtime, a provider-specific LLM wrapper, or a domain
+implementation. Schedulers, provider clients, policies, and orchestration
+belong in extension packages.
+
+## Install
+
+```bash
+pip install agentivium-core
+```
+
+For local development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Extend the core
+
+Domain packages subclass schemas and implement interfaces:
+
+```python
+from agentivium_core.intent import IntentIR, IntentParser
+
+
+class MyIntentIR(IntentIR):
+    domain: str = "my_domain"
+    task: str
+
+
+class MyIntentParser(IntentParser):
+    def parse(
+        self,
+        request: str,
+        context: dict[str, object] | None = None,
+    ) -> MyIntentIR:
+        return MyIntentIR(raw_request=request, task=request)
+```
+
+The dependency direction stays one-way: domain packages import
+`agentivium_core`; the core never imports a domain package.
+
+## Public API
+
+```python
+from agentivium_core.intent import IntentIR, IntentParser
+from agentivium_core.planner import ActionPlan, Planner
+from agentivium_core.policy import (
+    PolicyValidator,
+    ValidationIssue,
+    ValidationResult,
+)
+from agentivium_core.tools import ToolAdapter
+from agentivium_core.trace import ExecutionTrace
+from agentivium_core.eval import EvaluationRecord
+```
+
+## Provider-neutral LLM abstraction
+
+`agentivium-core` defines `LLMClient`, `LLMRequest`, `LLMResponse`,
+`PromptTemplate`, `StructuredOutputSpec`, and `LLMCallTrace` so downstream
+packages can use LLMs without coupling core to OpenAI, Anthropic, Gemini,
+Ollama, vLLM, llama.cpp, or any other provider.
+
+```python
+from agentivium_core.llm import (
+    LLMClient,
+    LLMRequest,
+    LLMResponse,
+    PromptTemplate,
+)
+
+
+class MyLocalLLMClient(LLMClient):
+    def generate(self, request: LLMRequest) -> LLMResponse:
+        return LLMResponse(content='{"intent": "example"}', model="local")
+
+
+template = PromptTemplate(
+    name="intent_parser",
+    system="You extract structured intent.",
+    user_template="Request: {request}",
+)
+
+messages = template.render({"request": "Run a small MPI job."})
+client = MyLocalLLMClient()
+response = client.generate(LLMRequest(messages=messages))
+print(response.content)
+```
+
+Production provider clients live in domain or provider packages. Core only
+defines the contracts and a `MockLLMClient` for tests and demos.
+
+See the [concepts](docs/concepts.md), [API reference](docs/api.md),
+[extension guide](docs/extension_guide.md), and
+[examples](docs/examples.md). The complete v0.1 rationale and boundaries are
+preserved in the original [design guideline](docs/design-guideline.md).

agentivium_core-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+agentivium_core/__init__.py,sha256=WZpVtYFUL8uwaCQ6FBUrr0mB8v6bxH5MqcYJwx57h-A,1113
+agentivium_core/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+agentivium_core/errors/__init__.py,sha256=ryvPxIWxLPFXf70fEQdXOpLEQizpFMwIPHEBQbHbRXU,324
+agentivium_core/errors/base.py,sha256=ur9r85d5JKQGB4qDMAhwV8Pt2UIwxbzeSdfm8yR9jGc,534
+agentivium_core/eval/__init__.py,sha256=VMYql6xHCbuptqIprPED5lOKhnkb-SmnyF3dQ3SUXWU,117
+agentivium_core/eval/record.py,sha256=rcZXGu9LHr35JrDyba_CGX5b_CcfN-0xtUHA4tM4f40,433
+agentivium_core/intent/__init__.py,sha256=lxdlA4p_63OsBHxFhMXAX2_qTpCGqLQj0ZakUxUaBjQ,148
+agentivium_core/intent/base.py,sha256=e52a8gmUyBLTNMPcLqk1fFc-k83JavSMH5N44jgqrFM,703
+agentivium_core/llm/__init__.py,sha256=YkjQE0w7sieuRibWv57EWb7sRfI4LVcixycr92NiMaU,698
+agentivium_core/llm/client.py,sha256=KayG8Eqj_N6wPq03KYRzW7K1QqEpW-EzUIgyb3JBUuM,892
+agentivium_core/llm/message.py,sha256=1mpLpyxnD--YkzDksz_4Ca7CIvYLGz4sBEKH4B1HTN8,337
+agentivium_core/llm/prompt.py,sha256=461XFnym20b93nzXRBBfk5RtOBl9inJPo00kbricl50,759
+agentivium_core/llm/request.py,sha256=g0p-ZY-mEgYxI6Pjw9efYmE-P0XMhaZD0EdCkPWczdw,524
+agentivium_core/llm/response.py,sha256=E8OZmo4ceNpFyZAyiRsLSwpwcdqAC3jlGZASKIJb4uw,618
+agentivium_core/llm/structured.py,sha256=Pv5hFWrX45F-i7F75ZfsQ9WDdQF8Y4jpxcDb7l5nrOg,1081
+agentivium_core/llm/trace.py,sha256=WV38teQj0Pcb1ARsMj0IVlQY1ZOHaZviloowpcH-Op8,631
+agentivium_core/planner/__init__.py,sha256=xrfJMALtTLSwFPecCpqQ5pBI_sXZ8i81oaY8qDS9ibE,191
+agentivium_core/planner/action.py,sha256=EZZADPbcE3g_2wonvjb2sOYI1T7bxp9orzHJomoZeRQ,447
+agentivium_core/planner/base.py,sha256=K4NQuD2Zo84s3uWEweeNCdWjVT7FSQxNW-VSwg0r5Bk,504
+agentivium_core/policy/__init__.py,sha256=fRN8lx-bGtF5MAED_ARneF6IQfPrUnMeEJ2jKfuk51Q,262
+agentivium_core/policy/base.py,sha256=jKgU8K0HmyxUukZTjNMdXdVLpgz3dMK29GIGVOgrqng,515
+agentivium_core/policy/result.py,sha256=9lD04xKcPb4NV9ghj_h3pEPnJbsp31XOoP8Oixgh_Xo,799
+agentivium_core/tools/__init__.py,sha256=pBMeyduYxiDVTSrV24D-0G39ICwjR_Y4AbXHJ-mmmeE,110
+agentivium_core/tools/base.py,sha256=Yp9eIFH2ceQAP52jD6P9pn9kPzLUPJ5e3NOCvWaDhVc,442
+agentivium_core/trace/__init__.py,sha256=xAjUFteFZI4eY_-yW5ike_lJm9QcDApdm6CBJU08rVE,122
+agentivium_core/trace/execution.py,sha256=Jk108HR-70sCV1sOjAACZ66zmXvs8HPhTvw3VNFXplk,835
+agentivium_core-0.2.0.dist-info/METADATA,sha256=jJNu4du-0UQVarKo07G15WxB-gQfmM4ZqE5fHzRHy4I,4850
+agentivium_core-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+agentivium_core-0.2.0.dist-info/licenses/LICENSE,sha256=Y6_XRGKm02xfb7s6v5nqxMR71bP9TglQ4ahfYsOXXK8,1070
+agentivium_core-0.2.0.dist-info/RECORD,,

agentivium_core-0.2.0.dist-info/WHEEL

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

agentivium_core-0.2.0.dist-info/licenses/LICENSE

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