lightmodel 0.2.0__tar.gz → 0.3.0__tar.gz

{lightmodel-0.2.0 → lightmodel-0.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Your Name
+Copyright (c) 2026 PlimbAI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{lightmodel-0.2.0/src/lightmodel.egg-info → lightmodel-0.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: lightmodel
-Version: 0.2.0
+Version: 0.3.0
 Summary: Ultra-light autonomous AI agents for any OpenAI-compatible API
-Author-email: Your Name <you@example.com>
+Author-email: PlimbAI <plimb.ai.contact@gmail.com>
 License-Expression: MIT
-Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling
+Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling,no-dependencies
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
@@ -20,10 +20,18 @@ Dynamic: license-file
 Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
 No `smolagents`, no `litellm`, no `openai` — just `requests`.
 
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
 ## Installation
 
     pip install lightmodel
-    pip install lightmodel[search]   # with beautifulsoup4 for web search
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
 
 ## Quick start
 
@@ -38,21 +46,47 @@ No `smolagents`, no `litellm`, no `openai` — just `requests`.
         model=model,
         tools=[SimpleDuckDuckGoSearchTool()],
         system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
     )
     print(agent.run("What are the latest AI news in 2026?"))
 
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
 ## Custom tools
 
     from lightmodel import Tool
 
     class CalculatorTool(Tool):
         name = "calculator"
-        description = "Evaluate a basic arithmetic expression."
+        description = "Evaluate arithmetic."
         inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
 
         def forward(self, expression):
             return str(eval(expression, {"__builtins__": {}}, {}))
 
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
 ## License
 
 MIT

lightmodel-0.3.0/README.md

@@ -0,0 +1,75 @@
+# LightModel
+
+Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
+No `smolagents`, no `litellm`, no `openai` — just `requests`.
+
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
+## Installation
+
+    pip install lightmodel
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
+
+## Quick start
+
+    from lightmodel import Agent, LightModel, SimpleDuckDuckGoSearchTool
+
+    model = LightModel(
+        model_id="meta/llama-3.3-70b-instruct",
+        api_base="https://integrate.api.nvidia.com/v1",
+        api_key="your_key",
+    )
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
+    )
+    print(agent.run("What are the latest AI news in 2026?"))
+
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
+## Custom tools
+
+    from lightmodel import Tool
+
+    class CalculatorTool(Tool):
+        name = "calculator"
+        description = "Evaluate arithmetic."
+        inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
+
+        def forward(self, expression):
+            return str(eval(expression, {"__builtins__": {}}, {}))
+
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
+## License
+
+MIT

