generator

Class info

Classes

Name	Children	Inherits
CodeGenerator llmling_agent.resource_providers.codemode.generator Meta-resource provider that exposes tools through Python execution.		object
Tool llmling_agent.tools.base Information about a registered tool.		object

🛈 DocStrings

Meta-resource provider that exposes tools through Python execution.

CodeGenerator dataclass

Meta-resource provider that exposes tools through Python execution.

Source code in src/llmling_agent/resource_providers/codemode/generator.py

@dataclass
class CodeGenerator:
    """Meta-resource provider that exposes tools through Python execution."""

    schema: OpenAIFunctionTool
    """Schema of the tool."""

    callable: Callable
    """Tool to generate code for."""

    name_override: str | None = None
    """Name of the tool."""

    @classmethod
    def from_tool(cls, tool: Tool) -> CodeGenerator:
        """Create a CodeGenerator from a Tool."""
        return cls(schema=tool.schema, callable=tool.callable, name_override=tool.name)

    @property
    def name(self) -> str:
        """Name of the tool."""
        return self.name_override or self.callable.__name__

    def _extract_basic_signature(self, return_type: str = "Any") -> str:
        """Fallback signature extraction from tool schema."""
        schema = self.schema["function"]
        params = schema.get("parameters", {}).get("properties", {})
        required = set(schema.get("required", []))  # type: ignore

        param_strs = []
        for name, param_info in params.items():
            # Use improved type inference
            type_hint = self._infer_parameter_type(name, param_info)

            if name not in required:
                param_strs.append(f"{name}: {type_hint} = None")
            else:
                param_strs.append(f"{name}: {type_hint}")

        return f"{self.name}({', '.join(param_strs)}) -> {return_type}"

    def _infer_parameter_type(self, param_name: str, param_info: Property) -> str:
        """Infer parameter type from schema and function inspection."""
        schema_type = param_info.get("type", "Any")

        # If schema has a specific type, use it
        if schema_type != "object":
            return TYPE_MAP.get(schema_type, "Any")

        # For 'object' type, try to infer from function signature
        try:
            callable_func = self.callable
            sig = inspect.signature(callable_func)

            if param_name in sig.parameters:
                param = sig.parameters[param_name]

                # Try annotation first
                if param.annotation != inspect.Parameter.empty:
                    if hasattr(param.annotation, "__name__"):
                        return param.annotation.__name__
                    return str(param.annotation)

                # Infer from default value
                if param.default != inspect.Parameter.empty:
                    default_type = type(param.default).__name__
                    # Map common types
                    if default_type in ["int", "float", "str", "bool"]:
                        return default_type
                # If no default and it's required, assume str for web-like functions
                required = set(
                    self.schema.get("function", {})
                    .get("parameters", {})
                    .get("required", [])
                )
                if param_name in required:
                    return "str"

        except Exception:  # noqa: BLE001
            pass

        # Fallback to Any for unresolved object types
        return "Any"

    def _get_return_model_name(self) -> str:
        """Get the return model name for a tool."""
        try:
            schema = create_schema(self.callable)
            if schema.returns.get("type") == "object":
                return f"{self.name.title()}Response"
            if schema.returns.get("type") == "array":
                return f"list[{self.name.title()}Item]"
            return TYPE_MAP.get(schema.returns.get("type", "string"), "Any")
        except Exception:  # noqa: BLE001
            return "Any"

    def get_function_signature(self) -> str:
        """Extract function signature using schemez."""
        try:
            return_model_name = self._get_return_model_name()
            return self._extract_basic_signature(return_model_name)
        except Exception:  # noqa: BLE001
            return self._extract_basic_signature("Any")

    def generate_return_model(self) -> str | None:
        try:
            schema = create_schema(self.callable)
            if schema.returns.get("type") not in {"object", "array"}:
                return None

            class_name = f"{self.name.title()}Response"
            model_code = schema.to_pydantic_model_code(class_name=class_name)
            return model_code.strip() or None

        except Exception:  # noqa: BLE001
            return None

callable instance-attribute

callable: Callable

Tool to generate code for.

name property

name: str

Name of the tool.

name_override class-attribute instance-attribute

name_override: str | None = None

Name of the tool.

schema instance-attribute

schema: OpenAIFunctionTool

Schema of the tool.

from_tool classmethod

from_tool(tool: Tool) -> CodeGenerator

Create a CodeGenerator from a Tool.

Source code in src/llmling_agent/resource_providers/codemode/generator.py

@classmethod
def from_tool(cls, tool: Tool) -> CodeGenerator:
    """Create a CodeGenerator from a Tool."""
    return cls(schema=tool.schema, callable=tool.callable, name_override=tool.name)

get_function_signature

get_function_signature() -> str

Extract function signature using schemez.

Source code in src/llmling_agent/resource_providers/codemode/generator.py

def get_function_signature(self) -> str:
    """Extract function signature using schemez."""
    try:
        return_model_name = self._get_return_model_name()
        return self._extract_basic_signature(return_model_name)
    except Exception:  # noqa: BLE001
        return self._extract_basic_signature("Any")