gptcmd 2.3.4__tar.gz → 2.3.5__tar.gz

{gptcmd-2.3.4 → gptcmd-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gptcmd
-Version: 2.3.4
+Version: 2.3.5
 Summary: Command line GPT conversation and experimentation environment
 Author-email: Bill Dengler <codeofdusk@gmail.com>
 License-Expression: MPL-2.0

{gptcmd-2.3.4 → gptcmd-2.3.5}/src/gptcmd/__init__.py

@@ -8,6 +8,6 @@ file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 __all__ = ["__version__", "Gptcmd"]
 
-__version__ = "2.3.4"
+__version__ = "2.3.5"
 
 from .cli import Gptcmd  # noqa: E402

{gptcmd-2.3.4 → gptcmd-2.3.5}/src/gptcmd/llm/openai.py

@@ -30,6 +30,11 @@ ModelCostInfo = namedtuple(
 )
 
 OPENAI_COSTS: Dict[str, ModelCostInfo] = {
+    "gpt-5.4-2026-03-05": ModelCostInfo(
+        Decimal("2.5") / Decimal("1000000"),
+        Decimal("15") / Decimal("1000000"),
+        Decimal("0.1"),
+    ),
     "gpt-5.2-2025-12-11": ModelCostInfo(
         Decimal("1.75") / Decimal("1000000"),
         Decimal("14") / Decimal("1000000"),
@@ -371,6 +376,7 @@ class OpenAI(LLMProvider):
 
     def get_best_model(self):
         BEST_MODELS = (
+            "gpt-5.4",
             "gpt-5.2",
             "gpt-5.1",
             "gpt-5",

{gptcmd-2.3.4 → gptcmd-2.3.5}/src/gptcmd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gptcmd
-Version: 2.3.4
+Version: 2.3.5
 Summary: Command line GPT conversation and experimentation environment
 Author-email: Bill Dengler <codeofdusk@gmail.com>
 License-Expression: MPL-2.0

{gptcmd-2.3.4 → gptcmd-2.3.5}/src/gptcmd.egg-info/SOURCES.txt

@@ -15,5 +15,7 @@ src/gptcmd.egg-info/requires.txt
 src/gptcmd.egg-info/top_level.txt
 src/gptcmd/llm/__init__.py
 src/gptcmd/llm/openai.py
+tests/test_cli.py
 tests/test_llm.py
-tests/test_message.py
+tests/test_message.py
+tests/test_openai.py

gptcmd-2.3.5/tests/test_cli.py

@@ -0,0 +1,81 @@
+import unittest
+
+from types import SimpleNamespace
+from typing import Dict, Sequence
+
+from gptcmd.cli import Gptcmd
+from gptcmd.llm import LLMProvider, LLMProviderFeature, LLMResponse
+from gptcmd.message import Message, MessageRole
+from gptcmd.tools import ToolDefinition, ToolKind
+
+
+class ToolCompletionProvider(LLMProvider):
+    SUPPORTED_FEATURES = LLMProviderFeature.TOOL_CALLING
+
+    def __init__(self):
+        self._tools_available = (
+            ToolDefinition(
+                name="web_search",
+                description="Search tool",
+                kind=ToolKind.PROVIDER_HOSTED,
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": True,
+                },
+                provider_payload={"type": "web_search_preview"},
+            ),
+        )
+        super().__init__(model="dummy-1")
+
+    @classmethod
+    def from_config(cls, conf: Dict):
+        return cls()
+
+    @property
+    def available_tools(self):
+        return self._tools_available
+
+    def complete(self, messages: Sequence[Message]) -> LLMResponse:
+        return LLMResponse(
+            Message(content="ok", role=MessageRole.ASSISTANT)
+        )
+
+    def validate_api_params(self, params):
+        return params
+
+    @property
+    def valid_models(self):
+        return ("dummy-1",)
+
+    def get_best_model(self):
+        return "dummy-1"
+
+
+class TestToolCompletion(unittest.TestCase):
+    def setUp(self):
+        self.cmd = Gptcmd.__new__(Gptcmd)
+        self.cmd._account = SimpleNamespace(provider=ToolCompletionProvider())
+
+    def test_complete_tool_name_when_partial_first_argument(self):
+        result = self.cmd.complete_tool(
+            text="we",
+            line="tool we",
+            begidx=5,
+            endidx=7,
+        )
+        self.assertEqual(result, ["web_search"])
+
+    def test_complete_policy_on_second_argument(self):
+        result = self.cmd.complete_tool(
+            text="a",
+            line="tool web_search a",
+            begidx=16,
+            endidx=17,
+        )
+        self.assertIn("always", result)
+        self.assertIn("ask", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

gptcmd-2.3.5/tests/test_openai.py

@@ -0,0 +1,155 @@
+import unittest
+
+from types import SimpleNamespace
+from typing import Dict, Sequence
+
+from gptcmd.llm.openai import OpenAI
+from gptcmd.message import Message, MessageRole
+from gptcmd.tools import (
+    ToolContext,
+    ToolExecutionPolicy,
+    ToolSettings,
+    callable_to_tool_definition,
+)
+
+
+def _sum_numbers(a: int, b: int, ctx: ToolContext) -> Dict[str, int]:
+    return {"sum": a + b}
+
+
+def _usage(
+    prompt_tokens: int,
+    completion_tokens: int,
+    cached_tokens: int,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        prompt_tokens=prompt_tokens,
+        prompt_tokens_details=SimpleNamespace(cached_tokens=cached_tokens),
+        completion_tokens=completion_tokens,
+    )
+
+
+def _choice(
+    *,
+    role: str,
+    content: str,
+    tool_calls: Sequence[SimpleNamespace],
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        message=SimpleNamespace(
+            role=role,
+            content=content,
+            tool_calls=list(tool_calls),
+        )
+    )
+
+
+def _response(
+    *,
+    model: str,
+    prompt_tokens: int,
+    cached_tokens: int,
+    completion_tokens: int,
+    choices: Sequence[SimpleNamespace],
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        model=model,
+        usage=_usage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            cached_tokens=cached_tokens,
+        ),
+        choices=list(choices),
+    )
+
+
+class _FakeCompletions:
+    def __init__(self, responses):
+        self.responses = list(responses)
+        self.calls = []
+
+    def create(self, **kwargs):
+        self.calls.append(kwargs)
+        if not self.responses:
+            raise AssertionError("No fake responses remain")
+        return self.responses.pop(0)
+
+
+class _FakeClient:
+    def __init__(self, responses):
+        self.models = SimpleNamespace(
+            list=lambda: SimpleNamespace(
+                data=[SimpleNamespace(id="gpt-4o-2024-11-20")]
+            )
+        )
+        self.chat = SimpleNamespace(
+            completions=_FakeCompletions(responses)
+        )
+
+
+class TestOpenAIToolUsage(unittest.TestCase):
+    def test_usage_is_accumulated_across_tool_iterations(self):
+        model = "gpt-4o-2024-11-20"
+        tool_call = SimpleNamespace(
+            type="function",
+            id="call-1",
+            function=SimpleNamespace(
+                name="sum_numbers",
+                arguments='{"a": 2, "b": 3}',
+            ),
+        )
+        responses = [
+            _response(
+                model=model,
+                prompt_tokens=10,
+                cached_tokens=1,
+                completion_tokens=2,
+                choices=[
+                    _choice(
+                        role="assistant",
+                        content="",
+                        tool_calls=[tool_call],
+                    )
+                ],
+            ),
+            _response(
+                model=model,
+                prompt_tokens=6,
+                cached_tokens=2,
+                completion_tokens=4,
+                choices=[
+                    _choice(
+                        role="assistant",
+                        content="done",
+                        tool_calls=[],
+                    )
+                ],
+            ),
+        ]
+        provider = OpenAI(client=_FakeClient(responses), model=model)
+        tool = callable_to_tool_definition("sum_numbers", _sum_numbers)
+
+        resp = provider._complete_with_tools(
+            messages=[Message(content="Please sum", role=MessageRole.USER)],
+            tool_map={"sum_numbers": tool},
+            active_tools={
+                "sum_numbers": ToolSettings(
+                    policy=ToolExecutionPolicy.ALWAYS
+                )
+            },
+        )
+
+        self.assertEqual(resp.message.content, "done")
+        self.assertEqual(resp.prompt_tokens, 16)
+        self.assertEqual(resp.sampled_tokens, 6)
+        expected_cost = provider.__class__._estimate_cost_in_cents(
+            model=model,
+            prompt_tokens=16,
+            cached_prompt_tokens=3,
+            sampled_tokens=6,
+        )
+        self.assertEqual(resp.cost_in_cents, expected_cost)
+
+
+if __name__ == "__main__":
+    unittest.main()