{lightmodel-0.2.0 → lightmodel-0.3.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lightmodel"
-version = "0.2.0"
+version = "0.3.0"
 description = "Ultra-light autonomous AI agents for any OpenAI-compatible API"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
-authors = [{name = "Your Name", email = "you@example.com"}]
-keywords = ["llm", "ai", "agent", "openai", "nvidia-nim", "tool-calling"]
+authors = [{name = "PlimbAI", email = "plimb.ai.contact@gmail.com"}]
+keywords = ["llm", "ai", "agent", "openai", "nvidia-nim", "tool-calling", "no-dependencies"]
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

lightmodel-0.3.0/src/lightmodel/__init__.py

@@ -0,0 +1,12 @@
+"""LightModel - Ultra-light autonomous AI agents."""
+from .model import LightModel
+from .tools import Tool, SimpleDuckDuckGoSearchTool, CalculatorTool, VisitWebpageTool
+from .agent import Agent
+from .exceptions import LightModelError, APIError, ToolError, MaxStepsError
+
+__version__ = "0.3.0"
+__all__ = [
+    "LightModel", "Agent",
+    "Tool", "SimpleDuckDuckGoSearchTool", "CalculatorTool", "VisitWebpageTool",
+    "LightModelError", "APIError", "ToolError", "MaxStepsError",
+]

lightmodel-0.3.0/src/lightmodel/agent.py

@@ -0,0 +1,134 @@
+"""LightModel Agent - autonomous tool-calling loop."""
+import json
+import logging
+import concurrent.futures
+
+from .exceptions import MaxStepsError
+
+logger = logging.getLogger(__name__)
+
+
+class Agent:
+    """Autonomous agent using native OpenAI tool calling."""
+
+    def __init__(self, model, tools=None, system_prompt=None,
+                 max_steps=10, verbose=False, parallel_tools=True,
+                 callbacks=None, raise_on_max_steps=False):
+        self.model = model
+        self.tools = {t.name: t for t in (tools or [])}
+        self.system_prompt = system_prompt
+        self.max_steps = max_steps
+        self.verbose = verbose
+        self.parallel_tools = parallel_tools
+        self.callbacks = callbacks or {}
+        self.raise_on_max_steps = raise_on_max_steps
+        self.messages = []
+        self.reset()
+
+    def reset(self):
+        """Clear conversation history (keeps system prompt)."""
+        self.messages = []
+        if self.system_prompt:
+            self.messages.append({"role": "system", "content": self.system_prompt})
+
+    def _cb(self, name, *args):
+        fn = self.callbacks.get(name)
+        if fn:
+            try:
+                fn(*args)
+            except Exception:
+                logger.exception("Callback %s failed", name)
+
+    def _log(self, msg):
+        if self.verbose:
+            print(msg)
+
+    def run(self, task, reset=True):
+        """Execute a task and return the final text answer."""
+        if reset:
+            self.reset()
+        self.messages.append({"role": "user", "content": task})
+        return self._loop()
+
+    def chat(self, message, reset=False):
+        """Continue the conversation with a new message."""
+        if reset:
+            self.reset()
+        self.messages.append({"role": "user", "content": message})
+        return self._loop()
+
+    def _loop(self):
+        openai_tools = [t.to_openai() for t in self.tools.values()] or None
+
+        for step in range(1, self.max_steps + 1):
+            try:
+                msg = self.model.chat(self.messages, tools=openai_tools)
+            except Exception as e:
+                self._cb("on_error", e)
+                raise
+
+            self._cb("on_step", step, msg)
+
+            assistant = {"role": "assistant"}
+            if msg.get("content"):
+                assistant["content"] = msg["content"]
+            if msg.get("tool_calls"):
+                assistant["tool_calls"] = msg["tool_calls"]
+            self.messages.append(assistant)
+
+            tool_calls = msg.get("tool_calls") or []
+            if not tool_calls:
+                final = msg.get("content") or ""
+                self._cb("on_final", final)
+                return final
+
+            self._log(f"[step {step}] {len(tool_calls)} tool call(s)")
+
+            if self.parallel_tools and len(tool_calls) > 1:
+                with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=len(tool_calls)) as ex:
+                    results = list(ex.map(self._run_tool, tool_calls))
+            else:
+                results = [self._run_tool(tc) for tc in tool_calls]
+
+            for tc, result in zip(tool_calls, results):
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+        err = MaxStepsError(
+            f"Reached {self.max_steps} steps without a final answer"
+        )
+        self._cb("on_error", err)
+        if self.raise_on_max_steps:
+            raise err
+        return str(err)
+
+    def _run_tool(self, tc):
+        name = tc["function"]["name"]
+        raw_args = tc["function"]["arguments"]
+        try:
+            args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
+            if not isinstance(args, dict):
+                args = {}
+        except json.JSONDecodeError:
+            args = {}
+
+        self._log(f"  → {name}({args})")
+        self._cb("on_tool_call", name, args)
+
+        tool = self.tools.get(name)
+        if tool is None:
+            result = f"Unknown tool: {name}"
+        else:
+            try:
+                result = str(tool.forward(**args))
+            except Exception as e:
+                result = f"Tool error ({name}): {e}"
+
+        preview = result[:120].replace("\n", " ")
+        self._log(f"  ← {preview}...")
+        self._cb("on_tool_result", name, result)
+        return result

lightmodel-0.3.0/src/lightmodel/exceptions.py

@@ -0,0 +1,22 @@
+"""Custom exceptions for lightmodel."""
+
+
+class LightModelError(Exception):
+    """Base exception for all lightmodel errors."""
+
+
+class APIError(LightModelError):
+    """Raised when the API returns an HTTP error."""
+
+    def __init__(self, status, message, body=None):
+        self.status = status
+        self.body = body
+        super().__init__(f"API {status}: {message}")
+
+
+class ToolError(LightModelError):
+    """Raised when a tool fails to execute."""
+
+
+class MaxStepsError(LightModelError):
+    """Raised when the agent reaches max_steps without a final answer."""

