deeptutor-server 1.7.0__py3-none-any.whl

deeptutor/api/utils/task_id_manager.py

@@ -0,0 +1,120 @@
+"""
+Task ID Manager - Assigns unique IDs to each background task
+"""
+
+from datetime import datetime, timedelta
+import logging
+import threading
+from typing import Optional
+import uuid
+
+logger = logging.getLogger(__name__)
+
+
+class TaskIDManager:
+    """Singleton class for managing task IDs"""
+
+    _MAX_COMPLETED_TASKS = 256
+
+    _instance: Optional["TaskIDManager"] = None
+    _lock = threading.Lock()
+    _task_ids: dict[str, str] = {}  # task_key -> task_id
+    _task_metadata: dict[str, dict] = {}  # task_id -> metadata
+
+    @classmethod
+    def get_instance(cls) -> "TaskIDManager":
+        """Get singleton instance"""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def generate_task_id(self, task_type: str, task_key: str) -> str:
+        """
+        Generate unique ID for task
+
+        Args:
+            task_type: Task type (e.g., 'kb_init', 'kb_upload', 'question_gen', 'solve', 'research')
+            task_key: Task unique identifier (e.g., knowledge base name, question ID, etc.)
+
+        Returns:
+            Task ID (format: {task_type}_{timestamp}_{uuid})
+        """
+        self.cleanup_old_tasks()
+        with self._lock:
+            # If task already exists, return existing ID
+            if task_key in self._task_ids:
+                return self._task_ids[task_key]
+
+            # Generate new ID
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            unique_id = str(uuid.uuid4())[:8]
+            task_id = f"{task_type}_{timestamp}_{unique_id}"
+
+            # Save mapping and metadata
+            self._task_ids[task_key] = task_id
+            self._task_metadata[task_id] = {
+                "task_type": task_type,
+                "task_key": task_key,
+                "created_at": datetime.now().isoformat(),
+                "status": "running",
+            }
+
+            return task_id
+
+    def get_task_id(self, task_key: str) -> str | None:
+        """Get task ID"""
+        with self._lock:
+            return self._task_ids.get(task_key)
+
+    def update_task_status(self, task_id: str, status: str, **kwargs):
+        """Update task status"""
+        with self._lock:
+            if task_id in self._task_metadata:
+                self._task_metadata[task_id]["status"] = status
+                self._task_metadata[task_id].update(kwargs)
+                if status in ["completed", "error", "cancelled"]:
+                    self._task_metadata[task_id]["finished_at"] = datetime.now().isoformat()
+
+    def get_task_metadata(self, task_id: str) -> dict | None:
+        """Get task metadata"""
+        with self._lock:
+            return self._task_metadata.get(task_id, {}).copy()
+
+    def cleanup_old_tasks(self, max_age_hours: int = 24):
+        """Clean up old tasks (completed tasks older than specified hours)"""
+        with self._lock:
+            cutoff = datetime.now() - timedelta(hours=max_age_hours)
+
+            to_remove = []
+            for task_id, metadata in self._task_metadata.items():
+                if metadata.get("status") in ["completed", "error", "cancelled"]:
+                    finished_at = metadata.get("finished_at")
+                    if finished_at:
+                        try:
+                            finished_time = datetime.fromisoformat(finished_at)
+                            if finished_time < cutoff:
+                                to_remove.append(task_id)
+                        except Exception:
+                            logger.warning("Failed to parse finished_at for task %s", task_id)
+
+            for task_id in to_remove:
+                metadata = self._task_metadata.pop(task_id, {})
+                task_key = metadata.get("task_key")
+                if task_key:
+                    self._task_ids.pop(task_key, None)
+
+            completed = sorted(
+                (
+                    (str(metadata.get("finished_at") or ""), task_id)
+                    for task_id, metadata in self._task_metadata.items()
+                    if metadata.get("status") in ["completed", "error", "cancelled"]
+                )
+            )
+            overflow = len(completed) - self._MAX_COMPLETED_TASKS
+            for _, task_id in completed[: max(0, overflow)]:
+                metadata = self._task_metadata.pop(task_id, {})
+                task_key = metadata.get("task_key")
+                if task_key:
+                    self._task_ids.pop(task_key, None)

