agentropic 0.2.2__tar.gz → 0.3.1__tar.gz

{agentropic-0.2.2 → agentropic-0.3.1}/.gitignore

@@ -1,9 +1,9 @@
-__pycache__/
-*.pyc
-.venv/
-venv/
-dist/
-build/
-*.egg-info/
-.pytest_cache/
-.env
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.env

agentropic-0.3.1/LICENSE

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

agentropic-0.3.1/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.5
+Name: agentropic
+Version: 0.3.1
+Summary: A minimal, hackable agentic framework: LLM calls via litellm, @tool-decorated functions, and MCP server support.
+Author-email: Vishal Tiwari <vishaltiwari.up2019@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agent,agents,ai,litellm,llm,mcp,tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: litellm>=1.40.0
+Requires-Dist: mcp>=1.0.0; python_version >= '3.10'
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# agentropic
+
+A small, hackable agentic framework in ~500 lines you fully own and can read
+top to bottom in an afternoon:
+
+- **LLM calls** go through [litellm](https://github.com/BerriAI/litellm), so you get
+  every provider (OpenAI, Anthropic, Gemini, Ollama, Bedrock, 100+ more) for free.
+- **`@tool` decorator** turns any python function into an LLM-callable tool with
+  an auto-generated JSON schema (from type hints + docstring).
+- **MCP support** — connect to any Model Context Protocol server (stdio or SSE)
+  and its tools show up in your agent automatically, indistinguishable from
+  local tools.
+- **Agent loop** handles the call → tool-call → tool-result → call cycle for you,
+  with memory, streaming, and a max-iteration safety valve.
+
+## Install (once published)
+
+```bash
+pip install agentropic
+```
+
+## Quick start
+
+```python
+import asyncio
+from agentropic import Agent, tool
+
+@tool()
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"It's sunny in {city}."
+
+async def main():
+    agent = Agent(
+        name="assistant",
+        model="gpt-4o-mini",         # any litellm model string
+        instructions="You are helpful and concise.",
+        tools=[get_weather],
+    )
+    print(await agent.arun("What's the weather in Paris?"))
+
+asyncio.run(main())
+```
+
+Sync usage: `agent.run("...")` (wraps `arun` in `asyncio.run` for you).
+
+## Streaming (`stream=True`)
+
+Same shape as the OpenAI / Anthropic SDKs. Tool calls work while streaming.
+
+```python
+async for event in await agent.arun("Weather in Tokyo?", stream=True):
+    if event.type == "text":
+        print(event.text, end="", flush=True)
+    elif event.type == "tool_call":
+        print(f"\n[calling {event.tool_call.name}({event.tool_call.arguments})]")
+    elif event.type == "tool_result":
+        print(f"[-> {event.tool_call.result}]")
+    elif event.type == "done":
+        result = event.result          # full AgentRunResult (usage, tool_calls, ...)
+```
+
+With `verbose=True` (the default) the colourful terminal tracer already prints
+tokens live, so only print `event.text` yourself when using `verbose=False`
+(e.g. rendering into your own UI).
+
+Sync: `for event in agent.run("...", stream=True): ...`
+Text only: `async for token in agent.astream("..."): ...`
+
+## Using MCP servers
+
+```python
+from agentropic import Agent
+from agentropic.mcp import StdioServer, HTTPServer
+
+agent = Agent(
+    name="fs-agent",
+    model="gpt-4o-mini",
+    mcp_servers=[
+        StdioServer(command="npx", args=["-y", "@modelcontextprotocol/server-filesystem", "."]),
+        # HTTPServer(url="https://example.com/mcp", headers={"Authorization": "Bearer ..."}),
+    ],
+)
+
+# Option A: connect once, keep servers alive across turns (recommended)
+async with agent:
+    print(await agent.arun("List the files in the current directory."))
+    print(await agent.arun("Now read README.md"))
+
+# Option B: no context manager — servers connect/disconnect around each run
+print(await agent.arun("List the files in the current directory."))
+```
+
+Requires the optional MCP dependency: `pip install "agentropic[mcp]"`, plus whatever
+the server itself needs (e.g. Node.js for `npx` servers). Transports: `StdioServer`,
+`HTTPServer` (streamable HTTP), `SSEServer` (legacy SSE).
+
+## Architecture
+
+```
+src/agentropic/
+├── __init__.py     # public API surface
+├── agent.py         # the run loop: LLM <-> tools <-> memory
+├── llm.py            # thin litellm wrapper (swap providers here)
+├── tools.py           # @tool decorator, Tool, ToolRegistry, schema generation
+├── memory.py           # in-memory conversation history (swap for your own store)
+└── mcp/
+    └── client.py        # MCP stdio/SSE client -> Tool adapter
+```
+
+Everything is a plain, editable python file — no hidden magic, no plugin
+registry you can't inspect. Read `agent.py` first; that's the whole loop.
+
+## Extending it
+
+- **Custom memory / persistence**: implement `.add()`, `.get()`, `.clear()`
+  matching `Memory` and pass `memory=YourMemory()` to `Agent`.
+- **Multi-agent handoff**: compose multiple `Agent` instances and route
+  between them yourself, or wrap one agent's `arun` as a tool for another.
+

{agentropic-0.2.2 → agentropic-0.3.1}/README.md

@@ -44,23 +44,56 @@ asyncio.run(main())
 
 Sync usage: `agent.run("...")` (wraps `arun` in `asyncio.run` for you).
 
+## Streaming (`stream=True`)
+
+Same shape as the OpenAI / Anthropic SDKs. Tool calls work while streaming.
+
+```python
+async for event in await agent.arun("Weather in Tokyo?", stream=True):
+    if event.type == "text":
+        print(event.text, end="", flush=True)
+    elif event.type == "tool_call":
+        print(f"\n[calling {event.tool_call.name}({event.tool_call.arguments})]")
+    elif event.type == "tool_result":
+        print(f"[-> {event.tool_call.result}]")
+    elif event.type == "done":
+        result = event.result          # full AgentRunResult (usage, tool_calls, ...)
+```
+
+With `verbose=True` (the default) the colourful terminal tracer already prints
+tokens live, so only print `event.text` yourself when using `verbose=False`
+(e.g. rendering into your own UI).
+
+Sync: `for event in agent.run("...", stream=True): ...`
+Text only: `async for token in agent.astream("..."): ...`
+
 ## Using MCP servers
 
 ```python
 from agentropic import Agent
-from agentropic.mcp import StdioServer
+from agentropic.mcp import StdioServer, HTTPServer
 
 agent = Agent(
     name="fs-agent",
     model="gpt-4o-mini",
     mcp_servers=[
         StdioServer(command="npx", args=["-y", "@modelcontextprotocol/server-filesystem", "."]),
+        # HTTPServer(url="https://example.com/mcp", headers={"Authorization": "Bearer ..."}),
     ],
 )
+
+# Option A: connect once, keep servers alive across turns (recommended)
+async with agent:
+    print(await agent.arun("List the files in the current directory."))
+    print(await agent.arun("Now read README.md"))
+
+# Option B: no context manager — servers connect/disconnect around each run
 print(await agent.arun("List the files in the current directory."))
 ```
 
-Requires the optional MCP dependency: `pip install "agentropic[mcp]"`.
+Requires the optional MCP dependency: `pip install "agentropic[mcp]"`, plus whatever
+the server itself needs (e.g. Node.js for `npx` servers). Transports: `StdioServer`,
+`HTTPServer` (streamable HTTP), `SSEServer` (legacy SSE).
 
 ## Architecture
 
@@ -82,9 +115,6 @@ registry you can't inspect. Read `agent.py` first; that's the whole loop.
 
 - **Custom memory / persistence**: implement `.add()`, `.get()`, `.clear()`
   matching `Memory` and pass `memory=YourMemory()` to `Agent`.
-- **Streaming with tool calls**: `astream()` currently falls back to a
-  non-streamed `arun()` when tools are registered — extend it if you need
-  token-level streaming mid-tool-loop.
 - **Multi-agent handoff**: compose multiple `Agent` instances and route
   between them yourself, or wrap one agent's `arun` as a tool for another.
 

{agentropic-0.2.2 → agentropic-0.3.1}/examples/basic_agent.py

@@ -25,13 +25,13 @@ def add(a: int, b: int) -> int:
 async def main():
     agent = Agent(
         name="assistant",
-        model="gemini/gemini-2.5-flash-lite",  
+        model="gemini/gemini-3.1-flash-lite",  
         api_key=os.getenv("api_key"),
         instructions="You are a concise, helpful assistant. Use tools when needed.",
         tools=[get_weather, add],
         # Optional: pull in tools from a live MCP server too.
         # mcp_servers=[StdioServer(command="npx", args=["-y", "@modelcontextprotocol/server-filesystem", "."])],
-        max_iterations=2,
+        max_iterations=5,
     )
 
     result = await agent.arun("What's the weather in Tokyo, and what's 12 + 30?")
@@ -55,6 +55,14 @@ async def main():
     result2 = await agent.arun("Say that last sum again, but doubled.")
     print(result2.output)
 
+    # Streaming (stream=True): with verbose=True (default) the colourful
+    # tracer prints tokens live for you, so just consume the events.
+    # If you render tokens yourself (e.g. a web UI), use verbose=False and
+    # handle event.type == "text" / "tool_call" / "tool_result" / "done".
+    async for event in await agent.arun("Weather in Delhi? Answer in one sentence.", stream=True):
+        if event.type == "done":
+            final = event.result
+
 
 if __name__ == "__main__":
     asyncio.run(main())

agentropic-0.3.1/old_022/src/agentropic-0.2.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+agentropic/__init__.py,sha256=6QOkNZLR9WtTDRc1hqIxPaMWrpLPEeqjVSTkYmr0fmM,627
+agentropic/agent.py,sha256=D6xNLWYt36FGAl2WO7urbb3GTXoUVnp1RIkSfMPeUhQ,12683
+agentropic/llm.py,sha256=Zqq4bcbL-O5GcZzE2v583h4VNSB-3uSTP4ACzZBjCNw,2797
+agentropic/memory.py,sha256=Vw7oCN36PQtckpoo5ImgNO9LHr085yOKYFXYyMH7rF0,782
+agentropic/tools.py,sha256=rQB18qjapoASE72vSk8kBLgBMgWiicBVAbNwcpEY_2A,5901
+agentropic/tracing.py,sha256=2ASQaSHuob_M_2knZ8CxvmYDedX1D9xh22rxmQutovk,10061
+agentropic/mcp/__init__.py,sha256=6tDmJRwKWkNuSZLz1BUR57xXe_EoILDUf9TKdd0984g,151
+agentropic/mcp/client.py,sha256=d0UMmHVRGnGSKrVCmdIPjfp660d_DpmKQ4j2eix_Kw0,3453
+agentropic-0.2.2.dist-info/METADATA,sha256=vsZGDz-DIYeMjPGz2NxU242b9dE43jh1Hy0-OGBM3jA,3952
+agentropic-0.2.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentropic-0.2.2.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+agentropic-0.2.2.dist-info/RECORD,,

agentropic-0.3.1/old_022/src/agentropic-0.2.2.dist-info/WHEEL

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

{agentropic-0.2.2 → agentropic-0.3.1}/pyproject.toml

@@ -1,34 +1,37 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "agentropic"
-version = "0.2.2"
-description = "A minimal, hackable agentic framework: LLM calls via litellm, @tool-decorated functions, and MCP server support."
-readme = "README.md"
-requires-python = ">=3.9"
-license = { text = "MIT" }
-authors = [
-    { name = "Vishal Tiwari", email = "vishaltiwari.up2019@gmail.com" }
-]
-keywords = ["llm", "agent", "agents", "litellm", "mcp", "tools", "ai"]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-]
-dependencies = [
-    "litellm>=1.40.0",
-    "pydantic>=2.0.0",
-]
-
-[project.optional-dependencies]
-mcp = ["mcp>=1.0.0"]
-dev = ["pytest", "pytest-asyncio", "build", "twine"]
-
-[tool.hatch.build.targets.wheel]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentropic"
+version = "0.3.1"
+description = "A minimal, hackable agentic framework: LLM calls via litellm, @tool-decorated functions, and MCP server support."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "Vishal Tiwari", email = "vishaltiwari.up2019@gmail.com" }
+]
+keywords = ["llm", "agent", "agents", "litellm", "mcp", "tools", "ai"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "litellm>=1.40.0",
+    "pydantic>=2.0.0",
+    # litellm imports `mcp` internally whenever tools are passed (seen in
+    # litellm 1.106.x), so it is effectively required for tool calling.
+    "mcp>=1.0.0; python_version>='3.10'",
+]
+
+[project.optional-dependencies]
+mcp = ["mcp>=1.0.0"]  # kept for backward compat: pip install "agentropic[mcp]"
+dev = ["pytest", "pytest-asyncio", "build", "twine"]
+
+[tool.hatch.build.targets.wheel]
 packages = ["src/agentropic"]

agentropic-0.3.1/src/agentropic/__init__.py

@@ -0,0 +1,30 @@
+from .agent import Agent, AgentError, AgentRunResult, StreamEvent, ToolCallRecord
+from .tools import tool, Tool, ToolRegistry
+from .llm import LLMClient, LLMResponse
+from .memory import Memory
+from .mcp.client import MCPConnection, MCPError, StdioServer, SSEServer, HTTPServer, MCPServerConfig
+from .tracing import AgentTracer, NullTracer
+
+__version__ = "0.3.1"
+
+__all__ = [
+    "Agent",
+    "AgentError",
+    "AgentRunResult",
+    "StreamEvent",
+    "ToolCallRecord",
+    "MCPError",
+    "HTTPServer",
+    "tool",
+    "Tool",
+    "ToolRegistry",
+    "LLMClient",
+    "LLMResponse",
+    "Memory",
+    "MCPConnection",
+    "StdioServer",
+    "SSEServer",
+    "MCPServerConfig",
+    "AgentTracer",
+    "NullTracer",
+]