@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/request_shortcuts.py

@@ -0,0 +1,253 @@
+"""Parse local router control requests embedded in runtime conversations."""
+
+from __future__ import annotations
+
+import re
+import shlex
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+PLACEHOLDER_VALUES = frozenset(
+    {"", "$0", "${0}", "$1", "${1}", "$2", "${2}", "$ARGUMENTS", "${ARGUMENTS}"}
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ShortcutTextServices:
+    latest_user_text: Callable[[dict[str, Any]], str]
+
+
+def has_marker(
+    body: dict[str, Any], markers: tuple[str, ...], services: ShortcutTextServices
+) -> bool:
+    text = services.latest_user_text(body)
+    return any(marker in text for marker in markers)
+
+
+def marker_tail(
+    body: dict[str, Any], markers: tuple[str, ...], services: ShortcutTextServices
+) -> str:
+    text = services.latest_user_text(body)
+    for marker in markers:
+        if marker in text:
+            return text.split(marker, 1)[1]
+    return ""
+
+
+def single_value(
+    body: dict[str, Any],
+    markers: tuple[str, ...],
+    services: ShortcutTextServices,
+    *,
+    empty_default: str,
+    blank_value_default: str,
+) -> str:
+    tail = marker_tail(body, markers, services)
+    if not tail:
+        return empty_default
+    for line in tail.splitlines():
+        stripped = line.strip()
+        if stripped.lower().startswith("value:"):
+            return stripped.split(":", 1)[1].strip() or blank_value_default
+    return tail.strip() or blank_value_default
+
+
+def live_option_value(
+    body: dict[str, Any], markers: tuple[str, ...], services: ShortcutTextServices
+) -> str:
+    tail = marker_tail(body, markers, services)
+    if not tail:
+        return "status"
+    fallback_values: list[str] = []
+    structured = False
+    for line in tail.splitlines():
+        stripped = line.strip()
+        lowered = stripped.lower()
+        if lowered.startswith("value:"):
+            structured = True
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                return value
+        elif lowered.startswith("arguments:"):
+            structured = True
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                fallback_values.append(value)
+    if fallback_values:
+        return fallback_values[0]
+    if structured:
+        return "status"
+    fallback = tail.strip()
+    return fallback if fallback not in PLACEHOLDER_VALUES else "status"
+
+
+def live_api_keys_value(
+    body: dict[str, Any], markers: tuple[str, ...], services: ShortcutTextServices
+) -> str:
+    tail = marker_tail(body, markers, services)
+    if not tail:
+        return "status"
+    value_line = ""
+    arguments: list[str] = []
+    structured = False
+    capture_arguments = False
+    for line in tail.splitlines():
+        stripped = line.strip()
+        if capture_arguments:
+            if stripped not in PLACEHOLDER_VALUES:
+                arguments.append(stripped)
+            continue
+        lowered = stripped.lower()
+        if lowered.startswith("value:"):
+            structured = True
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                value_line = value
+        elif lowered.startswith("arguments:"):
+            structured = True
+            capture_arguments = True
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                arguments.append(value)
+    if arguments:
+        return "\n".join(arguments)
+    if value_line:
+        return value_line
+    if structured:
+        return "status"
+    fallback = tail.strip()
+    return fallback if fallback not in PLACEHOLDER_VALUES else "status"
+
+
+def parse_channel_bridge_args(raw: str) -> tuple[str, dict[str, str]]:
+    text = str(raw or "").strip()
+    if not text:
+        return "status", {}
+    try:
+        parts = shlex.split(text)
+    except Exception:
+        parts = text.split()
+    if not parts:
+        return "status", {}
+    command = parts[0].strip().lower()
+    if command not in {"status", "poll", "wait", "send", "post", "sse"}:
+        parts = ["status", *parts]
+        command = "status"
+    options: dict[str, str] = {}
+    loose: list[str] = []
+    for part in parts[1:]:
+        if "=" in part:
+            key, value = part.split("=", 1)
+            options[key.strip().lower().replace("-", "_")] = value.strip()
+        elif part:
+            loose.append(part)
+    if loose and "message" not in options and command in {"send", "post"}:
+        options["message"] = " ".join(loose)
+    return command, options
+
+
+def format_channel_messages(messages: list[dict[str, Any]], after: int) -> str:
+    if not messages:
+        return f"No channel messages after id {after}."
+    lines = [f"Channel bridge messages ({len(messages)}):"]
+    for item in messages:
+        recipients = item.get("recipients") or []
+        recipient_text = (
+            ",".join(str(value) for value in recipients) or "all"
+            if isinstance(recipients, list)
+            else str(recipients or "all")
+        )
+        text = re.sub(r"\s+", " ", str(item.get("message") or "")).strip()
+        if len(text) > 500:
+            text = text[:500].rstrip() + "..."
+        lines.append(
+            f"- #{item.get('id')} [{item.get('channel')}] {item.get('sender_id')} -> {recipient_text}: {text}"
+        )
+    lines.append(f"Last id: {messages[-1].get('id')}")
+    return "\n".join(lines)
+
+
+def _strip_wrapping_quotes(value: str) -> str:
+    text = str(value or "").strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in {"'", '"'}:
+        return text[1:-1]
+    return text
+
+
+def split_import_session_arguments(value: str, *, posix: bool) -> tuple[str, str]:
+    raw = str(value or "").strip()
+    if not raw:
+        return "", ""
+    try:
+        parts = [_strip_wrapping_quotes(part) for part in shlex.split(raw, posix=posix)]
+    except Exception:
+        parts = raw.split()
+    if not parts:
+        return "", ""
+    target = parts[0].strip()
+    path_parts: list[str] = []
+    index = 1
+    while index < len(parts):
+        part = str(parts[index]).strip()
+        lowered = part.lower()
+        if lowered in {"--path", "-p", "path", "file", "transcript"} and index + 1 < len(parts):
+            path_parts = [str(parts[index + 1])]
+            index += 2
+            continue
+        if lowered.startswith(("--path=", "path=", "file=", "transcript=")):
+            path_parts = [part.split("=", 1)[1]]
+        else:
+            path_parts.append(part)
+        index += 1
+    return target, _strip_wrapping_quotes(" ".join(path_parts).strip())
+
+
+def import_session_args(
+    body: dict[str, Any],
+    markers: tuple[str, ...],
+    services: ShortcutTextServices,
+    *,
+    posix: bool,
+) -> tuple[str, str]:
+    tail = marker_tail(body, markers, services)
+    if not tail:
+        return "", ""
+    target = ""
+    path = ""
+    arguments: list[str] = []
+    capture = False
+    field_prefixes = ("target:", "source:", "format:", "runtime:")
+    path_prefixes = ("path:", "file:", "transcript:")
+    for line in tail.splitlines():
+        stripped = line.strip()
+        if capture:
+            if stripped not in PLACEHOLDER_VALUES:
+                arguments.append(stripped)
+            continue
+        lowered = stripped.lower()
+        if lowered.startswith(field_prefixes):
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                target = value
+        elif lowered.startswith(path_prefixes):
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                path = _strip_wrapping_quotes(value)
+        elif lowered.startswith("arguments:"):
+            capture = True
+            value = stripped.split(":", 1)[1].strip()
+            if value not in PLACEHOLDER_VALUES:
+                arguments.append(value)
+    arg_target, arg_path = split_import_session_arguments("\n".join(arguments), posix=posix)
+    target = arg_target or target
+    path = arg_path or path
+    if not target:
+        fallback = "\n".join(
+            line
+            for line in tail.splitlines()
+            if not line.strip().lower().startswith((*field_prefixes, *path_prefixes, "arguments:"))
+        ).strip()
+        target, fallback_path = split_import_session_arguments(fallback, posix=posix)
+        path = path or fallback_path
+    return target.strip(), _strip_wrapping_quotes(path)

package/ciel_runtime_support/request_trace.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .usage_events import UsageEvent
+
+
+@dataclass(frozen=True)
+class RequestTracePolicy:
+    enabled: Callable[[], bool]
+    request_path: Path
+    response_path: Path
+    request_max_bytes: int
+    response_max_bytes: int
+    response_text_limit: int
+
+
+@dataclass(frozen=True)
+class RequestTraceProjection:
+    content_to_text: Callable[[Any], str]
+    thinking_block_count: Callable[[dict[str, Any]], int]
+    tool_continuation_block_count: Callable[[dict[str, Any]], int]
+
+
+@dataclass(frozen=True)
+class RequestTraceServices:
+    policy: RequestTracePolicy
+    projection: RequestTraceProjection
+    log: Callable[[str, str], None]
+    timestamp: Callable[[], str] = lambda: time.strftime("%Y-%m-%dT%H:%M:%S")
+
+
+@dataclass(frozen=True, slots=True)
+class ResponseTraceController:
+    record_usage: Callable[[UsageEvent], None]
+    publish_event: Callable[..., Any]
+    services: Callable[[], RequestTraceServices]
+    log: Callable[[str, str], None]
+
+    def write(
+        self,
+        provider: str,
+        model: str,
+        text: str,
+        tool_calls: list[dict[str, Any]],
+        stop_reason: str | None,
+        input_tokens: int,
+        output_tokens: int,
+        last_chunk: dict[str, Any] | None = None,
+    ) -> None:
+        try:
+            self.record_usage(
+                UsageEvent(
+                    provider=provider,
+                    model=model,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                )
+            )
+            self.publish_event(
+                level="info",
+                category="usage.response",
+                message="upstream token usage recorded",
+                provider=provider,
+                model=model,
+                data={
+                    "input_tokens": max(0, input_tokens),
+                    "output_tokens": max(0, output_tokens),
+                },
+            )
+        except Exception as exc:
+            self.log(
+                "WARN",
+                "usage_event_record_failed "
+                f"error={type(exc).__name__}: {exc}",
+            )
+        dump_response_for_trace(
+            provider,
+            model,
+            text,
+            tool_calls,
+            stop_reason,
+            input_tokens,
+            output_tokens,
+            self.services(),
+            last_chunk=last_chunk,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RouterMessagePreviewPolicy:
+    environ: Mapping[str, str]
+    load_config: Callable[[], dict[str, Any]]
+    positive_int: Callable[[Any], int | None]
+    latest_user_text: Callable[[dict[str, Any]], str]
+    redact_text: Callable[[str], str]
+
+    def configured_chars(
+        self,
+        config: dict[str, Any] | None = None,
+    ) -> int:
+        current = config or self.load_config()
+        environment = self.environ.get(
+            "CIEL_RUNTIME_ROUTER_MESSAGE_PREVIEW_CHARS",
+            "",
+        ).strip()
+        value = self.positive_int(environment) if environment else None
+        if value is None:
+            value = self.positive_int(
+                current.get("router_debug_message_preview_chars")
+            )
+        return min(value or 0, 4_000)
+
+    def project(
+        self,
+        body: dict[str, Any],
+        config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        limit = self.configured_chars(config)
+        if limit <= 0:
+            return {}
+        text = self.latest_user_text(body).strip()
+        if not text:
+            return {
+                "message_preview_chars": limit,
+                "message_preview": "",
+                "message_preview_truncated": False,
+            }
+        normalized = re.sub(
+            r"\s+",
+            " ",
+            self.redact_text(text),
+        )
+        return {
+            "message_preview_chars": limit,
+            "message_preview": normalized[:limit].rstrip(),
+            "message_preview_truncated": len(normalized) > limit,
+        }
+
+
+def truncate_for_dump(value: Any, max_len: int = 4000) -> Any:
+    try:
+        text = json.dumps(value, ensure_ascii=False) if not isinstance(value, str) else value
+    except Exception:
+        text = str(value)
+    if len(text) > max_len:
+        return text[:max_len] + f"...<truncated {len(text) - max_len} chars>"
+    return value
+
+
+def summarize_messages_for_trace(
+    messages: Any,
+    projection: RequestTraceProjection,
+    max_messages: int = 30,
+) -> list[dict[str, Any]]:
+    if not isinstance(messages, list):
+        return []
+    selected = messages[-max_messages:]
+    offset = len(messages) - len(selected)
+    summary: list[dict[str, Any]] = []
+    for index, message in enumerate(selected, start=offset):
+        if not isinstance(message, dict):
+            continue
+        entry: dict[str, Any] = {"index": index, "role": message.get("role")}
+        blocks: list[dict[str, Any]] = []
+        content = message.get("content")
+        if isinstance(content, str):
+            blocks.append({"type": "text", "text": truncate_for_dump(content, 1000)})
+        elif isinstance(content, list):
+            for block in content:
+                projected = _project_trace_block(block, projection)
+                if projected is not None:
+                    blocks.append(projected)
+        else:
+            blocks.append(
+                {"type": type(content).__name__, "text": truncate_for_dump(content, 1000)}
+            )
+        entry["content"] = blocks
+        summary.append(entry)
+    return summary
+
+
+def _project_trace_block(
+    block: Any,
+    projection: RequestTraceProjection,
+) -> dict[str, Any] | None:
+    if isinstance(block, str):
+        return {"type": "text", "text": truncate_for_dump(block, 1000)}
+    if not isinstance(block, dict):
+        return None
+    block_type = str(block.get("type") or "")
+    if block_type == "text":
+        return {"type": "text", "text": truncate_for_dump(block.get("text", ""), 1000)}
+    if block_type == "tool_use":
+        return {
+            "type": "tool_use",
+            "id": block.get("id"),
+            "name": block.get("name"),
+            "input": truncate_for_dump(block.get("input"), 1200),
+        }
+    if block_type == "tool_result":
+        return {
+            "type": "tool_result",
+            "tool_use_id": block.get("tool_use_id"),
+            "is_error": block.get("is_error"),
+            "content": truncate_for_dump(
+                projection.content_to_text(block.get("content", "")),
+                1200,
+            ),
+        }
+    if block_type == "thinking":
+        return {
+            "type": "thinking",
+            "thinking_len": len(str(block.get("thinking") or "")),
+            "has_signature": bool(block.get("signature")),
+        }
+    if block_type == "redacted_thinking":
+        return {
+            "type": "redacted_thinking",
+            "data_len": len(str(block.get("data") or "")),
+        }
+    return {"type": block_type or "unknown"}
+
+
+def dump_request_for_trace(
+    provider: str,
+    path: str,
+    body: dict[str, Any],
+    services: RequestTraceServices,
+) -> None:
+    if not services.policy.enabled():
+        return
+    try:
+        _rotate_if_oversized(
+            services.policy.request_path,
+            services.policy.request_max_bytes,
+        )
+        record = {
+            "time": services.timestamp(),
+            "provider": provider,
+            "path": path,
+            "model": body.get("model"),
+            "stream": body.get("stream"),
+            "thinking": body.get("thinking"),
+            "thinking_blocks": services.projection.thinking_block_count(body),
+            "tool_continuation_blocks": services.projection.tool_continuation_block_count(body),
+            "messages_count": len(body.get("messages") or []),
+            "messages": summarize_messages_for_trace(body.get("messages"), services.projection),
+            "system": truncate_for_dump(body.get("system")),
+            "tools": body.get("tools"),
+        }
+        _append_json_line(services.policy.request_path, record)
+    except Exception as exc:
+        services.log("WARN", f"request_trace_dump_failed error={type(exc).__name__}: {exc}")
+
+
+def dump_response_for_trace(
+    provider: str,
+    model: str,
+    text_so_far: str,
+    tool_calls: list[dict[str, Any]],
+    stop_reason: str | None,
+    input_tokens: int,
+    output_tokens: int,
+    services: RequestTraceServices,
+    last_chunk: dict[str, Any] | None = None,
+) -> None:
+    if not services.policy.enabled():
+        return
+    try:
+        _rotate_if_oversized(
+            services.policy.response_path,
+            services.policy.response_max_bytes,
+        )
+        text_full_len = len(text_so_far)
+        text = text_so_far
+        if text_full_len > services.policy.response_text_limit:
+            text = (
+                text_so_far[: services.policy.response_text_limit]
+                + f"...<truncated {text_full_len - services.policy.response_text_limit} chars>"
+            )
+        tool_summary = []
+        for call in tool_calls:
+            function = call.get("function") if isinstance(call.get("function"), dict) else {}
+            tool_summary.append(
+                {
+                    "name": function.get("name"),
+                    "arguments": function.get("arguments"),
+                }
+            )
+        record = {
+            "time": services.timestamp(),
+            "provider": provider,
+            "model": model,
+            "stop_reason": stop_reason,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "text_full_len": text_full_len,
+            "tool_call_count": len(tool_calls),
+            "text": text,
+            "tool_calls": tool_summary,
+            "done_reason": (last_chunk or {}).get("done_reason"),
+        }
+        _append_json_line(services.policy.response_path, record)
+    except Exception as exc:
+        services.log("WARN", f"response_trace_dump_failed error={type(exc).__name__}: {exc}")
+
+
+def _rotate_if_oversized(path: Path, max_bytes: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists() and path.stat().st_size > max_bytes:
+        path.replace(path.with_suffix(".jsonl.1"))
+
+
+def _append_json_line(path: Path, record: dict[str, Any]) -> None:
+    with path.open("a", encoding="utf-8") as stream:
+        stream.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")