cecli-dev 1.4.0__tar.gz → 1.4.1__tar.gz

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/.flake8

@@ -1,3 +1,4 @@
 [flake8]
 ignore = E203,W503
 max-line-length = 120
+exclude = *.md,*.markdown

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.4.0
+Version: 1.4.1
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.4.0'
-__version_tuple__ = version_tuple = (1, 4, 0)
+__version__ = version = '1.4.1'
+__version_tuple__ = version_tuple = (1, 4, 1)
 
-__commit_id__ = commit_id = 'g1933dd2b7'
+__commit_id__ = commit_id = 'g2b8c49bf9'

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/coders/agent_coder.py

@@ -463,7 +463,6 @@ class AgentCoder(Coder):
                 "skills",
                 "servers",
                 "sub_agents",
-                "loaded_skills",
                 "orchestration",
             ]
             for block_type in block_types:
@@ -499,8 +498,6 @@ class AgentCoder(Coder):
             content = self.get_skills_context()
         elif block_name == "servers":
             content = self.get_servers_context()
-        elif block_name == "loaded_skills":
-            content = self.get_skills_content()
         elif block_name == "orchestration":
             content = self.get_orchestration_context()
         elif block_name == "sub_agents" and (
@@ -643,6 +640,10 @@ class AgentCoder(Coder):
         # Add pre-message context blocks (priority 125 - between REPO and READONLY_FILES)
         ConversationService.get_chunks(self).add_pre_message_context_blocks()
 
+        ConversationService.get_chunks(self).add_active_skills_messages(
+            getattr(self, "skills_manager", None)
+        )
+
         ConversationService.get_chunks(self).add_readonly_files_messages()
         ConversationService.get_chunks(self).add_chat_files_messages()
 

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/coders/base_coder.py

@@ -2919,6 +2919,17 @@ class Coder(metaclass=UsageMeta):
 
         edited = await self.apply_updates()
 
+        # Run tests before committing so failing tests abort the commit and
+        # reflect the errors back for the model to fix first.
+        if edited and self.auto_test and self.test_cmd:
+            test_errors = await self.commands.execute("test", self.test_cmd)
+            self.test_outcome = not test_errors
+            if test_errors:
+                ok = await self.io.confirm_ask("Attempt to fix test errors?")
+                if ok:
+                    self.reflected_message = test_errors
+                    return
+
         if edited:
             self.coder_edited_files.update(edited)
             saved_message = await self.auto_commit(edited)
@@ -2991,15 +3002,6 @@ class Coder(metaclass=UsageMeta):
                 mark_for_demotion=1,
             )
 
-        if edited and self.auto_test and self.test_cmd:
-            test_errors = await self.commands.execute("test", self.test_cmd)
-            self.test_outcome = not test_errors
-            if test_errors:
-                ok = await self.io.confirm_ask("Attempt to fix test errors?")
-                if ok:
-                    self.reflected_message = test_errors
-                    return
-
         # Turn complete: drop the per-turn LLM stream buffers.  They are reset at
         # the start of the next send(), so holding on to them while idle only
         # wastes memory (chunks can be large for long streaming responses).

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/commands/__init__.py

@@ -55,7 +55,6 @@ from .merge import MergeCommand
 from .model import ModelCommand
 from .models import ModelsCommand
 from .multiline_mode import MultilineModeCommand
-from .open import OpenCommand
 from .paste import PasteCommand
 from .queue import QueueCommand
 from .quit import QuitCommand
@@ -152,7 +151,6 @@ CommandRegistry.register(MergeCommand)
 CommandRegistry.register(ModelCommand)
 CommandRegistry.register(ModelsCommand)
 CommandRegistry.register(MultilineModeCommand)
-CommandRegistry.register(OpenCommand)
 CommandRegistry.register(PasteCommand)
 CommandRegistry.register(QueueCommand)
 CommandRegistry.register(QuitCommand)
