kash-shell 0.3.11__py3-none-any.whl → 0.3.13__py3-none-any.whl

kash/file_storage/file_store.py

@@ -5,7 +5,7 @@ import time
 from collections.abc import Callable, Generator
 from os.path import join, relpath
 from pathlib import Path
-from typing import Any, TypeVar
+from typing import Concatenate, ParamSpec, TypeVar
 
 from funlog import format_duration, log_calls
 from prettyfmt import fmt_lines, fmt_path
@@ -13,13 +13,13 @@ from strif import copyfile_atomic, hash_file, move_file
 from typing_extensions import override
 
 from kash.config.logger import get_log_settings, get_logger
-from kash.config.text_styles import EMOJI_SAVED, STYLE_HINT
+from kash.config.text_styles import EMOJI_SAVED
 from kash.file_storage.item_file_format import read_item, write_item
 from kash.file_storage.metadata_dirs import MetadataDirs
 from kash.file_storage.store_filenames import folder_for_type, join_suffix, parse_item_filename
 from kash.model.items_model import Item, ItemId, ItemType
 from kash.model.paths_model import StorePath
-from kash.shell.output.shell_output import PrintHooks, cprint
+from kash.shell.output.shell_output import PrintHooks
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.uniquifier import Uniquifier
 from kash.utils.common.url import Locator, Url, is_url
@@ -34,16 +34,18 @@ from kash.workspaces.workspaces import Workspace
 log = get_logger(__name__)
 
 
+SelfT = TypeVar("SelfT")
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
-def synchronized(method: Callable[..., T]) -> Callable[..., T]:
+def synchronized(method: Callable[Concatenate[SelfT, P], T]) -> Callable[Concatenate[SelfT, P], T]:
     """
     Simple way to synchronize a few methods.
     """
 
     @functools.wraps(method)
-    def synchronized_method(self, *args: Any, **kwargs: Any) -> T:
+    def synchronized_method(self, *args: P.args, **kwargs: P.kwargs) -> T:
         with self._lock:
             return method(self, *args, **kwargs)
 
@@ -180,12 +182,37 @@ class FileStore(Workspace):
         except (FileNotFoundError, InvalidFilename):
             pass
 
+    def resolve_path(self, path: Path | StorePath) -> StorePath | None:
+        """
+        Return a StorePath if the given path is within the store, otherwise None.
+        If it is already a StorePath, return it unchanged.
+        """
+        if isinstance(path, StorePath):
+            return path
+        resolved = path.resolve()
+        if resolved.is_relative_to(self.base_dir):
+            return StorePath(resolved.relative_to(self.base_dir))
+        else:
+            return None
+
+    def exists(self, store_path: StorePath) -> bool:
+        """
+        Check given store path refers to an existing file.
+        """
+        return (self.base_dir / store_path).exists()
+
     @synchronized
-    def _new_filename_for(self, item: Item) -> tuple[str, str | None]:
+    def _pick_filename_for(self, item: Item, *, overwrite: bool = False) -> tuple[str, str | None]:
         """
-        Get a suitable filename for this item that is close to the slugified title yet also unique.
-        Also return the old filename if it's different.
+        Get a suitable filename for this item.
+        If `overwrite` is true, use the the slugified title.
+        If it is false, use the slugified title with a suffix to make it unique
+        and in this case returns the old filename for this item, if it is different.
         """
+        if overwrite:
+            log.info("Picked default filename: %s for item: %s", item.default_filename(), item)
+            return item.default_filename(), None
+
         slug = item.slug_name()
         full_suffix = item.get_full_suffix()
         # Get a unique name per item type.
@@ -196,29 +223,15 @@ class FileStore(Workspace):
 
         old_filename = join_suffix(old_slugs[0], full_suffix) if old_slugs else None
 
+        log.info("Picked new unique filename: %s for item: %s", new_unique_filename, item)
         return new_unique_filename, old_filename
 
