coderio 0.4.0__py3-none-any.whl

coderio/llm/factory.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from langchain_anthropic import ChatAnthropic
+from langchain_openai import ChatOpenAI
+
+from coderio.config import Config
+
+# Max SDK-level retries on transient failures (429 / 5xx / network). The OpenAI
+# client defaults to 2 and Anthropic to 2; bump to 3 so a brief rate-limit spike
+# or a momentary network blip doesn't immediately surface as a fatal error to
+# the user. The SDK already backs off exponentially between attempts.
+_MAX_RETRIES: int = 3
+# Per-request timeout in seconds. Without an explicit value the SDK default
+# applies (OpenAI: none/60s, Anthropic: 600s), which is inconsistent across
+# providers and can hang the TUI on a stuck connection. 90s covers slow coding
+# models while still failing fast on a dead endpoint.
+_REQUEST_TIMEOUT: int = 90
+
+
+def _build_client(kind: str, *, model: str, base_url: str, api_key, max_tokens: int):
+    """Construct a ChatAnthropic or ChatOpenAI with uniform retry/timeout settings.
+
+    Centralizes the two knobs (max_retries, timeout) so every provider layer
+    (profile, registry provider_id, custom provider_id, S0 fallback) gets the
+    same resilience instead of each call site setting them ad hoc.
+    """
+    common = dict(
+        model=model,
+        base_url=base_url,
+        api_key=api_key,
+        max_tokens=max_tokens,
+        max_retries=_MAX_RETRIES,
+        timeout=_REQUEST_TIMEOUT,
+    )
+    if kind == "anthropic":
+        return ChatAnthropic(**common)
+    return ChatOpenAI(**common)
+
+
+def _pick_api_key(provider: str) -> str | None:
+    if provider == "anthropic":
+        return os.environ.get("ANTHROPIC_API_KEY")
+    return os.environ.get("Z_API_KEY") or os.environ.get("OPENAI_API_KEY")
+
+
+def _resolve_profile(cfg: Config):
+    """Pick the Profile to build from, or None to fall through to the legacy path.
+
+    - active_profile set → find the matching Profile by name. If the name
+      doesn't match any profile (stale config), fall through to legacy.
+    - active_profile empty but profiles exist → default to the first one, so a
+      freshly-onboarded user with one profile and no explicit active_profile
+      still uses it.
+    - no profiles → None (legacy [model] path, unchanged behavior).
+    """
+    profiles = cfg.profiles or []
+    if not profiles:
+        return None
+    if cfg.active_profile:
+        for p in profiles:
+            if p.name == cfg.active_profile:
+                return p
+        # Stale active_profile name — fall through rather than crash.
+        return None
+    return profiles[0]
+
+
+def build_chat_model(cfg: Config, creds_path: Path | str | None = None):
+    """Build a chat model.
+
+    Resolution order:
+      0. active_profile set → use that Profile's provider_id/model/base_url/kind
+         + credentials key (named multi-config, the /profile path)
+      1. provider_id in registry → use registry base_url/kind + credentials key
+      2. provider_id set but NOT in registry → use config.toml's base_url/provider
+         + credentials key (custom provider from config.toml or 'coderio config add')
+      3. no provider_id → S0 fallback: config.toml provider/base_url + env key
+
+    Layers 1-3 are the legacy single-config path. Layer 0 takes precedence when
+    the user has created named profiles via onboarding; without profiles,
+    cfg.active_profile is "" and layers 1-3 run unchanged.
+    """
+    m = cfg.model
+    max_tokens = m.max_output_tokens
+
+    # Layer 0: named profile (multi-config). Takes precedence over [model].
+    profile = _resolve_profile(cfg)
+    if profile is not None:
+        from coderio.cli.credentials import get_key
+        from coderio.cli.providers import get_provider
+
+        info = get_provider(profile.provider_id)
+        key = get_key(profile.provider_id, creds_path) or _pick_api_key(info.kind if info else profile.kind)
+        model_name = profile.model or (info.default_model if info and info.default_model else "")
+        # Registry providers supply their own base_url/kind; custom profiles
+        # carry their own (mirrors the [model] layer 1 vs 2 split).
+        base_url = info.base_url if info and info.base_url else profile.base_url
+        kind = info.kind if info else profile.kind
+        if not base_url:
+            raise ValueError(
+                f"profile '{profile.name}': provider_id '{profile.provider_id}' "
+                f"has no base_url. Set base_url in the profile or use a known provider_id."
+            )
+        return _build_client(
+            kind,
+            model=model_name,
+            base_url=base_url,
+            api_key=key,
+            max_tokens=max_tokens,
+        )
+
+    if m.provider_id:
+        from coderio.cli.credentials import get_key
+        from coderio.cli.providers import get_provider
+
+        info = get_provider(m.provider_id)
+        key = get_key(m.provider_id, creds_path) or _pick_api_key(info.kind if info else m.provider)
+        model_name = m.default or (info.default_model if info else "")
+        if info:
+            # Known provider — use registry base_url/kind.
+            return _build_client(
+                info.kind,
+                model=model_name,
+                base_url=info.base_url,
+                api_key=key,
+                max_tokens=max_tokens,
+            )
+        # Custom provider_id not in registry — use config.toml base_url/provider.
+        kind = m.provider or "openai_compatible"
+        if not m.base_url:
+            raise ValueError(
+                f"provider_id '{m.provider_id}' is not a known provider and "
+                f"no base_url is set in config.toml. Either use a known provider_id, "
+                f"or set [model] base_url and provider in config.toml."
+            )
+        if kind == "anthropic":
+            return _build_client(
+                kind,
+                model=model_name,
+                base_url=m.base_url,
+                api_key=key,
+                max_tokens=max_tokens,
+            )
+        return _build_client(
+            kind,
+            model=model_name,
+            base_url=m.base_url,
+            api_key=key,
+            max_tokens=max_tokens,
+        )
+
+    api_key = _pick_api_key(m.provider)
+    if m.provider in ("openai_compatible", "anthropic"):
+        return _build_client(
+            m.provider,
+            model=m.default,
+            base_url=m.base_url,
+            api_key=api_key,
+            max_tokens=max_tokens,
+        )
+    raise ValueError(f"Unknown provider: {m.provider!r} (expected 'openai_compatible' or 'anthropic')")

