agentforge-oss 0.1.0__py3-none-any.whl

agentforge_oss-0.1.0.dist-info/METADATA

@@ -0,0 +1,397 @@
+Metadata-Version: 2.4
+Name: agentforge-oss
+Version: 0.1.0
+Summary: Forge — an open-source, enterprise-ready multi-agent orchestration platform with cost awareness, governance, and security built in.
+Project-URL: Homepage, https://github.com/sekacorn/AgentForge
+Project-URL: Documentation, https://github.com/sekacorn/AgentForge#readme
+Project-URL: Repository, https://github.com/sekacorn/AgentForge
+Project-URL: Issues, https://github.com/sekacorn/AgentForge/issues
+Author-email: Sekacorn <Sekacorn@gmail.com>
+Maintainer-email: Sekacorn <Sekacorn@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,anthropic,claude,enterprise,governance,llm,multi-agent,observability,openai,orchestration,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Requires-Dist: typing-extensions>=4.10
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20; extra == 'all'
+Requires-Dist: openai>=1.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# Forge
+
+### The open-source multi-agent orchestration platform for teams that ship.
+
+**Build, run, optimize, and govern teams of AI agents for real business workflows —
+with cost-awareness, security, and compliance built in from line one.**
+
+[![CI](https://github.com/sekacorn/AgentForge/actions/workflows/ci.yml/badge.svg)](https://github.com/sekacorn/AgentForge/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/agentforge-oss.svg)](https://pypi.org/project/agentforge-oss/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
+[![Typed](https://img.shields.io/badge/typed-mypy%20strict-blue.svg)](pyproject.toml)
+[![Status: Beta](https://img.shields.io/badge/status-beta-orange.svg)](#roadmap)
+
+</div>
+
+---
+
+## Why Forge?
+
+A single AI agent is a clever assistant. **A coordinated _team_ of agents is a force
+multiplier** — it can plan, divide work, call tools, check itself, and deliver a
+finished outcome instead of a suggestion.
+
+But most teams can't put multi-agent systems into production. The demos are
+impressive; the operational reality is not. The questions that kill adoption are
+always the same:
+
+> _"What is this going to cost? Who can run it? What happens when a tool
+> misbehaves? Can we prove what it did for the auditors? Will it leak our data?"_
+
+**Forge is built to answer those questions out of the box.** It is an orchestration
+core that treats cost, security, governance, and observability as first-class
+features — not afterthoughts you bolt on before launch.
+
+```python
+import asyncio
+from forge import Orchestrator
+
+async def main() -> None:
+    # Zero config. Runs fully offline with the deterministic echo provider,
+    # and automatically uses Claude when ANTHROPIC_API_KEY is set.
+    async with Orchestrator() as forge:
+        result = await forge.run(
+            "Draft an outreach email to a prospect and compute a 12% discount on $4,200"
+        )
+        print(result.output)
+        print(result.usage.format_table())   # tokens + dollars, per model and per agent
+
+asyncio.run(main())
+```
+
+---
+
+## The force-multiplier thesis
+
+| Without Forge | With Forge |
+|---|---|
+| One prompt, one answer, no division of labor | A supervisor decomposes the goal and delegates to specialized workers |
+| Every call hits your most expensive model | Intelligent routing sends easy work to cheap models, hard work to frontier models |
+| Cost is a surprise on the invoice | Cost is tracked per run, per agent, per model — with hard budget caps |
+| Tools run with full trust | Tools run sandboxed, with side-effecting tools **denied by default** |
+| "Trust me, it worked" | A tamper-evident, hash-chained audit trail of every action |
+| Prototype you can't ship | A typed, tested core designed for production |
+
+---
+
+## Key features
+
+### Multi-agent orchestration
+- **Supervisor + dynamic workers.** A supervisor breaks a goal into independent
+  subtasks and spawns a focused worker agent for each, then synthesizes the result.
+- **Real agentic loop.** Workers reason, call tools, observe results, and iterate
+  until done — with a hard step budget so they never spin forever.
+
+### Intelligent routing & cost optimization
+- **Capability/price-aware router** with `cost_optimized`, `quality_first`,
+  `balanced`, and `fixed` strategies.
+- **One pricing source of truth.** The model registry knows real list pricing
+  (Claude Opus 4.8, Sonnet 4.6, Haiku 4.5, Fable 5) and computes spend consistently.
+- **Budgets that bite.** Per-run USD and token caps halt a runaway before the next
+  expensive call.
+
+### Tools, memory & RAG — extensible by design
+- **`@tool` decorator** turns any typed Python function into an agent tool, with
+  JSON-Schema generated automatically from your type hints and docstring.
+- **Pluggable memory.** Short-term conversation memory plus a dependency-free
+  in-memory vector store for RAG — swap in any backend behind one tiny interface.
+- **Provider-agnostic core.** Anthropic (Claude) and a deterministic offline
+  provider ship in the box; add any provider by implementing one method.
+
+### Security from the start
+- **Tool sandboxing** with allowlists/denylists, per-tool timeouts, and
+  **dangerous (network/filesystem) tools denied unless explicitly allowed**.
+- **Prompt-injection heuristics** and input normalization on untrusted goals.
+- **RBAC** — map your IdP groups onto roles and gate who can run agents or use
+  dangerous tools.
+
+### Compliance & governance
+- **Tamper-evident audit log.** Every model call, tool call, plan, and decision is
+  written to an append-only, **SHA-256 hash-chained** JSONL trail. Edits break the
+  chain — and `forge audit` detects it.
+- **PII redaction** of logs and audit records (emails, cards, SSNs, IPs, phones).
+- **Data-residency & retention** hints recorded on every entry for GDPR/SOC 2 stories.
+
+### Observability built in
+- A structured **event bus** emits every lifecycle moment (routing, model calls,
+  tool calls, budget thresholds, security violations).
+- **Structured logging** (human or JSON) and a per-run **usage/cost report**.
+
+---
+
+## Install
+
+```bash
+pip install agentforge-oss               # core (works offline, zero config)
+pip install "agentforge-oss[anthropic]"  # + Claude provider
+pip install "agentforge-oss[all,dev]"    # everything + test/lint tooling
+```
+
+> Forge runs **fully offline** out of the box using a deterministic provider, so you
+> can explore the whole platform — routing, tools, supervision, audit — without an
+> API key. Set `ANTHROPIC_API_KEY` to route to Claude automatically.
+
+---
+
+## Quickstart (CLI)
+
+```bash
+# Works with no API key — uses the offline provider.
+forge run "Plan a product launch and calculate 15% of 3,400" --verbose
+
+# See the model registry and pricing the router reasons over.
+forge models
+
+# Verify the audit log hasn't been tampered with.
+forge audit
+```
+
+`--verbose` streams a live trace so you can watch the supervisor plan, route each
+call, run tools in the sandbox, and tally cost in real time.
+
+---
+
+## Quickstart (library)
+
+### A custom tool + a single agent
+
+```python
+import asyncio
+from forge import Orchestrator, ToolRegistry, tool, calculator
+
+@tool
+def fx_convert(amount: float, rate: float) -> float:
+    """Convert an amount using an FX rate.
+
+    Args:
+        amount: The amount in the source currency.
+        rate: The exchange rate to apply.
+    """
+    return round(amount * rate, 2)
+
+async def main() -> None:
+    tools = ToolRegistry([calculator, fx_convert])
+    async with Orchestrator() as forge:
+        result = await forge.run(
+            "Convert 250 USD to EUR at 0.92 and then add a 3 EUR fee",
+            mode="single",
+            tools=tools,
+        )
+        print(result.output)
+
+asyncio.run(main())
+```
+
+### Retrieval-augmented generation (RAG), offline
+
+```python
+import asyncio
+from forge import InMemoryVectorStore
+
+async def main() -> None:
+    store = InMemoryVectorStore()
+    await store.add("Forge routes cheap tasks to small models to save cost.")
+    await store.add("The audit log is hash-chained and tamper-evident.")
+    hits = await store.search("how does Forge keep costs down?", k=1)
+    print(hits[0].text)   # -> the cost-routing fact
+
+asyncio.run(main())
+```
+
+See [`examples/`](examples/) for runnable end-to-end scripts, including enterprise
+governance (RBAC + budgets + audit verification).
+
+---
+
+## Architecture
+
+```
+                         ┌──────────────────────────────────────────────┐
+                         │                Orchestrator                  │
+                         │  access control · sanitization · accounting  │
+                         └───────────────┬──────────────────────────────┘
+                                         │  RunContext (per run)
+              ┌──────────────────────────┼───────────────────────────┐
+              ▼                          ▼                           ▼
+      ┌───────────────┐         ┌─────────────────┐          ┌──────────────┐
+      │  Supervisor   │ spawns  │   Worker Agent  │  calls   │ Tool Sandbox │
+      │  plan→delegate│────────▶│  reason ↔ act   │─────────▶│ allow/deny + │
+      │  →synthesize  │         │   (agentic loop)│          │  timeouts    │
+      └───────┬───────┘         └────────┬────────┘          └──────────────┘
+              │                          │
+              │      ┌───────────────────┴───────────────┐
+              ▼      ▼                                    ▼
+       ┌────────────────┐                        ┌──────────────────┐
+       │  Model Router  │  picks model by        │  Model Providers │
+       │ cost / quality │  strategy + budget ───▶│ Anthropic · Echo │
+       └───────┬────────┘                        └──────────────────┘
+               │ pricing
+               ▼
+       ┌────────────────┐   cross-cutting, on every step:
+       │ Model Registry │   Usage/Cost · Event Bus · Audit Log · Redaction
+       └────────────────┘
+```
+
+Every layer is swappable:
+
+| Layer | Default | Swap in… |
+|---|---|---|
+| Provider | Echo (offline), Anthropic | Any `ModelProvider` (OpenAI, local, Bedrock, …) |
+| Routing | `balanced` strategy | Your own strategy / `fixed` model |
+| Memory | In-memory vector store | Any `Memory` backend (pgvector, Pinecone, …) |
+| Tools | `calculator`, `utc_now` | Any `@tool` function |
+| Audit | Hash-chained JSONL | Forward events to your SIEM via the event bus |
+
+---
+
+## Enterprise use cases
+
+Forge is a force multiplier wherever a workflow is **multi-step, judgment-heavy, and
+needs a paper trail**:
+
+- **Revenue & RevOps** — enrich a lead, draft tailored outreach, compute discounts
+  within policy, and log every step for the deal record.
+- **Customer support** — triage a ticket, retrieve the right KB articles (RAG),
+  draft a grounded reply, and escalate by policy.
+- **Finance & operations** — reconcile figures with a sandboxed calculator, summarize
+  variances, and produce an auditable trail for controllers.
+- **Compliance & risk** — run document review where _every_ action is recorded in a
+  tamper-evident log, with PII redacted and access role-gated.
+- **Engineering** — fan out research across a codebase with a supervisor, keeping
+  cheap models on grunt work and frontier models on the hard reasoning.
+
+The common thread: Forge lets you **say yes to production** because the governance
+questions already have answers.
+
+---
+
+## Security & compliance posture
+
+- **Least privilege by default.** Dangerous tools (network egress, filesystem) are
+  denied unless you explicitly allowlist them.
+- **Defense in depth.** Input sanitization + prompt-injection heuristics sit in front
+  of every untrusted goal; tool execution is bounded by timeouts.
+- **Provable history.** The audit log is append-only and hash-chained; `forge audit`
+  (or `Orchestrator.verify_audit()`) detects any tampering.
+- **Privacy aware.** PII redaction runs before anything is written to logs or audit.
+- **Access control.** RBAC gates sensitive operations; map roles to your IdP groups.
+
+> Forge gives you strong application-level controls. It is not a substitute for OS-
+> level isolation when executing untrusted code — for that, run tools in a container
+> or microVM behind the same `ToolSandbox` interface. The design makes that a drop-in.
+
+---
+
+## Configuration
+
+Configuration layers (lowest to highest priority): **defaults → `forge.toml` →
+environment**.
+
+```toml
+# forge.toml
+[routing]
+strategy = "balanced"          # cost_optimized | quality_first | balanced | fixed
+default_model = "claude-opus-4-8"
+
+[budget]
+max_usd_per_run = 0.50
+max_steps_per_agent = 12
+max_workers = 6
+
+[security]
+detect_prompt_injection = true
+tool_timeout_seconds = 30
+# allow_tools = ["calculator", "http_get"]   # uncomment to permit a dangerous tool
+
+[compliance]
+audit_enabled = true
+redact_pii = true
+data_region = "eu-west-1"
+```
+
+Common environment variables: `ANTHROPIC_API_KEY`, `FORGE_DEFAULT_MODEL`,
+`FORGE_ROUTING_STRATEGY`, `FORGE_MAX_USD_PER_RUN`, `FORGE_LOG_LEVEL`,
+`FORGE_JSON_LOGS`, `FORGE_AUDIT_ENABLED`, `FORGE_REDACT_PII`. See
+[`.env.example`](.env.example).
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/sekacorn/AgentForge.git
+cd AgentForge
+python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -e ".[all,dev]"
+
+pytest            # run the test suite (offline, no API key needed)
+ruff check .      # lint
+mypy forge        # strict type-check
+```
+
+The entire test suite runs offline against the deterministic provider — fast,
+hermetic, and free.
+
+---
+
+## Roadmap
+
+- [ ] Streaming token output through the event bus
+- [ ] First-party OpenAI / Bedrock / local (Ollama) providers
+- [ ] Durable memory backends (pgvector, Redis, object storage)
+- [ ] Parallel worker execution & inter-agent messaging
+- [ ] OpenTelemetry export for traces and metrics
+- [ ] Policy-as-code for tool governance
+- [ ] Hosted SaaS control plane (TypeScript / Next.js) — Python core first
+
+---
+
+## Contributing
+
+Contributions are very welcome — see [CONTRIBUTING.md](CONTRIBUTING.md). Good first
+areas: new providers, new tools, memory backends, and routing strategies. Please keep
+the core typed (`mypy --strict`) and tested.
+
+## License
+
+[MIT](LICENSE) — free for commercial and private use. Build something that multiplies
+your team.

agentforge_oss-0.1.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+forge/__init__.py,sha256=C2KVD-9sR4usLA3l_V1dULXxr2E7rDokgE5V07Jrlqo,4073
+forge/_version.py,sha256=S58BeCqmY14bx8xoXBKCUG-ENzAp5Vh5HFNFxa8BO00,277
+forge/config.py,sha256=myeWvI5yJtcb29Yp6WEczft4B1c-X4FyL6FXQ1-lLlM,7272
+forge/exceptions.py,sha256=86WTZSiT82euOVh3jJPE6wRimrWzlqNTbk_s2tYa95w,3967
+forge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge/types.py,sha256=Wz_rBX_DOIrNdagyh7P60_DB-qaExJCdY6kMhWmV3Zs,5076
+forge/agents/__init__.py,sha256=3QfFyYJ7zsGbC3otEFeOoXvW4_W8uZZ78WY-jjHdTww,272
+forge/agents/agent.py,sha256=3QrOTgyOrhq1L8-pVuSpHlOwitkdaZefBg7NFDc2YM8,4055
+forge/agents/base.py,sha256=UHlx_NolbROG5aGfmMQDymEccXxCHen4yfNT3mYqqNI,4767
+forge/agents/supervisor.py,sha256=545W2I5P-qSxGoyhwlQ5YxjoKMDEyaGOsiTD7V4-WsI,6709
+forge/cli/__init__.py,sha256=mNg1utbiYubQgWjv6hn7LA1r83IyXQYEttaM2d8fA-8,91
+forge/cli/console.py,sha256=iT4vyS-932a-yyXzaFyOFEA7526teZrupjnlxRmx-4g,3214
+forge/cli/main.py,sha256=XZNKFc3LCmYWMEgNNivD9tw4gLnlEKueYexX96bqId0,4639
+forge/compliance/__init__.py,sha256=ShmSPxIiB6EBq-ZJzlDrWJsz8FWzoksi1MXyLuDyon0,233
+forge/compliance/audit.py,sha256=dLN-rQcnuEceZpSQiW0mPn-9lj9ZW-inKESXiAG1W2A,5121
+forge/compliance/redaction.py,sha256=CZ1dcjDfqbjZ3N85HavWT_p06YZlTQIgNak0oM_pIJQ,1746
+forge/memory/__init__.py,sha256=kC9T7P0vbvDb1FFYLNx6aNn71dF14W5ef1L5-dVbB5k,317
+forge/memory/base.py,sha256=LM-3Fs7DtdQjygPZpqoJx9KyWLVeA-cKAbevd3qlXPE,1521
+forge/memory/conversation.py,sha256=yqikrwHl4ka2aDMsCSIzk24M9nRCy58stMwMZHNldPU,1640
+forge/memory/vector.py,sha256=15XcfQRIPirEvtZ3F-uGTZF4veXcxmDBlBorvWvzAK4,2905
+forge/models/__init__.py,sha256=qCAy-uzmp1R-rN5RGuWQAkFjE29oFi6Ezl39enMlTGw,438
+forge/models/base.py,sha256=VrVs4LYdOhEYuzVAqwWGnRNOVzk87yDNX0gi2WrMdMg,2665
+forge/models/registry.py,sha256=xXyos97NiiduvCqw9DtONSoNHqdsntwHV1hs8oAtHmc,7905
+forge/models/router.py,sha256=eCvmLeAk6XKLecZaETfteAI_qcNrmmuxK_zkTLfyxUg,5882
+forge/models/providers/__init__.py,sha256=yQc3WRQhgAJYH8d8QHWIMACch_-UeRElMx_kozNy_ws,573
+forge/models/providers/anthropic.py,sha256=AC-Ff4ROqeV48CKk3cALwEMcso6Q9F9vGBVHN6Ee--8,7394
+forge/models/providers/echo.py,sha256=59ONIHh8RIt4ISyHYocGRfYM8DlVRHFI5kV8SFkm1IQ,6777
+forge/models/providers/openai.py,sha256=2t6HcemPmkzCVpecrsdQGDgmri2rnmamepgj0wT29sI,7576
+forge/observability/__init__.py,sha256=Wog7XA4koWP1vxvKE4BqsYbqUvGnyrPTtFXqZfO1hRM,456
+forge/observability/events.py,sha256=XaovN8Bwzwm-EcbnVVzOsKS33XBitX3-Y6zgWEZurGI,3004
+forge/observability/logging.py,sha256=e2OfmHlk-1ML1ohqk3uXblIne-C-TShrrj3JhdT4OnE,2813
+forge/observability/usage.py,sha256=SjsbwAoVDVB0se3HnhPPmDjKjY3Xg20FrIDCNtlHXhA,2911
+forge/orchestration/__init__.py,sha256=M5dPkjUGFFE10XOHE7CSSaXeSsDMqBPBdYZgkBUXTDQ,265
+forge/orchestration/context.py,sha256=LhJTOhzG2vCkSkmwq_JGXy6uVLbqjm5zqN10JEkqovY,3733
+forge/orchestration/orchestrator.py,sha256=dL6lWRUEcra4QsotLRcaYi6B4y2czLCFaoaTj86Lk58,11338
+forge/security/__init__.py,sha256=Umfe6Ajb8pxKV1J1mxnxA7Tizi7UY720PxMjuF8XRQE,490
+forge/security/access.py,sha256=db74CTvBAcjtR8JneGPFho7zntAkRm4dcc_17A9xafw,2664
+forge/security/sandbox.py,sha256=qKFl2KI0v7s0I32QRInvFYGG6bjYGOV4YMR0WVH_pr4,4377
+forge/security/sanitization.py,sha256=B0HS6K5o-iiXm5COksexJHgs7ITQ07SRsrq29eDl7NA,3381
+forge/tools/__init__.py,sha256=u3vuLER54jXLeqXzKZ-0tsamvuKpBi_mNvtU_bTUlZE,361
+forge/tools/base.py,sha256=G9lCdJozOS5-GeRYH-K3jSG8vWyJtod4uroQqmxgGhI,7354
+forge/tools/registry.py,sha256=BHua-ofAAdsGoqKIWKTtF7Uc8peffrwvSPdgGJftKUc,1590
+forge/tools/builtin/__init__.py,sha256=30AX_vQCOjBNVVniuN4BJ7keWvwVePlGVvV63eJVEOg,502
+forge/tools/builtin/calculator.py,sha256=bqfWINSkE_-_Gzy47rHXGYEHWgWOdohqhZGoJUVOVQw,2204
+forge/tools/builtin/http.py,sha256=v0uqTpiJwty7PU2JC27IxsUvvRqh8zMWscLM8AV7MUQ,1268
+forge/tools/builtin/time.py,sha256=VqW5U40eSePLFjQp02ZxiYONCxT4brPnXgwD9FV9UAM,264
+agentforge_oss-0.1.0.dist-info/METADATA,sha256=r2YBXblwx49A7kTMVMWajE7mo9XCm-97UlqQhMdhhNk,16468
+agentforge_oss-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+agentforge_oss-0.1.0.dist-info/entry_points.txt,sha256=5UQL796DdhlixNcJTesU1Tf39hyqe7gwuFDCfRKJLiI,45
+agentforge_oss-0.1.0.dist-info/licenses/LICENSE,sha256=1Lhwyrb1s7nZFr69Lo0MQpRv8NeH9FEecPO8pcX_150,1065
+agentforge_oss-0.1.0.dist-info/RECORD,,

agentforge_oss-0.1.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

agentforge_oss-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forge = forge.cli.main:app

agentforge_oss-0.1.0.dist-info/licenses/LICENSE

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

forge/__init__.py

@@ -0,0 +1,183 @@
+"""Forge (AgentForge) — an open-source, enterprise-ready multi-agent platform.
+
+Quick start::
+
+    import asyncio
+    from forge import Orchestrator
+
+    async def main() -> None:
+        async with Orchestrator() as forge:           # zero-config, offline by default
+            result = await forge.run("Research X and summarise the findings")
+            print(result.output)
+            print(result.usage.format_table())        # tokens + cost
+
+    asyncio.run(main())
+
+The most important entry point is :class:`Orchestrator`. The rest of the public
+surface is re-exported here for convenience and stability.
+"""
+
+from __future__ import annotations
+
+from forge._version import __version__
+from forge.agents import Agent, AgentResult, BaseAgent, Supervisor
+from forge.compliance import AuditEntry, AuditLogger, PIIRedactor
+from forge.config import (
+    BudgetConfig,
+    ComplianceConfig,
+    ForgeConfig,
+    ObservabilityConfig,
+    RoutingConfig,
+    SecurityConfig,
+)
+from forge.exceptions import (
+    AccessDeniedError,
+    AgentError,
+    BudgetExceededError,
+    ConfigurationError,
+    ForgeError,
+    MaxStepsExceededError,
+    ModelRoutingError,
+    OrchestrationError,
+    PromptInjectionError,
+    ProviderAuthError,
+    ProviderError,
+    ProviderRateLimitError,
+    ProviderResponseError,
+    SecurityError,
+    ToolError,
+    ToolExecutionError,
+    ToolNotFoundError,
+    ToolTimeoutError,
+    ToolValidationError,
+)
+from forge.memory import ConversationMemory, InMemoryVectorStore, Memory, MemoryItem
+from forge.models import (
+    Complexity,
+    ModelInfo,
+    ModelProvider,
+    ModelRegistry,
+    ModelRouter,
+    ModelTier,
+    RoutingDecision,
+)
+from forge.models.providers import AnthropicProvider, EchoProvider, OpenAIProvider
+from forge.observability import (
+    Event,
+    EventBus,
+    EventType,
+    UsageReport,
+    UsageTracker,
+    configure_logging,
+    get_logger,
+)
+from forge.orchestration import Orchestrator, RunContext, RunResult
+from forge.security import (
+    AccessController,
+    InputSanitizer,
+    Permission,
+    Principal,
+    ToolSandbox,
+)
+from forge.tools import SAFE_TOOLS, Tool, ToolRegistry, calculator, http_get, tool, utc_now
+from forge.types import (
+    FinishReason,
+    Message,
+    ModelResponse,
+    Role,
+    ToolCall,
+    ToolResult,
+    ToolSchema,
+    Usage,
+)
+
+__all__ = [
+    "__version__",
+    # Orchestration
+    "Orchestrator",
+    "RunResult",
+    "RunContext",
+    # Agents
+    "Agent",
+    "Supervisor",
+    "BaseAgent",
+    "AgentResult",
+    # Config
+    "ForgeConfig",
+    "RoutingConfig",
+    "BudgetConfig",
+    "SecurityConfig",
+    "ComplianceConfig",
+    "ObservabilityConfig",
+    # Types
+    "Role",
+    "Message",
+    "ToolCall",
+    "ToolResult",
+    "ToolSchema",
+    "Usage",
+    "ModelResponse",
+    "FinishReason",
+    # Models
+    "ModelProvider",
+    "ModelRegistry",
+    "ModelInfo",
+    "ModelTier",
+    "ModelRouter",
+    "Complexity",
+    "RoutingDecision",
+    "EchoProvider",
+    "AnthropicProvider",
+    "OpenAIProvider",
+    # Tools
+    "Tool",
+    "tool",
+    "ToolRegistry",
+    "SAFE_TOOLS",
+    "calculator",
+    "http_get",
+    "utc_now",
+    # Memory
+    "Memory",
+    "MemoryItem",
+    "ConversationMemory",
+    "InMemoryVectorStore",
+    # Observability
+    "Event",
+    "EventBus",
+    "EventType",
+    "UsageTracker",
+    "UsageReport",
+    "get_logger",
+    "configure_logging",
+    # Security
+    "InputSanitizer",
+    "ToolSandbox",
+    "AccessController",
+    "Principal",
+    "Permission",
+    # Compliance
+    "AuditLogger",
+    "AuditEntry",
+    "PIIRedactor",
+    # Exceptions
+    "ForgeError",
+    "ConfigurationError",
+    "ProviderError",
+    "ProviderAuthError",
+    "ProviderRateLimitError",
+    "ProviderResponseError",
+    "ModelRoutingError",
+    "ToolError",
+    "ToolNotFoundError",
+    "ToolValidationError",
+    "ToolExecutionError",
+    "ToolTimeoutError",
+    "AgentError",
+    "MaxStepsExceededError",
+    "OrchestrationError",
+    "BudgetExceededError",
+    "SecurityError",
+    "PromptInjectionError",
+    "AccessDeniedError",
+]

forge/_version.py

@@ -0,0 +1,8 @@
+"""Single source of truth for the package version.
+
+Hatchling reads ``__version__`` from this file at build time (see
+``[tool.hatch.version]`` in ``pyproject.toml``), and ``forge.__init__`` re-exports
+it for runtime access via ``forge.__version__``.
+"""
+
+__version__ = "0.1.0"

forge/agents/__init__.py

@@ -0,0 +1,7 @@
+"""Agents: the worker agent, the supervisor, and their shared base."""
+
+from forge.agents.agent import Agent
+from forge.agents.base import AgentResult, BaseAgent
+from forge.agents.supervisor import Supervisor
+
+__all__ = ["Agent", "AgentResult", "BaseAgent", "Supervisor"]