anosys-codex 0.1.0__py3-none-any.whl

anosys_codex-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: anosys-codex
+Version: 0.1.0
+Summary: AnoSys observability hook for OpenAI Codex CLI
+Author-email: AnoSys <support@anosys.ai>
+License: ../../../LICENSE
+Project-URL: Homepage, https://anosys.ai
+Project-URL: Documentation, https://docs.anosys.ai
+Project-URL: Repository, https://github.com/anosys-ai/anosys-sdk
+Keywords: anosys,codex,openai,observability,monitoring,audit,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: cryptography>=3.4.0
+Dynamic: license-file
+
+# anosys-codex (Python)
+
+AnoSys observability and analytics hook for OpenAI Codex CLI.
+
+This package automatically captures Codex CLI's telemetry, agent turns, tool calls (`shell`, `apply_patch`, Code Mode custom tools, `web_search`), token usage breakdowns (prompt, completion, cache read/write, reasoning tokens), and estimated API costs, sending them directly to your AnoSys workspace.
+
+It integrates seamlessly with Codex CLI's native `notify` hook mechanism.
+
+---
+
+## Installation
+
+```bash
+pip install anosys-codex
+```
+
+After installing the package, run the setup wizard to configure the hook:
+
+```bash
+anosys-codex install
+```
+
+The installer will prompt you for:
+1. **AnoSys API Key for logs**: Your ingestion API key from the [AnoSys Console](https://console.anosys.ai/collect/integrationoptions).
+   > **Pixel Type Requirement**: This key must belong to a **`CC` (Claude Code / Codex CLI)** pixel. The installer automatically validates the key against `https://console.anosys.ai/api/resolveapikeys` to ensure it resolves to a `/cc/` endpoint. Keys belonging to `T` (OTEL) or Web Traffic (`a`/`g`) pixels are rejected with a warning.
+2. **Content Redaction**: If enabled, sensitive conversation content (prompts, answers, code, tool inputs/outputs) will be redacted and replaced with `[REDACTED]`. Only metadata and token statistics will be tracked.
+3. **Automatic Config Update**: Confirms whether to automatically write `notify = ["anosys-codex", "run"]` to `~/.codex/config.toml` (and creates a `.bak` backup first).
+
+---
+
+## Non-Interactive / Headless Installation
+
+For CI/CD pipelines, Docker containers, devcontainer setups, or non-interactive dotfiles:
+
+### Using the `-y` / `--yes` flag (Recommended):
+```bash
+anosys-codex install --api-key "your_logs_api_key" -y
+```
+
+### Using environment variables:
+```bash
+export ANOSYS_API_KEY="your_logs_api_key"
+anosys-codex install -y
+```
+
+### Using explicit granular flags:
+```bash
+anosys-codex install \
+  --api-key "your_logs_api_key" \
+  --auto-update \
+  --no-redaction
+```
+
+> **Important (Codex Security Trust)**:
+> Codex requires explicit user approval for unmanaged external notify hooks. After running `install`, start a Codex CLI session, type `/hooks`, and select `approve` / `trust` for the `anosys-codex run` hook entry.
+
+---
+
+## CLI Commands
+
+The CLI safely manages `~/.codex/config.toml` and creates automatic timestamped backups (`config.toml.<TIMESTAMP>.bak`) before applying any modifications.
+
+### `status`
+Check the current installation and registration status of the hook:
+```bash
+anosys-codex status
+```
+
+### `install`
+Installs or updates the notify hook in `~/.codex/config.toml` and creates `~/.codex/anosys-env.sh`:
+```bash
+anosys-codex install [options]
+
+Options:
+  --api-key <key>             AnoSys logs API key
+  -y, --yes                   Skip interactive prompts (non-interactive mode)
+  --redaction                 Enable content redaction
+  --no-redaction              Disable content redaction
+  --auto-update               Automatically update ~/.codex/config.toml
+  --no-auto-update            Print manual setup instructions instead of modifying config
+```
+
+### `uninstall`
+Safely removes the AnoSys notify hook entry from `~/.codex/config.toml` and deletes `~/.codex/anosys-env.sh`:
+```bash
+anosys-codex uninstall
+```
+
+### `run`
+Executed automatically by the Codex CLI on turn-complete notify events. You do not need to invoke this manually:
+```bash
+anosys-codex run
+```
+
+---
+
+## How It Works
+
+1. When a Codex turn completes, Codex CLI triggers `notify = ["anosys-codex", "run"]` defined in `~/.codex/config.toml`.
+2. The hook runner receives the session thread ID and locates the session's rollout transcript at `~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<session_id>.jsonl`.
+3. It incrementally extracts user prompts, assistant messages, model details, token counts (including cached inputs and reasoning tokens), and tool calls.
+4. It maps the turn into the AnoSys schema (`cvs200: 'CodexHook'`), estimates USD cost using OpenAI's model pricing table, applies optional PII redaction, and batches the payload to `https://api.anosys.ai/ingestion`.
+5. If network connectivity is temporarily unavailable, failed records are buffered locally in `~/.codex/state/pending_records.jsonl` and automatically replayed on subsequent runs.
+
+---
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `ANOSYS_HOOK_APIKEY` / `ANOSYS_API_KEY` | AnoSys ingestion API key |
+| `ANOSYS_HOOK_ENDPOINT_URL` | Override default ingestion URL (`https://api.anosys.ai/ingestion`) |
+| `REDACTION` / `ANOSYS_REDACT_CONTENT` | Set to `"true"` to redact prompts, code, and tool outputs |
+| `ANOSYS_HOOK_DRY_RUN` | Set to `"true"` to log payloads to stderr without sending to network |
+| `CODEX_HOME` | Custom directory for Codex config and sessions (defaults to `~/.codex`) |

anosys_codex-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+anosys_codex-0.1.0.dist-info/licenses/LICENSE,sha256=rZsldTRUIZ33Yi94i4v6n7ffaPNNQmzB6gxnWzGlf2A,16
+anosys_sdk_codex/__init__.py,sha256=6iIPOqOJdN2wOzvLzeJBdsopL6yn7a4swZgYeKYAT_s,995
+anosys_sdk_codex/cli.py,sha256=GVfkaujy64cR2KA6zvV6f8Edquh4G8tChlyuNhBjj9E,6972
+anosys_sdk_codex/encryption.py,sha256=c-zJUge2V1SZe00nsD6Zjt29IzO49g3vEYBB0p_7evQ,5817
+anosys_sdk_codex/hook_runner.py,sha256=qi_BhfytXQ2668ohDUwyYpnwtsDYpIINiQDITCa1tz4,22484
+anosys_sdk_codex/installer.py,sha256=Kv-JRc1rNyBiHhlbXHbhS023idi14vX27WTNeFBAQrA,8742
+anosys_sdk_codex/mapper.py,sha256=jg87lUW3IprkwLYe2VC-xoKyXEO0e2Fc3f55r0vmM-o,9355
+anosys_sdk_codex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anosys_codex-0.1.0.dist-info/METADATA,sha256=srGxLyocRL27cGFFV6dskSE044Vg3FP8dk0XKXWQaP0,5965
+anosys_codex-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+anosys_codex-0.1.0.dist-info/entry_points.txt,sha256=G-RhC_Pcgrg64y4ebUCqD7TbJfzTk_piyJKpugAgfeY,59
+anosys_codex-0.1.0.dist-info/top_level.txt,sha256=TnOBiZGoAsifFOyUXKafdwHZ6we-8jwso09VrUbwmYI,17
+anosys_codex-0.1.0.dist-info/RECORD,,

anosys_codex-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

anosys_codex-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anosys-codex = anosys_sdk_codex.cli:main

anosys_codex-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+../../../LICENSE

anosys_codex-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+anosys_sdk_codex

anosys_sdk_codex/__init__.py

@@ -0,0 +1,40 @@
+"""
+AnoSys OpenAI Codex CLI integration — observability hook for Codex sessions.
+"""
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except ImportError:
+    from importlib_metadata import PackageNotFoundError, version
+
+from anosys_sdk_codex.installer import update_codex_config, update_codex_env
+from anosys_sdk_codex.mapper import transform_codex_turn
+from anosys_sdk_codex.encryption import (
+    ANOSYS_ENCRYPTION_PREFIX,
+    DEFAULT_ENCRYPTED_COLUMNS,
+    derive_256_bit_key,
+    encrypt,
+    decrypt,
+    get_encryption_key,
+    get_target_columns,
+    encrypt_payload,
+)
+
+try:
+    __version__ = version("anosys-codex")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__all__ = [
+    "transform_codex_turn",
+    "update_codex_config",
+    "update_codex_env",
+    "ANOSYS_ENCRYPTION_PREFIX",
+    "DEFAULT_ENCRYPTED_COLUMNS",
+    "derive_256_bit_key",
+    "encrypt",
+    "decrypt",
+    "get_encryption_key",
+    "get_target_columns",
+    "encrypt_payload",
+]

anosys_sdk_codex/cli.py

@@ -0,0 +1,200 @@
+"""
+CLI entry point for anosys-codex.
+
+Commands:
+  install    Register the AnoSys notify hook in ~/.codex/config.toml
+  uninstall  Remove the AnoSys notify hook from ~/.codex/config.toml
+  status     Show current hook registration status
+  run        Execute the hook (invoked by Codex CLI on notify events)
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from anosys_sdk_codex.installer import (
+    HOOK_COMMAND,
+    INGESTION_URL,
+    backup,
+    get_config_path,
+    get_env_path,
+    has_anosys_hook,
+    load_toml,
+    remove_codex_config,
+    remove_codex_env,
+    update_codex_config,
+    update_codex_env,
+    validate_api_key,
+)
+
+
+def _prompt(prompt: str, default: str = "") -> str:
+    try:
+        val = input(prompt).strip()
+        return val if val else default
+    except (EOFError, KeyboardInterrupt):
+        print()
+        sys.exit(0)
+
+
+def cmd_install(args: argparse.Namespace) -> None:
+    print("\nAnoSys OpenAI Codex Hook Installer")
+    print("=" * 45)
+
+    yes = getattr(args, "yes", False)
+
+    redaction = args.redaction
+    if not redaction and not args.no_redaction:
+        if yes:
+            redaction = False
+        else:
+            choice = _prompt("Enable content redaction? (y/N): ", "n").lower()
+            redaction = choice == "y"
+
+    api_key = args.api_key or os.environ.get("ANOSYS_API_KEY") or os.environ.get("ANOSYS_HOOK_APIKEY") or ""
+    if not api_key and not yes:
+        api_key = _prompt("AnoSys API key for logs (leave blank to skip): ")
+
+    if api_key:
+        print("Validating Logs API key...")
+        if not validate_api_key(api_key, "cc"):
+            print("⚠️  Warning: Logs API key validation failed: key does not belong to a CC (Claude Code / Codex) pixel or is invalid.")
+        else:
+            print("✅ Logs API key is valid (CC pixel).")
+
+    auto_update = args.auto_update
+    if auto_update is None:
+        if yes:
+            auto_update = True
+        else:
+            choice = _prompt("Would you like to automatically update ~/.codex/config.toml? (Y/n): ", "y").lower()
+            auto_update = choice != "n"
+
+    config_path = get_config_path()
+    env_path = get_env_path()
+
+    if auto_update:
+        print(f"\nUpdating {config_path} ...")
+        backup_path = backup(config_path)
+        update_codex_config(HOOK_COMMAND, path=config_path)
+        update_codex_env(api_key=api_key, redaction=redaction, path=env_path)
+
+        if backup_path:
+            print(f"  Backed up original settings -> {backup_path}")
+        print('  Hook command registered in notify: ["anosys-codex", "run"]')
+        print(f"  Ingestion URL: {INGESTION_URL}")
+        if api_key:
+            masked = ("*" * (len(api_key) - 4)) + api_key[-4:] if len(api_key) > 4 else "****"
+            print(f"  Logs API key: {masked}")
+        print(f"  Redaction: {'enabled' if redaction else 'disabled'}")
+        print("\n✅ Codex hook installed successfully.")
+        print("\n⚠️  IMPORTANT (Codex Security Trust):")
+        print("   In your next Codex CLI session, run the '/hooks' command")
+        print(f"   and approve the '{HOOK_COMMAND}' entry to allow tracing.\n")
+    else:
+        print("\n================================================================")
+        print("Add the following to your ~/.codex/config.toml file:")
+        print('\nnotify = ["anosys-codex", "run"]\n')
+        print("And create ~/.codex/anosys-env.sh with:")
+        print(f'export ANOSYS_HOOK_APIKEY="{api_key}"')
+        print(f'export ANOSYS_HOOK_ENDPOINT_URL="{INGESTION_URL}"')
+        print(f'export REDACTION="{"true" if redaction else "false"}"')
+        print("================================================================\n")
+
+
+def cmd_uninstall(args: argparse.Namespace) -> None:
+    print("\nAnoSys OpenAI Codex Hook Uninstaller")
+    print("=" * 45)
+
+    config_path = get_config_path()
+    env_path = get_env_path()
+
+    backup_path = backup(config_path)
+    removed_config = remove_codex_config(config_path)
+    removed_env = remove_codex_env(env_path)
+
+    if backup_path:
+        print(f"  Backed up settings -> {backup_path}")
+    if removed_config:
+        print(f"  Removed hook entry from {config_path}")
+    else:
+        print(f"  No AnoSys hook entry found in {config_path}")
+
+    if removed_env:
+        print(f"  Removed {env_path}")
+
+    print("\n✅ AnoSys Codex hook uninstalled successfully.\n")
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    config_path = get_config_path()
+    env_path = get_env_path()
+
+    print("\nAnoSys Codex Hook Status")
+    print("=" * 45)
+    print(f"Codex Config: {config_path}")
+    print(f"Env File:     {env_path}")
+
+    if not config_path.is_file():
+        print("\n⚠️  Codex config.toml does not exist.")
+        return
+
+    data = load_toml(config_path)
+    installed = has_anosys_hook(data)
+
+    if installed:
+        print("\nStatus: ✅ Installed and active in config.toml")
+        notify_list = data.get("notify", [])
+        print(f"Notify hooks: {notify_list}")
+    else:
+        print("\nStatus: ❌ Not registered in config.toml")
+
+    if env_path.is_file():
+        print("Env file exists: ✅ Yes")
+    else:
+        print("Env file exists: ❌ No")
+    print()
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+    from anosys_sdk_codex.hook_runner import run
+    run()
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="anosys-codex",
+        description="AnoSys CLI integration for OpenAI Codex",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    p_install = subparsers.add_parser("install", help="Install AnoSys hook into ~/.codex/config.toml")
+    p_install.add_argument("--api-key", help="AnoSys logs API key")
+    p_install.add_argument("-y", "--yes", action="store_true", default=False, help="Automatic yes to prompts (non-interactive)")
+    p_install.add_argument("--redaction", action="store_true", default=False, help="Enable content redaction")
+    p_install.add_argument("--no-redaction", action="store_true", default=False, help="Disable content redaction")
+    p_install.add_argument("--auto-update", dest="auto_update", action="store_true", default=None)
+    p_install.add_argument("--no-auto-update", dest="auto_update", action="store_false")
+    p_install.set_defaults(func=cmd_install)
+
+    p_uninstall = subparsers.add_parser("uninstall", help="Remove AnoSys hook from ~/.codex/config.toml")
+    p_uninstall.set_defaults(func=cmd_uninstall)
+
+    p_status = subparsers.add_parser("status", help="Check hook installation status")
+    p_status.set_defaults(func=cmd_status)
+
+    p_run = subparsers.add_parser("run", help="Run the hook (invoked by Codex notify)")
+    p_run.set_defaults(func=cmd_run)
+
+    args = parser.parse_args(argv)
+    if not hasattr(args, "func"):
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

anosys_sdk_codex/encryption.py

@@ -0,0 +1,182 @@
+"""
+Client-side encryption utilities for AnoSys Codex integration.
+
+Supports AES-256-CBC encryption of sensitive telemetry columns
+(prompts, completions, messages, raw context) before sending to AnoSys BE.
+"""
+
+import base64
+import hashlib
+import logging
+import os
+import sys
+from typing import Any, List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+ANOSYS_ENCRYPTION_PREFIX = "enc:"
+
+DEFAULT_ENCRYPTED_COLUMNS: List[str] = [
+    # Primary requested columns
+    "llm_input",
+    "llm_output",
+    "gen_ai_input_messages",
+    "gen_ai_output_messages",
+    "cvs199",
+    # System instructions and legacy system fields
+    "gen_ai_system_instructions",
+    "llm_system",
+    # User prompts and assistant responses across SDKs
+    "user_prompt",
+    "userPrompt",
+    "assistant_text",
+    "assistantText",
+    "cvs4",
+    "cvs5",
+    # Multi-turn prompt context and tool execution results
+    "last_prompt",
+    "cvs24",
+    "tool_use_result",
+    "cvs26",
+    # Additional task / speech prompt fields
+    "cvs65",
+    "task_description",
+    "summary_content",
+]
+
+try:
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+    from cryptography.hazmat.backends import default_backend
+    _HAS_CRYPTOGRAPHY = True
+except ImportError:
+    _HAS_CRYPTOGRAPHY = False
+
+
+def derive_256_bit_key(passphrase: str) -> bytes:
+    """Derive a 256-bit (32-byte) key from a passphrase using SHA-256."""
+    sha256 = hashlib.sha256()
+    sha256.update(passphrase.encode("utf-8"))
+    return sha256.digest()[:32]
+
+
+def encrypt(text: str, key: bytes) -> str:
+    """
+    Encrypt text with AES-256-CBC using a zero IV and PKCS#7 padding.
+    Returns standard Base64-encoded ciphertext.
+    """
+    if not _HAS_CRYPTOGRAPHY:
+        raise RuntimeError("The 'cryptography' library is required for encryption. Install with: pip install cryptography")
+
+    iv = b"\x00" * 16
+    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+    encryptor = cipher.encryptor()
+
+    text_bytes = text.encode("utf-8")
+    padding_length = 16 - (len(text_bytes) % 16)
+    padded_bytes = text_bytes + (bytes([padding_length]) * padding_length)
+
+    encrypted = encryptor.update(padded_bytes) + encryptor.finalize()
+    return base64.b64encode(encrypted).decode("utf-8")
+
+
+def decrypt(prefixed_or_raw: str, key: bytes) -> str:
+    """
+    Decrypt Base64 ciphertext with or without 'enc:' prefix.
+    """
+    if not _HAS_CRYPTOGRAPHY:
+        raise RuntimeError("The 'cryptography' library is required for decryption. Install with: pip install cryptography")
+
+    raw_b64 = prefixed_or_raw
+    if raw_b64.startswith(ANOSYS_ENCRYPTION_PREFIX):
+        raw_b64 = raw_b64[len(ANOSYS_ENCRYPTION_PREFIX):]
+
+    encrypted_bytes = base64.b64decode(raw_b64)
+    iv = b"\x00" * 16
+    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+    decryptor = cipher.decryptor()
+    decrypted = decryptor.update(encrypted_bytes) + decryptor.finalize()
+    if not decrypted:
+        return ""
+    padding_length = decrypted[-1]
+    if padding_length > 16 or padding_length <= 0:
+        return decrypted.decode("utf-8")
+    return decrypted[:-padding_length].decode("utf-8")
+
+
+def get_encryption_key() -> Optional[str]:
+    """Retrieve the encryption key from ANOSYS_ENCRYPTION_KEY env var if present and not null."""
+    key = os.environ.get("ANOSYS_ENCRYPTION_KEY")
+    if not key or not key.strip() or key.strip().lower() in ("null", "none", "undefined"):
+        return None
+    return key.strip()
+
+
+def get_target_columns() -> Set[str]:
+    """
+    Retrieve columns to encrypt.
+    If ANOSYS_ENCRYPTED_COLUMNS or ANOSYS_ENCRYPTES_COLUMNS is provided,
+    it overrides the default list.
+    """
+    raw = os.environ.get("ANOSYS_ENCRYPTED_COLUMNS") or os.environ.get("ANOSYS_ENCRYPTES_COLUMNS")
+    if raw and raw.strip():
+        cols = {col.strip() for col in raw.split(",") if col.strip()}
+        if cols:
+            return cols
+    return set(DEFAULT_ENCRYPTED_COLUMNS)
+
+
+def encrypt_payload(data: Any) -> Any:
+    """
+    Encrypt targeted fields in a payload dict (or list of dicts) if ANOSYS_ENCRYPTION_KEY is configured.
+    Warns on non-string values and skips them.
+    """
+    if data is None:
+        return None
+
+    if isinstance(data, list):
+        return [encrypt_payload(item) for item in data]
+
+    if not isinstance(data, dict):
+        return data
+
+    key_str = get_encryption_key()
+    if not key_str:
+        return data
+
+    if not _HAS_CRYPTOGRAPHY:
+        msg = "[ANOSYS] Warning: ANOSYS_ENCRYPTION_KEY is set but 'cryptography' library is not installed. Skipping encryption."
+        print(msg, file=sys.stderr)
+        logger.warning(msg)
+        return data
+
+    try:
+        derived_key = derive_256_bit_key(key_str)
+    except Exception as e:
+        msg = f"[ANOSYS] Warning: Failed to derive encryption key: {e}"
+        print(msg, file=sys.stderr)
+        logger.warning(msg)
+        return data
+
+    target_columns = get_target_columns()
+
+    for col in target_columns:
+        if col not in data:
+            continue
+        val = data[col]
+        if val is None:
+            continue
+        if not isinstance(val, str):
+            warn_msg = f"[ANOSYS] Warning: Column '{col}' contains non-string data (type: {type(val).__name__}). Skipping encryption."
+            print(warn_msg, file=sys.stderr)
+            logger.warning(warn_msg)
+            continue
+        if val.startswith(ANOSYS_ENCRYPTION_PREFIX):
+            continue
+        try:
+            data[col] = f"{ANOSYS_ENCRYPTION_PREFIX}{encrypt(val, derived_key)}"
+        except Exception as e:
+            warn_msg = f"[ANOSYS] Warning: Failed to encrypt column '{col}': {e}"
+            print(warn_msg, file=sys.stderr)
+            logger.warning(warn_msg)
+
+    return data