@@ -242,7 +240,6 @@ __all__ = [
     "ModelCommand",
     "ModelsCommand",
     "MultilineModeCommand",
-    "OpenCommand",
     "parse_quoted_filenames",
     "PasteCommand",
     "quote_filename",

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/commands/load_mcp.py

@@ -119,6 +119,7 @@ class LoadMcpCommand(BaseCommand):
                 server.name
                 for server in coder.mcp_manager
                 if server not in coder.mcp_manager.connected_servers
+                and server.name != "unnamed-server"
             ]
             return server_names
         except Exception:

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/commands/run.py

@@ -85,7 +85,7 @@ class RunCommand(BaseCommand):
                 io.placeholder = "What's wrong? Fix"
 
         if add_on_nonzero_exit and not exit_status:
-            return ""  # No test failures
+            return "Test command ran by user. All tests passed."  # No test failures
 
         # Return None if output wasn't added or command succeeded
         return format_command_result(io, "run", "Command executed successfully")

cecli_dev-1.4.1/cecli/commands/workspace.py

@@ -0,0 +1,238 @@
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class WorkspaceCommand(BaseCommand):
+    NORM_NAME = "workspace"
+    DESCRIPTION = "List, open or register workspace sub-agents"
+    show_completion_notification = True
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """List active workspace sub-agents, or open / register one.
+
+        Syntax:
+            /workspace                 — List active workspace sub-agents
+            /workspace <ws:name>       — Open an already-registered ``ws:name`` sub-agent (like /spawn-agent)
+            /workspace <name> <path>   — Register and open a ``ws:{name}`` sub-agent rooted at ``<path>``
+        """
+        parts = args.strip().split(maxsplit=1)
+
+        if not parts:
+            cls._list_workspace_subagents(io)
+            return
+
+        name = parts[0]
+        path_arg = parts[1].strip() if len(parts) > 1 else None
+
+        if path_arg is None:
+            await cls._open_existing(io, coder, name)
+            return
+
+        await cls._register_and_open(io, coder, name, path_arg)
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the workspace command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /workspace              # List active workspace sub-agents\n"
+        help_text += "  /workspace <ws:name>    # Open an already-registered ws: sub-agent (like /spawn-agent)\n"
+        help_text += "  /workspace <name> <path>  # Register and open a ws:{name} sub-agent rooted at <path>\n"
+        return help_text
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> list[str]:
+        """Return tab-completions for the workspace command.
+
+        - The first argument (the ``ws:{name}`` sub-agent name) is completed from
+          the active workspace sub-agent names, including the ``ws:`` prefix.
+        - The second argument (the project path) is completed by browsing the
+          folders at the typed path, independent of the coder's file completion
+          index. The folder list is ranked with rapidfuzz + ngram so prefix
+          matches surface first.
+        """
+        from cecli.helpers.agents.service import AgentService
+
+        partial = (args or "").strip()
+
+        if not partial or partial.startswith("ws:"):
+            return [name for name in AgentService.get_registry() if name.startswith("ws:")]
+
+        return cls._get_path_completions(partial)
+
+    @classmethod
+    def _list_workspace_subagents(cls, io) -> None:
+        """Print the registered ``ws:{name}`` workspace sub-agents and their roots."""
+        from cecli.helpers.agents.service import AgentService
+
+        registry = AgentService.get_registry()
+        ws_agents = sorted((name, cfg) for name, cfg in registry.items() if name.startswith("ws:"))
+
+        if not ws_agents:
+            io.tool_output("No workspace sub-agents are active.")
+            return
+
+        io.print("Workspace Sub-Agents:")
+        for name, cfg in ws_agents:
+            metadata = getattr(cfg, "metadata", {}) or {}
+            io.print(f"  - {name}")
+            io.print(f"    Root:   {metadata.get('root')}")
+            io.print(f"    Layout: {metadata.get('layout')}")
+            io.print("")
+
+    @classmethod
+    async def _open_existing(cls, io, coder, name) -> None:
+        """Open an already-registered workspace sub-agent, mirroring /spawn-agent."""
+        from cecli.helpers.agents.service import AgentService
+
+        if not name.startswith("ws:"):
+            io.tool_error(f"Error: '{name}' is not a registered workspace sub-agent.")
+            return
+
+        if name not in AgentService.get_registry():
+            io.tool_error(f"Error: workspace sub-agent '{name}' is not registered.")
+            return
+
+        try:
+            agent_service = AgentService.get_instance(coder)
+            new_coder, info = await agent_service.spawn(
+                name, prompt=None, parent=coder, auto_reap=False, independent=True
+            )
+
+            agent_service.foreground_uuid = info.coder.uuid
+
+            if coder.tui and coder.tui():
+                tui = coder.tui()
+                switch_key = tui.get_keys_for("next_agent")
+                io.tool_output(f"Sub-agent '{name}' spawned and active. Switch with {switch_key}")
+
+                try:
+                    tui.call_from_thread(tui._switch_to_container, info.coder.uuid)
+                except Exception:
+                    pass
+            else:
+                io.tool_output(f"Opened workspace sub-agent '{name}'.")
+        except ValueError as e:
+            io.tool_error(f"Error: {e}")
+        except RuntimeError as e:
+            io.tool_error(f"Error: {e}")
+        except Exception as e:
+            io.tool_error(f"Error spawning sub-agent '{name}': {e}")
+
+    @classmethod
+    async def _register_and_open(cls, io, coder, name, path_arg) -> None:
+        """Register a ``ws:{name}`` sub-agent rooted at ``<path>`` and open it."""
+        from pathlib import Path
+
+        from cecli.helpers.agents.service import AgentService
+        from cecli.helpers.workspaces.subagents import register_workspace_subagents
+
+        project_name = name[3:] if name.startswith("ws:") else name
+        agent_name = f"ws:{project_name}"
+        path = Path(path_arg).expanduser()
+
+        config = {
+            "name": project_name,
+            "projects": [{"name": project_name, "path": str(path)}],
+        }
+        registered = register_workspace_subagents(config)
+        if agent_name not in registered:
+            io.tool_error(f"Error: '{path}' is not a valid git repository or does not exist.")
+            return
+
+        root = AgentService.get_registry()[agent_name].metadata.get("root")
+
+        try:
+            agent_service = AgentService.get_instance(coder)
+            new_coder, info = await agent_service.spawn(
+                agent_name, prompt=None, parent=coder, auto_reap=False, independent=True
+            )
+
+            agent_service.foreground_uuid = info.coder.uuid
+
+            if coder.tui and coder.tui():
+                tui = coder.tui()
+                switch_key = tui.get_keys_for("next_agent")
+                io.tool_output(
+                    f"Opened workspace sub-agent '{agent_name}' rooted at {root}. Switch with {switch_key}"
+                )
+
+                try:
+                    tui.call_from_thread(tui._switch_to_container, info.coder.uuid)
+                except Exception:
+                    pass
+            else:
+                io.tool_output(f"Opened workspace sub-agent '{agent_name}' rooted at {root}.")
+        except Exception as e:
+            io.tool_error(f"Error opening workspace sub-agent '{agent_name}': {e}")
+
+    @classmethod
+    def _get_path_completions(cls, partial: str) -> list[str]:
+        """Browse the filesystem for folders matching the typed path prefix."""
+        from pathlib import Path
+
+        path = Path(partial)
+        if partial.endswith("/"):
+            search_dir = path
+            name_prefix = ""
+        else:
+            search_dir = path.parent
+            name_prefix = path.name
+
+        if not search_dir.is_dir():
+            return []
+
+        if search_dir == Path("."):
+            path_prefix = ""
+        else:
+            path_prefix = str(search_dir).rstrip("/") + "/"
+
+        folders: list[str] = []
+        try:
+            for entry in search_dir.iterdir():
+                if entry.is_dir():
+                    folders.append(path_prefix + entry.name + "/")
+        except (PermissionError, OSError):
+            return []
+
+        if name_prefix:
+            prefix_lower = name_prefix.lower()
+            folders = [f for f in folders if Path(f).name.lower().startswith(prefix_lower)]
+
+        return cls._rank_paths(partial, folders)
+
+    @staticmethod
+    def _rank_paths(query: str, candidates: list[str]) -> list[str]:
+        """Order path candidates with rapidfuzz + ngram so prefix matches surface first."""
+        if not candidates:
+            return []
+
+        query_lower = query.lower()
+
+        try:
+            from ngram import NGram
+            from rapidfuzz import fuzz, process
+        except ImportError:
+            return sorted(
+                candidates,
+                key=lambda c: (not c.lower().startswith(query_lower), c.lower()),
+            )
+
+        lower_candidates = [c.lower() for c in candidates]
+        results = process.extract(
+            query_lower,
+            lower_candidates,
+            scorer=fuzz.partial_ratio,
+            limit=min(len(candidates), 20),
+            score_cutoff=0,
+        )
+
+        matched = [candidates[idx] for _, _, idx in results]
+
+        if len(matched) < 100:
+            ng = NGram([c.lower() for c in matched], N=3)
+            reranked = ng.search(query_lower, threshold=0.0)
+            original_by_lower = {c.lower(): c for c in matched}
+            matched = [original_by_lower.get(item.lower(), item) for item, _ in reranked]
+
+        return matched

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/helpers/conversation/files.py

