codex-chat-bot 0.1.2__tar.gz → 0.1.4__tar.gz

{codex_chat_bot-0.1.2 → codex_chat_bot-0.1.4}/.gitignore

@@ -7,6 +7,8 @@ __pycache__/
 .ruff_cache/
 .tox/
 .nox/
+*.json
+tmp/
 
 # Virtual environments
 .venv/

{codex_chat_bot-0.1.2 → codex_chat_bot-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-chat-bot
-Version: 0.1.2
+Version: 0.1.4
 Summary: A small single-session chat client for OpenAI-compatible Responses API endpoints.
 Author-email: GGN_2015 <neko@jlulug.org>
 Requires-Python: >=3.10

{codex_chat_bot-0.1.2 → codex_chat_bot-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-chat-bot"
-version = "0.1.2"
+version = "0.1.4"
 description = "A small single-session chat client for OpenAI-compatible Responses API endpoints."
 readme = "README.md"
 authors = [

{codex_chat_bot-0.1.2 → codex_chat_bot-0.1.4}/src/codex_chat_bot/session.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import sys
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -15,6 +16,10 @@ SYSTEM_USERNAME = "system"
 DEVELOPER_USERNAME = "developer"
 DEFAULT_USERNAME = "user"
 ASSISTANT_USERNAME = "assistant"
+MAX_REQUEST_HISTORY_MESSAGES = 5
+ANSI_YELLOW = "\033[1;33m"
+ANSI_RESET = "\033[0m"
+EMPTY_RESPONSE_RETRY_WARNING = "Warning: The robot returned an empty string, and is currently retrying."
 
 
 @dataclass(frozen=True)
@@ -136,22 +141,29 @@ class ChatSession:
 
         self._messages.append(Message(role="user", content=message, username=username))
         try:
-            response = self._client.responses.create(**self._request_payload(extra_request_args))
+            response, text = self._create_response_until_text(extra_request_args)
         except Exception:
             self._messages.pop()
             self._save_bound_history()
             raise
 
-        text = _extract_response_text(response)
         self._messages.append(Message(role="assistant", content=text, username=ASSISTANT_USERNAME))
         self._trim_history()
         self._save_bound_history()
         return ChatResponse(text=text, raw=response, messages=self.messages)
 
+    def _create_response_until_text(self, extra_request_args: Mapping[str, Any]) -> tuple[Any, str]:
+        while True:
+            response = self._client.responses.create(**self._request_payload(extra_request_args))
+            text = _extract_response_text(response)
+            if text != "":
+                return response, text
+            _warn_empty_response_retry()
+
     def _request_payload(self, extra_request_args: Mapping[str, Any]) -> dict[str, Any]:
         payload: dict[str, Any] = {
             "model": self.config.model,
-            "input": [message.to_api() for message in self._messages],
+            "input": [message.to_api() for message in _latest_messages(self._messages, MAX_REQUEST_HISTORY_MESSAGES)],
         }
         if self.config.temperature is not None:
             payload["temperature"] = self.config.temperature
@@ -165,7 +177,7 @@ class ChatSession:
         rules = self.config.system_rules if system_rules is None else system_rules
 
         clean_rules = [str(rule).strip() for rule in rules if str(rule).strip()]
-        return "\n".join(clean_rules)
+        return " ".join(clean_rules)
 
     def _trim_history(self) -> None:
         max_messages = self.config.max_history_messages
@@ -213,6 +225,10 @@ class ChatSession:
 
 
 def _extract_response_text(response: Any) -> str:
+    error_json = _extract_response_error_json(response)
+    if error_json is not None:
+        return error_json
+
     output_text = _get_value(response, "output_text")
     if isinstance(output_text, str):
         return output_text
@@ -230,6 +246,36 @@ def _extract_response_text(response: Any) -> str:
     raise ResponseTextError("could not extract text from the model response")
 
 
+def _warn_empty_response_retry() -> None:
+    print(f"{ANSI_YELLOW}{EMPTY_RESPONSE_RETRY_WARNING}{ANSI_RESET}", file=sys.stderr, flush=True)
+
+
+def _extract_response_error_json(response: Any) -> str | None:
+    error = _get_value(response, "error")
+    if error is None:
+        return None
+    return json.dumps({"error": _to_jsonable(error)}, ensure_ascii=False, indent=4)
+
+
+def _to_jsonable(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _to_jsonable(item) for key, item in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_to_jsonable(item) for item in value]
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+
+    model_dump = getattr(value, "model_dump", None)
+    if callable(model_dump):
+        return _to_jsonable(model_dump(mode="json"))
+
+    to_dict = getattr(value, "to_dict", None)
+    if callable(to_dict):
+        return _to_jsonable(to_dict())
+
+    return str(value)
+
+
 def _messages_from_history_payload(payload: Any) -> tuple[Message, ...]:
     if isinstance(payload, list):
         raw_messages = payload
@@ -256,6 +302,19 @@ def _messages_from_history_payload(payload: Any) -> tuple[Message, ...]:
     return tuple(messages)
 
 
+def _latest_messages(messages: Sequence[Message], max_messages: int) -> tuple[Message, ...]:
+    if max_messages <= 0:
+        return tuple(messages)
+
+    non_system_indexes = [index for index, message in enumerate(messages) if message.role != "system"]
+    kept_non_system_indexes = set(non_system_indexes[-max_messages:])
+    return tuple(
+        message
+        for index, message in enumerate(messages)
+        if message.role == "system" or index in kept_non_system_indexes
+    )
+
+
 def normalize_username(username: str) -> str:
     username = str(username).strip()
     if not username:
@@ -279,7 +338,7 @@ def _username_from_history_item(item: Mapping[str, Any], index: int, role: Role)
 
 
 def _format_user_content_for_api(content: str, username: str) -> str:
-    return f"Message from {username}:\n{content}"
+    return f"{username}: {content}"
 
 
 def _default_username_for_role(role: Role) -> str:

{codex_chat_bot-0.1.2 → codex_chat_bot-0.1.4}/tests/test_session.py

@@ -4,7 +4,12 @@ import json
 import pytest
 
 from codex_chat_bot import ChatConfig, ChatSession, Message
-from codex_chat_bot.session import _extract_response_text
+from codex_chat_bot.session import (
+    ANSI_RESET,
+    ANSI_YELLOW,
+    EMPTY_RESPONSE_RETRY_WARNING,
+    _extract_response_text,
+)
 
 
 class FakeResponses:
@@ -14,8 +19,8 @@ class FakeResponses:
     def create(self, **kwargs):
         self.calls.append(kwargs)
         user_message = kwargs["input"][-1]["content"]
-        if user_message.startswith("Message from ") and "\n" in user_message:
-            user_message = user_message.split("\n", 1)[1]
+        if ": " in user_message:
+            user_message = user_message.split(": ", 1)[1]
         return SimpleNamespace(output_text=f"answer: {user_message}")
 
 
@@ -24,12 +29,33 @@ class FakeClient:
         self.responses = FakeResponses()
 
 
+class ScriptedResponses:
+    def __init__(self, output_texts):
+        self.output_texts = list(output_texts)
+        self.calls = []
+
+    def create(self, **kwargs):
+        self.calls.append(kwargs)
+        return SimpleNamespace(output_text=self.output_texts.pop(0))
+
+
+class ScriptedClient:
+    def __init__(self, output_texts):
+        self.responses = ScriptedResponses(output_texts)
+
+
 def make_session(**config_overrides):
     config = ChatConfig(api_key="test-key", base_url="https://api.example/v1", model="test-model", **config_overrides)
     client = FakeClient()
     return ChatSession(config=config, client=client), client
 
 
+def make_scripted_session(output_texts, **config_overrides):
+    config = ChatConfig(api_key="test-key", base_url="https://api.example/v1", model="test-model", **config_overrides)
+    client = ScriptedClient(output_texts)
+    return ChatSession(config=config, client=client), client
+
+
 def test_session_sends_full_single_session_history():
     session, client = make_session(system_rules=("Follow the test.",))
 
@@ -39,9 +65,9 @@ def test_session_sends_full_single_session_history():
     second_input = client.responses.calls[1]["input"]
     assert second_input == [
         {"role": "system", "content": "Follow the test."},
-        {"role": "user", "content": "Message from user:\nhello"},
+        {"role": "user", "content": "user: hello"},
         {"role": "assistant", "content": "answer: hello"},
-        {"role": "user", "content": "Message from user:\nwhat did I say?"},
+        {"role": "user", "content": "user: what did I say?"},
     ]
 
 
@@ -54,9 +80,9 @@ def test_session_sends_usernames_as_model_visible_user_context():
     second_input = client.responses.calls[1]["input"]
     assert second_input == [
         {"role": "system", "content": "Follow the test."},
-        {"role": "user", "content": "Message from alice:\nhello"},
+        {"role": "user", "content": "alice: hello"},
         {"role": "assistant", "content": "answer: hello"},
-        {"role": "user", "content": "Message from bob:\nsame chat, different person"},
+        {"role": "user", "content": "bob: same chat, different person"},
     ]
     assert session.messages == (
         Message(role="system", content="Follow the test.", username="system"),
@@ -67,6 +93,71 @@ def test_session_sends_usernames_as_model_visible_user_context():
     )
 
 
+def test_session_retries_empty_model_text_until_non_empty(capsys):
+    session, client = make_scripted_session(["", "", "answer: hello"], system_rules=("Follow the test.",))
+
+    response = session.send("hello")
+    captured = capsys.readouterr()
+
+    assert response.text == "answer: hello"
+    assert response.raw.output_text == "answer: hello"
+    assert captured.err.count(f"{ANSI_YELLOW}{EMPTY_RESPONSE_RETRY_WARNING}{ANSI_RESET}") == 2
+    assert len(client.responses.calls) == 3
+    assert [call["input"] for call in client.responses.calls] == [
+        [
+            {"role": "system", "content": "Follow the test."},
+            {"role": "user", "content": "user: hello"},
+        ],
+        [
+            {"role": "system", "content": "Follow the test."},
+            {"role": "user", "content": "user: hello"},
+        ],
+        [
+            {"role": "system", "content": "Follow the test."},
+            {"role": "user", "content": "user: hello"},
+        ],
+    ]
+    assert session.messages == (
+        Message(role="system", content="Follow the test.", username="system"),
+        Message(role="user", content="hello", username="user"),
+        Message(role="assistant", content="answer: hello", username="assistant"),
+    )
+
+
+def test_session_keeps_retrying_empty_model_texts(capsys):
+    session, client = make_scripted_session(["", "", "", "", "", "answer: hello"], system_rules=("Follow the test.",))
+
+    response = session.send("hello")
+    captured = capsys.readouterr()
+
+    assert response.text == "answer: hello"
+    assert response.raw.output_text == "answer: hello"
+    assert captured.err.count(f"{ANSI_YELLOW}{EMPTY_RESPONSE_RETRY_WARNING}{ANSI_RESET}") == 5
+    assert len(client.responses.calls) == 6
+    assert session.messages == (
+        Message(role="system", content="Follow the test.", username="system"),
+        Message(role="user", content="hello", username="user"),
+        Message(role="assistant", content="answer: hello", username="assistant"),
+    )
+
+
+def test_session_returns_response_error_json_as_message_text():
+    session, client = make_session(system_rules=("Follow the test.",))
+    client.responses.create = lambda **kwargs: SimpleNamespace(
+        error={"code": "model_error", "message": "generation failed"}
+    )
+
+    response = session.send("hello")
+
+    assert json.loads(response.text) == {
+        "error": {
+            "code": "model_error",
+            "message": "generation failed",
+        }
+    }
+    assert session.messages[-1] == Message(role="assistant", content=response.text, username="assistant")
+
+
 def test_session_adds_system_rules_to_system_message():
     session, client = make_session(
         system_rules=("Follow the test.", "Answer in English.", "Keep answers short."),
@@ -76,7 +167,7 @@ def test_session_adds_system_rules_to_system_message():
 
     assert client.responses.calls[0]["input"][0] == {
         "role": "system",
-        "content": "Follow the test.\nAnswer in English.\nKeep answers short.",
+        "content": "Follow the test. Answer in English. Keep answers short.",
     }
 
 
@@ -112,6 +203,31 @@ def test_history_limit_keeps_latest_non_system_messages():
     )
 
 
+def test_request_payload_keeps_all_system_messages_and_latest_five_non_system_messages():
+    session, client = make_session(system_rules=("ignored",))
+    history_messages = [
+        {"role": "system", "content": "Persisted system."},
+        {"role": "user", "content": "old user"},
+        {"role": "system", "content": "Later system."},
+    ]
+    history_messages.extend(
+        {"role": "user" if index % 2 == 0 else "assistant", "content": f"message {index}"}
+        for index in range(8)
+    )
+    session.load_history_json(json.dumps({"messages": history_messages}))
+
+    session.ask("new")
+
+    request_input = client.responses.calls[0]["input"]
+    assert len(request_input) == 7
+    assert request_input[0] == {"role": "system", "content": "Persisted system."}
+    assert request_input[1] == {"role": "system", "content": "Later system."}
+    assert request_input[2] == {"role": "user", "content": "user: message 4"}
+    assert request_input[-2] == {"role": "assistant", "content": "message 7"}
+    assert request_input[-1] == {"role": "user", "content": "user: new"}
+    assert session.messages[1] == Message(role="user", content="old user", username="user")
+
+
 def test_session_exports_and_imports_history_json():
     session, _ = make_session(system_rules=("Follow the test.",))
 
@@ -135,9 +251,9 @@ def test_session_exports_and_imports_history_json():
 
     assert client.responses.calls[0]["input"] == [
         {"role": "system", "content": "Follow the test."},
-        {"role": "user", "content": "Message from user:\nhello"},
+        {"role": "user", "content": "user: hello"},
         {"role": "assistant", "content": "answer: hello"},
-        {"role": "user", "content": "Message from user:\ncontinue"},
+        {"role": "user", "content": "user: continue"},
     ]
 
 
@@ -184,9 +300,9 @@ def test_session_bind_history_loads_existing_file_and_saves_updates(tmp_path):
 
     assert client.responses.calls[0]["input"] == [
         {"role": "system", "content": "Persisted system."},
-        {"role": "user", "content": "Message from user:\nold"},
+        {"role": "user", "content": "user: old"},
         {"role": "assistant", "content": "answer: old"},
-        {"role": "user", "content": "Message from user:\nnew"},
+        {"role": "user", "content": "user: new"},
     ]
     assert json.loads(history_file.read_text(encoding="utf-8")) == {
         "messages": [