agentforge-core 0.2.1__py3-none-any.whl

agentforge_core/values/messages.py

@@ -0,0 +1,153 @@
+"""Provider-agnostic message and response shapes for the LLM contract.
+
+Every `LLMClient` returns `LLMResponse`; every reasoning strategy
+operates on `list[Message]` regardless of which provider backs the
+agent. Streaming clients yield `StreamChunk`s; embedding clients
+return `EmbeddingResponse`.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+StreamChunkKind = Literal["text", "tool_call", "stop", "thinking"]
+"""Closed enum of stream-chunk kinds. Provider drivers normalise their
+event streams into a sequence of these chunks. Adding a new kind is a
+minor version bump."""
+
+MessageRole = Literal["system", "user", "assistant", "tool"]
+"""Allowed message roles. Mirrors the Anthropic / OpenAI common set."""
+
+StopReason = Literal["end_turn", "tool_use", "max_tokens", "stop_sequence", "other"]
+"""Provider-normalised reason the LLM stopped emitting tokens."""
+
+
+class Message(BaseModel):
+    """One turn in the chat-completion exchange."""
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    role: MessageRole
+    content: str
+    name: str | None = None
+    tool_call_id: str | None = None
+
+
+class ToolCall(BaseModel):
+    """A tool invocation emitted by the LLM."""
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    id: str
+    name: str
+    arguments: dict[str, Any] = Field(default_factory=dict)
+
+
+class ToolSpec(BaseModel):
+    """Provider-agnostic tool description sent to the LLM.
+
+    `schema` is the JSON-schema dict (typically from a Pydantic model's
+    `model_json_schema()`). The `Tool` ABC's `to_spec()` produces this.
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    name: str
+    description: str
+    schema_: dict[str, Any] = Field(alias="schema")
+
+
+class TokenUsage(BaseModel):
+    """Token accounting from a single LLM call."""
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    input_tokens: int = Field(ge=0)
+    output_tokens: int = Field(ge=0)
+    cache_read_tokens: int = Field(default=0, ge=0)
+    cache_write_tokens: int = Field(default=0, ge=0)
+    thinking_tokens: int = Field(default=0, ge=0)
+
+    @property
+    def total(self) -> int:
+        """Sum of input + output tokens (excludes cache and thinking metadata)."""
+        return self.input_tokens + self.output_tokens
+
+
+class LLMResponse(BaseModel):
+    """Provider-agnostic response from one LLM call."""
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    content: str
+    tool_calls: tuple[ToolCall, ...] = ()
+    stop_reason: StopReason
+    usage: TokenUsage
+    cost_usd: float = Field(ge=0.0)
+    model: str
+    provider: str
+
+
+class StreamChunk(BaseModel):
+    """One event in a provider's streaming response.
+
+    Streaming `LLMClient`s yield an `AsyncIterator[StreamChunk]`. The
+    chunks are ordered: text deltas, optional thinking blocks, optional
+    tool-call deltas, and exactly one terminal `stop` chunk carrying
+    the final usage and cost. Consumers that don't care about
+    streaming can accumulate chunks into a single `LLMResponse` via
+    a helper.
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    kind: StreamChunkKind
+    delta: str = ""
+    """Incremental content for `text` and `thinking` kinds (empty for
+    `tool_call` and `stop`)."""
+
+    tool_call: ToolCall | None = None
+    """The fully-assembled `ToolCall` for `kind == "tool_call"` chunks.
+    Provider drivers buffer tool-call argument streams internally and
+    emit one chunk once the call is complete."""
+
+    stop_reason: StopReason | None = None
+    """Set on the terminal `stop` chunk; `None` otherwise."""
+
+    usage: TokenUsage | None = None
+    """Final token accounting on the terminal `stop` chunk."""
+
+    cost_usd: float = Field(default=0.0, ge=0.0)
+    """Final cost on the terminal `stop` chunk; `0.0` on intermediate
+    chunks."""
+
+
+class EmbeddingResponse(BaseModel):
+    """Provider-agnostic response from an embedding call.
+
+    `vectors` is a list of float lists — one vector per input text in
+    the same order the texts were passed. Every vector has the same
+    `dimensions` (the model-declared dimensionality).
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    vectors: tuple[tuple[float, ...], ...]
+    """One vector per input text, in input order. Tuples-of-tuples
+    keeps the response frozen and hashable while the dimensionality
+    stays uniform across vectors."""
+
+    dimensions: int = Field(ge=1)
+    """Length of every vector. The `EmbeddingClient.dimensions()`
+    accessor declares this up front for callers that need to size
+    storage before the call."""
+
+    usage: TokenUsage
+    """Token accounting (input only — embeddings produce no output
+    tokens)."""
+
+    cost_usd: float = Field(ge=0.0)
+    model: str
+    provider: str