deeptutor/api/utils/task_log_stream.py

@@ -0,0 +1,362 @@
+import asyncio
+from collections import deque
+from collections.abc import AsyncGenerator
+import contextlib
+import importlib
+import json
+import logging
+import threading
+import time
+from typing import Any
+
+from deeptutor.logging import (
+    PROCESS_LOG_PRIVATE_ATTR,
+    ProcessLogEvent,
+    bind_log_context,
+    capture_process_logs,
+    current_log_context,
+)
+
+
+def _format_sse(event: str, payload: dict[str, Any]) -> str:
+    return f"event: {event}\ndata: {json.dumps(payload, ensure_ascii=False, default=str)}\n\n"
+
+
+class KnowledgeTaskStreamManager:
+    _HEARTBEAT_SECONDS = 15.0
+    _MAX_EVENTS_PER_TASK = 500
+    _MAX_BYTES_PER_TASK = 2 * 1024 * 1024
+    _MAX_RETAINED_TASKS = 32
+    _MAX_TERMINAL_TOMBSTONES = 256
+    _TERMINAL_TTL_SECONDS = 60 * 60
+    _TOMBSTONE_TTL_SECONDS = 24 * 60 * 60
+
+    _instance: "KnowledgeTaskStreamManager | None" = None
+    _instance_lock = threading.Lock()
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._buffers: dict[str, deque[dict[str, Any]]] = {}
+        self._buffer_bytes: dict[str, int] = {}
+        self._subscribers: dict[str, list[tuple[asyncio.Queue, asyncio.AbstractEventLoop]]] = {}
+        self._terminal_at: dict[str, float] = {}
+        self._terminal_tombstones: dict[str, tuple[float, dict[str, Any]]] = {}
+
+    @classmethod
+    def get_instance(cls) -> "KnowledgeTaskStreamManager":
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def ensure_task(self, task_id: str):
+        with self._lock:
+            self._prune_locked(time.monotonic())
+            if task_id not in self._buffers:
+                restored = self._terminal_tombstones.pop(task_id, None)
+                self._buffers[task_id] = deque(maxlen=self._MAX_EVENTS_PER_TASK)
+                self._buffer_bytes[task_id] = 0
+                if restored is not None:
+                    terminal_at, event = restored
+                    self._append_locked(task_id, event)
+                    self._terminal_at[task_id] = terminal_at
+            self._subscribers.setdefault(task_id, [])
+
+    def emit(self, task_id: str, event: str, payload: dict[str, Any]):
+        event_payload = {"event": event, "payload": payload}
+        with self._lock:
+            self._buffers.setdefault(task_id, deque(maxlen=self._MAX_EVENTS_PER_TASK))
+            self._buffer_bytes.setdefault(task_id, 0)
+            self._append_locked(task_id, event_payload)
+            if event in {"complete", "failed"}:
+                self._terminal_at[task_id] = time.monotonic()
+            subscribers = list(self._subscribers.get(task_id, []))
+            self._prune_locked(time.monotonic())
+
+        for queue, loop in subscribers:
+            try:
+                loop.call_soon_threadsafe(self._queue_event, queue, event_payload)
+            except RuntimeError:
+                continue
+        if event in {"complete", "failed"}:
+            self._schedule_memory_reclaim()
+
+    def emit_process_log(self, task_id: str, event: ProcessLogEvent):
+        payload = event.to_dict()
+        payload.setdefault("context", {})["task_id"] = task_id
+        self.emit(task_id, "process_log", payload)
+
+    def emit_log(self, task_id: str, line: str):
+        event = ProcessLogEvent(
+            level="INFO",
+            message=line,
+            logger="deeptutor.knowledge.task",
+            timestamp=time.time(),
+            context={"task_id": task_id, "capability": "knowledge", "sink": "ui"},
+        )
+        self.emit_process_log(task_id, event)
+
+    def emit_complete(self, task_id: str, detail: str = "Task completed"):
+        self.emit(task_id, "complete", {"detail": detail, "task_id": task_id})
+
+    def emit_failed(
+        self,
+        task_id: str,
+        detail: str,
+        *,
+        details: str | None = None,
+        error_code: str | None = None,
+        retryable: bool | None = None,
+    ):
+        payload: dict[str, Any] = {"detail": detail, "task_id": task_id}
+        if details:
+            payload["details"] = details
+        if error_code:
+            payload["error_code"] = error_code
+        if retryable is not None:
+            payload["retryable"] = retryable
+        self.emit(task_id, "failed", payload)
+
+    def subscribe(
+        self, task_id: str
+    ) -> tuple[asyncio.Queue[dict[str, Any]], list[dict[str, Any]], asyncio.AbstractEventLoop]:
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=200)
+        loop = asyncio.get_running_loop()
+        with self._lock:
+            self._prune_locked(time.monotonic())
+            if task_id not in self._buffers:
+                restored = self._terminal_tombstones.pop(task_id, None)
+                self._buffers[task_id] = deque(maxlen=self._MAX_EVENTS_PER_TASK)
+                self._buffer_bytes[task_id] = 0
+                if restored is not None:
+                    terminal_at, event = restored
+                    self._append_locked(task_id, event)
+                    self._terminal_at[task_id] = terminal_at
+            self._subscribers.setdefault(task_id, []).append((queue, loop))
+            backlog = list(self._buffers[task_id])
+        return queue, backlog, loop
+
+    def unsubscribe(
+        self, task_id: str, queue: asyncio.Queue[dict[str, Any]], loop: asyncio.AbstractEventLoop
+    ):
+        with self._lock:
+            subscribers = self._subscribers.get(task_id, [])
+            remaining = [
+                (subscriber_queue, subscriber_loop)
+                for subscriber_queue, subscriber_loop in subscribers
+                if subscriber_queue is not queue or subscriber_loop is not loop
+            ]
+            if remaining:
+                self._subscribers[task_id] = remaining
+            else:
+                self._subscribers.pop(task_id, None)
+            self._prune_locked(time.monotonic())
+
+    @staticmethod
+    def _event_bytes(event: dict[str, Any]) -> int:
+        try:
+            return len(json.dumps(event, ensure_ascii=False, default=str).encode("utf-8"))
+        except Exception:
+            return 256
+
+    def _append_locked(self, task_id: str, event: dict[str, Any]) -> None:
+        buffer = self._buffers[task_id]
+        size = self._event_bytes(event)
+        while buffer and (
+            len(buffer) >= self._MAX_EVENTS_PER_TASK
+            or self._buffer_bytes.get(task_id, 0) + size > self._MAX_BYTES_PER_TASK
+        ):
+            removed = buffer.popleft()
+            self._buffer_bytes[task_id] = max(
+                0, self._buffer_bytes.get(task_id, 0) - self._event_bytes(removed)
+            )
+        # Keep a single oversized terminal/error event so a subscriber always
+        # observes task completion. Its traceback is clipped to the hard byte
+        # budget rather than retaining an arbitrary multi-megabyte payload.
+        if size > self._MAX_BYTES_PER_TASK:
+            compact = {
+                "event": event.get("event", "process_log"),
+                "payload": {
+                    "detail": str((event.get("payload") or {}).get("detail") or "")[:8192],
+                    "truncated": True,
+                },
+            }
+            event = compact
+            size = self._event_bytes(event)
+        buffer.append(event)
+        self._buffer_bytes[task_id] = self._buffer_bytes.get(task_id, 0) + size
+
+    def _drop_task_locked(self, task_id: str) -> None:
+        buffer = self._buffers.pop(task_id, None)
+        terminal_at = self._terminal_at.pop(task_id, None)
+        if buffer and terminal_at is not None:
+            terminal = next(
+                (item for item in reversed(buffer) if item.get("event") in {"complete", "failed"}),
+                None,
+            )
+            if terminal is not None:
+                self._terminal_tombstones[task_id] = (terminal_at, terminal)
+        self._buffer_bytes.pop(task_id, None)
+        if not self._subscribers.get(task_id):
+            self._subscribers.pop(task_id, None)
+
+    def _prune_locked(self, now: float) -> None:
+        for task_id, terminal_at in list(self._terminal_at.items()):
+            if now - terminal_at >= self._TERMINAL_TTL_SECONDS and not self._subscribers.get(
+                task_id
+            ):
+                self._drop_task_locked(task_id)
+
+        overflow = len(self._buffers) - self._MAX_RETAINED_TASKS
+        if overflow > 0:
+            candidates = sorted(
+                (
+                    (terminal_at, task_id)
+                    for task_id, terminal_at in self._terminal_at.items()
+                    if not self._subscribers.get(task_id)
+                )
+            )
+            for _, task_id in candidates[:overflow]:
+                self._drop_task_locked(task_id)
+
+        expired_tombstones = [
+            task_id
+            for task_id, (terminal_at, _) in self._terminal_tombstones.items()
+            if now - terminal_at >= self._TOMBSTONE_TTL_SECONDS
+        ]
+        for task_id in expired_tombstones:
+            self._terminal_tombstones.pop(task_id, None)
+        overflow = len(self._terminal_tombstones) - self._MAX_TERMINAL_TOMBSTONES
+        if overflow > 0:
+            oldest = sorted(
+                self._terminal_tombstones,
+                key=lambda task_id: self._terminal_tombstones[task_id][0],
+            )
+            for task_id in oldest[:overflow]:
+                self._terminal_tombstones.pop(task_id, None)
+
+    def retained_task_count(self) -> int:
+        with self._lock:
+            self._prune_locked(time.monotonic())
+            return len(self._buffers)
+
+    @staticmethod
+    def _schedule_memory_reclaim() -> None:
+        """Run after the producing coroutine unwinds and releases job locals."""
+        from deeptutor.runtime.memory_reclaim import schedule_memory_reclaim
+
+        schedule_memory_reclaim()
+
+    async def stream(self, task_id: str) -> AsyncGenerator[str, None]:
+        queue, backlog, loop = self.subscribe(task_id)
+        try:
+            for item in backlog:
+                yield _format_sse(item["event"], item["payload"])
+
+            if backlog and backlog[-1]["event"] in {"complete", "failed"}:
+                return
+
+            while True:
+                try:
+                    item = await asyncio.wait_for(queue.get(), timeout=self._HEARTBEAT_SECONDS)
+                except TimeoutError:
+                    # SSE comments are ignored by EventSource but keep every
+                    # intermediary proxy from treating an idle indexing phase
+                    # as a dead connection.
+                    yield ": keep-alive\n\n"
+                    continue
+                yield _format_sse(item["event"], item["payload"])
+                if item["event"] in {"complete", "failed"}:
+                    break
+        finally:
+            self.unsubscribe(task_id, queue, loop)
+
+    @staticmethod
+    def _queue_event(queue: asyncio.Queue[dict[str, Any]], payload: dict[str, Any]):
+        try:
+            queue.put_nowait(payload)
+        except asyncio.QueueFull:
+            pass
+
+
+class _TaskScopedLogHandler(logging.Handler):
+    """Forward non-propagating library logs into one knowledge task stream."""
+
+    def __init__(self, task_id: str, manager: KnowledgeTaskStreamManager) -> None:
+        super().__init__(logging.INFO)
+        self._task_id = task_id
+        self._manager = manager
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if getattr(record, PROCESS_LOG_PRIVATE_ATTR, False):
+                return
+            context = current_log_context()
+            record_task_id = context.get("task_id")
+            if record_task_id and record_task_id != self._task_id:
+                return
+
+            context.setdefault("task_id", self._task_id)
+            context.setdefault("capability", "knowledge")
+            context.setdefault("sink", "ui")
+            self._manager.emit_process_log(
+                self._task_id,
+                ProcessLogEvent(
+                    level=record.levelname,
+                    message=record.getMessage(),
+                    logger=record.name,
+                    timestamp=record.created,
+                    context=context,
+                ),
+            )
+        except Exception:
+            self.handleError(record)
+
+
+@contextlib.contextmanager
+def _capture_non_propagating_task_logs(task_id: str, manager: KnowledgeTaskStreamManager):
+    """Capture library loggers that intentionally do not propagate to root."""
+    logger_names = ("lightrag", "graphrag", "graphrag_llm")
+    handlers: list[tuple[logging.Logger, _TaskScopedLogHandler]] = []
+    for logger_name in logger_names:
+        if logger_name == "lightrag":
+            with contextlib.suppress(Exception):
+                importlib.import_module("lightrag.utils")
+        source_logger = logging.getLogger(logger_name)
+        if source_logger.propagate:
+            continue
+        handler = _TaskScopedLogHandler(task_id, manager)
+        source_logger.addHandler(handler)
+        handlers.append((source_logger, handler))
+
+    try:
+        yield
+    finally:
+        for source_logger, handler in handlers:
+            if handler in source_logger.handlers:
+                source_logger.removeHandler(handler)
+            handler.close()
+
+
+@contextlib.contextmanager
+def capture_task_logs(task_id: str):
+    """Forward all logs bound to ``task_id`` into the task's SSE stream."""
+    manager = KnowledgeTaskStreamManager.get_instance()
+    manager.ensure_task(task_id)
+
+    def emit(event: ProcessLogEvent) -> None:
+        if event.logger in {"root", "asyncio"}:
+            return
+        if event.logger == "deeptutor.knowledge.progress_tracker":
+            return
+        manager.emit_process_log(task_id, event)
+
+    with bind_log_context(task_id=task_id, capability="knowledge", sink="ui"):
+        with capture_process_logs(emit, task_id=task_id):
+            with _capture_non_propagating_task_logs(task_id, manager):
+                yield
+
+
+def get_task_stream_manager() -> KnowledgeTaskStreamManager:
+    return KnowledgeTaskStreamManager.get_instance()

