llmadapt 0.1.0__py3-none-any.whl

llmadapt/__init__.py

@@ -0,0 +1,4 @@
+from .core import Agent, Conversation, ToolRegistry
+
+__all__ = ["Agent", "Conversation", "ToolRegistry"]
+__version__ = "0.1.0"

llmadapt/core.py

@@ -0,0 +1,545 @@
+import os
+import json
+import inspect
+import urllib.request
+import urllib.error
+from typing import get_type_hints, Callable
+
+
+class Conversation:
+    """ Conversation Class:
+    This needs to manage chat memory and has to have information of where the information came from, 
+    such as from a tool, model or the user.
+    This then needs to be able to send such memory when asked for based on the syntax and structure 
+    required depending on the AI model used.
+    Key Providers: Gemini, OpenAI, Anthropic, Ollama (for local models).
+    These providers should naturally work within the library.
+    Custom Providers are possible to use but a function to specify the structure is required. """
+    
+    def __init__(self, system_instruction: str = ""):
+        self.history = []
+        self.system_instruction = system_instruction
+        self.model_role = "assistant"
+
+        if self.system_instruction:
+            self.history.append({"role": "system", "content": self.system_instruction})
+
+    def add_user_msg(self, text: str):
+        self.history.append({"role": "user", "content": text})
+    
+    def add_model_msg(self, text: str = None, tool_calls: list = None, role: str = None,
+                       native: dict = None, native_provider: str = None):
+        if role is None:
+            role = self.model_role
+
+        msg = {"role": role} 
+        if text:
+            msg["content"] = text
+        if tool_calls:
+            normalized_calls = []
+            for tc in tool_calls:
+                func = tc.get("function") or {}
+                args = func.get("arguments") or {}
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        pass
+                normalized_calls.append({
+                    "id": tc.get("id"),
+                    "type": "function",
+                    "function": {
+                        "name": func.get("name"),
+                        "arguments": args
+                    }
+                })
+            msg["tool_calls"] = normalized_calls
+
+        if native is not None:
+            msg["_native"] = native
+            msg["_native_provider"] = native_provider
+        self.history.append(msg)
+    
+    def add_tool_response(self, function_name: str, output: str, tool_call_id: str = None):
+        msg = {
+            "role": "tool",
+            "name": function_name,
+            "content": output
+        }
+        if tool_call_id:
+            msg["tool_call_id"] = tool_call_id
+        self.history.append(msg)
+
+    def export_for(self, provider: str, special_format: Callable[[list], list] = None) -> list:
+        """Translates local flat memory frames into target external API layouts."""
+        if special_format and callable(special_format):
+            return special_format(self.history)
+
+        if provider in ["ollama", "openai", "custom"]:
+            cleaned_history = []
+            for msg in self.history:
+                cleaned_msg = {k: v for k, v in msg.items() if not k.startswith("_")}
+                
+                if provider in ["openai", "custom"] and "tool_calls" in cleaned_msg:
+                    stringified_calls = []
+                    for tc in cleaned_msg["tool_calls"]:
+                        func = tc.get("function") or {}
+                        args = func.get("arguments") or {}
+                        if not isinstance(args, str):
+                            args = json.dumps(args)
+                        
+                        stringified_calls.append({
+                            "id": tc.get("id"),
+                            "type": "function",
+                            "function": {
+                                "name": func.get("name"),
+                                "arguments": args
+                            }
+                        })
+                    cleaned_msg["tool_calls"] = stringified_calls
+                
+                cleaned_history.append(cleaned_msg)
+            return cleaned_history
+            
+        elif provider == "anthropic":
+            return self._export_anthropic()
+            
+        elif provider == "gemini":    
+            return self._export_gemini()
+
+    def change_system_instruction(self, new_instruction: str):
+        self.system_instruction = new_instruction
+        updated = False
+        for msg in self.history:
+            if msg["role"] == "system":
+                msg["content"] = self.system_instruction
+                updated = True
+                break
+        if not updated and self.system_instruction:
+            self.history.insert(0, {"role": "system", "content": self.system_instruction})
+
+    def change_model_role(self, new_role: str):
+        self.model_role = new_role
+
+    def _export_anthropic(self) -> list:
+        """Structures conversation blocks to comply with Anthropic context constraints."""
+        out = []
+        pending_tool_results = []
+        emitted_native_ids = set() 
+
+        def flush():
+            if pending_tool_results:
+                out.append({"role": "user", "content": pending_tool_results.copy()})
+                pending_tool_results.clear()
+
+        for msg in self.history:
+            if msg["role"] == "system":
+                continue
+
+            if msg.get("_native_provider") == "anthropic" and "_native" in msg:
+                native_hash = json.dumps(msg["_native"], sort_keys=True)
+                if native_hash in emitted_native_ids:
+                    continue
+                emitted_native_ids.add(native_hash)
+                flush()
+                out.append(msg["_native"])
+                continue
+
+            if msg["role"] == "tool":
+                pending_tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": msg.get("tool_call_id", ""),
+                    "content": msg["content"]
+                })
+                continue
+
+            flush()
+
+            if msg["role"] == "user":
+                out.append({"role": "user", "content": msg["content"]})
+            elif msg["role"] == "assistant":
+                content = []
+                if msg.get("content"):
+                    content.append({"type": "text", "text": msg["content"]})
+                for tool_call in msg.get("tool_calls", []):
+                    content.append({
+                        "type": "tool_use",
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "input": tool_call["function"]["arguments"]
+                    })
+                out.append({"role": "assistant", "content": content if content else (msg.get("content") or "")})
+
+        flush()
+        return out
+
+    def _export_gemini(self) -> list:
+        """Structures conversation blocks to comply with Gemini context constraints."""
+        gemini_history = []
+        for msg in self.history:
+            if msg["role"] == "system": 
+                continue 
+            if msg.get("_native_provider") == "gemini" and "_native" in msg:
+                gemini_history.append(msg["_native"])
+                continue
+            if msg["role"] == "user":
+                gemini_history.append({"role": "user", "parts": [{"text": msg["content"]}]})
+            elif msg["role"] == self.model_role:
+                parts = []
+                if msg.get("content"):
+                    parts.append({"text": msg["content"]})
+                if "tool_calls" in msg:
+                    for tool_call in msg["tool_calls"]:
+                        function_call_part = {
+                            "name": tool_call["function"]["name"],
+                            "args": tool_call["function"]["arguments"]
+                        }
+                        if tool_call.get("id"):
+                            function_call_part["id"] = tool_call["id"]
+                        parts.append({"functionCall": function_call_part})
+                gemini_history.append({"role": "model", "parts": parts})
+            elif msg["role"] == "tool":
+                function_response_part = {"name": msg["name"], "response": {"result": msg["content"]}}
+                if msg.get("tool_call_id"):
+                    function_response_part["id"] = msg["tool_call_id"]
+                gemini_history.append({
+                    "role": "user",
+                    "parts": [{"functionResponse": function_response_part}]
+                })
+        return gemini_history
+
+
+class ToolRegistry:
+    """ Tool Registry Class:
+    This class needs to handle tool storage and usage.
+    Methods to register tool use tool.
+    It should be able to export for all AI models and work with all providers.
+    Again, custom providers are possible to use but a function to specify the structure is required."""
+
+    def __init__(self):
+        self.functions_maps = {}
+        self.schemas = {} 
+    
+    def register(self, python_function, schema: dict = None):
+        if schema is None:
+            func_name = python_function.__name__
+            func_doc = inspect.getdoc(python_function) or "No description available."
+            type_mapping = {
+                str: "string", int: "integer", float: "number", bool: "boolean"
+            }
+
+            type_hints = get_type_hints(python_function)
+            signature = inspect.signature(python_function)
+            properties = {}
+            required_params = []
+
+            for param_name, param in signature.parameters.items():
+                param_type = type_hints.get(param_name, str)
+                gemini_type = type_mapping.get(param_type, "string")
+
+                properties[param_name] = {
+                    "type": gemini_type,
+                    "description": f"The {param_name} parameter"
+                }
+                if param.default == inspect.Parameter.empty:
+                    required_params.append(param_name)
+            
+            schema = {
+                "name": func_name,
+                "description": func_doc,
+                "parameters": {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required_params
+                }
+            }
+        else:
+            func_name = schema["name"]
+
+        self.functions_maps[func_name] = python_function
+        self.schemas[func_name] = schema 
+    
+    def execute(self, name: str, args: dict) -> str:
+        """Invokes a registered tool, safely converting crashes into explicit textual logs."""
+        if name not in self.functions_maps:
+            return f"Error: Tool '{name}' is not registered in this system."
+            
+        try:
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except json.JSONDecodeError:
+                    pass
+
+            if not isinstance(args, dict):
+                return f"Error: Arguments for tool '{name}' must be passed as a dictionary."
+
+            res = self.functions_maps[name](**args)
+            return _stringify_tool_output(res)
+        except Exception as e:
+            error_type = e.__class__.__name__
+            return f"Tool Execution Failure ({error_type}): {str(e)}. Please adjust your input arguments."
+
+    def export_for(self, provider: str, special_format: Callable[[list], list] = None) -> list:
+        if not self.schemas:
+            return []
+
+        schema_list = list(self.schemas.values()) 
+
+        if special_format and callable(special_format):
+            return special_format(schema_list)
+
+        if provider in ["ollama", "openai"]:
+            return [{"type": "function", "function": schema} for schema in schema_list]
+        elif provider == "anthropic":
+            return [{"name": s["name"], "description": s["description"], "input_schema": s["parameters"]} for s in schema_list]
+        elif provider == "gemini":
+            return [{"functionDeclarations": schema_list}]
+
+
+class Agent:
+    """ Agent Class:
+    This is the core agent class that needs to have several key features:
+    This agent handles the Conversation and Tool object.
+    When an AI responds asking for the results of certain tools, this must run it; however, there 
+    should be a max to how many times this iteration can happen - function to change max iterations.
+    A function to switch APIs and all - will make later additions easier.
+    Add tool and send request to AI model functions are needed.
+    An overall Chat function that handles sending the payload to the AI model and handles the response. """
+    
+    DEFAULT_MODELS = {
+        "gemini": "gemini-1.5-flash",
+        "anthropic": "claude-3-5-sonnet-20241022",
+        "openai": "gpt-4o-mini",
+        "ollama": "llama3.1:8b"
+    }
+
+    def __init__(self, provider: str, model: str = None, base_url: str = None, 
+                 api_key: str = None, system_instruction: str = "", max_tool_iterations: int = 6,
+                 max_tokens: int = None):
+        self.conversation = Conversation(system_instruction=system_instruction)
+        self.tool_registry = ToolRegistry()
+        self.change_api(provider=provider, model=model, base_url=base_url, api_key=api_key)
+        self.set_max_tool_iterations(max_tool_iterations)
+        self.max_tokens = max_tokens
+
+    def set_max_tool_iterations(self, n: int):
+        """Sets the upper threshold for consecutive tool execution cycles."""
+        if not isinstance(n, int) or n < 1:
+            raise ValueError("max_tool_iterations must be an integer >= 1")
+        self.max_tool_iterations = n
+
+    def change_api(self, provider: str, model: str = None, base_url: str = None, api_key: str = None):
+        """Re-routes active transport endpoints with fluent default model fallbacks."""
+        self.provider = provider.lower()
+        self.model = model or self.DEFAULT_MODELS.get(self.provider, "custom-model")
+        self.api_key = api_key
+
+        if base_url:
+            self.url = base_url
+        elif self.provider == "gemini":
+            self.url = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model}:generateContent"
+        elif self.provider == "openai":
+            self.url = "https://api.openai.com/v1/chat/completions"
+        elif self.provider == "anthropic":
+            self.url = "https://api.anthropic.com/v1/messages"
+        elif self.provider == "ollama":
+            self.url = "http://localhost:11434/api/chat"
+        else:
+            self.url = ""
+
+        if not self.api_key and self.provider != "ollama":
+            self.api_key = os.getenv(f"{self.provider.upper()}_API_KEY")
+
+    def add_tool(self, python_function: Callable, schema: dict = None):
+        self.tool_registry.register(python_function, schema)
+
+    def _send_request(self, payload: dict, headers: dict) -> dict:
+        """Executes native standard library post requests using zero external code."""
+        if not self.url:
+            raise ValueError(f"API endpoint URL is not configured for provider '{self.provider}'. "
+                             f"Please supply a valid base_url when calling change_api().")
+
+        data_bytes = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(self.url, data=data_bytes, headers=headers, method="POST")
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"\n[{self.provider.upper()} HTTP Error {e.code}]: {e.read().decode('utf-8')}")
+        except urllib.error.URLError as e:
+            raise RuntimeError(f"\n[Network Unreachable]: Check route {self.url}. Reason: {e.reason}")
+
+    def chat(self, user_input: str, custom_format_func: Callable[[list], list] = None, max_tokens: int = None) -> str:
+        self.conversation.add_user_msg(user_input)
+        max_tokens = max_tokens if max_tokens is not None else self.max_tokens
+
+        iterations = 0 
+        while True:
+            iterations += 1
+            if iterations > self.max_tool_iterations:
+                raise RuntimeError(
+                    f"Exceeded max_tool_iterations ({self.max_tool_iterations}) without a final "
+                    f"text response. Call agent.set_max_tool_iterations(n) to raise this limit."
+                )
+
+            history = self.conversation.export_for(self.provider, special_format=custom_format_func)
+            tools = self.tool_registry.export_for(self.provider, special_format=custom_format_func)
+            headers = {"Content-Type": "application/json"}
+
+            # --- GEMINI RUNTIME ---
+            if self.provider == "gemini":
+                if self.api_key: headers["x-goog-api-key"] = self.api_key
+                payload = {"contents": history}
+                if tools: payload["tools"] = tools
+                if self.conversation.system_instruction:
+                    payload["systemInstruction"] = {"parts": [{"text": self.conversation.system_instruction}]}
+                
+                if max_tokens is not None:
+                    payload["generationConfig"] = {"maxOutputTokens": max_tokens}
+
+                res = self._send_request(payload, headers)
+                
+                if 'candidates' not in res or not res['candidates']:
+                    error_msg = res.get('error', {}).get('message', 'Unknown Gemini API Error')
+                    raise RuntimeError(f"Gemini API empty response or error: {error_msg}")
+
+                parts = res['candidates'][0]['content']['parts']
+
+                function_calls = [p['functionCall'] for p in parts if 'functionCall' in p]
+                text_parts = [p['text'] for p in parts if 'text' in p]
+
+                if function_calls:
+                    # Gemini now returns a unique "id" with each functionCall and
+                    # expects that same id echoed back in the functionResponse so
+                    # it can match results to requests (older model versions may
+                    # not send an id at all, so fallback to "" when absent).
+                    tool_calls = [{"id": function_call.get("id", ""),
+                                   "function": {"name": function_call['name'], "arguments": function_call.get('args', {})}}
+                                  for function_call in function_calls]
+                    self.conversation.add_model_msg(
+                        text="".join(text_parts) or None,
+                        tool_calls=tool_calls,
+                        native={"role": "model", "parts": parts},
+                        native_provider="gemini"
+                    )
+                    for function_call in function_calls:
+                        name, args = function_call['name'], function_call.get('args', {})
+                        call_id = function_call.get("id", "")
+                        out_str = self.tool_registry.execute(name, args)
+                        function_response = {"name": name, "response": {"result": out_str}}
+                        if call_id:
+                            function_response["id"] = call_id
+                        self.conversation.history.append({
+                            "role": "tool", "name": name, "content": out_str,
+                            "tool_call_id": call_id,
+                            "_native": {"role": "user", "parts": [{"functionResponse": function_response}]},
+                            "_native_provider": "gemini"
+                        })
+                    continue
+                text = "".join(text_parts)
+                self.conversation.add_model_msg(text=text)
+                return text
+            
+            # --- ANTHROPIC RUNTIME ---
+            elif self.provider == "anthropic":
+                if max_tokens is None:
+                    max_tokens = 4096
+                headers.update({"x-api-key": self.api_key, "anthropic-version": "2023-06-01"})
+                payload = {"model": self.model, "messages": history, "max_tokens": max_tokens}
+                if tools: payload["tools"] = tools
+                if self.conversation.system_instruction: payload["system"] = self.conversation.system_instruction
+
+                res = self._send_request(payload, headers)
+                t_calls, final_text = [], ""
+                
+                for block in res.get("content", []):
+                    if block["type"] == "text": final_text += block["text"]
+                    elif block["type"] == "tool_use":
+                        t_calls.append({"id": block["id"], "function": {"name": block["name"], "arguments": block["input"]}})
+                
+                if t_calls:
+                    self.conversation.add_model_msg(
+                        text=final_text if final_text else None,
+                        tool_calls=t_calls,
+                        native={"role": "assistant", "content": res.get("content", [])},
+                        native_provider="anthropic"
+                    )
+                    tool_result_blocks = []
+                    for tc in t_calls:
+                        out_str = self.tool_registry.execute(tc["function"]["name"], tc["function"]["arguments"])
+                        tool_result_blocks.append({"type": "tool_result", "tool_use_id": tc["id"], "content": out_str})
+                    native_user_msg = {"role": "user", "content": tool_result_blocks}
+                    for tc, block in zip(t_calls, tool_result_blocks):
+                        self.conversation.history.append({
+                            "role": "tool", "name": tc["function"]["name"], "content": block["content"],
+                            "tool_call_id": tc["id"],
+                            "_native": native_user_msg, "_native_provider": "anthropic"
+                        })
+                    continue
+                self.conversation.add_model_msg(text=final_text)
+                return final_text
+
+            # --- OPENAI / CUSTOM MOCK RUNTIME ---
+            elif self.provider in ["openai", "custom"]:
+                if self.api_key: headers["Authorization"] = f"Bearer {self.api_key}"
+                payload = {"model": self.model, "messages": history}
+                if tools: payload["tools"] = tools
+
+                if max_tokens is not None:
+                    payload["max_completion_tokens"] = max_tokens
+                    payload["max_tokens"] = max_tokens
+
+                res = self._send_request(payload, headers)
+                
+                if 'choices' not in res or not res['choices']:
+                    error_msg = res.get('error', {}).get('message', 'Unknown OpenAI API Error')
+                    raise RuntimeError(f"OpenAI API empty response or error: {error_msg}")
+
+                msg = res['choices'][0]['message']
+                
+                if msg.get("tool_calls"):
+                    self.conversation.add_model_msg(text=msg.get("content"), tool_calls=msg["tool_calls"])
+                    for tool_call in msg["tool_calls"]:
+                        name = tool_call["function"]["name"]
+                        args = json.loads(tool_call["function"]["arguments"]) if isinstance(tool_call["function"]["arguments"], str) else tool_call["function"]["arguments"]
+                        out_str = self.tool_registry.execute(name, args)
+                        self.conversation.add_tool_response(name, out_str, tool_call["id"]) 
+                    continue
+                text = msg.get("content", "")
+                self.conversation.add_model_msg(text=text)
+                return text
+            
+            # --- OLLAMA RUNTIME ---
+            elif self.provider == "ollama":
+                payload = {"model": self.model, "messages": history, "stream": False}
+                if tools: payload["tools"] = tools
+                if max_tokens is not None:
+                    payload["options"] = {"num_predict": max_tokens}
+
+                res = self._send_request(payload, headers)
+                msg = res.get("message", {})
+                
+                if msg.get("tool_calls"):
+                    self.conversation.add_model_msg(text=msg.get("content"), tool_calls=msg["tool_calls"])
+                    for tool_call in msg["tool_calls"]:
+                        name, args = tool_call["function"]["name"], tool_call["function"]["arguments"]
+                        out_str = self.tool_registry.execute(name, args)
+                        self.conversation.add_tool_response(name, out_str, tool_call.get("id"))
+                    continue
+                text = msg.get("content", "")
+                self.conversation.add_model_msg(text=text)
+                return text
+
+    def change_default_max_tokens(self, max_tokens: int):
+        self.max_tokens = max_tokens
+
+
+def _stringify_tool_output(out) -> str:
+    """Serializes tool return values into valid JSON strings for model consumption."""
+    if isinstance(out, str):
+        return out
+    try:
+        return json.dumps(out)
+    except TypeError:
+        return str(out)

llmadapt-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: llmadapt
+Version: 0.1.0
+Summary: A lightweight, zero-dependency, provider-agnostic LLM agent with tool-calling support for Anthropic, OpenAI, Gemini, and Ollama.
+Author-email: Shyam Parikh <shyamparikh@yahoo.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Shyam-Parikh-2025/llmadapt
+Project-URL: Issues, https://github.com/Shyam-Parikh-2025/llmadapt/issues
+Keywords: llm,agent,tool-calling,anthropic,openai,gemini,ollama
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# llmadapt
+
+A small, zero-dependency, provider-agnostic agent for chatting with LLMs and
+giving them tools. Works with Anthropic, OpenAI, Gemini, and Ollama using only
+the Python standard library for HTTP — no `requests`, no provider SDKs.
+v0.1.0
+
+## Install
+
+From source (until published to PyPI):
+
+```bash
+git clone https://github.com/Shyam-Parikh-2025/llmadapt.git
+cd llmadapt
+pip install -e .
+```
+
+Once published:
+
+```bash
+pip install llmadapt
+```
+
+## Quick start
+
+```python
+from llmadapt import Agent
+
+agent = Agent(
+    provider="anthropic",
+    model="claude-sonnet-4-6",
+    api_key="sk-ant-...",  # or set ANTHROPIC_API_KEY in your environment
+    system_instruction="You are a helpful assistant.",
+)
+
+print(agent.chat("What's 12 * 7?"))
+```
+
+## Giving the agent tools
+
+```python
+def get_weather(city: str) -> dict:
+    """Look up the current weather for a city."""
+    return {"city": city, "tempF": 72, "condition": "sunny"}
+
+agent.add_tool(get_weather)
+print(agent.chat("What's the weather in NYC?"))
+```
+
+A JSON schema is auto-generated from the function's type hints, default
+values, and docstring. Tool outputs are JSON-serialized automatically
+(plain strings pass through untouched).
+
+## Switching providers
+
+```python
+agent.switch_api(provider="openai", model="gpt-4o", api_key="sk-...")
+```
+
+## Limiting tool-call loops
+
+```python
+agent.set_max_tool_iterations(20)  # default is 10
+```
+
+If the model gets stuck calling tools repeatedly without producing a final
+answer, `chat()` raises a `RuntimeError` instead of looping forever.
+
+## Supported providers
+
+| provider    | env var for API key   | notes                          |
+|-------------|------------------------|--------------------------------|
+| `anthropic` | `ANTHROPIC_API_KEY`    | Messages API                   |
+| `openai`    | `OPENAI_API_KEY`       | Chat Completions API           |
+| `gemini`    | `GEMINI_API_KEY`       | generateContent endpoint       |
+| `ollama`    | *(none — local)*       | defaults to `localhost:11434`  |
+| `custom`    | *(none — pass directly)* | requires `base_url` + a `custom_format_func` you supply to `chat()` |
+
+## Running tests
+
+```bash
+python tests/test_agent.py
+```
+
+Tests run entirely offline against scripted fake HTTP responses — no API key
+or network access required.
+
+## License
+
+MIT

llmadapt-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+llmadapt/__init__.py,sha256=ZBU1JvJqqS-P7YBJ__SNw7hPLlooI6iNt5_WKg63K3Y,127
+llmadapt/core.py,sha256=lnz2n0Y5lc8V7H6_A4d1FiYz1J60xK7k_drhIZDi0a4,25636
+llmadapt-0.1.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+llmadapt-0.1.0.dist-info/METADATA,sha256=NALUOxJVi-BJeaqkCzvIphSDztBZczDVZKfKKJduUwA,3390
+llmadapt-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+llmadapt-0.1.0.dist-info/top_level.txt,sha256=bT7NMnd6dQJIpY0Qk8dOWX1ha-8_jlm0D9I6peGWPSM,9
+llmadapt-0.1.0.dist-info/RECORD,,

llmadapt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

llmadapt-0.1.0.dist-info/licenses/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.

llmadapt-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llmadapt