coderio/llm/probe.py

@@ -0,0 +1,153 @@
+"""Provider context-window discovery.
+
+On setup, we want to record the actual model's context window so the context-
+compaction threshold is accurate. coderio defaults to 200K (covers most modern
+models), but a model like step-3.7-flash (256K) would be mistreated as 200K,
+triggering compaction at 120K instead of 153K.
+
+This module queries the provider's model-info endpoint once at onboarding time
+and returns the context window size. On ANY failure (network, parse, auth,
+shape mismatch), it returns 0 — the caller falls back to the config default.
+No retry, no exception: this is a best-effort optimization, never a blocker
+for the setup flow.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+
+# The fields different providers use to report context window size in their
+# /v1/models/{id} (OpenAI-compatible) or /v1/models/{id} (Anthropic) responses.
+# We check each in order and take the first that's a positive int.
+_CONTEXT_FIELDS = (
+    "context_length",
+    "max_context_length",
+    "context_window",
+    "context_window_tokens",
+    "max_input_tokens",
+    "input_context_length",
+)
+
+
+def probe_context_limit(
+    provider_kind: str,
+    base_url: str,
+    api_key: str,
+    model: str,
+    timeout: float = 5.0,
+) -> int:
+    """Query the provider's model-info endpoint for the context window size.
+
+    Args:
+        provider_kind: "anthropic" or "openai_compatible" (any other value
+            routes through the OpenAI-compatible path).
+        base_url: provider base URL (no trailing slash), e.g.
+            "https://api.stepfun.com/v1" or "https://api.anthropic.com".
+        api_key: API key for the Authorization header.
+        model: model id, e.g. "step-3.7-flash".
+        timeout: HTTP timeout in seconds. Default 5s — this runs during
+            onboarding and the user is waiting; a stuck probe shouldn't block.
+
+    Returns:
+        The context window size in tokens (e.g. 256000), or 0 on any failure
+        (network error, auth error, unexpected response shape, missing field).
+        Callers MUST treat 0 as "unknown, use default".
+    """
+    base = (base_url or "").rstrip("/")
+    if not base or not model:
+        return 0
+    try:
+        if provider_kind == "anthropic":
+            # Anthropic's GET /v1/models/{id} returns {"data": {"id": ..., ...}}
+            # and currently does NOT report context_window — but we probe anyway
+            # because the API surface may grow. Both header shapes accepted.
+            url = f"{base}/models/{urllib.parse.quote(model)}"
+            headers = (
+                "x-api-key",
+                api_key,
+                "anthropic-version",
+                "2023-06-01",
+            )
+        else:
+            # OpenAI-compatible: GET /v1/models/{id} (note: many compatible
+            # providers like Stepfun/DeepSeek/Together expose context_length in
+            # the per-model response even though vanilla OpenAI doesn't).
+            # base_url may or may not include /v1; normalize to .../v1/models/...
+            if base.endswith("/v1"):
+                url = f"{base}/models/{urllib.parse.quote(model)}"
+            else:
+                url = f"{base}/v1/models/{urllib.parse.quote(model)}"
+            headers = ("Authorization", f"Bearer {api_key}")
+        req = urllib.request.Request(url, headers=_pair_to_dict(headers), method="GET")
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            if resp.status != 200:
+                return 0
+            payload = json.loads(resp.read().decode("utf-8", errors="replace"))
+        return _extract_context_limit(payload)
+    except (
+        urllib.error.URLError,
+        urllib.error.HTTPError,
+        TimeoutError,
+        ValueError,
+        json.JSONDecodeError,
+        OSError,
+    ):
+        return 0
+    except Exception:
+        # Defensive: probe is best-effort, never raise to the caller.
+        return 0
+
+
+def _pair_to_dict(pairs) -> dict[str, str]:
+    """Accept either a tuple-of-pairs or a ready dict and return a dict."""
+    if isinstance(pairs, dict):
+        return pairs
+    return {pairs[i]: pairs[i + 1] for i in range(0, len(pairs) - 1, 2)}
+
+
+def _extract_context_limit(payload) -> int:
+    """Pull the context window size from a provider's model-info response.
+
+    Tries the top-level dict first, then the common nested locations
+    (``data``, ``data.metadata``) since OpenAI-compatible providers are
+    inconsistent about where they put it.
+    """
+    if not isinstance(payload, dict):
+        return 0
+    # 1) top-level fields
+    n = _first_positive_int(payload)
+    if n:
+        return n
+    # 2) nested under "data" (Anthropic shape, some OpenAI-compatible)
+    data = payload.get("data")
+    if isinstance(data, dict):
+        n = _first_positive_int(data) or _first_positive_int(data.get("metadata"))
+        if n:
+            return n
+    # 3) OpenAI list shape: {"data": [{...}]} — pick the first entry's fields
+    if isinstance(data, list):
+        for item in data:
+            if isinstance(item, dict):
+                n = _first_positive_int(item)
+                if n:
+                    return n
+    return 0
+
+
+def _first_positive_int(d) -> int:
+    """Return the first value found under any of _CONTEXT_FIELDS that's a
+    positive integer. Strings that are all digits count too."""
+    if not isinstance(d, dict):
+        return 0
+    for key in _CONTEXT_FIELDS:
+        if key in d:
+            v = d[key]
+            try:
+                iv = int(v)
+                if iv > 0:
+                    return iv
+            except (TypeError, ValueError):
+                continue
+    return 0

coderio/mcp_loader.py

@@ -0,0 +1,274 @@
+"""MCP (Model Context Protocol) tool loader.
+
+Reads Claude-Code-compatible ``.mcp.json`` config files, connects to the
+configured MCP servers via ``langchain-mcp-adapters``, and returns the tools
+as LangChain ``StructuredTool`` instances ready to pass to ``create_deep_agent``.
+
+Config format (identical to Claude Code's ``.mcp.json``):
+
+.. code-block:: json
+
+    {
+      "mcpServers": {
+        "filesystem": {
+          "command": "npx",
+          "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+        },
+        "github": {
+          "type": "http",
+          "url": "https://api.githubcopilot.com/mcp/",
+          "headers": {"Authorization": "Bearer xxx"}
+        }
+      }
+    }
+
+Config discovery (two scopes, project overrides user on name collision):
+  - Project: ``{search_from}/.mcp.json``
+  - User: ``~/.coderio/mcp.json``
+
+Tool naming: ``MultiServerMCPClient(tool_name_prefix=True)`` prefixes each tool
+name with its server (e.g. ``filesystem_read_file``) so MCP tools never collide
+with coderio's built-in ``read_file``, ``write_file``, etc.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+_log = logging.getLogger(__name__)
+
+
+def _find_mcp_config(search_from: str | Path = ".") -> Path | None:
+    """Find the project-level .mcp.json (walks upward from search_from).
+
+    Returns the path if found, None otherwise. Stops at the user's home dir
+    (the home ~/.coderio/mcp.json is the USER scope, handled separately).
+    """
+    cur = Path(search_from).resolve()
+    home = Path.home()
+    while cur != home and cur != cur.parent:
+        candidate = cur / ".mcp.json"
+        if candidate.is_file():
+            return candidate
+        cur = cur.parent
+    return None
+
+
+def _read_mcp_json(path: Path | None) -> dict[str, dict]:
+    """Read a single .mcp.json file, returning the mcpServers dict.
+
+    Returns {} on missing file, invalid JSON, or wrong structure — never raises.
+    """
+    if path is None or not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        _log.warning("Failed to read MCP config %s: %s", path, e)
+        return {}
+    servers = data.get("mcpServers", {})
+    if not isinstance(servers, dict):
+        return {}
+    return servers
+
+
+def load_mcp_config(
+    search_from: str | Path = ".",
+    user_dir: str | Path | None = None,
+) -> dict[str, dict]:
+    """Merge MCP server configs from project + user scope.
+
+    Project .mcp.json overrides user ~/.coderio/mcp.json on server-name
+    collision (project-specific config wins, same as skills/config layering).
+
+    Returns a dict of server_name → config_dict, possibly empty.
+    """
+    project_servers = _read_mcp_json(_find_mcp_config(search_from))
+    # User scope: ~/.coderio/mcp.json
+    user_path = Path(user_dir) if user_dir else Path.home() / ".coderio"
+    user_servers = _read_mcp_json(user_path / "mcp.json")
+    # Merge: user first, project overrides.
+    merged = dict(user_servers)
+    merged.update(project_servers)
+    return merged
+
+
+def _normalize_connection(server_name: str, cfg: dict) -> dict:
+    """Convert a .mcp.json entry to langchain-mcp-adapters connection format.
+
+    Claude Code uses ``"type": "http"``; the adapter expects
+    ``"transport": "streamable_http"``. stdio entries omit the transport key
+    (it's the default) — we add it explicitly.
+
+    ZCode-compatible fields (all optional, all backward-compatible):
+      - ``enabled`` (bool, default True): set False to temporarily disable a
+        server without removing its config. Legacy alias ``enable`` accepted.
+      - ``cwd`` (str, stdio only): working directory for the subprocess. Key
+        on Windows where ``npx`` may not be on PATH without it.
+      - ``timeoutMs`` (int): per-request timeout in milliseconds, forwarded to
+        the adapter as ``timeout`` (seconds). Default 30000 if unset by caller.
+      - ``type`` inference: when ``type`` is omitted, infer from the presence
+        of ``command`` (→ stdio) or ``url`` (→ http).
+
+    Legacy field migrations (ZCode auto-migrates these; we follow suit so
+    ZCode/Cursor-style configs work unchanged):
+      - ``type: "remote"`` → ``http``
+      - ``environment`` → ``env``
+      - ``http_headers`` → ``headers``
+      - ``enable`` → ``enabled``
+    """
+    # --- enabled gate (ZCode-compatible): disabled servers return {} → skipped.
+    if not cfg.get("enabled", cfg.get("enable", True)):
+        _log.info("MCP server %r is disabled (enabled=false), skipping", server_name)
+        return {}
+
+    # --- legacy field migrations (applied before branch logic).
+    server_type = cfg.get("type", "")
+    if server_type == "remote":  # ZCode legacy name for http
+        server_type = "http"
+
+    # timeoutMs → seconds (forwarded to adapter on each branch).
+    timeout_s: float | None = None
+    if "timeoutMs" in cfg:
+        try:
+            timeout_s = float(cfg["timeoutMs"]) / 1000.0
+        except (TypeError, ValueError):
+            _log.warning("MCP server %r has invalid timeoutMs %r, ignoring", server_name, cfg["timeoutMs"])
+
+    # --- stdio branch (command present, or type explicitly stdio).
+    if "command" in cfg:
+        conn: dict[str, Any] = {
+            "transport": "stdio",
+            "command": cfg["command"],
+            "args": cfg.get("args", []),
+        }
+        # env (ZCode legacy: environment → env)
+        env = cfg.get("env", cfg.get("environment"))
+        if env:
+            conn["env"] = env
+        # cwd (Windows PATH robustness — npx/node often need an explicit cwd)
+        if "cwd" in cfg:
+            conn["cwd"] = cfg["cwd"]
+        if timeout_s is not None:
+            conn["timeout"] = timeout_s
+        return conn
+
+    # --- type inference: url present without command → http (ZCode behavior).
+    if server_type in ("http", "streamable_http") or ("url" in cfg and not server_type):
+        if "url" not in cfg:
+            _log.warning("MCP server %r has type=http but no url, skipping", server_name)
+            return {}
+        conn = {
+            "transport": "streamable_http",
+            "url": cfg["url"],
+        }
+        # headers (ZCode legacy: http_headers → headers)
+        headers = cfg.get("headers", cfg.get("http_headers"))
+        if headers:
+            conn["headers"] = headers
+        if timeout_s is not None:
+            conn["timeout"] = timeout_s
+        return conn
+
+    if server_type == "sse":
+        if "url" not in cfg:
+            _log.warning("MCP server %r has type=sse but no url, skipping", server_name)
+            return {}
+        conn = {
+            "transport": "sse",
+            "url": cfg["url"],
+        }
+        headers = cfg.get("headers", cfg.get("http_headers"))
+        if headers:
+            conn["headers"] = headers
+        if timeout_s is not None:
+            conn["timeout"] = timeout_s
+        return conn
+
+    # Unknown format — return a marker that will be skipped.
+    _log.warning("MCP server %r has unrecognized config: %s", server_name, cfg)
+    return {}
+
+
+async def load_mcp_tools(
+    search_from: str | Path = ".",
+    user_dir: str | Path | None = None,
+) -> list:
+    """Connect to all configured MCP servers and return their tools.
+
+    Returns a list of LangChain ``BaseTool`` instances (empty if no servers
+    configured or all connections failed). Tool names are prefixed with the
+    server name (e.g. ``filesystem_read_file``) to avoid collisions with
+    coderio's built-in tools.
+
+    Connection failures (server not installed, network error, bad config) are
+    logged as warnings and skipped — they never block coderio startup.
+    """
+    config = load_mcp_config(search_from, user_dir)
+    if not config:
+        return []
+
+    # Build connections dict for MultiServerMCPClient.
+    connections: dict[str, dict] = {}
+    for name, raw_cfg in config.items():
+        if not isinstance(raw_cfg, dict):
+            continue
+        conn = _normalize_connection(name, raw_cfg)
+        if conn:
+            connections[name] = conn
+
+    if not connections:
+        return []
+
+    try:
+        from langchain_mcp_adapters.client import MultiServerMCPClient
+    except ImportError:
+        _log.warning(
+            "langchain-mcp-adapters not installed — MCP tools disabled. "
+            "Install with: pip install langchain-mcp-adapters"
+        )
+        return []
+
+    try:
+        client = MultiServerMCPClient(connections, tool_name_prefix=True)
+    except Exception as e:
+        _log.warning("Failed to initialize MCP client: %s", e)
+        return []
+
+    # Load tools from each server individually — one bad server (command not
+    # found, network error) must not prevent the good servers' tools from
+    # loading. MultiServerMCPClient connections are lazy; get_tools(server_name)
+    # only connects to that one server.
+    all_tools: list = []
+    for server_name in connections:
+        try:
+            server_tools = await client.get_tools(server_name=server_name)
+            all_tools.extend(server_tools)
+        except Exception as e:
+            _log.warning("MCP server %r failed to load (skipped): %s", server_name, e)
+
+    _log.info("Loaded %d MCP tools from %d servers", len(all_tools), len(connections))
+    return all_tools
+
+
+def load_mcp_tools_sync(
+    search_from: str | Path = ".",
+    user_dir: str | Path | None = None,
+) -> list:
+    """Sync wrapper for load_mcp_tools. Called from build_runtime (sync context).
+
+    Uses asyncio.run() — safe because this runs once at startup, not inside an
+    existing event loop.
+    """
+    import asyncio
+
+    try:
+        return asyncio.run(load_mcp_tools(search_from, user_dir))
+    except RuntimeError:
+        # Already inside an event loop (shouldn't happen at startup, but guard
+        # just in case). Return empty — MCP tools are opt-in, not critical.
+        _log.warning("Cannot load MCP tools inside an existing event loop")
+        return []

coderio/session/__init__.py

@@ -0,0 +1,3 @@
+from coderio.session.message import Message, ToolCall
+
+__all__ = ["Message", "ToolCall"]

coderio/session/message.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    args: dict[str, Any]
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "name": self.name, "args": self.args}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ToolCall":
+        return cls(id=d.get("id"), name=d.get("name"), args=d.get("args"))
+
+
+@dataclass
+class Message:
+    role: Literal["user", "assistant", "tool", "system"]
+    # content is normally a str; for multimodal user messages it may be a list of
+    # content blocks (e.g. [{"type":"text",...},{"type":"image",...}]) which
+    # langchain's HumanMessage accepts directly. For system messages with
+    # kind="phase_timeline", content holds the serialized timeline JSON.
+    content: str | list = ""
+    tool_calls: list[ToolCall] | None = None
+    tool_call_id: str | None = None
+    name: str | None = None
+    # Sub-kind for system-role messages: "phase_timeline" (turn-end phase record),
+    # "context_summary" (compacted history), "restart_checkpoint". Empty for
+    # non-system messages. Lets loaders filter system messages by purpose.
+    kind: str = ""
+    timestamp: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%S"))
+
+    @classmethod
+    def user(cls, content: str) -> "Message":
+        return cls(role="user", content=content)
+
+    @classmethod
+    def assistant(cls, content: str, tool_calls: list[ToolCall] | None = None) -> "Message":
+        return cls(role="assistant", content=content, tool_calls=tool_calls)
+
+    @classmethod
+    def tool_result(cls, tool_call_id: str, name: str, content: str) -> "Message":
+        return cls(role="tool", content=content, tool_call_id=tool_call_id, name=name)
+
+    @classmethod
+    def system(cls, content: str, kind: str = "") -> "Message":
+        """A system-role message: phase timeline, context summary, or checkpoint.
+        Not shown in conversation history; filtered by ``kind``."""
+        return cls(role="system", content=content, kind=kind)
+
+    def to_dict(self) -> dict:
+        d = {"role": self.role, "content": self.content, "timestamp": self.timestamp}
+        if self.tool_calls:
+            d["tool_calls"] = [tc.to_dict() for tc in self.tool_calls]
+        if self.tool_call_id:
+            d["tool_call_id"] = self.tool_call_id
+        if self.name:
+            d["name"] = self.name
+        if self.kind:
+            d["kind"] = self.kind
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Message":
+        return cls(
+            role=d["role"],
+            content=d.get("content", ""),
+            tool_calls=[ToolCall.from_dict(tc) for tc in d.get("tool_calls")] if d.get("tool_calls") else None,
+            tool_call_id=d.get("tool_call_id"),
+            name=d.get("name"),
+            kind=d.get("kind", ""),
+            timestamp=d.get("timestamp", time.strftime("%Y-%m-%dT%H:%M:%S")),
+        )