agentforge_core/values/module.py

@@ -0,0 +1,40 @@
+"""`ModuleInfo` — descriptor for a registered module (feat-010).
+
+Returned by `Resolver.list_installed`. Carries enough metadata for
+the `agentforge list modules` CLI to render a useful table:
+the entry-point category + name, the providing distribution + its
+version, and the class object itself (for introspection — e.g.
+capabilities, docstring).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModuleInfo(BaseModel):
+    """Metadata about one registered module.
+
+    Attributes:
+        category: Entry-point group suffix — e.g. `"providers"`,
+            `"memory"`, `"tools"`, `"hooks"`, `"renderers"`,
+            `"evaluators"`. Matches the second arg to `register`.
+        name: Per-category identifier — e.g. `"bedrock"`, `"sqlite"`.
+        package: Distribution that provided the class, if known
+            (`"agentforge-bedrock"`, `"agentforge"`, etc.). `None`
+            for classes registered via `@register` from an unpackaged
+            location (typical in tests or single-file agents).
+        version: Distribution version (`"0.2.1"`). `None` when
+            `package` is `None`.
+        cls_qualname: Fully-qualified class name (`"agentforge_bedrock.client.BedrockClient"`)
+            — useful for diagnostic output without pulling the class
+            object into the renderer.
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    category: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+    package: str | None = None
+    version: str | None = None
+    cls_qualname: str = Field(min_length=1)

agentforge_core/values/pipeline.py

@@ -0,0 +1,43 @@
+"""`PipelineResult` — the locked output of `Pipeline.run()`.
+
+feat-015 ships this as a frozen Pydantic value model. The runtime
+stores it on the agent for the duration of one run (system prompt
+addendum + ``pipeline_findings`` built-in tool) and optionally
+records it as a single ``__pipeline`` claim when ``record_runs`` is
+configured.
+
+`findings` is a list of `Finding` Protocol-compatible objects (the
+shipped variants from ``agentforge.findings`` all satisfy it). The
+shape stays tolerant of custom finding subclasses.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PipelineResult(BaseModel):
+    """Consolidated output of one `Pipeline.run()` call.
+
+    Fields:
+        findings: All findings emitted across every task, in the
+            order each task completed. Task-failure entries (when
+            ``on_task_error="continue"``) appear here too as
+            ``SimpleFinding(category="pipeline.task_failure")``.
+        task_durations_ms: Per-task wallclock duration in
+            milliseconds.
+        task_failures: Map of task name → error message for any
+            task that raised. Empty when every task succeeded.
+        total_cost_usd: Sum of ``cost_estimate_usd`` across all
+            tasks that ran (the engine charges this against the
+            agent's budget).
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    findings: tuple[Any, ...] = ()
+    task_durations_ms: dict[str, int] = Field(default_factory=dict)
+    task_failures: dict[str, str] = Field(default_factory=dict)
+    total_cost_usd: float = Field(default=0.0, ge=0.0)

agentforge_core/values/retrieval.py

@@ -0,0 +1,53 @@
+"""Retrieval-ergonomics value types (feat-023).
+
+`GraphExpansion` bundles the knobs callers pass when wiring a
+`Retriever` with graph-augmented expansion — the GraphStore to
+traverse, the hop budget, edge-type filtering, the node property
+to use as match text, and the per-hop score decay.
+
+Kept frozen + strict per the framework's value-type policy. The
+`store` field tolerates an `ABC` instance via
+`arbitrary_types_allowed=True` — `GraphStore` isn't itself a
+Pydantic model.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from agentforge_core.contracts.graph_store import GraphStore
+
+
+class GraphExpansion(BaseModel):
+    """Graph-traversal configuration for :class:`Retriever`
+    post-retrieve augmentation (feat-023).
+
+    Attributes:
+        store: The `GraphStore` driver to traverse.
+            ``VectorMatch.id`` ↔ ``GraphNode.id`` alignment is a
+            caller contract; mismatched ids silently skip
+            expansion for that seed.
+        max_hops: Maximum traversal depth (>= 1). Each hop
+            multiplies the candidate set by the average graph
+            fan-out — tune cautiously.
+        edge_types: If set, restricts traversal to these edge
+            types. ``None`` means all edge types.
+        text_property: Graph-node property used to populate the
+            synthesised ``VectorMatch.text``. Defaults to
+            ``"text"``.
+        decay: Per-hop score decay factor in ``(0, 1]``. An
+            expansion node at depth `d` gets score
+            ``seed.score * decay ** d``. Default 0.5.
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        strict=True,
+        arbitrary_types_allowed=True,
+    )
+
+    store: GraphStore
+    max_hops: int = Field(default=2, ge=1)
+    edge_types: tuple[str, ...] | None = None
+    text_property: str = Field(default="text", min_length=1)
+    decay: float = Field(default=0.5, gt=0.0, le=1.0)