@@ -39,6 +39,9 @@ class ConversationFiles:
         self._image_files: Dict[str, bool] = {}
         self._numbered_contexts: Dict[str, List[Tuple[int, int]]] = {}
         self._last_merged_ranges: Dict[str, List[Tuple[int, int]]] = {}
+        self._emitted_contexts: Dict[str, List[Tuple[int, int]]] = (
+            {}
+        )  # intervals already delivered as FILE_CONTEXTS
         self._initialized = True
 
     @classmethod
@@ -388,6 +391,7 @@ class ConversationFiles:
             self._file_stub_contents.clear()
             self._file_json_contents.clear()
             self._file_to_message_id.clear()
+            self._emitted_contexts.clear()
             if clear_contexts:
                 self._numbered_contexts.clear()
         else:
@@ -402,6 +406,7 @@ class ConversationFiles:
             self._file_json_contents.pop(abs_fname, None)
             self._file_to_message_id.pop(abs_fname, None)
             self._image_files.pop(abs_fname, None)
+            self._emitted_contexts.pop(abs_fname, None)
             if clear_contexts:
                 self._numbered_contexts.pop(abs_fname, None)
 
@@ -463,7 +468,9 @@ class ConversationFiles:
 
         if diff_version != context_version:
             self._file_context_versions[abs_fname] = diff_version