-    def _default_path_for(self, item: Item) -> StorePath:
-        folder_path = folder_for_type(item.type)
-        slug = item.slug_name()
-        suffix = item.get_full_suffix()
-        return StorePath(folder_path / join_suffix(slug, suffix))
-
-    def exists(self, store_path: StorePath) -> bool:
-        return (self.base_dir / store_path).exists()
-
-    def resolve_path(self, path: Path | StorePath) -> StorePath | None:
+    def default_path_for(self, item: Item) -> StorePath:
         """
-        Return a StorePath if the given path is within the store, otherwise None.
-        If it is already a StorePath, return it unchanged.
+        Get the default store path for an item based on slugifying its title or other metadata.
         """
-        if isinstance(path, StorePath):
-            return path
-        resolved = path.resolve()
-        if resolved.is_relative_to(self.base_dir):
-            return StorePath(resolved.relative_to(self.base_dir))
-        else:
-            return None
+        folder_path = folder_for_type(item.type)
+        return StorePath(folder_path / item.default_filename())
 
     @synchronized
     def find_by_id(self, item: Item) -> StorePath | None:
@@ -233,7 +246,7 @@ class FileStore(Workspace):
             store_path = self.id_map.get(item_id)
             if not store_path:
                 # Just in case the id_map is not complete, check the default path too.
-                default_path = self._default_path_for(item)
+                default_path = self.default_path_for(item)
                 if self.exists(default_path):
                     old_item = self.load(default_path)
                     if old_item.item_id() == item_id:
@@ -254,7 +267,7 @@ class FileStore(Workspace):
 
     @synchronized
     def store_path_for(
-        self, item: Item, as_tmp: bool = False
+        self, item: Item, *, as_tmp: bool = False, overwrite: bool = False
     ) -> tuple[StorePath, bool, StorePath | None]:
         """
         Return the store path for an item. If the item already has a `store_path`, we use that.
@@ -263,6 +276,10 @@ class FileStore(Workspace):
         Returns `store_path, found, old_store_path` where `found` indicates whether the path was
         already found (in the item or in the store by checking for identity) and `old_store_path`
         is the previous similarly named item with a different identity (or None there is none).
+
+        If `as_tmp` is true, will return a path from the temporary directory in the store.
+        Normally an item is always saved to a unique store path but if `overwrite` is true,
+        will always save to the same path
         """
         item_id = item.item_id()
         old_filename = None
@@ -279,9 +296,9 @@ class FileStore(Workspace):
             )
             return store_path, True, None
         else:
-            # We need to generate a new filename.
+            # We need to pick the path and filename.
             folder_path = folder_for_type(item.type)
-            filename, old_filename = self._new_filename_for(item)
+            filename, old_filename = self._pick_filename_for(item, overwrite=overwrite)
             store_path = folder_path / filename
 
             old_store_path = None
@@ -310,16 +327,33 @@ class FileStore(Workspace):
 
     @log_calls()
     def save(
-        self, item: Item, *, overwrite: bool = True, as_tmp: bool = False, no_format: bool = False
+        self,
+        item: Item,
+        *,
+        overwrite: bool = False,
+        skip_dup_names: bool = False,
+        as_tmp: bool = False,
+        no_format: bool = False,
     ) -> StorePath:
         """
         Save the item. Uses the `store_path` if it's already set or generates a new one.
         Updates `item.store_path`.
 
+        Unless `no_format` is true, also normalizes body text formatting (for Markdown)
+        and updates the item's body to match.
+
+        If `overwrite` is true, will overwrite a file that has the same path.
+
         If `as_tmp` is true, will save the item to a temporary file.
-        If `overwrite` is false, will skip saving if the item already exists.
-        If `no_format` is true, will not normalize body text formatting (for Markdown).
+
+        If `skip_dup_names` is true, will skip saving if an item if an item with a
+        matching path (based on its title) already exists.
         """
+        if overwrite and skip_dup_names:
+            raise ValueError("Cannot both overwrite and skip duplicate names.")
+        if overwrite and as_tmp:
+            raise ValueError("Cannot both overwrite and save to a temporary file.")
+
         # If external file already exists within the workspace, the file is already saved (without metadata).
         external_path = item.external_path and Path(item.external_path).resolve()
         if external_path and self._is_in_store(external_path):
@@ -331,10 +365,15 @@ class FileStore(Workspace):
             return StorePath(rel_path)
         else:
             # Otherwise it's still in memory or in a file outside the workspace and we need to save it.
