kolega-code 0.7.0__tar.gz → 0.7.2__tar.gz

{kolega_code-0.7.0 → kolega_code-0.7.2}/.env.example

@@ -3,6 +3,9 @@
 
 ANTHROPIC_API_KEY=
 OPENAI_API_KEY=
+# Prefer a ChatGPT subscription over an OpenAI API key? Run `/login` in the TUI
+# (no key needed). Optional override of the OAuth client id, for testing only:
+# KOLEGA_CODE_CHATGPT_CLIENT_ID=
 GOOGLE_API_KEY=
 MOONSHOT_API_KEY=
 DEEPSEEK_API_KEY=

{kolega_code-0.7.0 → kolega_code-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.7.0
+Version: 0.7.2
 Summary: Local-first AI coding agent for the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/
@@ -176,6 +176,14 @@ and DeepSeek — and lets you assign **different models to different roles**: a
 long-context model for coding, a fast cheap model for small utility calls, and one for extended
 "thinking". See [Providers & Models](https://kolega-ai.github.io/kolega-code/configuration/providers-and-models/).
 
+## Sign in with ChatGPT
+
+If you have a paid **ChatGPT** plan (Plus, Pro, or Business), you can use it to run OpenAI models
+instead of a separate API key. Run `/login chatgpt` in the TUI, complete the browser sign-in, and
+Kolega Code switches to the **OpenAI (ChatGPT subscription)** provider (default `gpt-5.5`). Tokens are
+stored locally (chmod `600`) and refreshed automatically; `/logout chatgpt` removes them. See
+[Sign in with ChatGPT](https://kolega-ai.github.io/kolega-code/configuration/sign-in-with-chatgpt/).
+
 ## Configuration
 
 Set your provider, model, and API keys from the **Settings** tab in the UI, or via environment

{kolega_code-0.7.0 → kolega_code-0.7.2}/README.md

@@ -103,6 +103,14 @@ and DeepSeek — and lets you assign **different models to different roles**: a
 long-context model for coding, a fast cheap model for small utility calls, and one for extended
 "thinking". See [Providers & Models](https://kolega-ai.github.io/kolega-code/configuration/providers-and-models/).
 
+## Sign in with ChatGPT
+
+If you have a paid **ChatGPT** plan (Plus, Pro, or Business), you can use it to run OpenAI models
+instead of a separate API key. Run `/login chatgpt` in the TUI, complete the browser sign-in, and
+Kolega Code switches to the **OpenAI (ChatGPT subscription)** provider (default `gpt-5.5`). Tokens are
+stored locally (chmod `600`) and refreshed automatically; `/logout chatgpt` removes them. See
+[Sign in with ChatGPT](https://kolega-ai.github.io/kolega-code/configuration/sign-in-with-chatgpt/).
+
 ## Configuration
 
 Set your provider, model, and API keys from the **Settings** tab in the UI, or via environment

{kolega_code-0.7.0 → kolega_code-0.7.2}/RELEASING.md

@@ -20,6 +20,12 @@ release branch.
 2. Update `pyproject.toml`, `uv.lock`, and package `__version__` values to the
    release version.
 
+   Running `uv lock` advances the `exclude-newer` cutoff recorded in `uv.lock`,
+   because `pyproject.toml` sets `exclude-newer = "1 week"` as a relative
+   duration. The cutoff timestamp moving forward, and any dependency versions
+   released within the new one-week window being pulled in, is expected and
+   acceptable. Do not revert these changes.
+
 3. Run the fast test suite:
 
    ```bash

{kolega_code-0.7.0 → kolega_code-0.7.2}/docs/astro.config.mjs

@@ -56,6 +56,10 @@ export default defineConfig({
               label: "Providers & Models",
               slug: "configuration/providers-and-models",
             },
+            {
+              label: "Sign in with ChatGPT",
+              slug: "configuration/sign-in-with-chatgpt",
+            },
             {
               label: "Settings & API Keys",
               slug: "configuration/settings-and-api-keys",

{kolega_code-0.7.0 → kolega_code-0.7.2}/docs/src/content/docs/configuration/providers-and-models.mdx

@@ -16,6 +16,7 @@ The agent runtime recognizes these providers:
 | --- | --- | --- |
 | Anthropic | `anthropic` | `ANTHROPIC_API_KEY` |
 | OpenAI | `openai` | `OPENAI_API_KEY` |
+| OpenAI (ChatGPT subscription) | `openai_chatgpt` | _none — [sign in with ChatGPT](../sign-in-with-chatgpt/)_ |
 | Google | `google` | `GOOGLE_API_KEY` |
 | Groq | `groq` | `GROQ_API_KEY` |
 | Together.ai | `together` | `TOGETHER_API_KEY` |

kolega_code-0.7.2/docs/src/content/docs/configuration/sign-in-with-chatgpt.mdx

@@ -0,0 +1,93 @@
+---
+title: Sign in with ChatGPT
+description: Use your ChatGPT subscription to run OpenAI models in Kolega Code, without an API key.
+---
+
+import { Aside, Steps } from '@astrojs/starlight/components';
+
+If you have a paid **ChatGPT** plan, you can use it to run OpenAI models in Kolega
+Code — no separate `OPENAI_API_KEY` required. Sign in once with `/login chatgpt`
+and Kolega Code uses your subscription for the **OpenAI (ChatGPT subscription)**
+provider.
+
+## Eligibility
+
+| Plan | Runs models |
+| --- | --- |
+| Plus | Yes |
+| Pro | Yes |
+| Business | Yes |
+| Free | No |
+
+A Free plan can sign in, but can't run models this way — use an
+[`OPENAI_API_KEY`](../providers-and-models/) instead.
+
+## Signing in
+
+<Steps>
+
+1. In the TUI composer, run:
+
+   ```text
+   /login chatgpt
+   ```
+
+2. Your browser opens to the ChatGPT sign-in page. Complete the sign-in there.
+   (If the browser doesn't open, the composer prints a URL you can paste in
+   yourself.)
+
+3. When sign-in finishes, the browser shows a confirmation page and Kolega Code
+   switches to the **OpenAI (ChatGPT subscription)** provider, ready to use.
+
+</Steps>
+
+## Models
+
+The ChatGPT-subscription provider (identifier `openai_chatgpt`) exposes the Codex
+model line-up:
+
+| Model | Label |
+| --- | --- |
+| `gpt-5.5` | GPT-5.5 — default, frontier coding and reasoning |
+| `gpt-5.4` | GPT-5.4 — strong everyday coding |
+| `gpt-5.4-mini` | GPT-5.4 Mini — fast and economical |
+| `gpt-5.3-codex-spark` | GPT-5.3 Codex Spark — ultra-fast |
+
+Switch between them with [`/model`](../../tui/slash-commands/) or from the
+**Settings** tab. Each model supports a reasoning **thinking effort** you can set
+with [`/effort`](../../tui/slash-commands/).
+
+## Where credentials live
+
+Sign-in tokens are stored in your `settings.json` under `oauth_tokens`, in the
+same [state directory](../settings-and-api-keys/#where-settings-live) as the rest
+of your settings, with `0600` permissions (readable and writable only by your
+user). They refresh automatically in the background, so a single sign-in keeps
+working across sessions.
+
+## Checking status
+
+`doctor` reports whether you're signed in, without exposing any token:
+
+```bash
+kolega-code doctor --project .
+```
+
+For the ChatGPT-subscription provider it shows `signed in as <email> (<plan>)` or
+`not signed in`. See [`doctor`](../../cli/doctor/).
+
+## Signing out
+
+To remove your stored ChatGPT credentials:
+
+```text
+/logout chatgpt
+```
+
+After signing out, switch to another provider — or sign in again with
+`/login chatgpt` — to keep working.
+
+<Aside type="tip">
+`/login` and `/logout` take a provider name so more sign-in options can be added
+over time. Today, `chatgpt` is the available target.
+</Aside>

{kolega_code-0.7.0 → kolega_code-0.7.2}/docs/src/content/docs/hooks.md

@@ -63,6 +63,7 @@ Both files use the same shape:
 | `PreToolUse` | Before a tool runs (after the permission gate) | Denies the tool; the reason is returned to the agent as a tool error, so it can adjust |
 | `PostToolUse` | After a tool succeeds (and on failure) | Ends the turn; the reason is shown as a warning |
 | `PreCompact` | Before the conversation is compacted | Advisory |
+| `PostCompact` | After the conversation is compacted | Advisory; payload reports before/after token counts |
 | `Stop` | The agent is about to finish its turn | Keeps the agent working; the reason becomes its next instruction |
 | `SubagentStop` | A dispatched sub-agent finished | Advisory; can annotate the result the parent sees |
 | `Notification` | A permission prompt is about to be shown | Advisory (desktop notifications, sounds) |

{kolega_code-0.7.0 → kolega_code-0.7.2}/docs/src/content/docs/tui/slash-commands.md

@@ -40,6 +40,8 @@ These control the app and your session.
 | `/permissions` | Show or switch the shell/edit permission mode |
 | `/model` | Choose the active model |
 | `/effort` | Choose the active model's thinking effort |
+| `/login` | Sign in to a provider, e.g. `/login chatgpt` |
+| `/logout` | Sign out of a provider, e.g. `/logout chatgpt` |
 | `/gigacode` | Toggle [gigacode](../../gigacode/) workflow orchestration on or off |
 | `/copy` | Copy the last response to the clipboard |
 | `/version` | Show the Kolega Code version |
@@ -53,6 +55,10 @@ provider. You can also switch directly with `/model <name>`.
 Run `/effort` to open a selectable list of supported effort values for the
 active model. You can also switch directly with `/effort <level>`.
 
+Run `/login chatgpt` to sign in with a ChatGPT subscription and use OpenAI models
+without an API key; `/logout chatgpt` removes the stored credentials. See
+[Sign in with ChatGPT](../../configuration/sign-in-with-chatgpt/).
+
 Run `/init` to have the agent inspect the repository and create or update a
 concise root `AGENTS.md`. Extra text after the command is passed as focus or
 constraints:

{kolega_code-0.7.0 → kolega_code-0.7.2}/kolega_code/__init__.py

@@ -148,4 +148,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"

{kolega_code-0.7.0 → kolega_code-0.7.2}/kolega_code/agent/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"

{kolega_code-0.7.0 → kolega_code-0.7.2}/kolega_code/agent/baseagent.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from typing import Any, AsyncGenerator, Dict, List, Optional
 
 from .common import LogMixin
-from .compression import HistoryCompressor
+from .compression import CompactionResult, HistoryCompressor
 from kolega_code.config import AgentConfig, ModelProvider
 from kolega_code.events import AgentConnectionManager
 from .context import AgentContext, AgentServices, Telemetry, WorkspaceInfo
@@ -398,6 +398,14 @@ class BaseAgent(LogMixin):
         """Restores the message history from a list of dictionaries using custom methods."""
         self.conversation.restore(serialized_history)
 
+    def dump_compaction_state(self) -> Dict[str, Any]:
+        """Serialize the compaction boundary (summary + how many leading messages it folds)."""
+        return self.conversation.dump_compaction()
+
+    def restore_compaction_state(self, data: Optional[Dict[str, Any]]) -> None:
+        """Restore the compaction boundary; must be called after restore_message_history."""
+        self.conversation.restore_compaction(data)
+
     def _sanitize_oversized_tool_results(self) -> int:
         return self.conversation.sanitize_oversized_tool_results()
 
@@ -549,9 +557,12 @@ class BaseAgent(LogMixin):
             message=message,
         )
 
-    async def compress_history(self) -> None:
+    async def compress_history(self) -> CompactionResult:
         """
-        Non-destructively summarize the current history and mark a compression boundary.
+        Non-destructively summarize the current history, keeping recent turns
+        verbatim. Emits a compaction_status event around the work so the UI can
+        show progress, then recounts + emits a context_update so the gauge
+        refreshes. Returns the structured outcome.
         """
 
         async def on_info(message: str) -> None:
@@ -560,16 +571,34 @@ class BaseAgent(LogMixin):
         async def on_error(message: str) -> None:
             await self.log_error(message, sender=self.agent_name)
 
-        await self.compressor.summarize(
-            self.conversation,
-            llm=self.llm,
-            model=self.primary_model_config.model,
-            max_completion_tokens=self.model_completion_tokens,
-            temperature=self.model_default_temperature,
-            thinking=self.primary_model_config.thinking_effort,
-            on_info=on_info,
-            on_error=on_error,
+        await self.emitter.compaction_status("started", "Compacting conversation…")
+        try:
+            result = await self.compressor.summarize(
+                self.conversation,
+                llm=self.llm,
+                model=self.primary_model_config.model,
+                temperature=self.model_default_temperature,
+                # No extended thinking: a bounded summary doesn't need it, and the
+                # thinking budget could otherwise exceed the small summary max_tokens.
+                thinking=None,
+                on_info=on_info,
+                on_error=on_error,
+            )
+        finally:
+            # Recount + emit so the context gauge reflects post-compaction reality
+            # (even on a no-op the UI may have been stale).
+            await self.count_current_context()
+
+        phase = "finished" if result.ok else "error"
+        summary_text = (
+            self.conversation.summary.get_text_content() if result.ok and self.conversation.summary else ""
         )
+        await self.emitter.compaction_status(phase, result.message, summary=summary_text)
+        return result
+
+    def clear_history(self) -> None:
+        """Drop all history and reset compaction state."""
+        self.conversation.clear()
 
     # ------------------------------------------------------------------
     # Tool execution
@@ -936,6 +965,7 @@ class BaseAgent(LogMixin):
             max_retries=model_config.rate_limits.max_retries,
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,
+            token_manager=self.config.get_chatgpt_token_manager(),
         )
         response = await client.generate(
             model=model_config.model,
@@ -1135,9 +1165,8 @@ class BaseAgent(LogMixin):
     #
     # process_message_stream is the single canonical loop shared by every
     # agent. Subclasses customize behavior through the hook methods below
-    # (build_user_content, apply_compression_fallback, on_tool_use_start,
-    # should_stop_after_tools, recap_agent_outcome) rather than overriding
-    # the loop itself.
+    # (build_user_content, on_tool_use_start, should_stop_after_tools,
+    # recap_agent_outcome) rather than overriding the loop itself.
     # ------------------------------------------------------------------
 
     completion_log_message = "Processing complete"
@@ -1165,21 +1194,6 @@ class BaseAgent(LogMixin):
 
         return content_blocks
 
-    def apply_compression_fallback(self) -> None:
-        """
-        Hard-truncate history when compression alone could not get under budget.
-
-        Default: keep the first message (the original task) plus any protected
-        skill-content messages.
-        """
-        first_message = self.history[0]
-        protected = [
-            message
-            for message in self.history
-            if message is not first_message and self._is_protected_skill_content(message)
-        ]
-        self.history = MessageHistory(protected + [first_message])
-
     async def on_tool_use_start(self, tool_call_delta: Dict[str, Any]) -> None:
         """
         Called when the provider streams a tool_use_start event (Anthropic only).
@@ -1251,20 +1265,35 @@ class BaseAgent(LogMixin):
                 logger.debug("Input token count: %s", token_count)
 
                 if self.compressor.over_budget(token_count.input_tokens, self.model_context_length):
+                    before_tokens = token_count.input_tokens
                     # PreCompact hooks (advisory): observe before history is compacted.
                     await self.fire_hook(
                         HookEvent.PRE_COMPACT,
                         {
                             "trigger": "auto",
-                            "input_tokens": token_count.input_tokens,
+                            "input_tokens": before_tokens,
                             "model_context_length": self.model_context_length,
                         },
                     )
-                    await self.compress_history()
+                    result = await self.compress_history()
                     token_count = await self.count_current_context()
 
-                    if self.compressor.over_budget(token_count.input_tokens, self.model_context_length):
-                        self.apply_compression_fallback()
+                    # PostCompact hooks (advisory): observe the outcome. There is no
+                    # destructive fallback — a bounded summary plus capped tool results
+                    # and a small verbatim tail keep us under budget; if somehow not, we
+                    # send as-is rather than wipe history.
+                    await self.fire_hook(
+                        HookEvent.POST_COMPACT,
+                        {
+                            "trigger": "auto",
+                            "ok": result.ok,
+                            "reason": result.reason,
+                            "summarized_messages": result.summarized_messages,
+                            "input_tokens_before": before_tokens,
+                            "input_tokens_after": token_count.input_tokens,
+                            "model_context_length": self.model_context_length,
+                        },
+                    )
 
                     self.mark_cache_checkpoint()
 

kolega_code-0.7.2/kolega_code/agent/compression.py

@@ -0,0 +1,146 @@
+"""History compression: summarize a conversation when it outgrows the context window."""
+
+import logging
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Optional
+
+from .conversation import Conversation
+from kolega_code.llm.models import Message, MessageHistory, TextBlock
+from .prompts import (
+    build_compression_summary_user_prompt,
+    COMPRESSION_SUMMARY_SYSTEM_PROMPT,
+)
+
+logger = logging.getLogger(__name__)
+
+LogCallback = Callable[[str], Awaitable[None]]
+
+
+@dataclass(frozen=True)
+class CompactionResult:
+    """Outcome of a compaction attempt, surfaced to callers and the UI.
+
+    ``reason`` is a machine tag: "ok" | "too_few" | "nothing_to_summarize" | "llm_error".
+    ``message`` is a human-readable line for the command output / logs.
+    """
+
+    ok: bool
+    reason: str
+    summarized_messages: int = 0
+    message: str = ""
+
+
+class HistoryCompressor:
+    """Summarizes a conversation non-destructively when it crosses the budget threshold."""
+
+    MIN_MESSAGES_TO_COMPRESS = 5
+    # How many of the most recent messages to keep verbatim after the summary.
+    KEEP_RECENT_MESSAGES = 6
+    # Don't bother summarizing a trivially short prefix.
+    MIN_PREFIX_TO_SUMMARIZE = 3
+    # Cap the summary length: the prompt targets ~600 words (~900 tokens), so a
+    # small ceiling keeps it tight and avoids the model's full completion budget.
+    SUMMARY_MAX_TOKENS = 2048
+
+    def __init__(self, threshold: float = 0.8) -> None:
+        # Fraction of the model context window above which compression kicks in
+        self.threshold = threshold
+
+    def over_budget(self, input_tokens: int, model_context_length: int) -> bool:
+        return input_tokens > model_context_length * self.threshold
+
+    async def summarize(
+        self,
+        conversation: Conversation,
+        *,
+        llm,
+        model: str,
+        temperature: float,
+        thinking,
+        on_info: Optional[LogCallback] = None,
+        on_error: Optional[LogCallback] = None,
+    ) -> CompactionResult:
+        """
+        Non-destructively summarize the aged-out prefix while keeping the most
+        recent turns verbatim, and move the compaction boundary.
+
+        Incremental: only the messages that have aged out since the previous
+        boundary are summarized, with the prior summary folded in for continuity.
+        Returns a CompactionResult describing what happened — never a silent no-op.
+        """
+        history = conversation.history
+        if not history or len(history) < self.MIN_MESSAGES_TO_COMPRESS:
+            return CompactionResult(
+                ok=False,
+                reason="too_few",
+                message=(
+                    f"Nothing to compress yet ({len(history)} message(s); "
+                    f"need at least {self.MIN_MESSAGES_TO_COMPRESS})."
+                ),
+            )
+
+        split = conversation.compaction_split_point(
+            keep_recent=self.KEEP_RECENT_MESSAGES, min_prefix=self.MIN_PREFIX_TO_SUMMARIZE
+        )
+        prior_through = conversation.compacted_through if conversation.summary is not None else 0
+        if split is None or split <= prior_through:
+            return CompactionResult(
+                ok=False,
+                reason="nothing_to_summarize",
+                message="Already compact — no older messages to summarize.",
+            )
+
+        if on_info:
+            await on_info("Compressing message history...")
+
+        try:
+            prefix = MessageHistory(list(history[prior_through:split]))
+            prefix_markdown = prefix.get_markdown_conversation()
+            previous_summary = conversation.summary.get_text_content() if conversation.summary is not None else None
+            user_prompt_filled = build_compression_summary_user_prompt(
+                prefix_markdown, previous_summary=previous_summary
+            )
+
+            messages = MessageHistory([Message(role="user", content=[TextBlock(text=user_prompt_filled)])])
+            system_message = Message(role="system", content=[TextBlock(text=COMPRESSION_SUMMARY_SYSTEM_PROMPT)])
+
+            # Stream and drain rather than calling generate(): the Anthropic SDK
+            # rejects non-streaming requests whose max_tokens is large enough to risk
+            # a >10-minute response, which the model's full completion budget triggers.
+            async with await llm.stream(
+                messages=messages,
+                system=system_message,
+                temperature=temperature,
+                model=model,
+                max_completion_tokens=self.SUMMARY_MAX_TOKENS,
+                thinking=thinking,
+            ) as stream:
+                async for _event in stream:
+                    pass
+            response = await stream.get_final_message()
+
+            summary_text = response.get_text_content()
+            if not summary_text or not summary_text.strip():
+                msg = "Compression produced an empty summary; history left unchanged."
+                if on_error:
+                    await on_error(msg)
+                else:
+                    logger.error(msg)
+                return CompactionResult(ok=False, reason="llm_error", message=msg)
+
+            folded = split - prior_through
+            conversation.apply_compaction(summary_text, split)
+
+            done = f"Compressed {folded} older message(s) into a summary; kept the latest turns verbatim."
+            if on_info:
+                await on_info(done)
+            return CompactionResult(ok=True, reason="ok", summarized_messages=folded, message=done)
+
+        except Exception as e:
+            # Never swallow into a fake success: log the full traceback and surface
+            # the real error to the caller.
+            logger.exception("Failed to compress message history")
+            msg = f"Failed to compress message history: {type(e).__name__}: {e}"
+            if on_error:
+                await on_error(msg)
+            return CompactionResult(ok=False, reason="llm_error", message=msg)

{kolega_code-0.7.0 → kolega_code-0.7.2}/kolega_code/agent/context.py

@@ -113,6 +113,7 @@ class AgentContext:
                 user_id=self.telemetry.user_id,
                 user_email=self.telemetry.user_email,
                 usage_recorder=self.telemetry.usage_recorder,
+                token_manager=self.config.get_chatgpt_token_manager(),
             )
 
         return LLMClient(
@@ -121,4 +122,5 @@ class AgentContext:
             max_retries=model_config.rate_limits.max_retries,
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,
+            token_manager=self.config.get_chatgpt_token_manager(),
         )