lightmodel-0.3.0/src/lightmodel/model.py

@@ -0,0 +1,126 @@
+"""LightModel - pure HTTP client for OpenAI-compatible APIs."""
+import json
+import time
+import logging
+import requests
+
+from .exceptions import APIError
+
+logger = logging.getLogger(__name__)
+
+
+class LightModel:
+    """Client for any OpenAI-compatible /chat/completions API."""
+
+    RETRIABLE_STATUS = {429, 500, 502, 503, 504}
+
+    def __init__(self, model_id, api_base, api_key="not-needed",
+                 temperature=0.7, max_tokens=2048, timeout=120,
+                 max_retries=3, retry_backoff=2.0, extra=None, headers=None):
+        self.model_id = model_id
+        base = api_base.rstrip("/")
+        if not base.endswith("/chat/completions"):
+            base += "/chat/completions"
+        self.api_url = base
+        self.api_key = api_key
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_backoff = retry_backoff
+        self.extra = extra or {}
+        self.headers = headers or {}
+
+    def __repr__(self):
+        return f"LightModel({self.model_id!r} @ {self.api_url!r})"
+
+    def _headers(self):
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        h.update(self.headers)
+        return h
+
+    def _payload(self, messages, tools=None, stream=False, **overrides):
+        payload = {
+            "model": self.model_id,
+            "messages": messages,
+            "temperature": overrides.get("temperature", self.temperature),
+            "max_tokens": overrides.get("max_tokens", self.max_tokens),
+            **self.extra,
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = overrides.get("tool_choice", "auto")
+        if "response_format" in overrides:
+            payload["response_format"] = overrides["response_format"]
+        if stream:
+            payload["stream"] = True
+        return payload
+
+    def chat(self, messages, tools=None, **overrides):
+        """Send messages and return the assistant message dict (with retry)."""
+        last_exc = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                return self._do_chat(messages, tools, **overrides)
+            except APIError as e:
+                if e.status not in self.RETRIABLE_STATUS:
+                    raise
+                last_exc = e
+                if attempt < self.max_retries:
+                    wait = self.retry_backoff ** attempt
+                    logger.warning("API %s, retrying in %.1fs", e.status, wait)
+                    time.sleep(wait)
+        raise last_exc
+
+    def _do_chat(self, messages, tools, **overrides):
+        r = requests.post(
+            self.api_url,
+            json=self._payload(messages, tools, **overrides),
+            headers=self._headers(),
+            timeout=self.timeout,
+        )
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:300], body=r.text)
+        try:
+            return r.json()["choices"][0]["message"]
+        except Exception as e:
+            raise APIError(r.status_code, f"Invalid response: {r.text[:300]}") from e
+
+    def stream_chat(self, messages, tools=None, **overrides):
+        """Yield content chunks as they arrive (streaming)."""
+        r = requests.post(
+            self.api_url,
+            json=self._payload(messages, tools, stream=True, **overrides),
+            headers=self._headers(),
+            timeout=self.timeout,
+            stream=True,
+        )
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:300])
+        for line in r.iter_lines():
+            if not line:
+                continue
+            line = line.decode("utf-8")
+            if not line.startswith("data: "):
+                continue
+            data = line[6:]
+            if data == "[DONE]":
+                break
+            try:
+                chunk = json.loads(data)
+                delta = chunk["choices"][0].get("delta", {})
+                content = delta.get("content")
+                if content:
+                    yield content
+            except (json.JSONDecodeError, KeyError, IndexError):
+                continue
+
+    def list_models(self):
+        """Return available model IDs (best-effort, server may not support it)."""
+        base = self.api_url.rsplit("/chat/completions", 1)[0]
+        r = requests.get(f"{base}/models", headers=self._headers(), timeout=30)
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:200])
+        return [m["id"] for m in r.json().get("data", [])]

lightmodel-0.3.0/src/lightmodel/tools.py