-        # auto clear on edit
+            # Content changed: force re-emission of context (stale blocks won't
+            # refresh otherwise).
+            self._emitted_contexts.pop(abs_fname, None)
         # existing_ranges = []
 
         # Add new range
@@ -642,6 +649,73 @@ class ConversationFiles:
 
         return None
 
+    def get_new_file_context(self, file_path: str) -> str:
+        """Return hashline content for ranges NOT yet emitted as FILE_CONTEXTS.
+
+        Append-only delta: only genuinely-new line ranges are emitted against
+        the previously-emitted intervals, so overlapping reads don't re-send
+        content already in the conversation. Nothing is removed, so the
+        conversation stays an append-only log.
+        """
+        abs_fname = os.path.abspath(file_path)
+        current = sorted(self._numbered_contexts.get(abs_fname, []))
+        if not current:
+            return ""
+        emitted = sorted(self._emitted_contexts.get(abs_fname, []))
+        delta = _subtract_intervals(current, emitted)
+        if not delta:
+            return ""
+        rendered = self._render_context_ranges(abs_fname, delta)
+        if not rendered:
+            return ""
+        # Mark everything currently requested as emitted so future reads only
+        # emit the overlap-free remainder.
+        self._emitted_contexts[abs_fname] = current
+        return rendered
+
+    def _render_context_ranges(self, abs_fname: str, ranges: List[Tuple[int, int]]) -> str:
+        """Render hashline content for the given 1-based line ranges. Returns JSON or ''."""
+        coder = self.get_coder()
+        if not coder:
+            return ""
+        try:
+            content = coder.io.read_text(abs_fname, silent=True)
+            if not content:
+                return ""
+        except Exception:
+            return ""
+        content_lines = content.splitlines()
+        results = []
+        for start_line, end_line in ranges:
+            start_line_adj = max(1, start_line)
+            end_line_adj = min(len(content_lines), end_line)
+            if start_line_adj > end_line_adj:
+                continue
+            # Hash the full file so adjacent-line hashes are consistent with ReadFile.
+            full_prefixed, _ = hashline_formatted(
+                content,
+                file_name=abs_fname,
+                total_lines=len(content_lines),
+                start_line=1,
+            )
+            prefixed_lines = full_prefixed.splitlines()
+            range_prefixed_lines = prefixed_lines[start_line_adj - 1 : end_line_adj]
+            range_prefixed_content = "\n".join(range_prefixed_lines)
+            json_str = json.dumps(
+                {
+                    "file_name": abs_fname,
+                    "start_line": start_line_adj,
+                    "end_line": end_line_adj,
+                    "total_lines": len(content_lines),
+                    "prefixed_contents": range_prefixed_content,
+                },
+                ensure_ascii=False,
+            )
+            results.append(json.loads(json_str))
+        if results:
+            return json.dumps({"file_path": abs_fname, "results": results}, ensure_ascii=False)
+        return ""
+
     def remove_file_context(self, file_path: str) -> None:
         """
         Remove all cached context for a file.
@@ -738,3 +812,30 @@ class ConversationFiles:
             "diff_count": len(self._file_diffs),
             "message_mappings": len(self._file_to_message_id),
         }
+
+
+def _subtract_intervals(
+    base: List[Tuple[int, int]], remove: List[Tuple[int, int]]
+) -> List[Tuple[int, int]]:
+    """Return the portions of ``base`` not covered by ``remove``.
+
+    Both inputs are lists of inclusive, disjoint, 1-based ``(start, end)``
+    intervals already sorted by start line. Used to compute the append-only
+    FILE_CONTEXTS delta (only genuinely-new ranges are emitted).
+    """
+    remaining = []
+    for a, b in base:
+        parts = [(a, b)]
+        for r0, r1 in remove:
+            new_parts = []
+            for s, e in parts:
+                if e < r0 or s > r1:
+                    new_parts.append((s, e))
+                else:
+                    if s < r0:
+                        new_parts.append((s, r0 - 1))
+                    if e > r1:
+                        new_parts.append((r1 + 1, e))
+            parts = new_parts
+        remaining.extend(parts)
+    return remaining

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/helpers/conversation/integration.py

@@ -762,8 +762,8 @@ class ConversationChunks:
             if not ranges:
                 continue
 
-            # Generate context content
-            context_content = ConversationService.get_files(coder).get_file_context(file_path)
+            # Generate context content (append-only delta: only new ranges are emitted)
+            context_content = ConversationService.get_files(coder).get_new_file_context(file_path)
             if not context_content:
                 continue
 
@@ -775,6 +775,9 @@ class ConversationChunks:
                 "content": f"ID-Prefixed Context For:\n{rel_fname}\n\n{context_content}",
             }
 
+            # Append-only: new FILE_CONTEXTS blocks are added, never removed, so
+            # the conversation message stream stays a log (no prefix rewrite).
+
             # Add to conversation manager
             content_hash = xxhash.xxh3_128_hexdigest(context_content.encode("utf-8"))
             ConversationService.get_manager(coder).queue_message(
@@ -850,8 +853,7 @@ class ConversationChunks:
         """
         Add pre-message context blocks to conversation (priority 125).
 