-            store_path, found, old_store_path = self.store_path_for(item, as_tmp=as_tmp)
+            store_path, found, old_store_path = self.store_path_for(
+                item, as_tmp=as_tmp, overwrite=overwrite
+            )
 
-            if not overwrite and found:
-                log.message("Skipping save of item already saved: %s", fmt_loc(store_path))
+            if skip_dup_names and found:
+                log.message(
+                    "Skipping save because an item of the same name already exists: %s",
+                    fmt_loc(store_path),
+                )
                 item.store_path = str(store_path)
                 return store_path
 
@@ -352,8 +391,14 @@ class FileStore(Workspace):
             # Now save the new item.
             try:
                 if item.external_path:
-                    copyfile_atomic(item.external_path, full_path)
+                    copyfile_atomic(item.external_path, full_path, make_parents=True)
                 else:
+                    if overwrite and full_path.exists():
+                        log.info(
+                            "Overwrite is enabled and a previous file exists so will archive it: %s",
+                            fmt_loc(store_path),
+                        )
+                        self.archive(store_path, quiet=True)
                     write_item(item, full_path, normalize=not no_format)
             except OSError as e:
                 log.error("Error saving item: %s", e)
@@ -475,7 +520,6 @@ class FileStore(Workspace):
                 store_path = self.save(item)
                 log.info("Imported text file: %s", item.as_str())
             else:
-                log.message("Importing non-text file: %s", fmt_loc(path))
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
                 store_path, _found, old_store_path = self.store_path_for(item)
@@ -586,12 +630,13 @@ class FileStore(Workspace):
         move_file(full_input_path, original_path)
         return StorePath(store_path)
 
-    def log_workspace_info(self, *, once: bool = False):
+    @synchronized
+    def log_workspace_info(self, *, once: bool = False) -> bool:
         """
         Log helpful information about the workspace.
         """
         if once and self.info_logged:
-            return
+            return False
 
         self.info_logged = True
 
@@ -606,25 +651,18 @@ class FileStore(Workspace):
             fmt_path(get_log_settings().log_file_path.absolute(), rel_to_cwd=False),
         )
         log.message(
-            "Media cache: %s", fmt_path(self.base_dir / self.dirs.media_cache_dir, rel_to_cwd=False)
-        )
-        log.message(
-            "Content cache: %s",
+            "Caches: %s, %s",
+            fmt_path(self.base_dir / self.dirs.media_cache_dir, rel_to_cwd=False),
             fmt_path(self.base_dir / self.dirs.content_cache_dir, rel_to_cwd=False),
         )
+        log.message("Current working directory: %s", fmt_path(Path.cwd(), rel_to_cwd=False))
+
         for warning in self.warnings:
             log.warning("%s", warning)
 
-        if self.is_global_ws:
-            PrintHooks.spacer()
-            log.warning("Note you are currently using the default global workspace.")
-            cprint(
-                "Create or switch to another workspace with the `workspace` command.",
-                style=STYLE_HINT,
-            )
-
         log.info("File store startup took %s.", format_duration(self.end_time - self.start_time))
         # TODO: Log more info like number of items by type.