@@ -0,0 +1,123 @@
+"""Lightweight tools for LightModel agents."""
+import requests
+
+
+def _get_bs4():
+    try:
+        from bs4 import BeautifulSoup
+        return BeautifulSoup
+    except ImportError:
+        raise ImportError(
+            "beautifulsoup4 is required: pip install 'lightmodel[search]'"
+        )
+
+
+class Tool:
+    """Base class for all tools. Subclass and override forward()."""
+
+    name = ""
+    description = ""
+    inputs = {}
+
+    def forward(self, **kwargs):
+        raise NotImplementedError
+
+    def to_openai(self):
+        props, required = {}, []
+        for name, spec in self.inputs.items():
+            props[name] = {
+                "type": spec.get("type", "string"),
+                "description": spec.get("description", ""),
+            }
+            required.append(name)
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": props,
+                    "required": required,
+                },
+            },
+        }
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} name={self.name!r}>"
+
+
+class SimpleDuckDuckGoSearchTool(Tool):
+    """Lightweight DuckDuckGo web search (HTML scraping, no API key)."""
+
+    name = "web_search"
+    description = "Search the web via DuckDuckGo. Returns the top 5 results."
+    inputs = {"query": {"type": "string", "description": "The search query."}}
+
+    def forward(self, query):
+        BeautifulSoup = _get_bs4()
+        headers = {"User-Agent": "Mozilla/5.0"}
+        try:
+            r = requests.post("https://html.duckduckgo.com/html/",
+                              data={"q": query}, headers=headers, timeout=10)
+            r.raise_for_status()
+            soup = BeautifulSoup(r.text, "html.parser")
+            out = []
+            for res in soup.select(".result")[:5]:
+                title = res.select_one(".result__a")
+                snippet = res.select_one(".result__snippet")
+                if title and snippet:
+                    out.append(
+                        f"- {title.get_text(strip=True)}\n  "
+                        f"{title['href']}\n  {snippet.get_text(strip=True)}"
+                    )
+            return "\n\n".join(out) if out else "No results found."
+        except Exception as e:
+            return f"Search error: {e}"
+
+
+class VisitWebpageTool(Tool):
+    """Fetch a webpage and return its main text content."""
+
+    name = "visit_webpage"
+    description = "Fetch a webpage and return its main text (truncated)."
+    inputs = {"url": {"type": "string", "description": "Full URL to visit"}}
+
+    def __init__(self, max_chars=3000):
+        self.max_chars = max_chars
+
+    def forward(self, url):
+        BeautifulSoup = _get_bs4()
+        headers = {"User-Agent": "Mozilla/5.0"}
+        try:
+            r = requests.get(url, headers=headers, timeout=15)
+            r.raise_for_status()
+            soup = BeautifulSoup(r.text, "html.parser")
+            for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+                tag.decompose()
+            text = " ".join(soup.get_text(separator=" ").split())
+            return text[:self.max_chars] or "(empty page)"
+        except Exception as e:
+            return f"Error fetching {url}: {e}"
+
+
+class CalculatorTool(Tool):
+    """Safe arithmetic evaluator."""
+
+    name = "calculator"
+    description = "Evaluate a basic arithmetic expression (numbers, + - * / % ( ) .)."
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "Python arithmetic expression like '2 + 2' or '3 * 7'",
+        }
+    }
+
+    def forward(self, expression):
+        allowed = set("0123456789+-*/().% ")
+        if not all(c in allowed for c in expression):
+            return "Error: only numbers and + - * / % ( ) . space allowed"
+        try:
+            return str(eval(expression, {"__builtins__": {}}, {}))
+        except Exception as e:
+            return f"Error: {e}"

{lightmodel-0.2.0 → lightmodel-0.3.0/src/lightmodel.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: lightmodel
-Version: 0.2.0
+Version: 0.3.0
 Summary: Ultra-light autonomous AI agents for any OpenAI-compatible API
-Author-email: Your Name <you@example.com>
+Author-email: PlimbAI <plimb.ai.contact@gmail.com>
 License-Expression: MIT
-Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling
+Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling,no-dependencies
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
@@ -20,10 +20,18 @@ Dynamic: license-file
 Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
 No `smolagents`, no `litellm`, no `openai` — just `requests`.
 
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
 ## Installation
 
     pip install lightmodel
-    pip install lightmodel[search]   # with beautifulsoup4 for web search
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
 
 ## Quick start
 
@@ -38,21 +46,47 @@ No `smolagents`, no `litellm`, no `openai` — just `requests`.
         model=model,
         tools=[SimpleDuckDuckGoSearchTool()],
         system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
     )
     print(agent.run("What are the latest AI news in 2026?"))
 
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
 ## Custom tools
 
     from lightmodel import Tool
 
     class CalculatorTool(Tool):
         name = "calculator"
