Add chatgpt

Author: StickyCoolDev

README.md

@@ -0,0 +1,94 @@
+# YakaLLM 
+A smaller, faster and cooler version of LangChain. the repo without `.git` is only 74k. Its like preact for react, but nothing is backward compatible.
+
+
+## how to install
+pip:
+```
+pip install yaka-llm
+# or 
+pip3 install yaka-llm
+```
+uv:
+```
+uv add yaka-llm
+# or 
+uv pip install yaka-llm
+```
+
+## Usage 
+```
+from typing import List
+from yaka_llm.open_ai import ChatGPTModel
+# from yaka_llm import GeminiModel 
+# ( warn : this example code is made with ai!)
+
+gm = ChatGPTModel(
+    model="openai/gpt-oss-20b:free",
+    url=".../v1/chat/completions",
+    api_key="",
+)
+
+
+# gm = GeminiModel("gemini-2.5-flash", "")
+def run_chat_system():
+
+    # 2. Register tools 
+    @gm.tool
+    def add_numbers(a: float, b: float):
+        """Add two numbers a and b. Use this for all arithmetic addition requests."""
+        return {"result": a + b}
+
+    print("🤖 LLM System Initialized. Type 'quit' or 'exit' to stop.")
+    print("-" * 30)
+
+    # 3. Initialize History
+    history: List[str] = []
+
+    # 4. Enter the Repeating Loop
+    while True:
+        try:
+            # Read user input
+            user_prompt = input("You: ")
+
+            # Check for exit commands
+            if user_prompt.lower() in ("quit", "exit"):
+                print("👋 Goodbye!")
+                break
+
+            if not user_prompt.strip():
+                continue
+
+            # Call the model
+            assistant_response = gm.call(
+                history=history, prompt=user_prompt, role="user"
+            )
+
+            # Print the response and update history
+            print(
+                f"Gemini: {assistant_response or '... (No response or an error occurred)'}"
+            )
+
+            # Update history for the next turn
+            # The current `call` method implementation uses the history for context,
+            # so we update it with the conversation turn.
+            if assistant_response:
+                # Add user prompt and assistant response to history
+                # Note: The `call` method already formats the history internally,
+                # so we just append the raw text of the turn.
+                history.append(user_prompt)
+                history.append(assistant_response)
+
+            print("-" * 30)
+
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            break
+
+
+if __name__ == "__main__":
+    run_chat_system()
+```

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "yaka-llm"
-version = "0.1.0"
-description = "Add your description here"
+version = "0.1.1"
+description = "Faster and Smaller alternative to Lanchain"
 readme = "README.md"
 authors = [
     { name = "StickyCoolDev", email = "hujifa.info@gmaill.com" }

src/yaka_llm/__init__.py

@@ -5,7 +5,8 @@
 import urllib.request
 import urllib.error
 from typing import Any, Callable, Dict, List, Optional, Tuple
-
+from .open_ai import ChatGPTModel
+from . import open_ai
 JSONSchema = Dict[str, Any]
 
 def _pytype_to_json_schema(py_type: Any) -> str:
@@ -35,7 +36,7 @@ def add_numbers(a: float, b: float):
             '''Add two numbers a and b.''' #This Docstring is used as the description for the tool
             return {"result": a + b}
 
-        text = gm.call([], prompt="Add 5 and 7 using your tools", role="user")
+        text = gm.call([], prompt="Add 58027934 and 7902783 using your tools", role="user")
     """
 
     def __init__(self, model: str, api_key: str, max_iterations: int = 6, sleep_between: float = 0.2):
@@ -305,6 +306,4 @@ def call(self, history: List[str], prompt: str, role: str = "user") -> Optional[
         return None
 
 
-__all__ = ["GeminiModel"]
-
-
+__all__ = ["GeminiModel", "ChatGPTModel"]

src/yaka_llm/open_ai.py

@@ -0,0 +1,175 @@
+import json
+import time
+import inspect
+from typing import Any, Callable, Dict, List, Optional, Tuple
+import urllib.request
+import urllib.error
+
+JSONSchema = Dict[str, Any]
+
+
+def _pytype_to_json_schema(py_type: Any) -> str:
+    if py_type in (int, float):
+        return "number"
+    if py_type is bool:
+        return "boolean"
+    if py_type is str:
+        return "string"
+    return "string"
+
+
+class ChatGPTModel:
+    """
+    OpenAI / OpenRouter compatible chat client with tool-calling loop.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str,
+        url: str,
+        max_iterations: int = 6,
+        sleep_between: float = 0.2,
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.url = url
+        self.max_iterations = max_iterations
+        self.sleep_between = sleep_between
+
+        self._functions: Dict[str, Callable[..., Any]] = {}
+        self._tools: List[Dict[str, Any]] = []
+
+    # ------------------------------------------------------------------ TOOLS
+
+    def tool(self, fn: Optional[Callable] = None, *, name: Optional[str] = None):
+        def register(f: Callable):
+            tool_name = name or f.__name__
+            self._functions[tool_name] = f
+            self._rebuild_tools()
+            return f
+
+        return register(fn) if fn else register
+
+    def _rebuild_tools(self):
+        tools = []
+
+        for name, fn in self._functions.items():
+            sig = inspect.signature(fn)
+            properties = {}
+            required = []
+
+            for pname, p in sig.parameters.items():
+                ann = p.annotation if p.annotation is not inspect._empty else str
+                properties[pname] = {"type": _pytype_to_json_schema(ann)}
+                if p.default is inspect._empty:
+                    required.append(pname)
+
+            tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "description": fn.__doc__ or "",
+                        "parameters": {
+                            "type": "object",
+                            "properties": properties,
+                            "required": required,
+                        },
+                    },
+                }
+            )
+
+        self._tools = tools
+
+    # ------------------------------------------------------------- HTTP CALL
+
+    def _post(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        data = json.dumps(payload).encode()
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        req = urllib.request.Request(self.url, data=data, headers=headers, method="POST")
+
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                return json.loads(resp.read().decode())
+        except urllib.error.HTTPError as e:
+            body = e.read().decode(errors="ignore")
+            raise RuntimeError(f"HTTP {e.code}: {body}")
+        except Exception as e:
+            raise RuntimeError(f"Network error: {e}")
+
+    # --------------------------------------------------------- TOOL EXECUTION
+
+    def _execute_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        fn = self._functions.get(name)
+        if not fn:
+            return {"error": f"Tool '{name}' not registered"}
+
+        try:
+            return fn(**args)
+        except Exception as e:
+            return {"error": str(e)}
+
+    # ------------------------------------------------------------------ CALL
+
+    def call(self, history: List[str], prompt: str, role: str = "user") -> Optional[str]:
+        self._rebuild_tools()
+
+        messages = [{"role": "user", "content": h} for h in history]
+        messages.append({"role": role, "content": prompt})
+
+        for _ in range(self.max_iterations):
+            payload = {
+                "model": self.model,
+                "messages": messages,
+            }
+
+            if self._tools:
+                payload["tools"] = self._tools
+                payload["tool_choice"] = "auto"
+
+            resp = self._post(payload)
+            choices = resp.get("choices", [])
+
+            for choice in choices:
+                msg = choice.get("message", {})
+
+                # ---------------- TOOL CALL
+                if "tool_calls" in msg:
+                    for call in msg["tool_calls"]:
+                        name = call["function"]["name"]
+                        args = json.loads(call["function"].get("arguments", "{}"))
+
+                        result = self._execute_tool(name, args)
+
+                        messages.append(msg)
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": call["id"],
+                                "content": json.dumps(result),
+                            }
+                        )
+
+                        time.sleep(self.sleep_between)
+                        break
+                    else:
+                        continue
+                    break
+
+                # ---------------- FINAL TEXT
+                content = msg.get("content")
+                if content:
+                    messages.append(msg)
+                    return content
+
+            return None
+
+        return None
+
+
+__all__ = ["ChatGPTModel"]