esbmc_ai 0.5.2.dev2__tar.gz → 0.5.2.dev4__tar.gz

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esbmc_ai
-Version: 0.5.2.dev2
+Version: 0.5.2.dev4
 Summary: LLM driven development and automatic repair kit.
 Project-URL: Documentation, https://github.com/esbmc/esbmc-ai/wiki
 Project-URL: Homepage, https://github.com/esbmc/esbmc-ai

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/__about__.py

@@ -1,4 +1,4 @@
 # Author: Yiannis Charalambous
 
-__version__ = "0.5.2.dev2"
+__version__ = "0.5.2.dev4"
 __author__: str = "Yiannis Charalambous"

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/ai_models.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 from uuid import UUID
-from langchain_core.messages import BaseMessage
+from langchain_core.messages import AIMessage, BaseMessage
 from langchain_core.outputs import ChatGeneration, Generation, LLMResult
 from typing_extensions import override
 import structlog
@@ -26,12 +26,17 @@ class LoggingCallbackHandler(BaseCallbackHandler):
             category=LogCategories.CHAT,
             prefix_name=ai_model,
         )
+        # Track last printed message index per group: {group_idx: last_msg_idx}
+        self._last_printed_idx: dict[int, int] = {}
 
     @staticmethod
     def _get_msg_formatted(
         group_idx: int, msg_idx: int, msg: BaseMessage | Generation
     ) -> str:
-        return f"MSG {group_idx}-{msg_idx} {msg.type.capitalize()}: {msg.text}"
+        base: str = f"MSG {group_idx}-{msg_idx} {msg.type.capitalize()}:"
+        if isinstance(msg, AIMessage) and msg.tool_calls:
+            return f"{base} <message-body>{msg.text}</message-body>\nTool Call: {msg.tool_calls}"
+        return f"{base} <message-body>{msg.text}</message-body>"
 
     # @override
     # def on_llm_start(
@@ -134,12 +139,16 @@ class LoggingCallbackHandler(BaseCallbackHandler):
         _ = run_id, parent_run_id, tags, metadata, kwargs
         self.logger.debug("=" * 80)
         self.logger.debug("Invoke Chat Model LLM")
-        for idx, msg_group in enumerate(messages):
+        for group_idx, msg_group in enumerate(messages):
+            last_printed = self._last_printed_idx.get(group_idx, -1)
             self.logger.debug("=" * 80)
-            for msg_idx, msg in enumerate(msg_group):
-                self.logger.debug(self._get_msg_formatted(idx, msg_idx, msg))
+            for msg_idx, msg in enumerate(
+                msg_group[last_printed + 1 :], start=last_printed + 1
+            ):
+                self.logger.debug(self._get_msg_formatted(group_idx, msg_idx, msg))
                 if msg_idx < len(msg_group) - 1:
                     self.logger.debug("-" * 80)
+            self._last_printed_idx[group_idx] = len(msg_group) - 1
 
 
 class AIModel:
@@ -154,9 +163,7 @@ class AIModel:
         temperature: float | None = None,
         url: str | None = None,
     ) -> BaseChatModel:
-        handler: BaseCallbackHandler = LoggingCallbackHandler(
-            ai_model=f"{provider}:{model}"
-        )
+        handler: BaseCallbackHandler = LoggingCallbackHandler(ai_model=model)
 
         chat_model: BaseChatModel = init_chat_model(
             model=model,

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/chats/key_template_renderer.py

@@ -3,16 +3,51 @@
 """Template renderer that integrates TemplateKeyProvider with ChatPromptTemplate."""
 
 from typing import Any, Sequence, override
+from jinja2.sandbox import SandboxedEnvironment
 from langchain_core.messages import BaseMessage
 from langchain_core.prompt_values import ChatPromptValue
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.prompts.chat import MessageLikeRepresentation
-from langchain_core.prompts.string import PromptTemplateFormat
-from pydantic import PrivateAttr
+from langchain_core.prompts.string import PromptTemplateFormat, DEFAULT_FORMATTER_MAPPING
+from pydantic import PrivateAttr, BaseModel
 from esbmc_ai.chats.template_key_provider import TemplateKeyProvider
 from .template_funcs import get_func_mapping
 
 
+class _PermissiveSandboxedEnvironment(SandboxedEnvironment):
+    """Custom Jinja2 sandbox that allows attribute access on trusted objects.
+
+    This environment allows attribute access on Pydantic models and other
+    trusted objects while still providing basic sandboxing protections.
+    """
+
+    def is_safe_attribute(self, obj: Any, attr: str, value: Any) -> bool:
+        """Allow attribute access on Pydantic models and common types."""
+        # Allow attribute access on Pydantic models
+        if isinstance(obj, BaseModel):
+            return True
+        # Allow attribute access on dicts, lists, and other safe types
+        if isinstance(obj, (dict, list, tuple, str, int, float, bool, type(None))):
+            return True
+        # Default to parent's behavior for other types
+        return super().is_safe_attribute(obj, attr, value)
+
+
+def _permissive_jinja2_formatter(template: str, **kwargs: Any) -> str:
+    """Format a template using a permissive Jinja2 sandbox.
+
+    Unlike LangChain's default restricted sandbox, this allows attribute
+    access on trusted objects like Pydantic models.
+    """
+    env = _PermissiveSandboxedEnvironment()
+    return env.from_string(template).render(**kwargs)
+
+
+# Override LangChain's default jinja2 formatter with our permissive one
+# This allows nested attribute access on Pydantic models in templates
+DEFAULT_FORMATTER_MAPPING["jinja2"] = _permissive_jinja2_formatter
+
+
 class KeyTemplateRenderer(ChatPromptTemplate):
     """Derives ChatPromptTemplate and automatically provides template keys via
     TemplateKeyProvider. This is to force standarization across types and keys."""

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/commands/fix_code_command.py

@@ -130,11 +130,10 @@ class FixCodeCommand(ChatCommand):
         )
         # Handle kwargs
         source_file: SourceFile = SourceFile.load(
-            self.global_config.solution.filenames[0],
-            Path(os.getcwd()),
+            self.global_config.solution.filenames[0]
         )
         self.original_source_file = SourceFile(
-            source_file.file_path, source_file.base_path, source_file.content
+            file_path=source_file.file_path, content=source_file.content
         )
         self.anim = (
             LoadingWidget() if self.global_config.loading_hints else BaseLoadingWidget()

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/log_handlers.py

@@ -62,7 +62,7 @@ class CategoryFileHandler(logging.Handler):
         if isinstance(category, Enum):
             category = category.value
 
-        assert isinstance(category, str)
+        assert isinstance(category, str), f"Category is not string: {category}"
 
         # Skip uncategorized if desired
         if (

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/solution.py

@@ -2,7 +2,8 @@
 
 """Keeps track of all the source files that ESBMC-AI is targeting."""
 
-from os import getcwd, walk
+from os import walk
+from os.path import commonpath
 from pathlib import Path
 from subprocess import PIPE, STDOUT, run, CompletedProcess
 from tempfile import NamedTemporaryFile, TemporaryDirectory
@@ -13,8 +14,9 @@ from langchain_core.language_models import BaseChatModel
 from langchain_core.load.serializable import Serializable
 from pydantic import Field, PrivateAttr
 import lizard
+from structlog.stdlib import get_logger
 
-from esbmc_ai.log_utils import get_log_level, print_horizontal_line
+from esbmc_ai.log_utils import LogCategories, get_log_level, print_horizontal_line
 
 _SourceFileFormatStyles = Literal["markdown", "xml", "plain"]
 
@@ -46,8 +48,7 @@ class SourceFile(Serializable):
     """Represents a source file in the Solution. Contains methods to manipulate
     and get information about different versions."""
 
-    file_path: Path = Field(description="Relative file path")
-    base_path: Path = Field(description="Base directory path")
+    file_path: Path = Field(description="Absolute file path")
     content: str = Field(description="File content")
 
     @staticmethod
@@ -71,28 +72,23 @@ class SourceFile(Serializable):
         return "\n".join(lines)
 
     @staticmethod
-    def load(file_path: Path, base_path: Path) -> "SourceFile":
+    def load(file_path: Path) -> "SourceFile":
         """Creates a new source file by loading the content from disk."""
-        if file_path.is_relative_to(base_path):
-            file_path = file_path.relative_to(base_path)
-        with open(base_path / file_path, "r") as file:
-            return SourceFile(file_path, base_path, file.read())
+        abs_path = file_path.absolute()
+        with open(abs_path, "r") as file:
+            return SourceFile(file_path=abs_path, content=file.read())
 
     def __init__(
         self,
         file_path: Path,
-        base_path: Path,
         content: str,
         **kwargs: Any,
     ) -> None:
-        if file_path.is_absolute():
-            raise ValueError(
-                f"SourceFile requires a relative file path, got absolute: {file_path}. "
-                f"Use SourceFile.load() to create from absolute paths."
-            )
+        # Ensure path is absolute
+        if not file_path.is_absolute():
+            file_path = file_path.absolute()
         super().__init__(
             file_path=file_path,
-            base_path=base_path,
             content=content,
             **kwargs,
         )
@@ -105,11 +101,6 @@ class SourceFile(Serializable):
     def __str__(self) -> str:
         return f"SourceFile({self.file_path})"
 
-    @property
-    def abs_path(self) -> Path:
-        """Returns the abs path"""
-        return self.base_path / self.file_path
-
     @property
     def file_extension(self) -> str:
         """Returns the file extension to the file."""
@@ -199,10 +190,10 @@ class SourceFile(Serializable):
     def verify_file_integrity(self) -> bool:
         """Verifies that this file matches with the file on disk and does not
         contain any differences."""
-        if not (self.abs_path.exists() and self.abs_path.is_file()):
+        if not (self.file_path.exists() and self.file_path.is_file()):
             return False
 
-        with open(self.abs_path, "r") as file:
+        with open(self.file_path, "r") as file:
             content: str = str(file.read())
 
         return content == self.content
@@ -233,6 +224,7 @@ class SourceFile(Serializable):
         style: _SourceFileFormatStyles = "markdown",
         include_line_numbers: bool = False,
         max_lines: int | None = None,
+        working_dir: Path | None = None,
     ) -> str:
         """Flexible formatting with options for use in LangChain prompts.
 
@@ -262,12 +254,15 @@ class SourceFile(Serializable):
             content = "\n".join(f"{i+1:4d} | {line}" for i, line in enumerate(lines))
 
         # Format based on style
+        show_path: Path = (
+            self.file_path.relative_to(working_dir) if working_dir else self.file_path
+        )
         if style == "markdown":
-            result = f"{self.file_path}\n```{lang}\n{content}\n```"
+            result = f"{show_path}\n```{lang}\n{content}\n```"
         elif style == "xml":
-            result = f"<file path='{self.file_path}'>\n{content}\n</file>"
+            result = f"<file path='{show_path}'>\n{content}\n</file>"
         elif style == "plain":
-            result = f"File: {self.file_path}\n{content}"
+            result = f"File: {show_path}\n{content}"
 
         return result
 
@@ -276,84 +271,96 @@ class Solution(Serializable):
     """Represents a solution, that is a collection of all the source files that
     ESBMC-AI will be involved in analyzing."""
 
-    base_dir: Path = Field(description="Base directory path")
     _files: list[SourceFile] = PrivateAttr(default_factory=list)
-    _include_dirs: dict[Path, list[SourceFile]] = PrivateAttr(default_factory=dict)
+    _include_dirs: list[Path] = PrivateAttr(default_factory=list)
 
     @staticmethod
-    def from_dir(
-        path: Path,
-        file_paths: list[Path] | None = None,
+    def from_paths(
+        *paths: Path,
         include_dirs: list[Path] | None = None,
     ) -> "Solution":
-        """Creates a solution from a base directory. Can append with files manually."""
-        path = path.absolute()
+        """Creates a solution from one or more paths (files or directories).
 
-        if file_paths:
-            return Solution(files=file_paths, base_dir=path, include_dirs=include_dirs)
+        Directories are scanned recursively for all files.
 
+        Args:
+            *paths: One or more file or directory paths
+            include_dirs: Optional include directories for C/C++ compilation
+
+        Example:
+            Solution.from_paths(Path("file1.c"), Path("file2.c"))
+            Solution.from_paths(Path("/project"))
+            Solution.from_paths(Path("src"), Path("tests/test.c"))
+        """
         result: list[Path] = []
-        for dir_path, _, files in walk(path):
-            result.extend(Path(dir_path) / file for file in files)
 
-        return Solution(files=result, base_dir=path, include_dirs=include_dirs)
+        for path in paths:
+            abs_path = path.absolute()
+            if abs_path.is_file():
+                result.append(abs_path)
+            elif abs_path.is_dir():
+                for dir_path, _, files in walk(abs_path):
+                    result.extend(Path(dir_path) / file for file in files)
+            else:
+                raise ValueError(
+                    f"Path does not exist or is neither file nor directory: {path}"
+                )
+
+        return Solution(files=result, include_dirs=include_dirs)
 
     def __init__(
         self,
         files: list[Path] | None = None,
-        base_dir: Path = Path(getcwd()),
         include_dirs: list[Path] | None = None,
         **kwargs: Any,
     ) -> None:
-        """Creates a new solution with a base directory."""
-        super().__init__(base_dir=base_dir, **kwargs)
+        """Creates a new solution from file paths."""
+        super().__init__(**kwargs)
 
         # Initialize private attributes
         self._files = []
-        self._include_dirs = {}
+        self._include_dirs = []
 
         # If files are loaded
         if files:
             for file_path in files:
-                # Check if file exists (handle both absolute and relative paths)
-                full_path = (
-                    file_path
-                    if file_path.is_absolute()
-                    else (self.base_dir / file_path)
+                # Convert to absolute path
+                abs_path = (
+                    file_path if file_path.is_absolute() else file_path.absolute()
                 )
-                if not full_path.is_file():
+                if not abs_path.is_file():
                     raise ValueError(f"Path is not a file: {file_path}")
-                # load_source_file() only accepts relative paths, so we need to
-                # normalize absolute paths to relative ones here
-                if file_path.is_absolute():
-                    if file_path.is_relative_to(self.base_dir):
-                        file_path = file_path.relative_to(self.base_dir)
-                    else:
-                        raise ValueError(
-                            f"File path '{file_path}' is not within base directory '{self.base_dir}'"
-                        )
-                self.load_source_file(file_path)
+                self._files.append(SourceFile.load(abs_path))
 
         if include_dirs:
             for d in include_dirs:
-                if not d.is_dir():
+                abs_dir = d if d.is_absolute() else d.absolute()
+                if not abs_dir.is_dir():
                     raise ValueError(f"Path is not a directory: {d}")
-                include_files: list[Path] = [p for p in d.rglob("*") if p.is_file()]
-                self._include_dirs[d] = [
-                    SourceFile.load(file_path=p, base_path=self.base_dir)
-                    for p in include_files
-                ]
+                self._include_dirs.append(abs_dir)
 
     @property
-    def include_dirs(self) -> dict[Path, list[SourceFile]]:
-        """Used by C based verifiers."""
-        return self._include_dirs
+    def include_dirs(self) -> list[Path]:
+        """Include directories for C based verifiers."""
+        return list(self._include_dirs)
 
     @property
     def files(self) -> list[SourceFile]:
         """Will return a list of the files. Returns by value."""
         return list(self._files)
 
+    @property
+    def working_dir(self) -> Path:
+        """Computes the common parent directory of all files."""
+        if not self._files:
+            return Path.cwd()
+
+        paths = [str(f.file_path) for f in self._files]
+        common = commonpath(paths)
+
+        # If only one file, commonpath returns the file itself, so use parent
+        return Path(common).parent if len(paths) == 1 else Path(common)
+
     def get_files_by_ext(self, included_ext: list[str]) -> list[SourceFile]:
         """Gets the files that are only specified in the included extensions. File
         extensions that have a . prefix are trimmed so they still work."""
@@ -401,43 +408,48 @@ class Solution(Serializable):
         """Saves the solution in a temporary directory it creates while preserving
         the file structure."""
         with TemporaryDirectory(
-            prefix="esbmc-ai", suffix=self.base_dir.name, delete=False
+            prefix="esbmc-ai-", suffix="-" + self.working_dir.name, delete=False
         ) as temp_dir:
             return self.save_solution(Path(temp_dir))
 
     def save_solution(self, path: Path) -> "Solution":
-        """Saves the solution to path, and then returns it. The solution's base
-        directory is replaced by the final component of path."""
-        base_dir_path: Path = path
+        """Saves the solution to path, preserving relative structure.
+
+        Files are saved relative to their common parent (working_dir)."""
+        get_logger().bind(category=LogCategories.SYSTEM).info(
+            f"Saving solution to {path}"
+        )
+
+        dest_path: Path = path.absolute()
+        dest_path.mkdir(parents=True, exist_ok=True)
+
+        # Get common parent to preserve relative structure
+        common_parent = self.working_dir
 
-        # Copy individual source files.
+        # Copy individual source files preserving structure
         new_file_paths: list[Path] = []
         for source_file in self.files:
-            # Handle absolute paths by flattening to just the filename
-            if source_file.file_path.is_absolute():
-                relative_path = Path(source_file.file_path.name)
-            else:
-                relative_path = source_file.file_path
+            # Get path relative to common parent
+            relative_path = source_file.file_path.relative_to(common_parent)
+            new_path: Path = dest_path / relative_path
 
-            new_file_paths.append(relative_path)
-            new_path: Path = base_dir_path / relative_path
             # Write new file
             new_path.parent.mkdir(parents=True, exist_ok=True)
             source_file.save_file(new_path)
+            new_file_paths.append(new_path)
 
-        # Copy include directories there
+        # Copy include directories
+        new_include_dirs: list[Path] = []
         for d in self.include_dirs:
-            new_dir: Path = base_dir_path / d
+            new_dir: Path = dest_path / d.name
             copytree(src=d, dst=new_dir, symlinks=True, dirs_exist_ok=True)
+            new_include_dirs.append(new_dir)
 
-        sol = Solution(
+        return Solution(
             files=new_file_paths,
-            base_dir=Path(base_dir_path),
-            include_dirs=list(self.include_dirs.keys()),
+            include_dirs=new_include_dirs,
         )
 
-        return sol
-
     def verify_solution_integrity(self) -> bool:
         """Verifies if the content of the solution match with the files on disk.
         If that's not the case, then the solution should be saved on disk before
@@ -467,23 +479,9 @@ class Solution(Serializable):
                 self.load_source_file(f)
 
     def load_source_file(self, file_path: Path) -> None:
-        """Add a source file to the solution. If content is provided then it will
-        not be loaded."""
-        # Get the relative path to the base dir.
-        if file_path.is_absolute():
-            raise ValueError(
-                f"Cannot load absolute path '{file_path}' into Solution. "
-                f"All file paths must be relative to the base directory '{self.base_dir}'. "
-                f"This is an internal error - paths should be normalized before reaching this point."
-            )
-        with open(self.base_dir / file_path, "r") as file:
-            self._files.append(
-                SourceFile(
-                    file_path=file_path,
-                    base_path=self.base_dir,
-                    content=file.read(),
-                )
-            )
+        """Add a source file to the solution by loading it from disk."""
+        abs_path = file_path if file_path.is_absolute() else file_path.absolute()
+        self._files.append(SourceFile.load(abs_path))
 
     def get_diff(self, other: "Solution") -> str:
         """Gets the diff with another solution. The following params are used: -ruN"""
@@ -495,10 +493,10 @@ class Solution(Serializable):
             other.save_temp()
 
         cmd = [
-            "patch",
+            "diff",
             "-ruN",  # (r)ecursive, (u) additional context, (N) treat absent files as empty
-            self.base_dir,
-            other.base_dir,
+            str(self.working_dir),
+            str(other.working_dir),
         ]
 
         process: CompletedProcess = run(
@@ -512,11 +510,18 @@ class Solution(Serializable):
         # https://askubuntu.com/questions/698784/exit-code-of-diff
         if process.returncode == 2:
             raise ValueError(
-                f"Diff for {self.base_dir} and {other.base_dir} failed (exit 2)."
+                f"Diff for {self.working_dir} and {other.working_dir} failed (exit 2)."
             )
 
         return process.stdout.decode("utf-8")
 
+    def save_diff(self, path: Path, solution: "Solution") -> Path:
+        """Saves the solution as a patch of the original."""
+        diff: str = self.get_diff(solution)
+        with open(path, "w") as file:
+            file.write(diff)
+        return path
+
     def resolve(self, file: SourceFile | Path) -> SourceFile | None:
         """Resolve a Path or SourceFile to its corresponding SourceFile in the solution.
 
@@ -527,23 +532,14 @@ class Solution(Serializable):
             The SourceFile if found, None otherwise
         """
         if isinstance(file, SourceFile):
-            # For SourceFile, compare by absolute path
-            for f in self._files:
-                if f.abs_path == file.abs_path:
-                    return f
-            return None
-
-        # For Path, handle both absolute and relative
-        path = Path(file)
-        if path.is_absolute():
-            for f in self._files:
-                if f.abs_path == path:
-                    return f
+            search_path = file.file_path
         else:
-            for f in self._files:
-                if f.file_path == path:
-                    return f
+            # Convert to absolute path for comparison
+            search_path = Path(file).absolute()
 
+        for f in self._files:
+            if f.file_path == search_path:
+                return f
         return None
 
     def __contains__(self, file: SourceFile | Path) -> bool:
@@ -574,6 +570,28 @@ class Solution(Serializable):
             raise KeyError(f"Path not found in solution: {path}")
         return result
 
+    def __add__(self, other: "Solution") -> "Solution":
+        """Combine two solutions by merging their files and include directories.
+
+        Args:
+            other: Another Solution instance to combine with this one
+
+        Returns:
+            A new Solution containing all files and include_dirs from both solutions
+
+        Example:
+            solution_c = solution_a + solution_b
+        """
+        if not isinstance(other, Solution):
+            return NotImplemented
+
+        return Solution(
+            # Combine files - create new list to avoid modifying originals
+            files=[source_file.file_path for source_file in self._files + other._files],
+            # Combine include_dirs - deduplicate by converting to set and back
+            include_dirs=list(set(self._include_dirs + other._include_dirs)),
+        )
+
     def patch_solution(self, patch: str) -> None:
         """Patches the solution using the patch command."""
         if not self.verify_solution_integrity():
@@ -586,10 +604,10 @@ class Solution(Serializable):
 
             cmd = [
                 "patch",
-                "-d",  # Change to base dir first
-                self.base_dir,
+                "-d",  # Change to working dir first
+                str(self.working_dir),
                 "-i",  # Flag to specify patch file
-                Path(patch_file.name).absolute(),
+                str(Path(patch_file.name).absolute()),
             ]
 
             process: CompletedProcess = run(
@@ -610,7 +628,7 @@ class Solution(Serializable):
                         + process.stdout.decode("utf-8")
                     )
                     raise ValueError(
-                        f"Patch failed for some files in solution {self.base_dir}"
+                        f"Patch failed for some files in solution {self.working_dir}"
                     )
                 case 2:
                     print_horizontal_line(get_log_level(0))
@@ -619,5 +637,5 @@ class Solution(Serializable):
                         + process.stdout.decode("utf-8")
                     )
                     raise ValueError(
-                        f"Patch failed SERIOUSLY in solution {self.base_dir}"
+                        f"Patch failed SERIOUSLY in solution {self.working_dir}"
                     )

{esbmc_ai-0.5.2.dev2 → esbmc_ai-0.5.2.dev4}/esbmc_ai/verifiers/esbmc.py

@@ -151,7 +151,7 @@ class ESBMCOutputParser:
     @staticmethod
     def _should_include_trace(trace: ProgramTrace, solution: Solution) -> bool:
         """Determine if a trace should be included based on solution files."""
-        return (solution.base_dir / trace.path).exists() and trace.path in solution
+        return (solution.working_dir / trace.path).exists() and trace.path in solution
 
     @staticmethod
     def filter_traces(esbmc_output: "ESBMCOutput", solution: Solution) -> "ESBMCOutput":
@@ -668,7 +668,7 @@ class ESBMC(BaseSourceVerifier):
             str(file.file_path) for file in solution.get_files_by_ext(["c", "cpp"])
         )
         # Header files/dir
-        esbmc_cmd.extend("-I" + str(d) for d in solution.include_dirs.keys())
+        esbmc_cmd.extend("-I" + str(d) for d in solution.include_dirs)
 
         # Add timeout suffix for parameter.
         if timeout:
@@ -686,12 +686,12 @@ class ESBMC(BaseSourceVerifier):
         # Measure execution time
         start_time = perf_counter()
 
-        # Run ESBMC from solution base_dir and get output
+        # Run ESBMC from solution working_dir and get output
         process: CompletedProcess = run(
             esbmc_cmd,
             stdout=PIPE,
             stderr=STDOUT,
-            cwd=solution.base_dir,
+            cwd=solution.working_dir,
             timeout=process_timeout,
             check=False,
         )