-        description = "Evaluate a basic arithmetic expression."
+        description = "Evaluate arithmetic."
         inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
 
         def forward(self, expression):
             return str(eval(expression, {"__builtins__": {}}, {}))
 
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
 ## License
 
 MIT

{lightmodel-0.2.0 → lightmodel-0.3.0}/src/lightmodel.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 src/lightmodel/__init__.py
 src/lightmodel/agent.py
+src/lightmodel/exceptions.py
 src/lightmodel/model.py
 src/lightmodel/tools.py
 src/lightmodel.egg-info/PKG-INFO

lightmodel-0.2.0/README.md

@@ -1,41 +0,0 @@
-# LightModel
-
-Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
-No `smolagents`, no `litellm`, no `openai` — just `requests`.
-
-## Installation
-
-    pip install lightmodel
-    pip install lightmodel[search]   # with beautifulsoup4 for web search
-
-## Quick start
-
-    from lightmodel import Agent, LightModel, SimpleDuckDuckGoSearchTool
-
-    model = LightModel(
-        model_id="meta/llama-3.3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_key",
-    )
-    agent = Agent(
-        model=model,
-        tools=[SimpleDuckDuckGoSearchTool()],
-        system_prompt="You are a helpful research assistant.",
-    )
-    print(agent.run("What are the latest AI news in 2026?"))
-
-## Custom tools
-
-    from lightmodel import Tool
-
-    class CalculatorTool(Tool):
-        name = "calculator"
-        description = "Evaluate a basic arithmetic expression."
-        inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
-
-        def forward(self, expression):
-            return str(eval(expression, {"__builtins__": {}}, {}))
-
-## License
-
-MIT

lightmodel-0.2.0/src/lightmodel/__init__.py

@@ -1,7 +0,0 @@
-"""LightModel - Ultra-light autonomous AI agents."""
-from .model import LightModel
-from .tools import Tool, SimpleDuckDuckGoSearchTool
-from .agent import Agent
-
-__version__ = "0.2.0"
-__all__ = ["LightModel", "Tool", "SimpleDuckDuckGoSearchTool", "Agent"]

lightmodel-0.2.0/src/lightmodel/agent.py

@@ -1,71 +0,0 @@
-"""LightModel Agent - autonomous tool-calling loop."""
-import json
-
-
-class Agent:
-    """Autonomous agent using native OpenAI tool calling."""
-
-    def __init__(self, model, tools=None, system_prompt=None,
-                 max_steps=10, verbose=False):
-        self.model = model
-        self.tools = {t.name: t for t in (tools or [])}
-        self.system_prompt = system_prompt
-        self.max_steps = max_steps
-        self.verbose = verbose
-
-    def run(self, task):
-        messages = []
-        if self.system_prompt:
-            messages.append({"role": "system", "content": self.system_prompt})
-        messages.append({"role": "user", "content": task})
-
-        openai_tools = [t.to_openai() for t in self.tools.values()] or None
-
-        for step in range(1, self.max_steps + 1):
-            msg = self.model.chat(messages, tools=openai_tools)
-
-            assistant_msg = {"role": "assistant"}
-            if msg.get("content"):
-                assistant_msg["content"] = msg["content"]
-            if msg.get("tool_calls"):
-                assistant_msg["tool_calls"] = msg["tool_calls"]
-            messages.append(assistant_msg)
-
-            tool_calls = msg.get("tool_calls") or []
-            if not tool_calls:
-                return msg.get("content") or ""
-
-            if self.verbose:
-                print(f"[step {step}] {len(tool_calls)} tool call(s)")
-
-            for tc in tool_calls:
-                name = tc["function"]["name"]
-                raw_args = tc["function"]["arguments"]
-                try:
-                    args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
-                except json.JSONDecodeError:
-                    args = {}
-
-                if self.verbose:
-                    print(f"  → {name}({args})")
-
-                tool = self.tools.get(name)
-                if tool is None:
-                    result = f"Unknown tool: {name}"
-                else:
-                    try:
-                        result = tool.forward(**args)
-                    except Exception as e:
-                        result = f"Tool error: {e}"
-
-                if self.verbose:
-                    preview = str(result)[:120].replace("\n", " ")
-                    print(f"  ← {preview}...")
-
-                messages.append({
-                    "role": "tool",
-                    "tool_call_id": tc["id"],
-                    "content": str(result),
-                })
-
-        return "[max_steps reached without final answer]"