deeptutor/api/utils/tool_options.py

@@ -0,0 +1,133 @@
+"""Configurable-tool surface shared by the partners and multi-user admin APIs.
+
+``tools`` mirrors the user-toggleable system tools (the same pool the chat
+composer / settings expose); ``builtin_tools`` lists the auto-mounted built-in
+tools (rag / read_memory / web_fetch / …) a partner owner can selectively
+allow or deny; ``mcp_tools`` lists every configured MCP tool that a whitelist
+(partner config or user grant) could allow.
+
+Each ``mcp_tools`` row carries its provider identity — ``kind`` (``"mcp"``
+today) and ``provider_id`` (the server name) — so the pickers can fold
+hundreds of tools into one row per service. ``server`` is the pre-provider
+spelling of ``provider_id`` and stays populated for existing clients.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+import logging
+from typing import Any
+
+from deeptutor.i18n.metadata_i18n import localized_description, tool_description_i18n
+from deeptutor.services.i18n import current_language
+
+logger = logging.getLogger(__name__)
+
+
+async def build_tool_options(
+    *,
+    exclude_builtin: set[str] | None = None,
+    optional_tools: Iterable[str] | None = None,
+) -> dict[str, list[dict[str, Any]]]:
+    """Build the configurable-tool surface.
+
+    ``exclude_builtin`` drops built-in tools from the ``builtin_tools`` list —
+    the partners API passes ``{"read_memory", "write_memory"}`` because partners
+    use the mandatory ``partner_*`` memory tools instead and cannot configure
+    chat's memory tools.
+
+    ``optional_tools`` is an optional allow-list for the user-toggleable
+    surface.  The generic builder intentionally owns no admin or partner
+    policy: callers that need a restricted view pass it explicitly, while the
+    multi-user grant editor keeps seeing the complete assignable catalog.
+    """
+    from deeptutor.agents._shared.tool_composition import (
+        default_optional_tools,
+    )
+    from deeptutor.runtime.registry.deferred_tools import provider_identity
+    from deeptutor.runtime.registry.tool_registry import get_tool_registry
+    from deeptutor.tools.builtin import CONFIGURABLE_BUILTIN_TOOL_NAMES
+
+    exclude = exclude_builtin or set()
+
+    registry = get_tool_registry()
+    language = current_language()
+    try:
+        from deeptutor.services.mcp import get_mcp_manager
+
+        await get_mcp_manager().ensure_started()
+    except Exception:
+        logger.debug("MCP manager unavailable for tool options", exc_info=True)
+
+    def _describe(name: str) -> dict[str, Any]:
+        tool = registry.get(name)
+        description = ""
+        if tool is not None:
+            try:
+                description = tool.get_definition().description or ""
+            except Exception:
+                description = ""
+        descriptions = tool_description_i18n(name, description)
+        return {
+            "name": name,
+            "description": localized_description(descriptions, language),
+            "description_i18n": descriptions,
+        }
+
+    allowed_optional = None if optional_tools is None else frozenset(optional_tools)
+    tools: list[dict[str, Any]] = [
+        _describe(name)
+        for name in default_optional_tools()
+        if allowed_optional is None or name in allowed_optional
+    ]
+    builtin_tools: list[dict[str, Any]] = [
+        _describe(name) for name in CONFIGURABLE_BUILTIN_TOOL_NAMES if name not in exclude
+    ]
+
+    # Only MCP rows belong in ``mcp_tools``: that list is written into
+    # ``grant.mcp_tools`` / a partner's ``mcp_tools``, and per
+    # ``runtime.providers.authorize`` a CLI app must be governed by its own grant
+    # field instead — collapsing the two is exactly how a CLI app ends up
+    # authorised by an MCP whitelist. CLI providers get their own list when they
+    # land; until then they are simply not offered here.
+    mcp_tools: list[dict[str, Any]] = []
+    for tool in registry.deferred_tools():
+        try:
+            definition = tool.get_definition()
+        except Exception as exc:
+            # The definition is the only place a deferred tool's name lives,
+            # so identify the failure by provider and adapter class instead
+            # of dropping it from the options without a trace.
+            kind, provider_id = provider_identity(tool)
+            logger.warning(
+                "tool options skipped %s tool %r (provider %r): get_definition() failed: %s",
+                kind or "unknown",
+                type(tool).__name__,
+                provider_id or "unknown",
+                exc,
+            )
+            continue
+        kind, provider_id = provider_identity(tool)
+        if (kind or "mcp") != "mcp":
+            continue
+        mcp_tools.append(
+            {
+                "name": definition.name,
+                # Adapters written before ``provider_kind`` existed are all MCP,
+                # so an absent kind means "mcp" rather than "unknown".
+                "kind": kind or "mcp",
+                "provider_id": provider_id,
+                # Legacy alias — drop once no client reads ``server``.
+                "server": provider_id,
+                "description": definition.description or "",
+                "description_i18n": {
+                    "en": definition.description or "",
+                    "zh": definition.description or "",
+                },
+            }
+        )
+
+    return {"tools": tools, "builtin_tools": builtin_tools, "mcp_tools": mcp_tools}
+
+
+__all__ = ["build_tool_options"]

deeptutor_server-1.7.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: deeptutor-server
+Version: 1.7.0
+Summary: DeepTutor server module
+Requires-Python: <3.15,>=3.11
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn[standard]>=0.24.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: bcrypt>=4.0.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: pocketbase>=0.12.0
+Requires-Dist: redis<7.0.0,>=5.0.0
+Requires-Dist: deeptutor==1.7.0

deeptutor_server-1.7.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+deeptutor/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deeptutor/api/main.py,sha256=Dj2X_CScpNxdIiAUfsy5qwCSKGL0RzSimP82CxvD3GM,21081
+deeptutor/api/module_routes.py,sha256=Yo_Tz8AHN9M9oNcD62b0d8qVehTdeJ7rwpBQtcqxGqk,1356
+deeptutor/api/router_index.json,sha256=lzvm_O053ZghpU_U2eIFXB6A3oNCrI4-RwtyGoIETrY,123108
+deeptutor/api/router_loader.py,sha256=uwn7JTirokgHgzCXQq4pOAn2jhCLYnBKKxwu4lbktXQ,5302
+deeptutor/api/run_server.py,sha256=Hhp_12avWrjpoNYsfOKkU6DOuOGWhZamFmiDjOtrXcM,3737
+deeptutor/api/security_guard.py,sha256=ErrkmVXh98QuQsefcHMjn_E_4eU_v1dsOE_yo00cwdE,3725
+deeptutor/api/contracts/__init__.py,sha256=lZiZCc6bhvHrcI8KDB0VdtBChA0LutNIAv-j91RDn9c,387
+deeptutor/api/contracts/export.py,sha256=giieILHH615i2KG_B4EjsPsZtM19tgpNgOVVxzb7K24,3803
+deeptutor/api/contracts/turn_protocol.py,sha256=0LHJFCIdqyD9J2w37enLWRj-VDf_GRQAKW6N2z1nXnI,8755
+deeptutor/api/routers/__init__.py,sha256=eH0nWjt-2ODjP6MLdmMl_lgcoD1nCep0eHqUJOTj01k,24
+deeptutor/api/routers/agent_config.py,sha256=UVpOTPLjUZXsYUvBJNUGzYlv98H-QccoamP0LMSgGoc,1354
+deeptutor/api/routers/attachments.py,sha256=0Rcy992wJHpGqKVAQhW3QCvW9VIvVFSE0qS7jdj0od0,2788
+deeptutor/api/routers/auth.py,sha256=kOF-L9gtQYvtbHX7XU9FLTxZPyGxJdvrJdHV_YXZ4o8,70565
+deeptutor/api/routers/capabilities.py,sha256=bCjOLPXtjUuwoI_ziJ4-8acPqU18IK4Ssz8BIAZdh70,1798
+deeptutor/api/routers/capabilities_settings.py,sha256=piAn-ArwkT5o3hEhvl2usxtjOPrNQgurI9mJ68nBq7k,1186
+deeptutor/api/routers/dashboard.py,sha256=tBMPzXL-NwzCl1bOra0StdkuMvtc6yKw7vb2mZ6uIEY,11118
+deeptutor/api/routers/file_library.py,sha256=eW0XxImPrT8lfcY_cYPMbTrKQDYdO2WqLXkSnuUVvhU,5679
+deeptutor/api/routers/file_preview.py,sha256=zpxzzAn_sHxuM8xy_ZGjc0oK5_mVhW9HBRRlYwwYLGk,9110
+deeptutor/api/routers/imports.py,sha256=CzkdX-lFtkBPQ8APE2MUvZw0c7w0nb44XgI_8BVc0DQ,5435
+deeptutor/api/routers/learning_journal.py,sha256=oPEoRlgS5-FoUnVxZ_joBPqMeCvQtWGNDdkcAnvqFl8,529
+deeptutor/api/routers/mcp_settings.py,sha256=R4elNGUPAAsg8VundJUGxFeZAfPO_x-aCmgAM0BtVp4,4512
+deeptutor/api/routers/modules.py,sha256=jw18YKRsV3wNeeWvEiifXRJkMtJvgpL8St3ZK2M-W78,265
+deeptutor/api/routers/multi_user.py,sha256=KjO-laxX2CZuuF3xB73wNPSImuFPFnhOg8_L1GMVKv8,34771
+deeptutor/api/routers/outputs.py,sha256=zDA2jPZTBsvmg6cGOM7eDYmOp9JPj5iy27CX_0Tt2Hw,4090
+deeptutor/api/routers/personas.py,sha256=Ahc4YANPXv8PmVURaeqaUAMbzQLJVd7-8C8atKKC8EE,5330
+deeptutor/api/routers/plugins.py,sha256=GxScBpc38BEW81pFC-HVqnn-Dna9mPpktoyJZ_O12tg,14698
+deeptutor/api/routers/quiz_judge.py,sha256=2p1zea-1xG3XypucUWpnziyJT5vEmcUDAHoS5f183IQ,18746
+deeptutor/api/routers/sessions.py,sha256=cYM4KrsKpPI3AHsx-jxVnugjeIvW4s0G9oKE7Nz1F78,31898
+deeptutor/api/routers/settings.py,sha256=U93GOgXH6KD4oAhH0IKlDfaLZpDZybWU0eU8AQYkBh4,94956
+deeptutor/api/routers/skills.py,sha256=C5QRnmEGYsOWxCcpziTewdSOxQ0BUDHZYrrXpye-q2I,11178
+deeptutor/api/routers/space_cli_apps.py,sha256=fLcSW4DiPPOoikR3Rrpi220TiepeMnDe31Zn_umSKPQ,7924
+deeptutor/api/routers/space_mcp.py,sha256=jO4AsfCJEzZ_kaUctL09-Lba4Ci8ZJn5Fs234UAPH20,18651
+deeptutor/api/routers/subagents.py,sha256=KW13snZddj5gCZc-WrAagNzwEKCb52ZEIEsXtGp-soA,11791
+deeptutor/api/routers/system.py,sha256=v1xaZLxamPPESByFjoGUGZaSDFwaqkFFDztWp5A2gmI,22031
+deeptutor/api/routers/task_board.py,sha256=Zq0LI4iM8Pg1uBaApZV26Grj1SrV_auiDtN58NTQFrE,5719
+deeptutor/api/routers/tools.py,sha256=nqT6fA-q-eG7uPQzm3KKCo3jWCiXeV1qB2XyW8HG2jw,9662
+deeptutor/api/routers/unified_ws.py,sha256=IhpiErmkpraCNzwIrgb1bzrjdxtx0TnCKb7N_cbeUFI,14590
+deeptutor/api/routers/workspace.py,sha256=P3wl9b35wUko0p9I37g4Uyaq-V1cYZ-zSfJmePC-6Jg,14196
+deeptutor/api/utils/http_headers.py,sha256=tkNPOLrvZpbCRacO8M36EtljjcybA35BTiP0zisVqzQ,1101
+deeptutor/api/utils/progress_broadcaster.py,sha256=0CjFgb4ZiRfVkXQ_9GrnV2U4NHsglb3A7dQ5EzSoUfE,2734
+deeptutor/api/utils/task_id_manager.py,sha256=hTS7-NCiafXS6sd1MPfOPKxv3KcUkn3nDh2PY6WCKjg,4515
+deeptutor/api/utils/task_log_stream.py,sha256=qBRmss7EApUeRHkRP25D__QVaHsWtZ_pCQsLPehsoak,14139
+deeptutor/api/utils/tool_options.py,sha256=gl5jnQ7N5UIp9Mjd1PWw-1G2Bfjq_TRo-Mq8ojl9cPc,5471
+deeptutor_server-1.7.0.dist-info/METADATA,sha256=yXqGmEdMgcUdUmfnNkHcCHKuji1JslEHThB3eu4M-Kk,445
+deeptutor_server-1.7.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+deeptutor_server-1.7.0.dist-info/top_level.txt,sha256=hnSHUG_vphMnHpT-DbMqcemCKadJ24laFGAWlovG2xM,10
+deeptutor_server-1.7.0.dist-info/RECORD,,

deeptutor_server-1.7.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
+