+        return True
 
     def walk_items(
         self,

kash/file_storage/item_file_format.py

@@ -7,10 +7,10 @@ from prettyfmt import custom_key_sort, fmt_size_human
 from kash.config.logger import get_logger
 from kash.model.items_model import ITEM_FIELDS, Item
 from kash.model.operations_model import OPERATION_FIELDS
-from kash.text_handling.doc_normalization import normalize_formatting_ansi
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.file_utils.mtime_cache import MtimeCache
+from kash.utils.text_handling.doc_normalization import normalize_formatting
 
 log = get_logger(__name__)
 
@@ -25,7 +25,7 @@ _item_cache = MtimeCache[Item](max_size=2000, name="Item")
 def write_item(item: Item, path: Path, normalize: bool = True):
     """
     Write a text item to a file with standard frontmatter format YAML.
-    Also normalizes formatting of the body text.
+    By default normalizes formatting of the body text and updates the item's body.
     """
     item.validate()
     if item.is_binary:
@@ -37,7 +37,7 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     _item_cache.delete(path)
 
     if normalize:
-        body = normalize_formatting_ansi(item.body_text(), item.format)
+        body = normalize_formatting(item.body_text(), item.format)
     else:
         body = item.body_text()
 
@@ -79,6 +79,9 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     # Update cache.
     _item_cache.update(path, item)
 
+    # Update the item's body to reflect normalization.
+    item.body = body
+
 
 def read_item(path: Path, base_dir: Path | None) -> Item:
     """

kash/file_storage/store_filenames.py

@@ -1,15 +1,19 @@
+from functools import cache
 from pathlib import Path
 
+from prettyfmt import plural
+
 from kash.config.logger import get_logger
 from kash.model.items_model import ItemType
 from kash.utils.file_utils.file_formats_model import FileExt, Format
 from kash.utils.file_utils.filename_parsing import split_filename
-from kash.utils.lang_utils.inflection import plural
 
 log = get_logger(__name__)
 
 
-_type_to_folder = {name: plural(name) for name, _value in ItemType.__members__.items()}
+@cache
+def _get_type_to_folder() -> dict[str, str]:
+    return {name: plural(name) for name, _value in ItemType.__members__.items()}
 
 
 def folder_for_type(item_type: ItemType) -> Path:
@@ -22,7 +26,7 @@ def folder_for_type(item_type: ItemType) -> Path:
     export -> exports
     etc.
     """
-    return Path(_type_to_folder[item_type.name])
+    return Path(_get_type_to_folder()[item_type.name])
 
 
 def join_suffix(base_slug: str, full_suffix: str) -> str:

kash/help/help_embeddings.py

@@ -62,9 +62,9 @@ class HelpIndex:
             embeddings.to_npz(target_path)
 
         key = f"kash_help_embeddings_v1_{len(self.docs)}.npz"
-        path, _ = cache_file(
+        path = cache_file(
             Loadable(key, save=calculate_and_save_help_embeddings), global_cache=True
-        )
+        ).content.path
         log.info("Loaded help doc embeddings from: %s", path)
         return Embeddings.read_from_npz(path)
 

kash/llm_utils/clean_headings.py

@@ -1,6 +1,6 @@
 from kash.llm_utils import Message, MessageTemplate, llm_template_completion
 from kash.llm_utils.llms import LLM
-from kash.text_handling.markdown_utils import as_bullet_points
+from kash.utils.text_handling.markdown_utils import as_bullet_points
 
 # TODO: Enforce that the edits below doesn't contain anything extraneous.
 

kash/{text_handling → llm_utils}/custom_sliding_transforms.py

@@ -31,9 +31,6 @@ log = get_logger(__name__)
 # more customized logging and task stack.
 
 
-log = get_logger(__name__)
-
-
 def filtered_transform(
     doc: TextDoc,
     transform_func: TextDocTransform,

kash/llm_utils/init_litellm.py

@@ -0,0 +1,16 @@
+from functools import cache
+
+
+@cache
+def init_litellm():
+    """
+    Configure litellm to suppress overly prominent exception messages.
+    Do this lazily since litellm is slow to import.
+    """
+    try:
+        import litellm
+        from litellm import _logging  # noqa: F401
+
+        litellm.suppress_debug_info = True  # Suppress overly prominent exception messages.
+    except ImportError:
+        pass

kash/llm_utils/llm_api_keys.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-import litellm
 from clideps.env_vars.dotenv_utils import env_var_is_set
 from clideps.env_vars.env_names import EnvName
-from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
 
+from kash.llm_utils.init_litellm import init_litellm
 from kash.llm_utils.llm_names import LLMName
 from kash.llm_utils.llms import LLM
 
@@ -13,6 +12,11 @@ def api_for_model(model: LLMName) -> EnvName | None:
     """
     Get the API key name for a model or None if not found.
     """
+    import litellm
+    from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
+
+    init_litellm()
+
     try:
         _model, custom_llm_provider, _dynamic_api_key, _api_base = get_llm_provider(model)
     except litellm.exceptions.BadRequestError:

kash/llm_utils/llm_completion.py

@@ -1,24 +1,27 @@
+from __future__ import annotations
+
 import time
-from typing import cast
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
 
-import litellm
 from flowmark import Wrap, fill_text
 from funlog import format_duration, log_calls
-from litellm.types.utils import Choices, ModelResponse
-from litellm.types.utils import Message as LiteLLMMessage
 from prettyfmt import slugify_snake
 from pydantic import BaseModel
-from pydantic.dataclasses import dataclass
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import EMOJI_TIMING
 from kash.llm_utils.fuzzy_parsing import is_no_results
+from kash.llm_utils.init_litellm import init_litellm
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.llm_utils.llm_names import LLMName
 from kash.utils.common.url import Url, is_url
 from kash.utils.errors import ApiResultError
 from kash.utils.file_formats.chat_format import ChatHistory, ChatMessage, ChatRole
 
+if TYPE_CHECKING:
+    from litellm.types.utils import Message as LiteLLMMessage
+
 log = get_logger(__name__)
 
 
@@ -68,6 +71,10 @@ def llm_completion(
     """
     Perform an LLM completion with LiteLLM.
     """
+    import litellm
+    from litellm.types.utils import Choices, ModelResponse
+
+    init_litellm()
 
     chat_history = ChatHistory.from_dicts(messages)
     log.info(

kash/local_server/__init__.py

@@ -2,4 +2,4 @@ from pathlib import Path
 
 from kash.exec.importing import import_and_register
 
-import_and_register(__package__, Path(__file__).parent, ["."])
+import_and_register(__package__, Path(__file__).parent, ["local_server_commands"])

kash/local_server/local_server_commands.py

@@ -1,7 +1,6 @@
 from kash.config.logger import get_logger
 from kash.config.settings import global_settings
 from kash.exec import kash_command
-from kash.local_server.local_url_formatters import enable_local_urls
 from kash.shell.utils.native_utils import tail_file
 from kash.utils.errors import InvalidState
 
@@ -17,6 +16,7 @@ def start_ui_server() -> None:
     tooltips.
     """
     from kash.local_server.local_server import start_ui_server
+    from kash.local_server.local_url_formatters import enable_local_urls
 
     start_ui_server()
     enable_local_urls(True)
@@ -28,6 +28,7 @@ def stop_ui_server() -> None:
     Stop the kash local server.
     """
     from kash.local_server.local_server import stop_ui_server
+    from kash.local_server.local_url_formatters import enable_local_urls
 
     stop_ui_server()
     enable_local_urls(False)

kash/mcp/__init__.py

@@ -2,4 +2,4 @@ from pathlib import Path
 
 from kash.exec.importing import import_and_register
 
-import_and_register(__package__, Path(__file__).parent, ["."])
+import_and_register(__package__, Path(__file__).parent, ["mcp_server_commands"])

kash/mcp/mcp_cli.py

@@ -9,9 +9,10 @@ import logging
 import os
 from pathlib import Path
 
+from clideps.utils.readable_argparse import ReadableColorFormatter
+
 from kash.config.settings import DEFAULT_MCP_SERVER_PORT, LogLevel, global_settings
 from kash.config.setup import kash_setup
-from kash.shell.utils.argparse_utils import WrappedColorFormatter
 from kash.shell.version import get_version
 
 __version__ = get_version()
@@ -27,7 +28,7 @@ log = logging.getLogger()
 def build_parser():
     from kash.workspaces.workspaces import global_ws_dir
 
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=WrappedColorFormatter)
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
     parser.add_argument(
         "--version",
         action="version",

kash/mcp/mcp_server_commands.py

@@ -6,8 +6,6 @@ from kash.config.settings import (
     global_settings,
 )
 from kash.exec import kash_command
-from kash.mcp import mcp_server_routes
-from kash.mcp.mcp_cli import MCP_CLI_LOG_PATH
 from kash.shell.output.shell_formatting import format_name_and_value
 from kash.shell.output.shell_output import cprint, print_h2
 from kash.shell.utils.native_utils import tail_file
@@ -21,6 +19,7 @@ def start_mcp_server() -> None:
     """
     Start the MCP server, using all currently known actions marked as MCP tools.
     """
+    from kash.mcp import mcp_server_routes
     from kash.mcp.mcp_server_sse import start_mcp_server_sse
 
     mcp_server_routes.publish_mcp_tools()
@@ -42,6 +41,7 @@ def restart_mcp_server() -> None:
     """
     Restart the MCP server, republishing all actions marked as MCP tools.
     """
+    from kash.mcp import mcp_server_routes
     from kash.mcp.mcp_server_sse import restart_mcp_server_sse
 
     mcp_server_routes.unpublish_mcp_tools(None)
@@ -57,6 +57,8 @@ def mcp_logs(follow: bool = False, all: bool = False) -> None:
     :param follow: Follow the file as it grows.
     :param all: Show all logs, not just the server logs, including Claude Desktop logs if found.
     """
+    from kash.mcp.mcp_cli import MCP_CLI_LOG_PATH
+
     settings = global_settings()
     if all:
         global_log_base = settings.system_logs_dir
@@ -96,6 +98,7 @@ def list_mcp_tools() -> None:
     """
     List published MCP tools.
     """
+    from kash.mcp import mcp_server_routes
 
     tools = mcp_server_routes.get_published_tools()
 
@@ -118,6 +121,8 @@ def publish_mcp_tool(*action_names: str) -> None:
     Publish one or more actions as local MCP tools. With no arguments, publish all
     actions marked as MCP tools.
     """
+    from kash.mcp import mcp_server_routes
+
     if not action_names:
         log.message("Publishing all actions marked as MCP tools.")
         mcp_server_routes.publish_mcp_tools()
@@ -131,6 +136,7 @@ def unpublish_mcp_tool(*action_names: str) -> None:
     Un-publish one or more actions as local MCP tools. With no arguments,
     un-publish all published actions.
     """
+    from kash.mcp import mcp_server_routes
 
     if not action_names:
         log.message("Un-publishing all actions marked as MCP tools.")

kash/mcp/mcp_server_routes.py

@@ -13,12 +13,13 @@ from strif import AtomicVar
 from kash.config.capture_output import CapturedOutput, captured_output
 from kash.config.logger import get_logger
 from kash.config.settings import global_settings
+from kash.exec import kash_runtime
 from kash.exec.action_exec import prepare_action_input, run_action_with_caching
 from kash.exec.action_registry import get_all_actions_defaults, look_up_action_class
-from kash.model.actions_model import Action, ActionResult, ExecContext
+from kash.model.actions_model import Action, ActionResult
+from kash.model.exec_model import ExecContext
 from kash.model.params_model import TypedParamValues
 from kash.model.paths_model import StorePath
-from kash.workspaces.workspaces import current_ws, get_ws
 
 log = get_logger(__name__)
 
@@ -214,9 +215,14 @@ def run_mcp_tool(action_name: str, arguments: dict) -> list[TextContent]:
             # current workspace, which could be changed by the user by changing working
             # directories. Maybe confusing?
             explicit_mcp_ws = global_settings().mcp_ws_dir
-            ws = get_ws(explicit_mcp_ws) if explicit_mcp_ws else current_ws()
 
-            with ws:
+            with kash_runtime(
+                workspace_dir=explicit_mcp_ws,
+                rerun=True,  # Enabling rerun always for now, seems good for tools.
+                refetch=False,  # Using the file caches.
+                # Keeping all transient files for now, but maybe make transient?
+                override_state=None,
+            ) as exec_settings:
                 action_cls = look_up_action_class(action_name)
 
                 # Extract items array and remaining params from arguments.
@@ -228,14 +234,7 @@ def run_mcp_tool(action_name: str, arguments: dict) -> list[TextContent]:
                 action = action_cls.create(param_values)
 
                 # Create execution context and assemble action input.
-                context = ExecContext(
-                    action=action,
-                    workspace_dir=ws.base_dir,
-                    rerun=True,  # Enabling rerun always for now, seems good for tools.
-                    refetch=False,  # Using the file caches.
-                    # Keeping all transient files for now, but maybe make transient?
-                    override_state=None,
-                )
+                context = ExecContext(action=action, settings=exec_settings)
                 action_input = prepare_action_input(*input_items)
 
                 result, result_store_paths, _archived_store_paths = run_action_with_caching(