lightmodel-0.2.0/src/lightmodel/model.py

@@ -1,45 +0,0 @@
-"""LightModel - pure HTTP client for OpenAI-compatible APIs."""
-import requests
-
-
-class LightModel:
-    """Client for any OpenAI-compatible /chat/completions API."""
-
-    def __init__(self, model_id, api_base, api_key="not-needed",
-                 temperature=0.7, max_tokens=2048, timeout=120, extra=None):
-        self.model_id = model_id
-        base = api_base.rstrip("/")
-        if not base.endswith("/chat/completions"):
-            base += "/chat/completions"
-        self.api_url = base
-        self.api_key = api_key
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-        self.timeout = timeout
-        self.extra = extra or {}
-
-    def chat(self, messages, tools=None):
-        """Send messages to the API. Returns the assistant message dict."""
-        headers = {"Content-Type": "application/json"}
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-
-        payload = {
-            "model": self.model_id,
-            "messages": messages,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            **self.extra,
-        }
-        if tools:
-            payload["tools"] = tools
-            payload["tool_choice"] = "auto"
-
-        r = requests.post(self.api_url, json=payload, headers=headers,
-                          timeout=self.timeout)
-        if r.status_code >= 400:
-            raise RuntimeError(f"API {r.status_code}: {r.text[:300]}")
-        try:
-            return r.json()["choices"][0]["message"]
-        except (KeyError, IndexError):
-            raise RuntimeError(f"Invalid response: {r.text[:300]}")

lightmodel-0.2.0/src/lightmodel/tools.py

@@ -1,61 +0,0 @@
-"""Lightweight tools for LightModel agents."""
-import requests
-from bs4 import BeautifulSoup
-
-
-class Tool:
-    """Base class for all tools. Subclass and override forward()."""
-    name = ""
-    description = ""
-    inputs = {}  # {"arg_name": {"type": "string", "description": "..."}}
-
-    def forward(self, **kwargs):
-        raise NotImplementedError
-
-    def to_openai(self):
-        props, required = {}, []
-        for name, spec in self.inputs.items():
-            props[name] = {
-                "type": spec.get("type", "string"),
-                "description": spec.get("description", ""),
-            }
-            required.append(name)
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": {
-                    "type": "object",
-                    "properties": props,
-                    "required": required,
-                },
-            },
-        }
-
-
-class SimpleDuckDuckGoSearchTool(Tool):
-    """Lightweight DuckDuckGo web search (HTML scraping, no API key)."""
-    name = "web_search"
-    description = "Search the web via DuckDuckGo. Returns the top 5 results."
-    inputs = {
-        "query": {"type": "string", "description": "The search query."}
-    }
-
-    def forward(self, query):
-        url = "https://html.duckduckgo.com/html/"
-        headers = {"User-Agent": "Mozilla/5.0"}
-        try:
-            r = requests.post(url, data={"q": query}, headers=headers, timeout=10)
-            r.raise_for_status()
-            soup = BeautifulSoup(r.text, "html.parser")
-            out = []
-            for res in soup.select(".result")[:5]:
-                title = res.select_one(".result__a")
-                snippet = res.select_one(".result__snippet")
-                if title and snippet:
-                    out.append(f"- {title.get_text(strip=True)}\n  "
-                               f"{title['href']}\n  {snippet.get_text(strip=True)}")
-            return "\n\n".join(out) if out else "No results found."
-        except Exception as e:
-            return f"Search error: {e}"