-        Pre-message blocks include: symbol_outline, git_status, todo_list,
-        loaded_skills, context_summary
+        Pre-message blocks include: symbol_outline, git_status, todo_list, context_summary
         """
         coder = self.get_coder()
         if not coder:
@@ -875,10 +877,6 @@ class ConversationChunks:
                 block = coder.get_cached_context_block("git_status")
                 if block:
                     message_blocks["git_status"] = block
-            if "skills" in coder.allowed_context_blocks:
-                block = coder._generate_context_block("loaded_skills")
-                if block:
-                    message_blocks["loaded_skills"] = block
 
         # Process other blocks
         for block_type, block_content in message_blocks.items():
@@ -890,6 +888,58 @@ class ConversationChunks:
                 force=True,
             )
 
+    def add_active_skills_messages(self, skills_manager) -> None:
+        """Add a distinct message per active (loaded) skill.
+
+        Unlike the prior single ``loaded_skills`` context block, this emits one
+        message per loaded skill so the model can see each skill's content in
+        isolation. Replacement is driven by a stable per-skill hash key, and any
+        message for a skill that is no longer loaded is pruned.
+
+        Args:
+            skills_manager: The SkillsManager instance from which to source
+                active skills.
+        """
+        coder = self.get_coder()
+        if not coder:
+            return
+
+        if not skills_manager:
+            return
+
+        if not hasattr(coder, "use_enhanced_context") or not coder.use_enhanced_context:
+            return
+
+        loaded_skills = getattr(skills_manager, "_loaded_skills", set())
+
+        # Prune messages for skills that are no longer loaded.
+        def is_stale_skill(hash_key) -> bool:
+            if not hash_key or hash_key[0] != "active_skill":
+                return False
+            return hash_key[1] not in loaded_skills
+
+        ConversationService.get_manager(coder).remove_messages_by_hash_key_pattern(is_stale_skill)
+
+        if not loaded_skills:
+            return
+
+        for skill_name in sorted(loaded_skills):
+            skill_content = skills_manager.get_skill_content(skill_name)
+            if not skill_content:
+                continue
+
+            block = skills_manager.format_active_skill_message(skill_content)
+            if not block:
+                continue
+
+            ConversationService.get_manager(coder).add_message(
+                message_dict={"role": "user", "content": block},
+                tag=MessageTag.ACTIVE_SKILLS,
+                hash_key=("active_skill", skill_name),
+                force=True,
+                update_timestamp=False,
+            )
+
     def add_post_message_context_blocks(self) -> None:
         """
         Add post-message context blocks to conversation (priority 250).

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/helpers/conversation/tags.py