agentforge_core/values/state.py

@@ -0,0 +1,118 @@
+"""`AgentState`, `Step`, `RunResult` — the trace shape of an agent run.
+
+Per ADR-0008, `state.steps` is uniform across reasoning strategies so
+debugging skills transfer between agents that use different loop
+shapes (ReAct, Plan-Execute, ToT, Multi-Agent).
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from agentforge_core.contracts.evaluator import EvalResult
+from agentforge_core.values.messages import ToolCall
+
+StepKind = Literal[
+    "think",
+    "act",
+    "observe",
+    "plan",
+    "synthesize",
+    "branch",
+    "delegate",
+    "system",
+]
+"""Closed enum of step kinds. Every reasoning strategy emits steps from
+this set; new kinds require a feature doc + minor version bump."""
+
+FinishReason = Literal[
+    "completed",
+    "iteration_cap",
+    "budget_exceeded",
+    "guardrail",
+    "pipeline",
+    "error",
+    "cancelled",
+]
+"""How a run terminated. Mirrors the runtime's branching of
+`BudgetExceeded` / `GuardrailViolation` / `PipelineFailure` / clean
+completion."""
+
+
+class Step(BaseModel):
+    """One unit of progress in `AgentState.steps`."""
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    iteration: int = Field(ge=0)
+    kind: StepKind
+    content: str | dict[str, Any]
+    tool_call: ToolCall | None = None
+    tokens_in: int = Field(default=0, ge=0)
+    tokens_out: int = Field(default=0, ge=0)
+    cost_usd: float = Field(default=0.0, ge=0.0)
+    duration_ms: int = Field(default=0, ge=0)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class AgentState(BaseModel):
+    """Mutable per-run state passed through the reasoning loop.
+
+    Strategies append to `steps`; tools and pipeline tasks may append
+    to `findings`. The runtime owns the lifecycle.
+
+    The per-run execution context (`RuntimeContext` — LLM client,
+    tools, memory, budget, system prompt) is stored on
+    `state.metadata` under the key `"__agentforge_runtime__"`,
+    populated by `Agent.run()` before calling the strategy.
+    Strategies access it via the `get_runtime(state)` helper in
+    `agentforge.strategies._base`. Storing it on metadata keeps
+    `agentforge-core` free of dependencies on runtime modules.
+    """
+
+    model_config = ConfigDict(strict=True, validate_assignment=True)
+
+    run_id: str
+    task: str
+    steps: list[Step] = Field(default_factory=list)
+    findings: list[Any] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class RunResult(BaseModel):
+    """Final, immutable output of `Agent.run()`.
+
+    Carries the agent's answer plus full trace, cost accounting, and the
+    run's `run_id` for cross-system correlation (ADR-0010).
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    output: str | dict[str, Any]
+    findings: tuple[Any, ...] = ()
+    steps: tuple[Step, ...] = ()
+    cost_usd: float = Field(ge=0.0)
+    tokens_in: int = Field(ge=0)
+    tokens_out: int = Field(ge=0)
+    run_id: str
+    duration_ms: int = Field(ge=0)
+    finish_reason: FinishReason = "completed"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    guardrail_events: tuple[dict[str, Any], ...] = ()
+    """feat-018: one entry per guardrail decision (input / output /
+    tool-gate). Each event carries `validator`, `passed`, `violations`,
+    `action`, `stage` ("input" / "output" / "tool"), and a hash of the
+    content (full content is never persisted here)."""
+
+    eval_scores: tuple[EvalResult, ...] = ()
+    """Per-evaluator `EvalResult` from the post-run evaluator pass.
+
+    Ordered by the order evaluators were configured on the Agent.
+    Empty when no evaluators ran (no `evaluators=` passed) or when
+    every evaluator was budget-skipped. See feat-006 §4.3 for the
+    cost-gating rule.
+    """

