toolproxy 0.3.0__tar.gz → 0.4.0__tar.gz

{toolproxy-0.3.0 → toolproxy-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toolproxy
-Version: 0.3.0
+Version: 0.4.0
 Summary: Universal tool-calling wrapper for non-tool-native LLMs — emulates function calling via structured JSON planning
 Project-URL: Homepage, https://github.com/yourusername/toolproxy
 Project-URL: Repository, https://github.com/yourusername/toolproxy
@@ -33,8 +33,12 @@ Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
 Requires-Dist: pytest-mock>=3.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == 'fastapi'
+Requires-Dist: httpx>=0.25; extra == 'fastapi'
 Provides-Extra: full
 Requires-Dist: anthropic>=0.25; extra == 'full'
+Requires-Dist: fastapi>=0.110; extra == 'full'
 Requires-Dist: opentelemetry-api>=1.20; extra == 'full'
 Requires-Dist: opentelemetry-sdk>=1.20; extra == 'full'
 Provides-Extra: gemini

toolproxy-0.4.0/examples/caching_demo.py

@@ -0,0 +1,96 @@
+"""
+Caching Demo — toolproxy v0.4
+
+Shows how InMemoryToolCache prevents repeated tool invocations when
+the same query is made multiple times during an agent conversation.
+
+Run with:
+    python examples/caching_demo.py
+
+No API key needed (uses MockClient).
+"""
+import time
+
+from toolproxy import UniversalAgent, tool
+from toolproxy.cache import InMemoryToolCache
+from toolproxy.llm_client import MockClient, ModelResponse
+
+
+# ---------------------------------------------------------------------------
+# Simulated "expensive" tool
+# ---------------------------------------------------------------------------
+
+call_count = 0
+
+
+@tool
+def search_web(query: str) -> str:
+    """Search the web for information about a topic."""
+    global call_count
+    call_count += 1
+    # Simulate a slow API call
+    time.sleep(0.05)
+    print(f"  [Tool call #{call_count}] search_web(query={query!r})")
+    return f"Results for '{query}': Python was created by Guido van Rossum in 1991."
+
+
+# ---------------------------------------------------------------------------
+# Mock responses that ask for the same tool twice
+# ---------------------------------------------------------------------------
+
+responses = [
+    # First run: call search_web
+    ModelResponse(
+        raw_text='{"type": "tool_call", "tool": {"tool_name": "search_web", "arguments": {"query": "Python history"}}}'
+    ),
+    ModelResponse(
+        raw_text='{"type": "final", "content": "Python was created in 1991."}'
+    ),
+    # Second run: ask for same query again (should hit cache)
+    ModelResponse(
+        raw_text='{"type": "tool_call", "tool": {"tool_name": "search_web", "arguments": {"query": "Python history"}}}'
+    ),
+    ModelResponse(
+        raw_text='{"type": "final", "content": "As I mentioned, Python was created in 1991."}'
+    ),
+]
+
+
+def main():
+    cache = InMemoryToolCache(ttl=300)  # 5-minute TTL
+
+    agent = UniversalAgent(
+        model="mock/test",
+        client=MockClient(responses=responses),
+        tools=[search_web],
+        cache=cache,
+    )
+
+    print("=" * 60)
+    print("toolproxy v0.4 — Tool Result Caching Demo")
+    print("=" * 60)
+    print()
+
+    print("Run 1: First query (cache miss — tool will be called)")
+    t0 = time.perf_counter()
+    result = agent.run("Tell me about Python's history")
+    t1 = time.perf_counter()
+    print(f"  Answer: {result.content}")
+    print(f"  Time: {(t1 - t0)*1000:.1f}ms")
+    print()
+
+    print("Run 2: Same query (cache HIT — tool skipped)")
+    t0 = time.perf_counter()
+    result = agent.run("Tell me about Python's history again")
+    t1 = time.perf_counter()
+    print(f"  Answer: {result.content}")
+    print(f"  Time: {(t1 - t0)*1000:.1f}ms")
+    print()
+
+    stats = cache.stats()
+    print(f"Cache stats: {stats}")
+    print(f"Total tool invocations: {call_count} (expected 1 — second was cached)")
+
+
+if __name__ == "__main__":
+    main()

toolproxy-0.4.0/examples/fastapi_agent.py

@@ -0,0 +1,139 @@
+"""
+FastAPI Agent Server — toolproxy v0.4
+
+Shows how to expose a UniversalAgent as an HTTP API using
+the built-in FastAPI integration.
+
+Install dependencies:
+    pip install toolproxy[fastapi] uvicorn
+
+Run:
+    python examples/fastapi_agent.py
+
+Then test with curl or a browser:
+
+    # Single-shot run
+    curl -X POST http://localhost:8000/agent/run \\
+         -H "Content-Type: application/json" \\
+         -d '{"prompt": "What is the weather in Chennai?"}'
+
+    # List tools
+    curl http://localhost:8000/agent/tools
+
+    # Agent info
+    curl http://localhost:8000/agent/info
+
+    # Stream (SSE)
+    curl -N -X POST http://localhost:8000/agent/stream \\
+         -H "Content-Type: application/json" \\
+         -d '{"prompt": "Tell me something interesting"}'
+
+    # Reset memory
+    curl -X POST http://localhost:8000/agent/reset
+"""
+from __future__ import annotations
+
+try:
+    import uvicorn
+    from fastapi import FastAPI
+except ImportError:
+    print("Please install FastAPI: pip install toolproxy[fastapi] uvicorn")
+    raise SystemExit(1)
+
+from toolproxy import UniversalAgent, tool
+from toolproxy.cache import InMemoryToolCache
+from toolproxy.integrations.fastapi import create_agent_router
+from toolproxy.llm_client import MockClient, ModelResponse
+from toolproxy.memory import ConversationBuffer
+
+
+# ---------------------------------------------------------------------------
+# Tools
+# ---------------------------------------------------------------------------
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    weather_data = {
+        "chennai": "Sunny, 34°C",
+        "london": "Cloudy, 15°C",
+        "new york": "Partly cloudy, 22°C",
+    }
+    return weather_data.get(city.lower(), f"Weather data unavailable for {city}")
+
+
+@tool
+def calculate(expression: str) -> str:
+    """Evaluate a simple mathematical expression safely."""
+    try:
+        # Only allow safe mathematical operations
+        allowed = set("0123456789+-*/()., ")
+        if not all(c in allowed for c in expression):
+            return "Error: Only basic arithmetic is supported."
+        result = eval(expression, {"__builtins__": {}})  # noqa: S307
+        return str(result)
+    except Exception as exc:
+        return f"Calculation error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Mock LLM for demo (replace with a real model string for production)
+# ---------------------------------------------------------------------------
+
+def _make_mock_client():
+    """Returns a MockClient with demo responses."""
+    return MockClient(
+        responses=[
+            ModelResponse(
+                raw_text='{"type": "tool_call", "tool": {"tool_name": "get_weather", "arguments": {"city": "Chennai"}}}'
+            ),
+            ModelResponse(
+                raw_text='{"type": "final", "content": "The weather in Chennai is Sunny, 34°C."}'
+            ),
+        ]
+        * 10  # repeat for multiple requests
+    )
+
+
+# ---------------------------------------------------------------------------
+# Build the app
+# ---------------------------------------------------------------------------
+
+def create_app() -> FastAPI:
+    agent = UniversalAgent(
+        # Replace with a real model for production:
+        # model="openrouter/mistralai/mistral-7b-instruct",
+        model="mock/test",
+        client=_make_mock_client(),
+        tools=[get_weather, calculate],
+        memory=ConversationBuffer(),
+        cache=InMemoryToolCache(ttl=300),
+    )
+
+    app = FastAPI(
+        title="toolproxy Agent API",
+        description="Universal tool-calling agent exposed as an HTTP service.",
+        version="0.4.0",
+    )
+
+    # Mount the agent router at /agent
+    app.include_router(
+        create_agent_router(agent),
+        prefix="/agent",
+        tags=["Agent"],
+    )
+
+    @app.get("/", tags=["Health"])
+    async def health():
+        return {"status": "ok", "version": "0.4.0"}
+
+    return app
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    print("Starting toolproxy FastAPI demo on http://localhost:8000")
+    print("API docs: http://localhost:8000/docs")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

toolproxy-0.4.0/examples/persistent_memory.py

@@ -0,0 +1,91 @@
+"""
+Persistent Memory Demo — toolproxy v0.4
+
+Shows JsonFileMemory that keeps conversation history across
+multiple script runs (survives process restarts).
+
+Run this script several times to see the agent remember prior context:
+    python examples/persistent_memory.py
+
+No API key needed (uses MockClient that echoes memory-aware responses).
+"""
+import os
+from pathlib import Path
+
+from toolproxy import UniversalAgent, tool
+from toolproxy.llm_client import MockClient, ModelResponse
+from toolproxy.memory import JsonFileMemory
+
+
+HISTORY_FILE = Path("chat_history.json")
+
+
+# ---------------------------------------------------------------------------
+# Tool
+# ---------------------------------------------------------------------------
+
+@tool
+def get_time() -> str:
+    """Get the current time."""
+    from datetime import datetime
+    return datetime.now().strftime("%H:%M:%S")
+
+
+# ---------------------------------------------------------------------------
+# Mock responses
+# ---------------------------------------------------------------------------
+
+def _responses_for_run(run_number: int):
+    if run_number == 1:
+        return [
+            ModelResponse(raw_text='{"type": "final", "content": "Nice to meet you! I\'ll remember your name."}'),
+        ]
+    elif run_number == 2:
+        return [
+            ModelResponse(raw_text='{"type": "final", "content": "Hello again! I remember you from our last conversation."}'),
+        ]
+    else:
+        return [
+            ModelResponse(raw_text='{"type": "final", "content": "Welcome back! I still remember all our previous conversations."}'),
+        ]
+
+
+def main():
+    memory = JsonFileMemory(HISTORY_FILE, max_messages=20)
+    history = memory.load()
+    run_number = max(1, len([m for m in history if m.role == "user"]) + 1)
+
+    print("=" * 60)
+    print("toolproxy v0.4 — Persistent Memory Demo")
+    print("=" * 60)
+    print(f"Run #{run_number}  |  History file: {HISTORY_FILE}")
+    print(f"Messages in memory: {len(history)}")
+    print()
+
+    agent = UniversalAgent(
+        model="mock/test",
+        client=MockClient(responses=_responses_for_run(run_number)),
+        tools=[get_time],
+        memory=memory,
+    )
+
+    prompts = {
+        1: "Hi! My name is Alice.",
+        2: "Do you remember who I am?",
+        3: "How many times have we spoken?",
+    }
+    prompt = prompts.get(run_number, "Tell me something you remember.")
+
+    print(f"User: {prompt}")
+    result = agent.run(prompt)
+    print(f"Agent: {result.content}")
+    print()
+
+    updated = memory.load()
+    print(f"History now has {len(updated)} message(s).")
+    print(f"Run this script again to continue the conversation!")
+    print(f"(Delete '{HISTORY_FILE}' to start fresh)")
+
+
+if __name__ == "__main__":
+    main()

{toolproxy-0.3.0 → toolproxy-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "toolproxy"
-version = "0.3.0"
+version = "0.4.0"
 description = "Universal tool-calling wrapper for non-tool-native LLMs — emulates function calling via structured JSON planning"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -58,12 +58,17 @@ groq = [
 cohere = [
     # No extra package needed — uses Cohere's OpenAI-compat endpoint
 ]
+fastapi = [
+    "fastapi>=0.110",
+    "httpx>=0.25",
+]
 otel = [
     "opentelemetry-sdk>=1.20",
     "opentelemetry-api>=1.20",
 ]
 full = [
     "anthropic>=0.25",
+    "fastapi>=0.110",
     "opentelemetry-sdk>=1.20",
     "opentelemetry-api>=1.20",
 ]

{toolproxy-0.3.0 → toolproxy-0.4.0}/src/toolproxy/__init__.py

@@ -16,6 +16,9 @@ Public API:
 Memory (v0.3):
     BaseMemory, ConversationBuffer, SlidingWindowMemory, TokenWindowMemory
 
+Memory persistent (v0.4):
+    JsonFileMemory
+
 Observability (v0.3):
     BaseTracer, FileTracer, PrintTracer, OpenTelemetryTracer
 
@@ -25,6 +28,12 @@ Adapters (v0.3):
 MCP (v0.3):
     MCPToolset, MCPClient, MCPToolInfo
 
+Caching (v0.4):
+    ToolCache, InMemoryToolCache, FileToolCache
+
+Retry (v0.4):
+    RetryConfig, with_retry, awith_retry, HTTP_RETRY_CONFIG
+
 Utilities:
     probe_tool_support — (v0.2) async helper to detect native tool support
 
@@ -87,6 +96,15 @@ from .adapters import (
 # v0.3 — MCP
 from .mcp import MCPClient, MCPToolInfo, MCPToolset
 
+# v0.4 — Caching
+from .cache import FileToolCache, InMemoryToolCache, ToolCache
+
+# v0.4 — Retry
+from .retry import HTTP_RETRY_CONFIG, RetryConfig, awith_retry, with_retry
+
+# v0.4 — Persistent memory (JsonFileMemory added to memory module)
+from .memory import JsonFileMemory
+
 __all__ = [
     # Main API
     "UniversalAgent",
@@ -134,6 +152,17 @@ __all__ = [
     "MCPClient",
     "MCPToolInfo",
     "MCPToolset",
+    # v0.4 Caching
+    "ToolCache",
+    "InMemoryToolCache",
+    "FileToolCache",
+    # v0.4 Retry
+    "RetryConfig",
+    "with_retry",
+    "awith_retry",
+    "HTTP_RETRY_CONFIG",
+    # v0.4 Persistent Memory
+    "JsonFileMemory",
     # Exceptions
     "UniversalAgentError",
     "ToolNotFoundError",
@@ -144,4 +173,4 @@ __all__ = [
     "ExecutionPolicyError",
 ]
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"