cecli-dev 1.2.0__tar.gz → 1.2.1__tar.gz

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.0
+Version: 1.2.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.2.0 → cecli_dev-1.2.1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.2.1'
+__version_tuple__ = version_tuple = (1, 2, 1)
 
-__commit_id__ = commit_id = 'gd8d0c6996'
+__commit_id__ = commit_id = 'g9eedb354e'

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/coders/base_coder.py

@@ -892,7 +892,7 @@ class Coder(metaclass=UsageMeta):
             rel_repo_dir = self.repo.get_rel_repo_dir()
             num_files = len(self.repo.get_tracked_files())
             env_items.append(f"{rel_repo_dir} ({num_files:,} files)")
-            if num_files > 1000:
+            if num_files > 1000 and self.verbose:
                 env_items.append(
                     "Warning: For large repos, consider using --subtree-only and .cecli.ignore"
                 )
@@ -1759,6 +1759,7 @@ class Coder(metaclass=UsageMeta):
             except (SwitchCoderSignal, SystemExit):
                 raise
             except Exception as e:
+                self.error_code = 1
                 traceback_str = traceback.format_exc()
                 update_error_prefix(traceback_str)
 
@@ -2759,6 +2760,7 @@ class Coder(metaclass=UsageMeta):
                             dict(role="assistant", content=self.multi_response_content, prefix=True)
                         )
                 except Exception as err:
+                    self.error_code = 1
                     self.mdstream = None
                     lines = traceback.format_exception(type(err), err, err.__traceback__)
                     self.io.tool_warning("".join(lines))
@@ -3253,6 +3255,12 @@ class Coder(metaclass=UsageMeta):
         if not isinstance(arguments, dict):
             arguments = {}
 
+        # Some models mirror the OpenAI wire format and wrap the real params
+        # under a single "arguments"/"parameters"/"params" key. Unwrap so the
+        # server receives the actual parameters instead of rejecting the call
+        # with a "missing required parameter" error.
+        arguments = responses.coerce_tool_structure(arguments)
+
         return await session.call_tool(name=name, arguments=arguments)
 
     async def process_tool_calls(self, tool_call_response):
@@ -3508,6 +3516,7 @@ class Coder(metaclass=UsageMeta):
                 # but response.dict() is the Pydantic V1 method name.
                 response_dict = dict(response)
             except TypeError:
+                self.error_code = 1
                 self.io.tool_warning("Response parsing error.")
                 return
 
@@ -4277,9 +4286,21 @@ class Coder(metaclass=UsageMeta):
         cache_hit_tokens = 0
         cache_write_tokens = 0
 