agentforge_core/values/vector.py

@@ -0,0 +1,59 @@
+"""Frozen value types for the `VectorStore` contract.
+
+`VectorItem` is what callers upsert into a vector store; `VectorMatch`
+is what searches return. Both are immutable Pydantic models so they
+can be freely passed across async boundaries without aliasing bugs.
+
+Per ADR-0007 these shapes are part of the framework's locked surface.
+Adding a field is a minor bump; removing or renaming requires a major
+bump.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class VectorItem(BaseModel):
+    """One indexable record in a `VectorStore`.
+
+    Attributes:
+        id: Caller-controlled identifier. Re-upserting an existing id
+            replaces the prior record (write-through, not append).
+        vector: The embedding. Length must match the store's declared
+            `dimensions()`; mismatch raises on `upsert`.
+        text: The source text the vector was computed from. Surfaced on
+            `VectorMatch` so callers don't have to keep a parallel
+            text store. Empty strings are allowed but discouraged.
+        metadata: Free-form key-value tags. Used by `search`'s
+            `filter_metadata=` argument for AND-style filtering. Kept
+            as a plain dict (not frozen) so Pydantic doesn't have to
+            recurse into arbitrary user payloads.
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    id: str = Field(min_length=1)
+    vector: tuple[float, ...]
+    text: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class VectorMatch(BaseModel):
+    """One result from `VectorStore.search`.
+
+    `score` is normalised cosine similarity in `[0, 1]`:
+      - 1.0 means identical direction (highest relevance)
+      - 0.0 means orthogonal (effectively unrelated)
+      - the contract is store-agnostic; drivers that return raw cosine
+        distance or negative inner-product convert at the boundary.
+    """
+
+    model_config = ConfigDict(frozen=True, strict=True)
+
+    id: str
+    text: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    score: float = Field(ge=0.0, le=1.0)

agentforge_core-0.2.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: agentforge-core
+Version: 0.2.1
+Summary: AgentForge core — stable contracts (ABCs, value types) for the agentic framework
+Project-URL: Homepage, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Repository, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Documentation, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Changelog, https://github.com/Scaffoldic/agentforge-py/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Scaffoldic/agentforge-py/issues
+Author: The AgentForge Authors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agent,ai,contracts,framework,llm
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: opentelemetry-api>=1.27
+Requires-Dist: pydantic>=2.10
+Requires-Dist: python-ulid>=3.0
+Description-Content-Type: text/markdown
+
+# agentforge-core
+
+The stable contract layer for AgentForge. ABCs, Protocols, and value
+types that every module implements.
+
+## What's in here
+
+(Once feat-001 lands.)
+
+- `LLMClient`, `EmbeddingClient` — provider abstractions
+- `ReasoningStrategy` — agent loop shape
+- `Tool` — pluggable capabilities
+- `MemoryStore`, `GraphStore` — persistence
+- `Evaluator` — post-run scoring
+- `InputValidator`, `OutputValidator`, `ToolCallGate` — real-time safety
+- `Finding` — output Protocol with shipped variants
+- `BudgetPolicy`, `RunContext`, `RunIdFilter` — production rails
+- Value types: `Claim`, `Step`, `RunResult`, etc.
+
+This package is a **locked contract** — adding a method to an ABC is a
+major version bump. See ADR-0007.
+
+## What's NOT in here
+
+- Reference implementations (`ReActLoop`, `InMemoryStore`, etc.) — those
+  live in `agentforge`
+- Provider clients — those live in `agentforge-anthropic`, etc.
+- Anything that does I/O
+
+## Install
+
+```bash
+pip install agentforge-core
+```
+
+Most users install `agentforge` directly, which depends on this package.
+
+## License
+
+Apache 2.0.

agentforge_core-0.2.1.dist-info/RECORD

