voidx 1.0.0__py3-none-any.whl

voidx/memory/context_frames.py

@@ -0,0 +1,188 @@
+"""Compiled LLM context frame snapshots."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
+from pydantic import BaseModel, Field
+
+from voidx.memory.session import _now
+from voidx.memory.store import _execute_commit, _fetch_all
+
+
+class ContextFrameRecord(BaseModel):
+    id: int | None = None
+    session_id: str
+    user_message_id: int | None = None
+    frame_kind: str = "main"
+    agent_role: str = "orchestrator"
+    provider: str
+    model: str
+    prefix_hash: str
+    frame_hash: str
+    message_count: int
+    token_estimate: int = 0
+    messages: list[dict[str, Any]]
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: str = Field(default_factory=_now)
+
+
+def build_context_frame(
+    *,
+    session_id: str,
+    messages: list[BaseMessage],
+    provider: str,
+    model: str,
+    frame_kind: str = "main",
+    agent_role: str = "orchestrator",
+    user_message_id: int | None = None,
+    token_estimate: int = 0,
+    metadata: dict[str, Any] | None = None,
+) -> ContextFrameRecord:
+    serialized = [_serialize_message(message) for message in messages]
+    return ContextFrameRecord(
+        session_id=session_id,
+        user_message_id=user_message_id,
+        frame_kind=frame_kind,
+        agent_role=agent_role,
+        provider=provider,
+        model=model,
+        prefix_hash=_hash_payload(_stable_prefix_payload(serialized)),
+        frame_hash=_hash_payload(serialized),
+        message_count=len(serialized),
+        token_estimate=token_estimate,
+        messages=serialized,
+        metadata=metadata or {},
+    )
+
+
+async def save_context_frame(record: ContextFrameRecord) -> int:
+    cur = await _execute_commit(
+        """INSERT INTO context_frames (
+               session_id, user_message_id, frame_kind, agent_role, provider,
+               model, prefix_hash, frame_hash, message_count, token_estimate,
+               messages_json, metadata_json, created_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            record.session_id,
+            record.user_message_id,
+            record.frame_kind,
+            record.agent_role,
+            record.provider,
+            record.model,
+            record.prefix_hash,
+            record.frame_hash,
+            record.message_count,
+            record.token_estimate,
+            json.dumps(record.messages, ensure_ascii=False, sort_keys=True),
+            json.dumps(record.metadata, ensure_ascii=False, sort_keys=True),
+            record.created_at,
+        ),
+    )
+    return cur.lastrowid
+
+
+async def save_context_frame_from_messages(
+    *,
+    session_id: str,
+    messages: list[BaseMessage],
+    provider: str,
+    model: str,
+    frame_kind: str = "main",
+    agent_role: str = "orchestrator",
+    user_message_id: int | None = None,
+    token_estimate: int = 0,
+    metadata: dict[str, Any] | None = None,
+) -> int:
+    return await save_context_frame(build_context_frame(
+        session_id=session_id,
+        messages=messages,
+        provider=provider,
+        model=model,
+        frame_kind=frame_kind,
+        agent_role=agent_role,
+        user_message_id=user_message_id,
+        token_estimate=token_estimate,
+        metadata=metadata,
+    ))
+
+
+async def load_context_frames(session_id: str, limit: int = 50) -> list[ContextFrameRecord]:
+    rows = await _fetch_all(
+        """SELECT * FROM context_frames
+           WHERE session_id = ?
+           ORDER BY id DESC
+           LIMIT ?""",
+        (session_id, limit),
+    )
+    records = [
+        ContextFrameRecord(
+            id=row["id"],
+            session_id=row["session_id"],
+            user_message_id=row["user_message_id"],
+            frame_kind=row["frame_kind"],
+            agent_role=row["agent_role"],
+            provider=row["provider"],
+            model=row["model"],
+            prefix_hash=row["prefix_hash"],
+            frame_hash=row["frame_hash"],
+            message_count=row["message_count"],
+            token_estimate=row["token_estimate"],
+            messages=json.loads(row["messages_json"]),
+            metadata=json.loads(row["metadata_json"]),
+            created_at=row["created_at"],
+        )
+        for row in rows
+    ]
+    return list(reversed(records))
+
+
+def _serialize_message(message: BaseMessage) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "role": _message_role(message),
+        "content": _json_safe(getattr(message, "content", "")),
+    }
+    if isinstance(message, AIMessage) and getattr(message, "tool_calls", None):
+        payload["tool_calls"] = _json_safe(message.tool_calls)
+    if isinstance(message, ToolMessage):
+        payload["tool_call_id"] = getattr(message, "tool_call_id", "")
+    return payload
+
+
+def _message_role(message: BaseMessage) -> str:
+    if isinstance(message, SystemMessage):
+        return "system"
+    if isinstance(message, HumanMessage):
+        return "user"
+    if isinstance(message, AIMessage):
+        return "assistant"
+    if isinstance(message, ToolMessage):
+        return "tool"
+    return getattr(message, "type", message.__class__.__name__)
+
+
+def _stable_prefix_payload(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    if not messages or messages[0].get("role") != "system":
+        return []
+    content = str(messages[0].get("content", ""))
+    stable_content = content.split("\n\n## Current Date", 1)[0]
+    return [{"role": "system", "content": stable_content}]
+
+
+def _hash_payload(payload: Any) -> str:
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        default=str,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _json_safe(value: Any) -> Any:
+    return json.loads(json.dumps(value, ensure_ascii=False, sort_keys=True, default=str))

voidx/memory/model_profiles.py

@@ -0,0 +1,98 @@
+"""User-level model profile persistence."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from voidx.memory.session import _now
+from voidx.memory.store import _get_db, _write_lock
+
+
+@dataclass(frozen=True)
+class ModelProfileRow:
+    name: str
+    provider: str
+    model: str
+    api_key: str = ""
+    base_url: str | None = None
+    protocol: str | None = None
+
+def list_model_profiles() -> list[ModelProfileRow]:
+    conn = _get_db()
+    rows = conn.execute(
+        """SELECT name, provider, model, api_key, base_url, protocol
+           FROM model_profiles
+           ORDER BY updated_at DESC, name ASC"""
+    ).fetchall()
+    return [_row_to_profile(row) for row in rows]
+
+
+def get_model_profile(name: str) -> ModelProfileRow | None:
+    conn = _get_db()
+    row = conn.execute(
+        """SELECT name, provider, model, api_key, base_url, protocol
+           FROM model_profiles
+           WHERE name = ?""",
+        (name,),
+    ).fetchone()
+    return _row_to_profile(row) if row else None
+
+
+def first_model_profile_for_provider(provider: str) -> ModelProfileRow | None:
+    conn = _get_db()
+    row = conn.execute(
+        """SELECT name, provider, model, api_key, base_url, protocol
+           FROM model_profiles
+           WHERE provider = ?
+           ORDER BY updated_at DESC, name ASC
+           LIMIT 1""",
+        (provider,),
+    ).fetchone()
+    return _row_to_profile(row) if row else None
+
+
+def save_model_profile(profile: ModelProfileRow) -> None:
+    now = _now()
+    conn = _get_db()
+    with _write_lock:
+        conn.execute(
+            """INSERT INTO model_profiles
+               (name, provider, model, api_key, base_url, protocol, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+               ON CONFLICT(name) DO UPDATE SET
+                   provider = excluded.provider,
+                   model = excluded.model,
+                   api_key = excluded.api_key,
+                   base_url = excluded.base_url,
+                   protocol = excluded.protocol,
+                   updated_at = excluded.updated_at""",
+            (
+                profile.name,
+                profile.provider,
+                profile.model,
+                profile.api_key,
+                profile.base_url,
+                profile.protocol,
+                now,
+                now,
+            ),
+        )
+        conn.commit()
+
+
+def delete_model_profile(name: str) -> None:
+    conn = _get_db()
+    with _write_lock:
+        conn.execute("DELETE FROM model_profiles WHERE name = ?", (name,))
+        conn.commit()
+
+
+def _row_to_profile(row) -> ModelProfileRow:
+    return ModelProfileRow(
+        name=row["name"],
+        provider=row["provider"],
+        model=row["model"],
+        api_key=row["api_key"],
+        base_url=row["base_url"],
+        protocol=row["protocol"],
+    )

voidx/memory/runtime_state.py

@@ -0,0 +1,240 @@
+"""Structured runtime state persistence for session resume."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from voidx.agent.runtime_context import InteractionMode, TaskIntent
+from voidx.agent.task_state import TaskPhase, TaskRun, TaskRunStatus, TaskState
+from voidx.memory.session import _now
+from voidx.memory.store import _execute_commit, _fetch_one
+
+
+class RuntimeStateSnapshot(BaseModel):
+    interaction_mode: InteractionMode = InteractionMode.AUTO
+    task_state: TaskState = Field(default_factory=TaskState)
+    task_run: TaskRun = Field(default_factory=TaskRun)
+    compaction_summary: str = ""
+
+
+class MessageRuntimeSnapshot(BaseModel):
+    message_id: int
+    session_id: str
+    interaction_mode: InteractionMode = InteractionMode.AUTO
+    task_intent: TaskIntent = TaskIntent.CHAT
+    implementation_allowed: bool = False
+    intent_resolution_reason: str = ""
+    goal: str = ""
+    goal_phase: str = TaskPhase.CLARIFY.value
+    goal_status: str = TaskRunStatus.IDLE.value
+    goal_turn_count: int = 0
+    awaiting_implementation_approval: bool = False
+    approved_scope: str = ""
+    created_at: str = Field(default_factory=_now)
+
+
+async def save_runtime_state(session_id: str, snapshot: RuntimeStateSnapshot) -> None:
+    await save_session_runtime_state(
+        session_id,
+        snapshot.interaction_mode,
+        snapshot.task_state,
+        snapshot.compaction_summary,
+    )
+    await save_session_task_run(session_id, snapshot.task_run)
+
+
+async def load_runtime_state(session_id: str) -> RuntimeStateSnapshot:
+    return RuntimeStateSnapshot(
+        interaction_mode=await load_interaction_mode(session_id),
+        task_state=await load_task_state(session_id),
+        task_run=await load_task_run(session_id),
+        compaction_summary=await load_compaction_summary(session_id),
+    )
+
+
+async def save_session_runtime_state(
+    session_id: str,
+    interaction_mode: InteractionMode,
+    task_state: TaskState,
+    compaction_summary: str = "",
+) -> None:
+    await _execute_commit(
+        """INSERT INTO session_runtime_state (
+               session_id, interaction_mode, current_intent, previous_intent,
+               current_goal, awaiting_implementation_approval, approved_scope,
+               last_plan_summary, compaction_summary, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(session_id) DO UPDATE SET
+               interaction_mode = excluded.interaction_mode,
+               current_intent = excluded.current_intent,
+               previous_intent = excluded.previous_intent,
+               current_goal = excluded.current_goal,
+               awaiting_implementation_approval = excluded.awaiting_implementation_approval,
+               approved_scope = excluded.approved_scope,
+               last_plan_summary = excluded.last_plan_summary,
+               compaction_summary = excluded.compaction_summary,
+               updated_at = excluded.updated_at""",
+        (
+            session_id,
+            interaction_mode.value,
+            task_state.current_intent.value,
+            task_state.previous_intent.value if task_state.previous_intent else None,
+            task_state.current_goal,
+            1 if task_state.awaiting_implementation_approval else 0,
+            task_state.approved_scope,
+            task_state.last_plan_summary,
+            compaction_summary,
+            _now(),
+        ),
+    )
+
+
+async def load_interaction_mode(session_id: str) -> InteractionMode:
+    row = await _fetch_one(
+        "SELECT interaction_mode FROM session_runtime_state WHERE session_id = ?",
+        (session_id,),
+    )
+    if not row:
+        return InteractionMode.AUTO
+    return InteractionMode.parse(row["interaction_mode"])
+
+
+async def load_task_state(session_id: str) -> TaskState:
+    row = await _fetch_one(
+        "SELECT * FROM session_runtime_state WHERE session_id = ?",
+        (session_id,),
+    )
+    if not row:
+        return TaskState()
+    return TaskState(
+        current_intent=TaskIntent(row["current_intent"]),
+        previous_intent=TaskIntent(row["previous_intent"]) if row["previous_intent"] else None,
+        current_goal=row["current_goal"],
+        awaiting_implementation_approval=bool(row["awaiting_implementation_approval"]),
+        approved_scope=row["approved_scope"],
+        last_plan_summary=row["last_plan_summary"],
+    )
+
+
+async def load_compaction_summary(session_id: str) -> str:
+    row = await _fetch_one(
+        "SELECT compaction_summary FROM session_runtime_state WHERE session_id = ?",
+        (session_id,),
+    )
+    if not row:
+        return ""
+    return row["compaction_summary"] if "compaction_summary" in row.keys() else ""
+
+
+async def save_session_task_run(session_id: str, task_run: TaskRun) -> None:
+    await _execute_commit(
+        """INSERT INTO session_task_runs (
+               session_id, goal, phase, status, approved_scope,
+               awaiting_implementation_approval, turn_count, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(session_id) DO UPDATE SET
+               goal = excluded.goal,
+               phase = excluded.phase,
+               status = excluded.status,
+               approved_scope = excluded.approved_scope,
+               awaiting_implementation_approval = excluded.awaiting_implementation_approval,
+               turn_count = excluded.turn_count,
+               updated_at = excluded.updated_at""",
+        (
+            session_id,
+            task_run.goal,
+            task_run.phase.value,
+            task_run.status.value,
+            task_run.approved_scope,
+            1 if task_run.awaiting_implementation_approval else 0,
+            task_run.turn_count,
+            _now(),
+        ),
+    )
+
+
+async def load_task_run(session_id: str) -> TaskRun:
+    row = await _fetch_one(
+        "SELECT * FROM session_task_runs WHERE session_id = ?",
+        (session_id,),
+    )
+    if not row:
+        return TaskRun()
+    return TaskRun(
+        goal=row["goal"],
+        phase=TaskPhase(row["phase"]),
+        status=TaskRunStatus(row["status"]),
+        approved_scope=row["approved_scope"],
+        awaiting_implementation_approval=bool(row["awaiting_implementation_approval"]),
+        turn_count=row["turn_count"],
+    )
+
+
+async def save_message_runtime_snapshot(snapshot: MessageRuntimeSnapshot) -> None:
+    await _execute_commit(
+        """INSERT INTO message_runtime_snapshots (
+               message_id, session_id, interaction_mode, task_intent,
+               implementation_allowed, intent_resolution_reason, goal, goal_phase,
+               goal_status, goal_turn_count, awaiting_implementation_approval,
+               approved_scope, created_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(message_id) DO UPDATE SET
+               interaction_mode = excluded.interaction_mode,
+               task_intent = excluded.task_intent,
+               implementation_allowed = excluded.implementation_allowed,
+               intent_resolution_reason = excluded.intent_resolution_reason,
+               goal = excluded.goal,
+               goal_phase = excluded.goal_phase,
+               goal_status = excluded.goal_status,
+               goal_turn_count = excluded.goal_turn_count,
+               awaiting_implementation_approval = excluded.awaiting_implementation_approval,
+               approved_scope = excluded.approved_scope""",
+        (
+            snapshot.message_id,
+            snapshot.session_id,
+            snapshot.interaction_mode.value,
+            snapshot.task_intent.value,
+            1 if snapshot.implementation_allowed else 0,
+            snapshot.intent_resolution_reason,
+            snapshot.goal,
+            snapshot.goal_phase,
+            snapshot.goal_status,
+            snapshot.goal_turn_count,
+            1 if snapshot.awaiting_implementation_approval else 0,
+            snapshot.approved_scope,
+            snapshot.created_at,
+        ),
+    )
+
+
+async def load_message_runtime_snapshot(message_id: int) -> MessageRuntimeSnapshot | None:
+    row = await _fetch_one(
+        "SELECT * FROM message_runtime_snapshots WHERE message_id = ?",
+        (message_id,),
+    )
+    if not row:
+        return None
+    return MessageRuntimeSnapshot(
+        message_id=row["message_id"],
+        session_id=row["session_id"],
+        interaction_mode=InteractionMode(row["interaction_mode"]),
+        task_intent=TaskIntent(row["task_intent"]),
+        implementation_allowed=bool(row["implementation_allowed"]),
+        intent_resolution_reason=row["intent_resolution_reason"],
+        goal=row["goal"],
+        goal_phase=row["goal_phase"],
+        goal_status=row["goal_status"],
+        goal_turn_count=row["goal_turn_count"],
+        awaiting_implementation_approval=bool(row["awaiting_implementation_approval"]),
+        approved_scope=row["approved_scope"],
+        created_at=row["created_at"],
+    )
+
+
+async def clear_runtime_state(session_id: str) -> None:
+    await _execute_commit("DELETE FROM session_runtime_state WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM session_task_runs WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM message_runtime_snapshots WHERE session_id = ?", (session_id,))