-        if completion and hasattr(completion, "usage") and completion.usage is not None:
-            prompt_tokens = completion.usage.prompt_tokens
-            completion_tokens = completion.usage.completion_tokens
+        if (
+            completion
+            and nested.getter(completion, "usage.prompt_tokens") is not None
+            and nested.getter(completion, "usage.completion_tokens") is not None
+        ):
+            prompt_tokens = (
+                nested.getter(completion.usage, "prompt_tokens", 0)
+                or nested.getter(completion.usage, "prompt_eval_count", 0)
+                or 0
+            )
+            completion_tokens = (
+                nested.getter(completion.usage, "completion_tokens", 0)
+                or nested.getter(completion.usage, "eval_count", 0)
+                or 0
+            )
             cache_hit_tokens = (
                 getattr(completion.usage, "prompt_cache_hit_tokens", 0)
                 or getattr(completion.usage, "cache_read_input_tokens", 0)

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/helpers/agents/defaults/memorizer.md

@@ -46,7 +46,6 @@ Use these tags (and invent new ones as needed) to categorise facts:
 - **relationships** – how modules / systems interact with each other
 - **decisions**     – architectural or design choices that were made and why
 - **entities**      – important classes, functions, or data structures
-- **changes**       – summaries of changes made and their intent
 
 ## Tools
 
@@ -67,10 +66,13 @@ context (e.g. compaction / yield summaries).  Your job:
 2. Use ReplaceFacts to insert new facts and delete the obsolete ones so
    the database stays clean and up-to-date.
 3. Task specific details are not worth recording, focus on user intention and add facts
-   that would help them explain the project to another person succinctly
+   that would help them explain the project to another person succinctly. 
+4. Record notes on strategy, purpose, structure, expectations, and unintuitive/novel discoveries over project 
+   and activity specific details.
+   We are trying to preserve why we took the actions we have done, not a log of the actions themselves.
 
 Start each response with an incrementing number at the beginning, e.g. "1) ...", "2) ..."
-When this number hits at most 10, update what you can and yield. Do not deliberate over many turns.
+Before this number hits at most 10, update what you can and yield. Do not deliberate over many turns.
 Important facts will be easy to search for and extract from the given context.
 
 Always prefer **concrete, reusable** facts over vague prose.

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/helpers/background_commands.py

@@ -12,6 +12,8 @@ import threading
 from collections import deque
 from typing import Dict, List, Optional, Tuple
 
+import xxhash
+
 from cecli.decoding import safe_open
 
 try:
@@ -419,7 +421,8 @@ class BackgroundCommandManager:
             Unique command key
         """
         with cls._lock:
-            key = f"bg_{cls._next_id}_{hash(command) % 10000:04d}"
+            digest = xxhash.xxh64(command.encode("utf-8")).intdigest()
+            key = f"bg_{cls._next_id}_{digest % 10000:04d}"
             cls._next_id += 1
             return key
 

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/helpers/memory/utils.py

@@ -6,6 +6,7 @@ Public API
 - ``add_fact(fact=..., tags=[...])`` – insert a fact with optional tags
 - ``remove_facts(id_facts=[...])`` – delete facts by id
 - ``search_facts(words=[...], tags=[...])`` – full-text search the fact store
+- ``recent_tags(coder, limit=100)`` – most recently used tags + total count
 - ``invoke_memorizer(coder, additional_context=...)`` – fire the memorizer
   sub-agent with current context
 """
@@ -203,6 +204,51 @@ def search_facts(
     return results
 
 
+def recent_tags(coder, limit: int = 100) -> dict:
+    """Return the most recently used tags plus the total tag count.
+
+    Tags are deduplicated and ordered by the recency of the most recent
+    fact they are attached to (facts sorted by ``id_fact`` descending),
+    then truncated to *limit* entries.
+
+    Args:
+        coder: The active Coder instance (used to locate the project root).
+        limit: Maximum number of recent tags to return (default 100).
+
+    Returns:
+        A dict with keys ``tags`` (list of tag strings, most recent first)
+        and ``total`` (int count of all distinct tags in the store).
+    """
+
+    init_db(root=coder.root)
+
+    conn = _get_connection(root=coder.root)
+    cursor = conn.cursor()
+
+    # Tags ordered by the recency of the most recent fact they tag:
+    # sort facts by id descending and dedupe on the tag name.
+    cursor.execute(
+        """
+        SELECT t.tag
+        FROM Facts f
+        JOIN FactTags ft ON ft.id_fact = f.id_fact
+        JOIN Tags t ON t.id_tag = ft.id_tag
+        GROUP BY t.tag
+        ORDER BY MAX(f.id_fact) DESC
+        LIMIT ?
+        """,
+        (limit,),
+    )
+
+    tags = [row["tag"] for row in cursor.fetchall()]
+
+    cursor.execute("SELECT COUNT(*) AS total FROM Tags")
+
+    total = cursor.fetchone()["total"]
+
+    return {"tags": tags, "total": total}
+
+
 async def invoke_memorizer(
     coder,
     additional_context: str = "",
@@ -242,6 +288,14 @@ async def invoke_memorizer(
     # Gather context pieces
     parts: list[str] = []
 
+    # Recent tags (deduplicated, most recently used first) plus the total
+    # tag count — first context part so the memorizer sees active tags
+    recent = recent_tags(coder)
+
+    tag_list = ", ".join(recent["tags"]) if recent["tags"] else "(none)"
+
+    parts.append(f"## Recent Tags\n\n{tag_list}\n\n## Total Tags in DB\n\n{recent['total']}")
+
     # Latest user message
     last_user = getattr(coder, "last_user_message", "")
 

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/helpers/responses.py

@@ -367,20 +367,24 @@ def unprefix_tool_call(tool_call):
 
 
 def parse_tool_arguments(args_string: str) -> dict:
-    """Parse tool-call arguments, merging glued ``{…}{} {…}`` object fragments."""
+    """Parse tool-call arguments, merging glued ``{…}{} {…}`` object fragments.
+
+    Also unwraps a single ``arguments``/``parameters``/``params`` wrapper key
+    that some models emit when mirroring the OpenAI wire format.
+    """
     text = (args_string or "").strip()
     if not text:
         return {}
     try:
         parsed = json.loads(text)
         if isinstance(parsed, dict):
-            return parsed
+            return coerce_tool_structure(parsed)
     except json.JSONDecodeError:
         pass
 
     parsed = try_parse_json_value(text)
     if isinstance(parsed, dict):
-        return parsed
+        return coerce_tool_structure(parsed)
 
     chunks = utils.split_concatenated_json(text)
     if len(chunks) <= 1:
@@ -388,18 +392,18 @@ def parse_tool_arguments(args_string: str) -> dict:
             return {}
         lone = try_parse_json_value(chunks[0])
         if isinstance(lone, dict):
-            return lone
+            return coerce_tool_structure(lone)
         try:
             json_string = json_repair.repair_json(chunks[0], ensure_ascii=False)
             single = json.loads(json_string)
         except json.JSONDecodeError as err:
             return {"@error": f"Malformed JSON arguments: {err}"}
-        return single if isinstance(single, dict) else {}
+        return coerce_tool_structure(single) if isinstance(single, dict) else {}
 
     merged = merge_glued_json_objects(chunks)
 
     if merged is not None:
-        return merged
+        return coerce_tool_structure(merged)
 
     return {
         "@error": "Could not merge glued JSON objects: argument fragments are not all JSON objects"
@@ -618,3 +622,40 @@ def _parse_bracket_arguments(payload_str: str) -> dict:
             arguments[key] = val_str
 
     return arguments
+
+
+def coerce_tool_structure(args: dict) -> dict:
+    """Unwrap a single ``arguments``/``parameters``/``params`` wrapper key.
+
+    Some models mirror the OpenAI wire format and emit the real params nested
+    under a single top-level ``arguments`` key (as a dict or a JSON-encoded
+    string) instead of as the params dict itself. Without normalization the
+    wrapper key is forwarded verbatim to the tool, which then fails required
+    parameter validation (e.g. MCP servers reporting "missing required
+    parameter").
+
+    Only unwraps when ``args`` has exactly one key matching one of the wrapper
+    names and that value is a dict (or a JSON string that parses to a dict), so
+    tools that legitimately declare a parameter named ``arguments`` are never
+    clobbered.
+    """
+    if not isinstance(args, dict) or len(args) != 1:
+        return args
+
+    for key in ("arguments", "parameters", "params"):
+        if key not in args:
+            continue
+
+        value = args[key]
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                return args
+
+        if isinstance(value, dict):
+            return value
+
+        return args
+
+    return args

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/helpers/skills.py

@@ -71,7 +71,29 @@ class SkillsManager:
         if default_skill_dir not in directory_paths:
             directory_paths = [default_skill_dir] + list(directory_paths)
 
-        self.directory_paths = [Path(p).expanduser().resolve() for p in directory_paths]
+        # Resolve every path and drop exact directory duplicates.
+        resolved_paths = []
+        seen_paths = set()
+        for p in directory_paths:
+            try:
+                path = Path(p).expanduser().resolve()
+            except Exception:
+                continue
+            if path in seen_paths:
+                continue
+            seen_paths.add(path)
+            resolved_paths.append(path)
+
+        # Order paths: local project dirs first, then configured, home dirs last.
+        git_root_path = Path(git_root).expanduser().resolve() if git_root else None
+        ordered = sorted(
+            enumerate(resolved_paths),
+            key=lambda item: (
+                self._directory_priority(item[1], git_root_path),
+                item[0],
+            ),
+        )
+        self.directory_paths = [path for _, path in ordered]
         self.include_list = set(include_list) if include_list else None
         self.exclude_list = set(exclude_list) if exclude_list else set()
         self.git_root = Path(git_root).expanduser().resolve() if git_root else None
@@ -111,6 +133,35 @@ class SkillsManager:
 
             # Save initial state from config
 
+    @staticmethod
+    def _directory_priority(path: Path, git_root: Optional[Path] = None) -> int:
+        """Return the ordering priority of a skill directory.
+
+        Lower values are scanned first and therefore win by-name conflicts:
+
+        0 - local project directory (under the git root or working directory)
+        1 - any other configured directory
+        2 - a home directory (including the implicit ``~/.cecli/skills`` default)
+        """
+        home = Path.home().resolve()
+
+        # Implicit default skills dir is always treated as a home dir.
+        if path == (home / ".cecli" / "skills"):
+            return 2
+
+        local_anchor = git_root if git_root is not None else Path.cwd()
+        try:
+            path.relative_to(local_anchor)
+            return 0
+        except ValueError:
+            pass
+
+        try:
+            path.relative_to(home)
+            return 2
+        except ValueError:
+            return 1
+
     def _get_coder(self):
         """Return coder via weak reference, or None if collected."""
         if self._coder_ref is not None:
@@ -176,6 +227,7 @@ class SkillsManager:
             return self._skills_find_cache
 
         skills = []
+        seen_names: set[str] = set()
 
         for directory_path in self.directory_paths:
             directory_path = Path(directory_path)
@@ -193,6 +245,11 @@ class SkillsManager:
                         metadata = self._parse_skill_metadata(skill_md_path)
                         skill_name = metadata.name
 
+                        # First directory wins for duplicate skill names.
+                        if skill_name in seen_names:
+                            continue
+                        seen_names.add(skill_name)
+
                         # Apply include/exclude filters
                         if self.include_list and skill_name not in self.include_list:
                             continue

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/main.py

@@ -1437,7 +1437,7 @@ async def main_async(
         )
         io.tool_output(f"Cur working dir: {Path.cwd()}")
         io.tool_output(f"Git working dir: {git_root}")
-    if args.stream and args.cache_prompts:
+    if args.stream and args.cache_prompts and args.verbose:
         io.tool_warning("Cost estimates may be inaccurate when using streaming and caching.")
     if args.load:
         await commands.execute("load", args.load)

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/tools/command.py

@@ -108,7 +108,7 @@ class Tool(BaseTool):
         if not command:
             return command
 
-        return xxhash.xxh64(command).hexdigest()
+        return xxhash.xxh64(command.encode("utf-8")).hexdigest()
 
     @classmethod
     async def execute(

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/tools/search_facts.py

@@ -64,11 +64,6 @@ class Tool(BaseTool):
         try:
             results = search_facts(coder, words=words, tags=tags)
 
-            if not results:
-                # Re-search without tags as fallback
-                if tags:
-                    results = search_facts(coder, words=words, tags=None)
-
             for r in results:
                 response.append_result(
                     {

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/config/adv-model-settings.md

@@ -41,7 +41,7 @@ The json file should be a dictionary with an entry for each model, as follows:
 
 ### Contribute model metadata
 
-Cecli relies on [litellm's model_prices_and_context_window.json file](https://github.com/BerriAI/litellm/blob/main/model_prices_and_context_window.json) for model metadata.
+Cecli ships its own bundled model metadata in `cecli/resources/model-metadata.json` (see the file in the [cecli repository](https://github.com/cecli-dev/cecli/blob/main/cecli/resources/model-metadata.json)). It is based on LiteLLM's configuration scheme [here](https://github.com/BerriAI/litellm/blob/main/model_prices_and_context_window.json).
 
 Consider submitting a PR to that file to add missing models.
 
@@ -62,9 +62,9 @@ If the files above exist, they will be loaded in that order. Files loaded last w
 
 The YAML file should be a list of dictionary objects for each model.
 
-### Passing extra params to litellm.completion
+### Passing extra params to model requests
 
-The `extra_params` attribute of model settings is used to pass arbitrary extra parameters to the `litellm.completion()` call when sending data to the given model.
+The `extra_params` attribute of model settings is used to pass arbitrary extra parameters to cecli's completion dispatcher when sending data to the given model. These become request parameters sent to the provider API.
 
 For example:
 
@@ -76,7 +76,7 @@ For example:
     max_tokens: 8192
 ```
 
-You can use the special model name `cecli/extra_params` to define `extra_params` that will be passed to `litellm.completion()` for all models. Only the `extra_params` dict is used from this special model name.
+You can use the special model name `cecli/extra_params` to define `extra_params` that will be passed to cecli's completion dispatcher for all models. Only the `extra_params` dict is used from this special model name.
 
 For example:
 

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/config/model-configuration.md

@@ -16,12 +16,12 @@ Cecli allows you to customize and override LLM configurations to fine-tune their
 
 For advanced configurations, you can organize override parameters into three logical groups: `api`, `llm`, and `agent`.
 ### 1. `api`
-Values under `api` are merged directly into the model's API request parameters (`headers`). This is useful for configuring provider-specific API options, temperature, or custom headers. For the full list of supported parameters, see the [LiteLLM completion input documentation](https://docs.litellm.ai/docs/completion/input).
+Values under `api` are request-level parameters that cecli passes to the provider API. This is useful for configuring provider-specific API options, temperature, or custom headers. For more details, see the [advanced model settings](../config/adv-model-settings.html) page.
 
 **Common parameters**: `temperature`, `top_p`, `max_tokens`, `parallel_tool_calls`, `extra_body` (e.g., `thinking: true` or `reasoning_effort: "high"`).
 
 ### 2. `llm`
-Values under `llm` are merged into the model's info dictionary (`self.info`). This allows you to override or augment model metadata and capabilities. For a comprehensive list of available model metadata fields, see the [LiteLLM model prices and context window reference](https://github.com/BerriAI/litellm/blob/litellm_internal_staging/model_prices_and_context_window.json).
+Values under `llm` are merged into the model's info dictionary (`self.info`). This allows you to override or augment model metadata and capabilities. For a comprehensive list of available model metadata fields, see cecli's bundled metadata in [cecli/resources/model-metadata.json](https://github.com/cecli-dev/cecli/blob/main/cecli/resources/model-metadata.json).
 
 **Common parameters**: `supports_vision`, `supports_function_calling`, token limits, or pricing information.
 

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/config/skills.md

@@ -77,6 +77,14 @@ Skills are configured through the `agent-config` parameter in the YAML configura
 - **`skills_includelist`**: Array of skill names to include (whitelist)
 - **`skills_excludelist`**: Array of skill names to exclude (blacklist)
 
+> **Duplicate skill names**: When the same skill name is found in more than
+> one configured directory, only one copy is loaded. Directories are scanned
+> in priority order: local project directories (e.g. `./.cecli/skills`) first,
+> then other configured directories in the order they are listed, with home
+> directories (e.g. `~/skills` and the implicit `~/.cecli/skills` default)
+> last. If no `skills_paths` are configured, the only directory searched is
+> `~/.cecli/skills`.
+
 Complete configuration example in YAML configuration file (`.cecli.conf.yml` or `~/.cecli.conf.yml`):
 
 ```yaml

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/llms/bedrock.md

@@ -17,7 +17,7 @@ Amazon Bedrock has added support for a new feature called [cross-region "inferen
 
 If you attempt to use a `Model ID` for a model that exclusively supports the Inference Profile feature, you will receive an error message like the following:
 
-> litellm.BadRequestError: BedrockException - b'{"message":"Invocation of model ID
+> BadRequestError: BedrockException - b'{"message":"Invocation of model ID
 anthropic.claude-3-7-sonnet-20250219-v1:0 with on-demand throughput isn\xe2\x80\x99t supported. Retry your request with the ID or ARN of an inference profile that contains this model."}'
 
 ## Installation and Configuration
@@ -94,22 +94,11 @@ cecli --list-models bedrock/
 
 Make sure you have access to these models in your AWS account before attempting to use them with cecli.
 
-## Install boto3
-You may need to install the `boto3` package.
+## AWS credentials
 
-```bash
-# If you installed with cecli-install or `uv tool`
-uv tool run --from cecli-dev pip install boto3
-
-# Or with pipx...
-pipx inject cecli-dev boto3
-
-# Or with pip
-pip install -U boto3
-```
+Cecli signs Bedrock requests itself (AWS SigV4) using the standard AWS credentials from your environment (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` and optionally `AWS_SESSION_TOKEN`), so the `boto3` package is not required.
 
 # More info
 
 For more information on Amazon Bedrock and its models, refer to the [official AWS documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
 
-Also, see the [litellm docs on Bedrock](https://litellm.vercel.app/docs/providers/bedrock).

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/llms/gemini.md

@@ -36,15 +36,3 @@ cecli --model gemini-exp
 cecli --list-models gemini/
 ```
 
-You may need to install the `google-generativeai` package. 
-
-```bash
-# If you installed with cecli-install or `uv tool`
-uv tool run --from cecli-dev pip install google-generativeai
-
-# Or with pipx...
-pipx inject cecli-dev google-generativeai
-
-# Or with pip
-pip install -U google-generativeai
-```

cecli_dev-1.2.1/cecli/website/docs/llms/github.md

@@ -0,0 +1,22 @@
+---
+parent: Connecting to LLMs
+nav_order: 510
+---
+
+# GitHub Copilot
+
+Cecli can connect to GitHub Copilot’s LLMs because Copilot exposes a standard **OpenAI-style** endpoint at:
+
+```
+https://api.githubcopilot.com
+```
+
+First, install cecli:
+
+```bash
+uv tool install cecli-dev
+```
+
+---
+
+When you specify a GitHub Copilot model on start up (e.g. `github_copilot/gpt-5-mini`), cecli will enter a GitHub auth workflow natively, wherein you will connect to your GitHub account with the provided auth code to grant the system access.

cecli_dev-1.2.1/cecli/website/docs/llms/other.md

@@ -0,0 +1,46 @@
+---
+parent: Connecting to LLMs
+nav_order: 800
+---
+
+# Other LLMs
+
+Cecli connects directly to hundreds of models through their providers' APIs, so there is no extra model-routing package to install. You can use `cecli --model <model-name>` to use any supported model.
+
+To explore the list of supported models you can run `cecli --list-models <model-name>` with a partial model name. If the supplied name is not an exact match for a known model, cecli will return a list of possible matching models. For example:
+
+```
+$ cecli --list-models turbo
+
+cecli v0.29.3-dev
+Models which match "turbo":
+- gpt-4-turbo-preview (openai/gpt-4-turbo-preview)
+- gpt-4-turbo (openai/gpt-4-turbo)
+- gpt-4-turbo-2024-04-09 (openai/gpt-4-turbo-2024-04-09)
+- gpt-3.5-turbo (openai/gpt-3.5-turbo)
+- ...
+```
+
+See the [model warnings](warnings.html) section for information on warnings which will occur when working with models that cecli is not familiar with.
+
+## Connecting to other providers
+
+Cecli connects to each provider through its own request dispatcher (`cecli/helpers/llms/`): when you specify a model, cecli resolves the provider's base URL, API-key environment variable and API family (OpenAI-compatible chat, Anthropic Messages, Responses, Gemini, or Bedrock) and handles authentication and headers itself.
+
+## Other API key variables
+
+The authoritative list of provider base URLs and API-key environment variables is cecli's own provider configuration (`cecli/resources/providers.json`, which covers 61 providers) plus built-in defaults for the major providers. Each provider page in this section lists the variables you need to set, and `cecli --list-models <partial-name>` shows the model names cecli knows about.
+
+Here are some of the most commonly used API key environment variables:
+
+- OPENAI_API_KEY
+- ANTHROPIC_API_KEY
+- DEEPSEEK_API_KEY
+- OPENROUTER_API_KEY
+- GEMINI_API_KEY
+- META_API_KEY
+- GROQ_API_KEY
+- XAI_API_KEY
+- MISTRAL_API_KEY
+- OLLAMA_API_KEY
+- AZURE_API_KEY

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/llms/warnings.md

@@ -67,5 +67,5 @@ If required variables are missing,
 you may get errors when you attempt to chat with the model.
 You can look in the [cecli's LLM documentation](../llms.html)
 or the
-[litellm documentation](https://docs.litellm.ai/docs/providers)
+provider pages in this section
 to see if the required variables are listed there.

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/troubleshooting/imports.md

@@ -35,4 +35,3 @@ Cecli pins its dependencies and is tested to work with those specific versions.
 
 In particular, be careful with the packages with pinned versions noted at the end of [cecli's requirements.in file](https://github.com/cecli-dev/cecli/blob/main/requirements/requirements.in). These versions are pinned because cecli is known not to work with the latest versions of these libraries.
 
-Also be wary of upgrading `litellm`, as it changes versions frequently and sometimes introduces bugs or backwards incompatible changes.

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/troubleshooting/support.md

@@ -45,9 +45,9 @@ Yes, you can use local LLMs with cecli. Here's a summary of the options:
 
 2. OpenAI-compatible API: cecli can access local models that provide an OpenAI-compatible API.
 
-3. Other local models: cecli uses the LiteLLM package to connect to various LLM providers, which may include options for running models locally.
+3. Other local models: cecli connects directly to many LLM providers, including local and OpenAI-compatible endpoints (Ollama, LM Studio, etc.).
 
-However, it's important to note that cecli works best with more capable models. Less capable models may have difficulty properly returning "code edits," which could result in cecli not being able to edit your files and commit changes effectively.
+However, it's important to note that cecli works best with more capable models. Less capable models may have difficulty properly returning code edits, which could result in cecli not being able to edit your files and commit changes effectively.
 
 For more detailed information on using local LLMs and connecting to various models, you might want to check out these relevant documentation pages:
 

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli/website/docs/troubleshooting/warnings.md

@@ -66,8 +66,7 @@ which variables are required for the model.
 If required variables are missing,
 you may get errors when you attempt to chat with the model.
 You can look in the [cecli's LLM documentation](../llms.html)
-or the
-[litellm documentation](https://docs.litellm.ai/docs/providers)
+or the provider-specific pages (e.g. [OpenAI-compatible endpoints](../llms/openai-compat.html))
 to see if the required variables are listed there.
 
 ## More help

{cecli_dev-1.2.0 → cecli_dev-1.2.1}/cecli_dev.egg-info/PKG-INFO

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