@@ -21,6 +21,7 @@ class MessageTag(str, Enum):
     DIFFS = "diffs"
     LINT = "lint"
     FILE_CONTEXTS = "file_contexts"
+    ACTIVE_SKILLS = "active_skills"
     CUR = "cur"
     DONE = "done"
     REMINDER = "reminder"
@@ -42,6 +43,7 @@ DEFAULT_TAG_PRIORITY: Dict[MessageTag, int] = {
     MessageTag.FILE_CONTEXTS: 200,
     MessageTag.DONE: 200,
     MessageTag.CUR: 200,
+    MessageTag.ACTIVE_SKILLS: 200,
     MessageTag.REMINDER: 300,
 }
 
@@ -62,6 +64,7 @@ DEFAULT_TAG_TIMESTAMP_OFFSET: Dict[MessageTag, int] = {
     MessageTag.FILE_CONTEXTS: 0,
     MessageTag.DONE: 0,
     MessageTag.CUR: 0,
+    MessageTag.ACTIVE_SKILLS: 0,
     MessageTag.REMINDER: 0,
 }
 

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/helpers/llms/config.py

@@ -159,6 +159,7 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         "extra_headers": extra_headers,
         "extra_body": extra_body,
         "extra_query": dict(pcfg.get("extra_query") or {}),
+        "session_header": mpm.get_provider_session_header(provider),
         "api_block": api_block,
         "llm_block": llm_block,
         "agent_block": agent_block,

{cecli_dev-1.4.0 → cecli_dev-1.4.1}/cecli/helpers/llms/pipeline.py

@@ -58,6 +58,17 @@ async def acompletion(
 
     headers = dict(resolved.get("extra_headers") or {})
     headers.update(extra_headers or {})
+
+    # Some providers expose a ``session_header`` that carries the per-session
+    # prompt cache key (unique per agent session).
+    session_header = resolved.get("session_header")
+
+    if session_header:
+        prompt_cache_key = kwargs.get("prompt_cache_key")
+
+        if prompt_cache_key:
+            headers[session_header] = prompt_cache_key
+
     headers = provider.build_headers(resolved, key, family, headers)
 
     if stream: