cometapi-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] — 2026-05-29
+
+### Fixed
+
+- `logs` now emits a consistent field set across all output formats. Previously `--json` dumped the raw API response (no computed `cost`, `other` left as a stringified blob, internal junk fields), while `table`/`yaml`/`markdown` showed a curated card.
+- `logs --request-id` detail duration now reflects true end-to-end latency (`other.total_ms`) instead of the coarse `use_time` seconds value.
+- `logs --request-id` cost now shows 6 decimal places (e.g. `$0.000384`) so sub-cent calls are no longer rounded to `$0.0004`.
+
+### Changed
+
+- `logs` JSON/YAML output is now a canonical, typed record (raw numbers, booleans, ISO 8601 time, computed `cost_usd`, exploded `other` fields, normalized `model_price`) with a stable schema; `table`/`markdown` render the same fields as formatted strings.
+
 ## [0.3.0] — 2026-05-26
 
 ### Added

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cometapi-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: CometAPI CLI — official command-line interface for the CometAPI AI gateway
 Project-URL: Homepage, https://pypi.org/project/cometapi-cli/
 Project-URL: Documentation, https://apidoc.cometapi.com/libraries/cli/overview

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/docs/commands/logs.md

@@ -102,7 +102,10 @@ Internal quota values are converted to USD:
 $1.00 USD = 500,000 quota units
 ```
 
-Cost is displayed with 4 decimal places (e.g., `$0.0014`).
+In the logs list, cost is displayed with 4 decimal places (e.g., `$0.0014`). The
+per-request detail view (`--request-id`) uses 6 decimal places (e.g., `$0.000384`)
+so sub-cent calls are not rounded away, and machine formats expose the raw
+`cost_usd` float.
 
 ## CSV Export
 
@@ -160,27 +163,80 @@ cometapi logs --request-id req-abc-123
 cometapi logs --request-id req-abc-123 --json
 ```
 
-Output shows a cost summary card:
+Output shows a request detail card:
 
 ```
-                   Request Cost
-┌──────────────┬──────────────────────────┐
-│ Field        │ Value                    │
-├──────────────┼──────────────────────────┤
-│ Request Id   │ req-abc-123              │
-│ Cost         │ $0.0034                  │
-│ Quota (raw)  │ 1,700                    │
-│ RPM          │ 1                        │
-│ TPM          │ 165                      │
-└──────────────┴──────────────────────────┘
+                         Request Detail
+┌───────────────────┬──────────────────────────────────────────┐
+│ Field             │ Value                                      │
+├───────────────────┼──────────────────────────────────────────┤
+│ Request ID        │ req-abc-123                                │
+│ Response ID       │ chatcmpl-xyz-789                           │
+│ Time              │ 2026-05-29 06:00:21                        │
+│ Model             │ gpt-5.4                                    │
+│ Token Name        │ Production Key                             │
+│ Type              │ consume                                    │
+│ Stream            │ No                                         │
+│ Prompt Tokens     │ 18                                         │
+│ Completion Tokens │ 13                                         │
+│ Cost (USD)        │ $0.000384                                  │
+│ Quota (raw)       │ 192                                        │
+│ Model Ratio       │ 2.5                                        │
+│ Completion Ratio  │ 6x                                         │
+│ Group Ratio       │ 0.8                                        │
+│ Model Price       │ default                                    │
+│ Duration          │ 3,128 ms                                   │
+│ Endpoint          │ /v1/chat/completions                       │
+└───────────────────┴──────────────────────────────────────────┘
 ```
 
-JSON output returns the raw stat data:
+### Unified output schema
+
+All formats expose the **same field set** — the difference is only presentation:
+
+- `table` / `markdown` — human-friendly labels and formatted strings (`$0.000384`, `Yes`/`No`, `6x`, `3,128 ms`); optional fields are omitted when absent.
+- `json` / `yaml` / `csv` — the canonical record with **raw typed values** (numbers, booleans, ISO 8601 time) and a stable schema (`null` when a value is absent), suitable for scripting.
+
+```bash
+cometapi logs --request-id req-abc-123 -f json
+```
 
 ```json
-{"quota": 1700, "rpm": 1, "tpm": 165}
+{
+  "request_id": "req-abc-123",
+  "response_id": "chatcmpl-xyz-789",
+  "time": "2026-05-29T06:00:21+00:00",
+  "type": "consume",
+  "model": "gpt-5.4",
+  "token_name": "Production Key",
+  "username": "google_9550",
+  "user_id": 9550,
+  "ip": "203.0.113.7",
+  "stream": false,
+  "prompt_tokens": 18,
+  "completion_tokens": 13,
+  "cache_tokens": 0,
+  "cost_usd": 0.000384,
+  "quota": 192,
+  "model_ratio": 2.5,
+  "completion_ratio": 6,
+  "group_ratio": 0.8,
+  "model_price": null,
+  "cache_ratio": 0.1,
+  "duration_ms": 3128,
+  "first_token_ms": null,
+  "endpoint": "/v1/chat/completions"
+}
 ```
 
+Notes:
+
+- `cost_usd` is `quota / 500000`, rounded to 6 decimals (matches the backend). In the `table`/`markdown` card it is shown as `$0.000384` so sub-cent calls are not rounded away.
+- `duration_ms` uses the request's true end-to-end latency (`other.total_ms`); it falls back to the coarse `use_time` value only when `total_ms` is unavailable.
+- `model_price` is `null` when the backend uses ratio-based pricing (the `-1` sentinel); the `table`/`markdown` card renders this as `default`.
+- `time` is ISO 8601 UTC in machine formats; the card renders `YYYY-MM-DD HH:MM:SS`.
+- `ip` is the client IP recorded by the backend — treat it as sensitive when sharing logs.
+
 You can combine `--request-id` with filter options like `--type` and `--model` for additional precision. `--request-id` cannot be used with `--export`.
 
 > **Note:** The upstream provider's response ID (e.g., `chatcmpl-DSfol...` from OpenAI) is NOT stored

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cometapi-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "CometAPI CLI — official command-line interface for the CometAPI AI gateway"
 readme = "README.md"
 license = { text = "MIT" }

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/src/cometapi_cli/__init__.py

@@ -1,3 +1,3 @@
 """CometAPI CLI — professional terminal interface for CometAPI."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/src/cometapi_cli/commands/logs.py

@@ -9,7 +9,14 @@ from typing import Annotated
 import typer
 
 from ..config import get_client
-from ..constants import extract_items, format_ts, parse_date, quota_to_usd
+from ..constants import (
+    QUOTA_PER_UNIT,
+    extract_items,
+    format_iso,
+    format_ts,
+    parse_date,
+    quota_to_usd,
+)
 from ..errors import handle_errors
 from ..formatters import OutputFormat, output, resolve_format
 
@@ -70,61 +77,111 @@ def _find_log_by_id(
     return None
 
 
-def _format_log_detail(log: dict) -> dict:
-    """Build a rich key-value detail card from a single log entry."""
+def _build_log_record(log: dict) -> dict:
+    """Build the canonical, machine-friendly record for a single log entry.
+
+    Returns a stable schema with raw, typed values (numbers, booleans, ISO 8601
+    time). The same field set drives every output format; human-facing formats
+    layer display formatting on top via :func:`_record_to_detail_display`.
+    Missing values are ``None`` so the schema stays consistent across entries.
+    """
     other = _parse_other(log.get("other"))
-    prompt_tokens = log.get("prompt_tokens", 0)
-    completion_tokens = log.get("completion_tokens", 0)
-    quota = log.get("quota", 0)
+    quota = log.get("quota", 0) or 0
+
+    # model_price == -1 is the backend sentinel for "use ratio-based pricing"
+    # (i.e. no fixed per-call price); expose it as null in the canonical record.
+    raw_model_price = other.get("model_price")
+    model_price = None if raw_model_price == -1 else raw_model_price
+
+    # Prefer total_ms (true end-to-end latency) over use_time, which the backend
+    # records in seconds and is too coarse to be useful as a duration.
+    total_ms = other.get("total_ms")
+    use_time = log.get("use_time", 0) or 0
+    duration_ms = total_ms if total_ms else (use_time or None)
 
+    frt = other.get("frt")
+    user_id = log.get("user_id")
+
+    return {
+        "request_id": log.get("request_id") or None,
+        "response_id": log.get("response_id") or None,
+        "time": format_iso(log.get("created_at", 0)),
+        "type": _LOG_TYPE_NAMES.get(log.get("type", 0), "unknown"),
+        "model": log.get("model_name") or None,
+        "token_name": log.get("token_name") or None,
+        "username": log.get("username") or None,
+        "user_id": user_id if user_id else None,
+        "ip": log.get("ip") or None,
+        "stream": bool(log.get("is_stream")),
+        "prompt_tokens": log.get("prompt_tokens", 0) or 0,
+        "completion_tokens": log.get("completion_tokens", 0) or 0,
+        "cache_tokens": other.get("cache_tokens", 0) or 0,
+        "cost_usd": round(quota / QUOTA_PER_UNIT, 6),
+        "quota": quota,
+        "model_ratio": other.get("model_ratio"),
+        "completion_ratio": other.get("completion_ratio"),
+        "group_ratio": other.get("group_ratio"),
+        "model_price": model_price,
+        "cache_ratio": other.get("cache_ratio"),
+        "duration_ms": duration_ms,
+        "first_token_ms": frt if frt and frt > 0 else None,
+        "endpoint": other.get("request_path") or None,
+    }
+
+
+def _record_to_detail_display(rec: dict) -> dict:
+    """Render a canonical log record as a formatted key-value detail card.
+
+    Mirrors the field set of :func:`_build_log_record` but uses human-friendly
+    labels and formatted strings (USD, ``Yes``/``No``, ``ms``). Optional fields
+    are omitted when absent to keep the card readable.
+    """
+    em_dash = "—"
     info: dict[str, str | int | float] = {}
-    info["Request ID"] = log.get("request_id", "") or "—"
-    info["Response ID"] = log.get("response_id", "") or "—"
-    info["Time"] = format_ts(log.get("created_at", 0))
-    info["Model"] = log.get("model_name", "") or "—"
-    info["Token Name"] = log.get("token_name", "") or "—"
-    info["Group"] = log.get("group", "") or "—"
-    info["Stream"] = "Yes" if log.get("is_stream") else "No"
+    info["Request ID"] = rec["request_id"] or em_dash
+    info["Response ID"] = rec["response_id"] or em_dash
+    iso = rec["time"]
+    info["Time"] = iso[:19].replace("T", " ") if iso else em_dash
+    info["Model"] = rec["model"] or em_dash
+    info["Token Name"] = rec["token_name"] or em_dash
+    if rec["username"]:
+        info["Username"] = rec["username"]
+    if rec["user_id"] is not None:
+        info["User ID"] = rec["user_id"]
+    if rec["ip"]:
+        info["IP"] = rec["ip"]
+    info["Type"] = rec["type"]
+    info["Stream"] = "Yes" if rec["stream"] else "No"
 
     # Tokens
-    info["Prompt Tokens"] = f"{prompt_tokens:,}"
-    info["Completion Tokens"] = f"{completion_tokens:,}"
-    cache_tokens = other.get("cache_tokens", 0)
-    if cache_tokens:
-        info["Cache Tokens"] = f"{cache_tokens:,}"
-
-    # Cost
-    info["Cost (USD)"] = quota_to_usd(quota)
-    info["Quota (raw)"] = f"{quota:,}"
-
-    # Pricing breakdown from 'other'
-    model_ratio = other.get("model_ratio")
-    if model_ratio is not None:
-        info["Model Ratio"] = model_ratio
-    completion_ratio = other.get("completion_ratio")
-    if completion_ratio is not None:
-        info["Completion Ratio"] = f"{completion_ratio}x"
-    group_ratio = other.get("group_ratio")
-    if group_ratio is not None:
-        info["Group Ratio"] = group_ratio
-    model_price = other.get("model_price")
-    if model_price is not None:
-        info["Model Price"] = "default" if model_price == -1 else model_price
-    cache_ratio = other.get("cache_ratio")
-    if cache_ratio is not None:
-        info["Cache Ratio"] = cache_ratio
+    info["Prompt Tokens"] = f"{rec['prompt_tokens']:,}"
+    info["Completion Tokens"] = f"{rec['completion_tokens']:,}"
+    if rec["cache_tokens"]:
+        info["Cache Tokens"] = f"{rec['cache_tokens']:,}"
+
+    # Cost (6 decimals so sub-cent calls are not rounded away)
+    info["Cost (USD)"] = f"${rec['cost_usd']:,.6f}"
+    info["Quota (raw)"] = f"{rec['quota']:,}"
+
+    # Pricing breakdown
+    if rec["model_ratio"] is not None:
+        info["Model Ratio"] = rec["model_ratio"]
+    if rec["completion_ratio"] is not None:
+        info["Completion Ratio"] = f"{rec['completion_ratio']}x"
+    if rec["group_ratio"] is not None:
+        info["Group Ratio"] = rec["group_ratio"]
+    info["Model Price"] = "default" if rec["model_price"] is None else rec["model_price"]
+    if rec["cache_ratio"] is not None:
+        info["Cache Ratio"] = rec["cache_ratio"]
 
     # Timing
-    use_time = log.get("use_time", 0)
-    info["Duration"] = f"{use_time:,} ms" if use_time else "—"
-    frt = other.get("frt")
-    if frt and frt > 0:
-        info["First Token"] = f"{frt:,} ms"
+    info["Duration"] = f"{rec['duration_ms']:,} ms" if rec["duration_ms"] else em_dash
+    if rec["first_token_ms"]:
+        info["First Token"] = f"{rec['first_token_ms']:,} ms"
 
     # Path
-    request_path = other.get("request_path")
-    if request_path:
-        info["Endpoint"] = request_path
+    if rec["endpoint"]:
+        info["Endpoint"] = rec["endpoint"]
 
     return info
 
@@ -221,12 +278,13 @@ def logs(
             )
             raise typer.Exit(code=1)
 
-        if fmt == OutputFormat.JSON:
-            output(log_entry, fmt)
+        record = _build_log_record(log_entry)
+        # Machine formats get raw typed values; human formats get the formatted card.
+        if fmt in (OutputFormat.JSON, OutputFormat.YAML, OutputFormat.CSV):
+            output(record, fmt)
             return
 
-        info = _format_log_detail(log_entry)
-        output(info, fmt, title="Request Detail")
+        output(_record_to_detail_display(record), fmt, title="Request Detail")
         return
 
     # Server-side CSV export — write raw bytes to stdout and return early
@@ -270,8 +328,10 @@ def logs(
 
     data = extract_items(resp)
 
-    if fmt == OutputFormat.JSON:
-        output(data, fmt)
+    # Machine formats emit the full canonical record per entry (typed values,
+    # incl. cost_usd); table/markdown/csv keep the compact summary rows.
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
+        output([_build_log_record(log) for log in data], fmt)
         return
 
     if not data:

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/src/cometapi_cli/constants.py

@@ -24,6 +24,13 @@ def format_ts(ts: int, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     return datetime.fromtimestamp(ts, tz=timezone.utc).strftime(fmt)
 
 
+def format_iso(ts: int) -> str | None:
+    """Format a Unix timestamp as an ISO 8601 UTC string, or None when absent."""
+    if not ts:
+        return None
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+
+
 def parse_date(value: str, label: str) -> int:
     """Parse a date string into a Unix timestamp (UTC).
 

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/tests/conftest.py

@@ -166,14 +166,17 @@ def mock_client():
                     "type": 2,
                     "model_name": "gpt-5.4",
                     "token_name": "Production Key",
+                    "username": "google_9550",
+                    "user_id": 9550,
+                    "ip": "203.0.113.7",
                     "quota": 150,
                     "prompt_tokens": 120,
                     "completion_tokens": 45,
-                    "use_time": 1200,
+                    "use_time": 1,
                     "is_stream": True,
                     "request_id": "req-abc-001",
                     "response_id": "chatcmpl-xyz-001",
-                    "other": '{"model_ratio":0.625,"completion_ratio":8,"group_ratio":0.8,"model_price":-1,"frt":120}',
+                    "other": '{"model_ratio":0.625,"completion_ratio":8,"group_ratio":0.8,"model_price":-1,"frt":120,"total_ms":1200,"request_path":"/v1/chat/completions"}',
                 },
                 {
                     "id": 101,

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/tests/test_help.py

@@ -1,7 +1,15 @@
 """Tests for CLI version and help output."""
 
+import re
+
 from cometapi_cli import __version__
 
+ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+
+def clean_output(output: str) -> str:
+    return ANSI_RE.sub("", output)
+
 
 def test_version(cli_runner):
     result = cli_runner("--version")
@@ -46,42 +54,59 @@ def test_subcommand_help_short_flag(cli_runner):
     """Test that -h works for subcommands."""
     result = cli_runner("balance", "-h")
     assert result.exit_code == 0
-    assert "--source" in result.output
+    assert "--source" in clean_output(result.output)
 
 
 def test_chat_help(cli_runner):
     result = cli_runner("chat", "--help")
     assert result.exit_code == 0
-    assert "MESSAGE" in result.output
-    assert "--model" in result.output
-    assert "--json" in result.output
+    output = clean_output(result.output)
+    assert "MESSAGE" in output
+    assert "--model" in output
+    assert "--json" in output
 
 
 def test_models_help(cli_runner):
     result = cli_runner("models", "--help")
     assert result.exit_code == 0
-    assert "--search" in result.output
-    assert "--provider" in result.output
-    assert "--limit" in result.output
+    output = clean_output(result.output)
+    assert "--search" in output
+    assert "--provider" in output
+    assert "--limit" in output
 
 
 def test_model_info_help(cli_runner):
     result = cli_runner("model", "info", "--help")
     assert result.exit_code == 0
-    assert "MODEL_ID" in result.output
+    assert "MODEL_ID" in clean_output(result.output)
 
 
 def test_run_help(cli_runner):
     result = cli_runner("run", "--help")
     assert result.exit_code == 0
-    assert "--endpoint" in result.output
-    assert "--input-file" in result.output
+    output = clean_output(result.output)
+    assert "--endpoint" in output
+    assert "--input-file" in output
 
 
 def test_doctor_help(cli_runner):
     result = cli_runner("doctor", "--help")
     assert result.exit_code == 0
-    assert "--json" in result.output
+    assert "--json" in clean_output(result.output)
+
+
+def test_help_flag_assertions_tolerate_color(cli_runner):
+    cases = [
+        (("balance", "-h"), "--source"),
+        (("chat", "--help"), "--model"),
+        (("models", "--help"), "--search"),
+        (("run", "--help"), "--endpoint"),
+        (("doctor", "--help"), "--json"),
+    ]
+    for args, expected in cases:
+        result = cli_runner(*args, color=True)
+        assert result.exit_code == 0
+        assert expected in clean_output(result.output)
 
 
 def test_config_help(cli_runner):

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/tests/test_logs.py

@@ -15,11 +15,11 @@ class TestLogsTable:
         patched_client.list_logs.assert_called_once()
 
     def test_logs_type_column(self, cli_runner, patched_client):
-        """Verify type column displays by checking JSON output."""
+        """Verify type is exposed by name in the canonical JSON record."""
         result = cli_runner("logs", "--json")
         assert result.exit_code == 0
         data = json.loads(result.output)
-        assert data[0]["type"] == 2
+        assert data[0]["type"] == "consume"
 
     def test_logs_filter_model(self, cli_runner, patched_client):
         result = cli_runner("logs", "--model", "gpt-5.4")
@@ -153,8 +153,10 @@ class TestLogsJSON:
         data = json.loads(result.output)
         assert isinstance(data, list)
         assert len(data) == 2
-        assert data[0]["model_name"] == "gpt-5.4"
+        assert data[0]["model"] == "gpt-5.4"
         assert data[0]["prompt_tokens"] == 120
+        # cost_usd is computed and present in every format now
+        assert data[0]["cost_usd"] == 0.0003
 
     def test_logs_format_yaml(self, cli_runner, patched_client):
         result = cli_runner("logs", "--format", "yaml")
@@ -183,12 +185,20 @@ class TestLogsRequestId:
         result = cli_runner("logs", "--request-id", "req-abc-001", "--json")
         assert result.exit_code == 0
         data = json.loads(result.output)
-        # JSON returns the full raw log entry
-        assert data["model_name"] == "gpt-5.4"
+        # JSON returns the canonical typed record (same field set as table/yaml)
+        assert data["model"] == "gpt-5.4"
         assert data["prompt_tokens"] == 120
         assert data["completion_tokens"] == 45
         assert data["quota"] == 150
         assert data["request_id"] == "req-abc-001"
+        # Computed cost is present (was missing from raw JSON before)
+        assert data["cost_usd"] == 0.0003
+        # Time is ISO 8601, not an epoch int
+        assert data["time"].startswith("2023-11-16T")
+        # Duration comes from total_ms, not the coarse use_time seconds field
+        assert data["duration_ms"] == 1200
+        # model_price == -1 sentinel is normalized to null
+        assert data["model_price"] is None
 
     def test_logs_request_id_not_found(self, cli_runner, patched_client):
         result = cli_runner("logs", "--request-id", "nonexistent-id")

{cometapi_cli-0.3.0 → cometapi_cli-0.3.1}/uv.lock

@@ -66,7 +66,7 @@ wheels = [
 
 [[package]]
 name = "cometapi-cli"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "openai" },