@@ -0,0 +1,58 @@
+agentforge_core/__init__.py,sha256=McXfkBb7e78HMPMpg415VF_-4Dxu2Fy7rWVfHUj7cvg,5023
+agentforge_core/_bm25.py,sha256=1mjvh7lOBbZPcCYuSFjP6GKJYc7ZpubCeIrpR8Orl04,4632
+agentforge_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentforge_core/config/__init__.py,sha256=wTQGgHGmqLuUpjkpmh044xvxULiifUyX6m326_-hyf8,1690
+agentforge_core/config/loader.py,sha256=NJhKjkLWUc-H0H_f-qXgo0B0ONYlB3NtWh95pHO3DgA,8428
+agentforge_core/config/module_schemas.py,sha256=6PsWBK7gtT-96mopXiHUFNktKR5y-Pv0xTUNv3LbWMk,6746
+agentforge_core/config/schema.py,sha256=uW7OfE2eMPW9nkQ_Cnu3MX9BNDoTLuGkTMvRQo17dF8,15430
+agentforge_core/contracts/__init__.py,sha256=XrbuACw7RI99tcQWkIHZJ2zf0wo3x5qCtEmWJFcgHko,1697
+agentforge_core/contracts/auth.py,sha256=zd-JP-POj7TuXg4ymm7wQDAJHECDh90N3Wp9sONE9C4,1195
+agentforge_core/contracts/chat.py,sha256=VRPZM5PfdFO0hBaESIy9VE8VciOQQlur2_8jQNiLd-8,3873
+agentforge_core/contracts/embedding.py,sha256=tOfiml6NQknmrqO5crR1GXmFHwP5r3jrzwkqYju2x4Q,2582
+agentforge_core/contracts/evaluator.py,sha256=gk0nqtKkXdA-wh6LlEqGwJ7DchYBB5a6yUigd6qvbVs,1842
+agentforge_core/contracts/finding.py,sha256=Z3KuEwuk_07f_yuaHC09C5w9v88eXlZspBsHpiUZK4I,1288
+agentforge_core/contracts/graph_store.py,sha256=XGzRFBzCMyPhTDzXQQTBVOerZqMzFuK9jHFc_nkx1oQ,6441
+agentforge_core/contracts/guardrails.py,sha256=pDOolGTZre0R8sl5_wShcqTy48HxjfC3se8NWGyNxhs,3907
+agentforge_core/contracts/llm.py,sha256=HMxdR3iBcU7ANPNaMo6qecP4XzAH064p3PAYpHXuBdc,5384
+agentforge_core/contracts/memory.py,sha256=VE49No2WYubaUemJNvwNP1Cl7MIy0jDTJzfT_7KGd-g,3861
+agentforge_core/contracts/migrator.py,sha256=gyfQkR2NZu5HjMhQhE4mI2Rz8jkbaGHAQps_b72VuDM,4147
+agentforge_core/contracts/renderer.py,sha256=g3zRlADPhK_wwegyt1rJ5HTMfB3TzMpaSTM3uknUa54,2217
+agentforge_core/contracts/reranker.py,sha256=o3bp7tDGaoEAPaAiq7G3KJ7QzLHirEv162YdCHSKtq0,3404
+agentforge_core/contracts/strategy.py,sha256=zukHQ8yQsgaYWf-13e57YExLM81lq56PN4CQeSsuWcg,2801
+agentforge_core/contracts/task.py,sha256=UGFR48u4yltQbsNJbmgR99FP409ldFO6QIAuT1sZbEs,2501
+agentforge_core/contracts/tool.py,sha256=XUxKt8DvBYqZJICyNWMUaNbt_Oq2cC9hQo148pOUCao,2419
+agentforge_core/contracts/vector_store.py,sha256=tn6s1MBMQrDD7g4xCQnLx69dlKKhuI5nt6BATzmi5ZM,5788
+agentforge_core/migrations/__init__.py,sha256=G2lBRpsMpQehBJMvRGiSMjnoKJ54vRhZ2pqMx78F7uA,525
+agentforge_core/migrations/discover.py,sha256=91QNdJ3I0y5ugKtHvm0BM2KxBYm3ulDeCXl0hFuYJQw,2586
+agentforge_core/migrations/template.py,sha256=REROlDA_BPzcFhXHX3-3esgmBecpyqcXzoWLBzgDW1U,1333
+agentforge_core/observability/__init__.py,sha256=6f4XeuJxVHFMCbP4Z9kBANmDQ3PvKdU8G6GyEFOTK6E,593
+agentforge_core/observability/tracing.py,sha256=tyC6KH8C5zJU4t0ZNsQ1b3tTbCWy4i_rlytSIXgaBos,1260
+agentforge_core/production/__init__.py,sha256=ggvR4qPDMUx1hcRnU2puQcfnLlNx-NoCDXbELkJ7lyQ,2179
+agentforge_core/production/budget.py,sha256=odQMsinrIt5a8RfB7ggrgTEujtxkO13XmCpwU68TM3k,5091
+agentforge_core/production/exceptions.py,sha256=sFeEIC6wHds-Pj_nbro4wX0P8gp2Z_O5dbXXUL2K7qs,4222
+agentforge_core/production/fallback.py,sha256=VXTLcxdlZqd0m_u4mYDKddToXzzRdRf5si5u9aPrZKY,12011
+agentforge_core/production/log_filter.py,sha256=c0zX_UOQQAHusu2k62sfv9Nm9lnAAWgS_TSq3ffffUU,1634
+agentforge_core/production/log_format.py,sha256=ZQ5JBatpYFfGQedFMkryiA4l8ZbA6RT0JlldPVt3hKU,3738
+agentforge_core/production/run_context.py,sha256=gQLRxtBRghOuZ_P_qg24sDCHy8TseNJMBtKoevegr8A,3383
+agentforge_core/resolver/__init__.py,sha256=gXpuZ4cVVmxDviblnPSwh0YFNEOVQyQZwcUa389HVog,1096
+agentforge_core/resolver/discover.py,sha256=w8WaWtt2JHv0HGJmB7XFpx-PuN0ubx3HBC5nqh2aw0E,5045
+agentforge_core/resolver/resolve.py,sha256=iOKV5L7qxgqDOP8kkugih6gXzPSHdAB5WmakqTuzUGI,6234
+agentforge_core/testing/__init__.py,sha256=d3ciS5qI6sjezqiRcX5-FYM0azfGRoy498aESBLEqoQ,1425
+agentforge_core/testing/conformance.py,sha256=_SymngwwBu9Sm5CPwaaBCywkeIC7r9NRedyJ0nbupDg,44951
+agentforge_core/values/__init__.py,sha256=gXQ17KLzotM7TmR7N2mwh_xnAwGImmOv4XChqzot5CI,2192
+agentforge_core/values/auth.py,sha256=dErBR6xagq_wZwhU5x3gD0N1-1Mr4Xtnne-L-IIzLgg,569
+agentforge_core/values/chat.py,sha256=HbIPWoQXYSaHCLny01_j53ozTvG0pEwy5uvCDgun0Cs,4293
+agentforge_core/values/claim.py,sha256=yEd1CW9A6pYj3Htq6an9zk3cWiN0IOjWrE-A4vj594M,900
+agentforge_core/values/graph.py,sha256=WeuClLzIiS3Jo5_CZ30dWObLa0I6-RcgLSTj8sgCs9k,5112
+agentforge_core/values/guardrails.py,sha256=9M-Z6eapS6SD8otbXD9bLoR7yHHOcewWRh0NzeuVr5E,1715
+agentforge_core/values/manifest.py,sha256=rcC1yYgXkBUgq-05OuUoU4wwUb6ohqGPZi8MUBsGmpI,4326
+agentforge_core/values/messages.py,sha256=mNnp7VPS-W0T-Xj2xY38T9hMYhkd9ELeV_ziFaf--Pk,4834
+agentforge_core/values/module.py,sha256=whlYMCx-QwUSitHPv_Ybw95bDWsr9DvanefTDb9qj0s,1614
+agentforge_core/values/pipeline.py,sha256=Fa4Fy73O4wsjSt0oJarIyFRNiNv6dXyEq4QjC-vAsLg,1660
+agentforge_core/values/retrieval.py,sha256=gQt94qmzGz2UI7e07ytR9ITV8xEqthIByMemL7qfowc,1942
+agentforge_core/values/state.py,sha256=9GsRmDONQNxgXnkXF9YoHWEbLXq801cTbpmdEExBf-c,3911
+agentforge_core/values/vector.py,sha256=NCgJ7HZ0cMJ9mewfwV7Bygugu7-5LwhzP5LtSKQCfs8,2122
+agentforge_core-0.2.1.dist-info/METADATA,sha256=fCCvY5CPwETd8oMkmzA9VP3KQoF16822Nzmu6imBI3c,2276
+agentforge_core-0.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentforge_core-0.2.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+agentforge_core-0.2.1.dist-info/RECORD,,

agentforge_core-0.2.1.dist-info/WHEEL

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