codex-agent-framework 0.1.1__py3-none-any.whl

codex_agent/tool.py

@@ -0,0 +1,235 @@
+from .message import DeveloperMessage
+from contextvars import ContextVar
+from modict import modict
+from typing import get_args, get_origin, Literal, Union
+import json
+import inspect
+
+TOOL_MARKER = "__codex_agent_tool__"
+_current_agent = ContextVar("codex_agent_current_agent", default=None)
+
+
+def tool(func=None, **options):
+    """Mark a function as an agent tool for automatic discovery."""
+    if func is None:
+        def decorator(f):
+            return tool(f, **options)
+        return decorator
+
+    setattr(func, TOOL_MARKER, modict(options))
+    return func
+
+
+def tool_options(func):
+    return getattr(func, TOOL_MARKER, None)
+
+
+def get_agent():
+    agent = _current_agent.get()
+    if agent is None:
+        raise RuntimeError("No current agent is available outside an agent tool call.")
+    return agent
+
+
+def set_current_agent(agent):
+    return _current_agent.set(agent)
+
+
+def reset_current_agent(token):
+    _current_agent.reset(token)
+
+
+class ServerTool(modict):
+    """Responses API server-side tool without a local Python handler."""
+
+    type = None
+
+    def to_response_tool(self):
+        return {key: value for key, value in self.items() if value is not None}
+
+
+class WebSearchTool(ServerTool):
+    type = "web_search"
+
+
+class ImageGenerationTool(ServerTool):
+    type = "image_generation"
+    output_format = "png"
+    size = None
+    quality = None
+    background = None
+    moderation = None
+
+
+class Tool:
+    """Local tool callable exposed to the model."""
+
+    def __init__(
+        self,
+        obj,
+        name=None,
+        description=None,
+        parameters=None,
+        required=None,
+        type=None,
+        mode=None,
+        format=None,
+    ):
+        self.obj=obj
+        self.name=name or getattr(obj,'__name__',None) or obj.__class__.__name__ 
+        self.schema:modict=self.infer_schema()
+        self.schema.update(self.parse_doc())
+        if description:
+            self.schema.description=description
+        if parameters:
+            self.schema.parameters=parameters
+        if required:
+            self.schema.required=required
+        if format:
+            self.schema.format=format
+        self.mode = mode or self.schema.pop('mode', None) or 'api'
+        self.type = type or self.schema.pop('type',None) or 'function'
+        self.format = self.schema.pop('format', None)
+
+    def __getattr__(self,name):
+        return getattr(self.obj,name)
+
+    def __call__(self,*args,**kwargs):
+        return self.obj(*args,**kwargs)
+
+    def infer_schema(self):
+        try:
+            signature = inspect.signature(self.obj)
+        except (TypeError, ValueError):
+            return modict()
+
+        parameters = modict()
+        required = []
+        for name, parameter in signature.parameters.items():
+            if name in ("self", "cls"):
+                continue
+            if parameter.kind in (
+                inspect.Parameter.VAR_POSITIONAL,
+                inspect.Parameter.VAR_KEYWORD,
+            ):
+                continue
+
+            schema = self.annotation_to_schema(parameter.annotation)
+            if parameter.default is inspect.Parameter.empty:
+                required.append(name)
+            else:
+                schema["default"] = parameter.default
+            parameters[name] = schema
+
+        return modict(parameters=parameters, required=required)
+
+    def annotation_to_schema(self, annotation):
+        if annotation is inspect.Parameter.empty:
+            return {"type": "string"}
+
+        origin = get_origin(annotation)
+        args = get_args(annotation)
+
+        if origin is Literal:
+            values = list(args)
+            schema = {"enum": values}
+            if values:
+                schema["type"] = self.json_type(type(values[0]))
+            return schema
+
+        if origin in (list, tuple, set):
+            item_type = args[0] if args else str
+            return {
+                "type": "array",
+                "items": self.annotation_to_schema(item_type),
+            }
+
+        if origin is dict:
+            return {"type": "object"}
+
+        if origin is Union:
+            non_null_args = [arg for arg in args if arg is not type(None)]
+            if len(non_null_args) == 1:
+                schema = self.annotation_to_schema(non_null_args[0])
+                schema["nullable"] = True
+                return schema
+            return {"anyOf": [self.annotation_to_schema(arg) for arg in non_null_args]}
+
+        return {"type": self.json_type(annotation)}
+
+    def json_type(self, python_type):
+        return {
+            str: "string",
+            int: "integer",
+            float: "number",
+            bool: "boolean",
+            dict: "object",
+            list: "array",
+            tuple: "array",
+            set: "array",
+        }.get(python_type, "string")
+
+    def parse_doc(self):
+        """Parses the YAML docstring of the tool's function to extract metadata.
+
+        Returns:
+            modict: Schema containing description, parameters, and required fields.
+        """
+        import yaml
+        from textwrap import dedent
+
+        doc = self.obj.__doc__
+        if not doc:
+            return modict()
+
+        # Nettoie l'indentation avec dedent, puis strip les quotes et espaces
+        doc_str = dedent(doc).strip().strip('"""').strip("'''").strip()
+
+        try:
+            schema = yaml.safe_load(doc_str)
+            if not isinstance(schema, dict):
+                return modict(description=doc_str)
+        except Exception:
+            return modict(description=doc_str)
+
+        return modict(schema)
+
+    def to_response_tool(self):
+        """Converts the Tool object into a Responses API tool schema."""
+        if self.type == "custom":
+            tool = dict(
+                type="custom",
+                name=self.name,
+                description=self.schema.get('description','No description provided'),
+            )
+            if self.format:
+                tool["format"] = dict(self.format)
+            return tool
+
+        properties=dict()
+        for name,param in self.schema.get('parameters',{}).items():
+            if isinstance(param,dict):
+                properties[name]=dict(param)
+            elif isinstance(param,str):
+                properties[name]=param
+
+        tool=dict(
+            type="function",
+            name=self.name,
+            description=self.schema.get('description','No description provided'),
+            parameters=dict(
+                type="object",
+                properties=properties,
+                required=self.schema.get('required',[])
+            ),
+        )
+        return tool
+    
+    def to_developer_message(self):
+        """Converts the Tool object into a developer message for parsed tool guidance.
+        For tools that don't use the usual API function call pipeline, this can be used to provide the AI with the tool's schema in a more flexible way.
+
+        Returns:
+            Message: Developer message containing the tool's schema.
+        """
+        return DeveloperMessage(content=f"Tool: {self.name}\nSchema:\n{json.dumps(self.to_response_tool(), indent=2, ensure_ascii=False)}")

codex_agent/utils.py

@@ -0,0 +1,374 @@
+import os
+import shutil
+import tiktoken
+import re
+from datetime import datetime
+from textwrap import dedent
+import random, string
+import json
+import regex
+from threading import Thread as ThreadBase
+import sys
+import inspect
+from importlib import import_module
+from io import BytesIO
+
+RUNTIME_DIR=os.path.expanduser(os.environ.get("AGENT_RUNTIME_DIR", "~/.agent_runtime"))
+
+def runtime_join(*args):
+    return os.path.join(RUNTIME_DIR,*args)
+
+def ensure_runtime_dir():
+    if not os.path.isdir(RUNTIME_DIR):
+        os.makedirs(RUNTIME_DIR,exist_ok=True)
+
+def set_root_path(file=None):
+    file=file or __file__
+    os.environ['AGENT_ROOT_PATH']=os.path.dirname(os.path.abspath(file))
+
+def root_join(*args):
+    return os.path.join(os.getenv('AGENT_ROOT_PATH'),*args)
+
+def text_content(file):
+    if os.path.isfile(file):
+        with open(file,encoding="utf-8") as f:
+            return f.read()
+    else:
+        return None
+    
+def add_line_numbers(text: str) -> str:
+    lines = text.splitlines()
+    n = len(lines)
+    width = len(str(n))
+    
+    lines_num = [f"{i:0{width}d}|{line}" 
+                  for i, line in enumerate(lines, start=1)]
+    return "\n".join(lines_num)
+    
+def short_id(length=8):
+    return "".join(random.choices(string.ascii_letters,k=length))
+
+def session_id():
+    """Generate a unique, lexicographically sortable session ID."""
+    return datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+tokenizer = tiktoken.get_encoding("cl100k_base")
+
+def tokenize(string):
+    int_tokens = tokenizer.encode(string)
+    str_tokens = [tokenizer.decode([int_token]) for int_token in int_tokens]
+    return str_tokens
+
+def utf8_safe_tokenize(s):
+    return regex.findall(r'\X', s)
+
+def token_count(string):
+    return len(tokenizer.encode(string))
+
+def sort(messages):
+    return sorted(messages, key=lambda msg: msg.timestamp)
+
+def snake_case_type(cls):
+    name = cls.__name__
+    chars = []
+    for i, char in enumerate(name):
+        if char.isupper() and i > 0:
+            chars.append('_')
+        chars.append(char.lower())
+    return ''.join(chars)
+
+def truncate(string, max_tokens=2000, start_line=1):
+    """
+    Truncate a string to a maximum number of tokens using line-based chunking.
+
+    Args:
+        string: The string to truncate
+        max_tokens: Maximum number of tokens to keep
+        start_line: The line number of the first line in the string (1-indexed).
+                   Used for skipping content and tracking line numbers in truncation messages.
+
+    Returns:
+        Truncated string with indication of removed content
+    """
+    # Quick check - if already under limit, return as-is
+    tokens = tokenize(string)
+    if len(tokens) <= max_tokens:
+        return string
+
+    # line-based truncation
+    lines = string.splitlines(keepends=True)
+
+    # Skip to start_line if needed
+    if start_line > 1:
+        if start_line > len(lines):
+            return ""
+        lines = lines[start_line - 1:]
+
+    # Calculate the actual last line number after skipping
+    remaining_lines = len(lines)
+
+    # Assemble lines up to max_tokens
+    result_lines = []
+    current_tokens = 0
+
+    for line in lines:
+        line_tokens = token_count(line)
+        if current_tokens + line_tokens <= max_tokens:
+            result_lines.append(line)
+            current_tokens += line_tokens
+        else:
+            break
+
+    if result_lines:
+        result = ''.join(result_lines)
+        num_kept = len(result_lines)
+
+        # Only show truncation message if we didn't include all lines
+        if num_kept < remaining_lines:
+            first_truncated = start_line + num_kept
+            last_line = start_line + remaining_lines - 1
+
+            if not result.endswith('\n'):
+                result += '\n'
+            result += f"\n...\n\n[Lines {first_truncated}-{last_line} truncated]\n"
+
+        return result
+    else:
+        return f"[Lines {start_line}-{start_line + remaining_lines - 1} truncated - first lineexceeds token limit]\n"
+
+def pack_msgs(messages):
+    text = ''
+    for message in messages:
+        text += message.name + ':\n'
+        text += message.content.strip() + '\n\n'
+    return text
+
+def msg_token_count(msg):
+    count=0
+    if msg.type=='image_message':
+        count+=1000
+        count+=token_count(str(msg.get('description') or ''))
+        count+=token_count(str(msg.get('image_name') or msg.get('content') or ''))
+    else:
+        count+=token_count(str(msg.get('content') or ''))
+
+    for tool_call in msg.get('tool_calls') or []:
+        count+=token_count(json.dumps(tool_call.get('arguments','')))
+    return count
+
+def total_tokens(messages):
+    return sum(msg_token_count(msg) for msg in messages)
+
+def split_history_turns(messages):
+    """Split a message history into complete turns and a trailing remainder.
+
+    Any message can start a turn. The split is driven only by end markers:
+    a final assistant message, or an interruption marker. Assistant messages
+    with tool calls are intermediate loop messages, not final answers.
+    """
+    turns = []
+    current = []
+
+    def msg_type(msg):
+        return msg.get("type") if isinstance(msg, dict) else getattr(msg, "type", None)
+
+    def is_final_assistant(msg):
+        if msg_type(msg) != "assistant_message":
+            return False
+        tool_calls = msg.get("tool_calls") if isinstance(msg, dict) else getattr(msg, "tool_calls", None)
+        return not tool_calls
+
+    def is_interruption_marker(msg):
+        if msg_type(msg) != "developer_message":
+            return False
+        content = msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", "")
+        return "interrupted by the user" in str(content).lower()
+
+    for msg in messages:
+        current.append(msg)
+        if is_final_assistant(msg) or is_interruption_marker(msg):
+            turns.append(current)
+            current = []
+
+    return turns, current
+
+def find_pattern(text, pattern=None):
+    """
+    Renvoie une liste de tuples contenant TOUS les groupes capturés par le pattern.
+
+    - Si le pattern contient 1 groupe  -> tuple de 1 élément
+    - Si le pattern contient n groupes -> tuple de n éléments
+    """
+
+    pattern = pattern or r'```python(.*?)```'
+    iterator = re.finditer(pattern, text, re.DOTALL)
+
+    return [
+        tuple(match.groups())     # groups() renvoie *tous* les groupes capturés
+        for match in iterator
+    ]
+
+def format(string, context=None):
+    # Si aucun contexte n'est fourni, utiliser un dictionnaire vide
+    if context is None:
+        context = {}
+    # Trouver les expressions entre <<...>>
+    def replace_expr(match):
+        expr = match.group(1)
+        try:
+            # Évaluer l'expression dans le contexte donné et la convertir en chaîne
+            return str(eval(expr, context))
+        except Exception as e:
+            # print(f"could not evaluate expr: {expr}\n Exception:\n {str(e)}")
+            # En cas d'erreur, retourner l'expression non évaluée
+            return '<<' + expr + '>>'
+    # Remplacer chaque expression par son évaluation
+    return re.sub(r'<<(.*?)>>', replace_expr, string)
+
+def timestamp(digits=3):
+    base = datetime.now().strftime("%Y%m%dT%H%M%S.%f")
+    if digits == 0:
+        return base[:15]  # Jusqu'à la seconde uniquement
+    return base[:15 + 1 + digits]
+
+def guess_extension_from_bytes(data):
+    """
+    Guess file extension from byte content using filetype library.
+    Returns None if unable to determine the file type.
+
+    Args:
+        data: bytes or BytesIO object containing file data
+
+    Returns:
+        str: File extension with leading dot (e.g., '.png') or None if unable to determine
+    """
+    import filetype
+    from io import BytesIO
+
+    # Ensure we have bytes
+    if isinstance(data, BytesIO):
+        data = data.getvalue()
+    elif hasattr(data, 'read'):
+        data = data.read()
+
+    if not data or len(data) == 0:
+        return None
+
+    kind = filetype.guess(data)
+    if kind is not None:
+        return f'.{kind.extension}'
+
+    return None
+
+def _uploaded_filename(source, data, name=None):
+    if name is None:
+        if isinstance(source, str):
+            name = os.path.basename(source)
+        elif hasattr(source, 'name') and source.name:
+            name = source.name
+        else:
+            name = f"uploaded_file_{short_id()}"
+
+    _, name_ext = os.path.splitext(name)
+    if name_ext:
+        extension = name_ext
+    elif isinstance(source, str):
+        extension = os.path.splitext(source)[1]
+    else:
+        extension = guess_extension_from_bytes(data) or ''
+
+    return os.path.splitext(name)[0] + extension
+
+def upload_file_to_folder(source, folder, name=None):
+    """Copy or write a file-like source into folder and return its absolute path."""
+    if source is None:
+        raise ValueError("A file source must be provided")
+
+    os.makedirs(folder, exist_ok=True)
+
+    if isinstance(source, str):
+        if not os.path.exists(source):
+            raise ValueError(f"File not found: {source}")
+        data = None
+        filename = _uploaded_filename(source, data, name=name)
+        dest_path = os.path.join(folder, filename)
+        shutil.copy2(source, dest_path)
+    elif isinstance(source, BytesIO):
+        data = source.getvalue()
+        filename = _uploaded_filename(source, data, name=name)
+        dest_path = os.path.join(folder, filename)
+        with open(dest_path, 'wb') as f:
+            f.write(data)
+    elif isinstance(source, bytes):
+        data = source
+        filename = _uploaded_filename(source, data, name=name)
+        dest_path = os.path.join(folder, filename)
+        with open(dest_path, 'wb') as f:
+            f.write(data)
+    else:
+        raise TypeError(f"Unsupported source type: {type(source)}. Expected str, BytesIO, or bytes.")
+
+    return os.path.abspath(dest_path)
+
+class Logger:
+
+    def __init__(self,file=None):
+        self.file=file or root_join('logs',"log.txt")
+        open(self.file,'w', encoding='utf-8').close()
+
+    def log(self,message):
+        with open(self.file,'a',encoding="utf-8") as f:
+            f.write(str(message)+'\n')
+
+    def log_to_file(self,content,file=None):
+        file = file or self.file
+        with open(file,'w',encoding="utf-8") as f:
+            f.write(str(content)+'\n')
+
+def read_document_content(source, start_at_line=1, max_tokens=8000):
+    """
+    Read and extract text content from various document formats.
+
+    Args:
+        source: Document source - either a local file path or URL (http/https)
+        start_at_line: Line number to start reading from (1-indexed)
+        max_tokens: Maximum tokens for truncation (0 to disable)
+
+    Returns:
+        Extracted text content, possibly truncated
+    """
+    get_text = import_module(".get_text.get_text", __package__).get_text
+
+    text=get_text(source)
+
+    # Apply truncation - truncate function handles smart chunking internally
+    if max_tokens > 0:
+        text = truncate(text, max_tokens=max_tokens, start_line=start_at_line)
+
+    return text
+
+def is_running_in_streamlit_runtime():
+    try:
+        from streamlit.runtime.scriptrunner import get_script_run_ctx
+    except Exception:
+        return False
+
+    return get_script_run_ctx() is not None
+
+class ThreadPool:
+    threads = {}
+
+    @classmethod
+    def register(cls, thread):
+        cls.threads[thread.name] = thread
+
+    @classmethod
+    def join_all(cls, timeout=None):
+        for thread in list(cls.threads.values()):
+            if thread.is_alive():
+                thread.join(timeout=timeout)
+
+def Thread(*args,**kwargs):
+    thread = ThreadBase(*args,**kwargs)
+    ThreadPool.register(thread)
+    return thread