cognis-executor 0.2.0__tar.gz → 0.3.0__tar.gz

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognis-executor
-Version: 0.2.0
+Version: 0.3.0
 Summary: Standalone remote executor for Cognis
 Author-email: Filip Pytloun <filip@pytloun.cz>
 License: TBD
@@ -18,7 +18,7 @@ Requires-Dist: ddgs>=9.0.0
 Requires-Dist: email-validator>=2.0.0
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: litellm>=1.40.0
+Requires-Dist: litellm>=1.82.0
 Requires-Dist: markdown>=3.7
 Requires-Dist: markdownify>=0.14.0
 Requires-Dist: mcp>=1.6.0

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/cognis/api/app.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import hashlib
 import secrets
 import sys
@@ -43,6 +44,7 @@ from cognis.api.websocket import handle_websocket
 from cognis.bootstrap import bootstrap_runtime
 from cognis.config import load_config
 from cognis.core.agent_loop import AgentLoop, PauseWaiter, SessionLock
+from cognis.core.agent_registry import AgentRegistry
 from cognis.core.compaction import CompactionStrategy
 from cognis.core.context import ContextAssembler
 from cognis.core.decision import DecisionEngine
@@ -52,7 +54,9 @@ from cognis.core.scheduler import Scheduler
 from cognis.core.session import SessionManager
 from cognis.core.session_cache import SessionCache
 from cognis.core.step_evaluator import StepEvaluator
+from cognis.core.step_profiles import StepProfileRegistry
 from cognis.core.task_queue import TaskQueue
+from cognis.core.tool_classification_queue import ToolClassificationQueue
 from cognis.core.tool_output_store import ToolOutputStore
 from cognis.core.tool_router import ToolRouter
 from cognis.core.workflow_engine import WorkflowEngine
@@ -145,8 +149,19 @@ def create_app() -> FastAPI:
             config_runtime.jwt_private_key_path, config_runtime.jwt_public_key_path
         )
         providers = build_provider_registry(config_runtime, session_factory, auth_provider)
-        remember_queue = RememberRetryQueue(providers.memory)
+        event_bus = EventBus()
+        remember_queue = RememberRetryQueue(
+            providers.memory,
+            session_factory=session_factory,
+            event_reader=providers.guardrails,
+            event_bus=event_bus,
+        )
         await remember_queue.start()
+        tool_classification_queue = ToolClassificationQueue(
+            session_factory=session_factory,
+            llm_provider=providers.llm,
+        )
+        await tool_classification_queue.start()
         await _print_startup_status(config_runtime, providers, ui_build_dir)
 
         async with session_factory() as session:
@@ -188,14 +203,20 @@ def create_app() -> FastAPI:
                     )
                 sys.stdout.flush()
 
-        event_bus = EventBus()
+        pause_waiter = PauseWaiter()
+        session_lock = SessionLock()
+        session_lock_sweeper_task: asyncio.Task[None] | None = None
         session_cache = SessionCache(
             providers.guardrails,
             max_entries=cache_max_entries,
             redis_url=config_runtime.redis_url,
         )
         session_manager = SessionManager(
-            session_factory, providers, session_cache, event_bus=event_bus
+            session_factory,
+            providers,
+            session_cache,
+            event_bus=event_bus,
+            session_lock=session_lock,
         )
         context_assembler = await ContextAssembler.from_session_factory(
             session_factory=session_factory,
@@ -215,8 +236,6 @@ def create_app() -> FastAPI:
             session_factory=session_factory,
             llm=providers.llm,
         )
-        pause_waiter = PauseWaiter()
-        session_lock = SessionLock()
         from cognis.core.tool_output_store import (
             FilesystemToolOutputBackend,
             S3ToolOutputBackend,
@@ -263,6 +282,7 @@ def create_app() -> FastAPI:
         )
 
         from cognis.core.artifact_maintenance import ArtifactMaintenanceService
+        from cognis.store.queries import get_setting_value
 
         artifact_maintenance = ArtifactMaintenanceService(
             session_factory=session_factory,
@@ -273,13 +293,16 @@ def create_app() -> FastAPI:
         tool_router = await ToolRouter.from_session_factory(
             providers.guardrails,
             session_factory,
+            llm=providers.llm,
             memory=providers.memory,
             credentials_provider=providers.credentials,
             tool_output_store=tool_output_store,
             image_generation_provider=providers.image_generation,
             artifact_store=artifact_store,
         )
+        agent_registry = AgentRegistry(session_factory)
         workflow_registry = WorkflowRegistry(session_factory)
+        step_profile_registry = await StepProfileRegistry.from_session_factory(session_factory)
         step_evaluator = await StepEvaluator.from_session_factory(
             session_factory=session_factory,
             llm=providers.llm,
@@ -290,7 +313,14 @@ def create_app() -> FastAPI:
             shared_registry=shared_runtime.tool_registry,
             shared_connection=shared_runtime.executor_connection,
             session_factory=session_factory,
+            artifact_store=artifact_store,
         )
+        async with session_factory() as session:
+            step_timeout_seconds = await get_setting_value(
+                session,
+                "session.step_timeout_seconds",
+                3600,
+            )
         agent_loop = AgentLoop(
             providers=providers,
             session_manager=session_manager,
@@ -302,6 +332,12 @@ def create_app() -> FastAPI:
             event_bus=event_bus,
             session_lock=session_lock,
             pause_waiter=pause_waiter,
+            session_factory=session_factory,
+            tool_classification_queue=tool_classification_queue,
+            step_profile_registry=step_profile_registry,
+            default_step_timeout_seconds=(
+                int(step_timeout_seconds) if isinstance(step_timeout_seconds, int) else 3600
+            ),
             tool_output_store=tool_output_store,
             step_runtime_factory=step_runtime_factory,
         )
@@ -324,6 +360,7 @@ def create_app() -> FastAPI:
             workflow_engine=workflow_engine,
             workflow_registry=workflow_registry,
             event_bus=event_bus,
+            agent_registry=agent_registry,
             llm_provider=providers.llm,
         )
         agent_loop.set_task_queue(task_queue)
@@ -383,6 +420,41 @@ def create_app() -> FastAPI:
         recovered_sessions = await session_manager.recover_stale_sessions()
         recovered_tasks = await task_queue.recover_stale_tasks()
         recovered_paused_tasks = await task_queue.recover_paused_tasks()
+        recovered_orphaned_step_runs = await task_queue.recover_orphaned_running_step_runs()
+
+        # System-wide invariant reconciliation. Runs after the focused
+        # recovery helpers above so any residual drift (e.g. conversations
+        # whose active_session_id still points at a terminal session) is
+        # cleaned before the drain loop starts picking tasks. The
+        # implementation is idempotent and covered by unit tests.
+        from cognis.core.invariants import reconcile_invariants
+
+        async with session_factory() as recon_session:
+            invariant_reports = await reconcile_invariants(recon_session)
+        reconciled_invariant_counts = {
+            report.category: report.reconciled_count
+            for report in invariant_reports
+            if report.reconciled_count
+        }
+        if reconciled_invariant_counts:
+            logger.warning(
+                "startup: reconciled invariant violations",
+                extra={"extra_data": {"counts": reconciled_invariant_counts}},
+            )
+
+        logger.info(
+            "startup: recovery summary",
+            extra={
+                "extra_data": {
+                    "recovered_sessions": len(recovered_sessions),
+                    "recovered_tasks": len(recovered_tasks),
+                    "recovered_paused_tasks": len(recovered_paused_tasks),
+                    "recovered_orphaned_step_runs": recovered_orphaned_step_runs,
+                    "invariant_reports": [report.as_dict() for report in invariant_reports],
+                }
+            },
+        )
+
         await task_queue.start()
 
         # Scheduler — evaluates cron/interval/one-shot schedules and
@@ -410,6 +482,7 @@ def create_app() -> FastAPI:
         app.state.provider_test_results = {}
         app.state.provider_test_cooldowns = {}
         app.state.remember_queue = remember_queue
+        app.state.tool_classification_queue = tool_classification_queue
         app.state.artifact_store = artifact_store
         app.state.artifact_maintenance = artifact_maintenance
         app.state.serve_ui = config_runtime.serve_ui
@@ -425,7 +498,9 @@ def create_app() -> FastAPI:
         app.state.pause_waiter = pause_waiter
         app.state.session_lock = session_lock
         app.state.tool_router = tool_router
+        app.state.agent_registry = agent_registry
         app.state.workflow_registry = workflow_registry
+        app.state.step_profile_registry = step_profile_registry
         app.state.step_evaluator = step_evaluator
         app.state.agent_loop = agent_loop
         app.state.workflow_engine = workflow_engine
@@ -438,6 +513,8 @@ def create_app() -> FastAPI:
         app.state.recovered_session_ids = frozenset(recovered_sessions)
         app.state.recovered_task_ids = frozenset(recovered_tasks)
         app.state.recovered_paused_task_ids = frozenset(recovered_paused_tasks)
+        app.state.recovered_orphaned_step_runs = recovered_orphaned_step_runs
+        app.state.startup_invariant_reports = [report.as_dict() for report in invariant_reports]
 
         app.state.notification_service = notification_service
         app.state.turn_scheduler = turn_scheduler
@@ -488,6 +565,7 @@ def create_app() -> FastAPI:
             channel_manager_ref=_get_channel_manager,
             turn_scheduler=turn_scheduler,
         )
+        workflow_engine._channel_delivery = channel_delivery  # noqa: SLF001
 
         app.state.channel_manager = channel_manager
         app.state.channel_delivery = channel_delivery
@@ -506,8 +584,24 @@ def create_app() -> FastAPI:
 
         await channel_delivery.start()
 
+        async def _session_lock_sweeper() -> None:
+            interval_seconds = 900.0
+            idle_seconds = 900.0
+            while True:
+                await asyncio.sleep(interval_seconds)
+                for session_id in session_lock.stale_unlocked_session_ids(
+                    max_idle_seconds=idle_seconds
+                ):
+                    session_lock.evict(session_id, reason="sweeper")
+
+        session_lock_sweeper_task = asyncio.create_task(_session_lock_sweeper())
+
         yield
 
+        if session_lock_sweeper_task is not None:
+            session_lock_sweeper_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await session_lock_sweeper_task
         await artifact_maintenance.stop()
         await channel_delivery.stop()
         await channel_manager.stop_all()
@@ -515,6 +609,7 @@ def create_app() -> FastAPI:
         await task_queue.stop()
         await shared_runtime.cleanup()
         await remember_queue.stop()
+        await tool_classification_queue.stop()
         await providers.executor.cleanup()
         await session_cache.aclose()
         await providers.memory.client.aclose()

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/cognis/api/common.py

@@ -6,6 +6,7 @@ import base64
 import json
 import re
 from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, cast
 
@@ -14,6 +15,8 @@ from fastapi.responses import JSONResponse
 
 from cognis.api.middleware import AuthenticatedUser
 from cognis.api.models import ErrorBody, ErrorResponse
+from cognis.ownership import normalize_executor_scope
+from cognis.store.queries import get_active_agent_grant
 
 
 def api_exception(
@@ -54,15 +57,21 @@ def require_current_user(request: Request) -> AuthenticatedUser:
     return user
 
 
-def require_jwt_user(request: Request) -> AuthenticatedUser:
-    """Require a user authenticated with a JWT/session token."""
+def require_session_user(request: Request) -> AuthenticatedUser:
+    """Require a human interactive session authenticated by cookie or bearer."""
 
     user = require_current_user(request)
-    if user.auth_type != "jwt":
+    if user.auth_type not in {"jwt", "session"}:
         raise api_exception(403, "forbidden", "This endpoint requires session authentication")
     return user
 
 
+def require_jwt_user(request: Request) -> AuthenticatedUser:
+    """Backward-compatible alias for interactive session auth."""
+
+    return require_session_user(request)
+
+
 def require_admin(request: Request) -> AuthenticatedUser:
     """Require the authenticated user to be an admin."""
     user = require_current_user(request)
@@ -79,6 +88,74 @@ def require_owner_or_admin(request: Request, owner_email: str) -> AuthenticatedU
     return user
 
 
+def require_resource_owner(request: Request, owner_email: str) -> AuthenticatedUser:
+    """Require strict resource ownership with no admin bypass."""
+
+    user = require_current_user(request)
+    if user.email != owner_email:
+        raise api_exception(403, "forbidden", "Resource access denied")
+    return user
+
+
+@dataclass(slots=True)
+class AgentAccess:
+    """Resolved caller access to an agent."""
+
+    user: AuthenticatedUser
+    owner_email: str
+    is_owner: bool
+    grant: Any | None = None
+
+    @property
+    def granted_permission(self) -> str | None:
+        return str(self.grant.permission) if self.grant is not None else None
+
+    @property
+    def executor_scope(self) -> str | None:
+        return normalize_executor_scope(str(self.grant.executor_scope)) if self.grant is not None else None
+
+
+async def check_agent_access(request: Request, agent: Any, *, required: str) -> AgentAccess:
+    """Resolve agent access for the caller.
+
+    ``required`` may be ``view``, ``use``, ``edit``, ``delete``, or ``share``.
+    Ownership is the only write path; active ``use`` grants permit only
+    ``view`` and ``use``. Admin role is intentionally ignored here.
+    """
+
+    user = require_current_user(request)
+    owner_email = str(getattr(agent, "owner_email", "") or "")
+    if not owner_email:
+        raise api_exception(500, "internal_error", "Agent owner is missing")
+    if user.email == owner_email:
+        return AgentAccess(user=user, owner_email=owner_email, is_owner=True)
+
+    if required not in {"view", "use", "edit", "delete", "share"}:
+        raise api_exception(500, "internal_error", f"Unsupported agent access requirement: {required}")
+    if required not in {"view", "use"}:
+        raise api_exception(403, "forbidden", "Resource access denied")
+
+    session_factory = getattr(request.app.state, "session_factory", None)
+    if session_factory is None:
+        raise api_exception(500, "internal_error", "Session factory unavailable")
+    async with session_factory() as session:
+        grant = await get_active_agent_grant(session, str(agent.agent_id), user.email)
+    if grant is None:
+        raise api_exception(403, "forbidden", "Resource access denied")
+    return AgentAccess(user=user, owner_email=owner_email, is_owner=False, grant=grant)
+
+
+def apply_agent_access_metadata(agent: Any, access: AgentAccess) -> Any:
+    """Annotate an agent row/definition with caller-scoped sharing metadata."""
+
+    agent.is_shared_with_me = not access.is_owner
+    agent.shared_by_email = None if access.is_owner else access.owner_email
+    agent.granted_permission = access.granted_permission
+    agent.executor_scope = access.executor_scope
+    agent.is_readonly_for_caller = not access.is_owner
+    return agent
+
+
 def forbid_mutation_for_viewer(request: Request) -> None:
     """Reject mutation attempts from viewer accounts."""
     user = require_current_user(request)

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/cognis/api/executor_runtime.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from cognis.logging import get_logger
 from cognis.models.agent import AgentDefinition
-from cognis.models.tool import ExecutorCapabilities
+from cognis.models.tool import ExecutorCapabilities, ToolDefinition
 from cognis.store.queries import get_executor_row, update_executor_runtime_state
 from cognis.tools.skills import resolve_skills_for_agent
 
@@ -247,7 +247,7 @@ async def _persist_runtime_state(
     runtime_metadata: dict[str, Any],
 ) -> None:
     async with app.state.session_factory() as session:
-        await update_executor_runtime_state(
+        row = await update_executor_runtime_state(
             session,
             executor_id,
             applied_config_version=applied_config_version,
@@ -257,6 +257,22 @@ async def _persist_runtime_state(
             runtime_state=runtime_state,
         )
         await session.commit()
+    queue = getattr(app.state, "tool_classification_queue", None)
+    if queue is None or row is None or not observed_tools:
+        return
+    try:
+        tool_defs = [
+            ToolDefinition.model_validate(item)
+            for item in observed_tools
+            if isinstance(item, dict)
+        ]
+        await queue.enqueue_tools(tool_defs, owner_email=getattr(row, "owner_email", None))
+    except Exception:
+        _logger.warning(
+            "executor_runtime: failed to enqueue tool classifications",
+            extra={"extra_data": {"executor_id": executor_id, "observed_tools": len(observed_tools)}},
+            exc_info=True,
+        )
 
 
 async def _build_configure_payload(
@@ -266,6 +282,7 @@ async def _build_configure_payload(
 ) -> tuple[dict[str, Any], dict[str, Any]]:
     from cognis.api.executor_ws import _resolve_executor_mcp_payload
     from cognis.api.runtime_support import _resolve_web_config
+    from cognis.tools.skills import _qualified_skill_tool_name
 
     mcp_servers, scoped_secrets = await _resolve_executor_mcp_payload(row, app.state.providers)
     web_config = await _resolve_web_config(app.state.providers, row.owner_email)
@@ -287,19 +304,34 @@ async def _build_configure_payload(
                     "skill_id": skill.skill_id,
                     "version_id": skill.version_id,
                     "content_hash": skill.content_hash,
-                    "tools": [t.model_dump(mode="json") for t in skill.tools],
+                    "tools": [
+                        {
+                            **t.model_dump(mode="json"),
+                            "qualified_name": _qualified_skill_tool_name(skill.skill_id, t.name),
+                        }
+                        for t in skill.tools
+                    ],
                     "asset_manifest": [a.model_dump(mode="json") for a in skill.asset_manifest],
                 }
-                artifact_store = getattr(app.state.providers, "artifact_store", None)
+                artifact_store = getattr(app.state, "artifact_store", None)
                 if artifact_store and skill.asset_manifest:
+                    ttl_seconds = getattr(
+                        getattr(artifact_store, "_config", None),  # noqa: SLF001
+                        "signed_url_ttl_seconds",
+                        None,
+                    )
                     for asset_entry in manifest["asset_manifest"]:
                         ns = asset_entry.get("artifact_namespace", "skills")
                         oid = asset_entry.get("artifact_object_id", "")
+                        filename = asset_entry.get("filename", "")
                         if oid:
                             with contextlib.suppress(Exception):
-                                asset_entry[
-                                    "signed_url"
-                                ] = await artifact_store.async_get_signed_url(ns, oid)
+                                asset_entry["url"] = await artifact_store.async_get_public_url(
+                                    ns,
+                                    oid,
+                                    filename,
+                                    ttl_seconds=ttl_seconds,
+                                )
                 skill_manifests.append(manifest)
     except Exception:
         _logger.warning(

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/cognis/api/executor_ws.py

@@ -13,6 +13,7 @@ from cognis.api.executor_runtime import reconcile_executor
 from cognis.core.executor_policy import is_executor_type_allowed, load_executor_policy
 from cognis.logging import get_logger
 from cognis.models.tool import MCP_SERVER_IDS_KEY, ExecutorCapabilities, MCPServerConfig
+from cognis.ownership import is_shared_owner_email
 from cognis.providers.executor.websocket import WebSocketExecutorProvider
 from cognis.store.queries import get_executor_row, get_mcp_server, update_executor_runtime_state
 from cognis.tools.mcp import invalid_mcp_config_reason
@@ -91,6 +92,7 @@ async def handle_executor_websocket(
             environment=params.get("environment"),
             platform=params.get("platform") or {},
             status=row.status,
+            owner_email=row.owner_email,
         ),
     )
 
@@ -251,11 +253,14 @@ def _executor_connection_metadata(
     environment: Any,
     platform: dict[str, Any],
     status: str,
+    owner_email: str | None,
 ) -> dict[str, Any]:
     metadata: dict[str, Any] = {
         "labels": labels,
         "platform": platform,
         "status": status,
+        "owner_email": owner_email,
+        "shared": is_shared_owner_email(owner_email),
     }
     if isinstance(environment, dict):
         metadata["environment"] = environment

{cognis_executor-0.2.0 → cognis_executor-0.3.0}/cognis/api/middleware.py

@@ -14,7 +14,12 @@ from starlette.responses import Response
 from cognis.api.models import ErrorBody, ErrorResponse
 from cognis.runtime_context import current_user_email
 from cognis.security import parse_api_key, verify_api_key
-from cognis.store.queries import get_api_key, get_user, touch_api_key_last_used
+from cognis.store.queries import (
+    get_api_key,
+    get_browser_session_by_token,
+    get_user,
+    touch_api_key_last_used,
+)
 
 PUBLIC_ROUTES = {
     ("GET", "/api/bootstrap-status"),
@@ -177,20 +182,28 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                 finally:
                     current_user_email.reset(context_token)
 
-        # Fallback: check cognis_session cookie (cross-service SSO)
+        # Fallback: check opaque browser session cookie.
         if cookie_token:
-            try:
-                claims = auth_provider.verify_jwt(cookie_token, audience=["cognis"])
-            except Exception:
-                return JSONResponse(
-                    status_code=401,
-                    content=ErrorResponse(
-                        error=ErrorBody(code="unauthorized", message="Invalid session cookie")
-                    ).model_dump(),
-                )
-            # Check if user is disabled
             async with session_factory() as session:
-                user_row = await get_user(session, str(claims["sub"]))
+                browser_session = await get_browser_session_by_token(session, cookie_token)
+                if browser_session is None or browser_session.revoked_at is not None:
+                    return JSONResponse(
+                        status_code=401,
+                        content=ErrorResponse(
+                            error=ErrorBody(code="unauthorized", message="Invalid session cookie")
+                        ).model_dump(),
+                    )
+                expires_at = browser_session.expires_at
+                if expires_at.tzinfo is None:
+                    expires_at = expires_at.replace(tzinfo=UTC)
+                if expires_at < datetime.now(UTC):
+                    return JSONResponse(
+                        status_code=401,
+                        content=ErrorResponse(
+                            error=ErrorBody(code="unauthorized", message="Session expired")
+                        ).model_dump(),
+                    )
+                user_row = await get_user(session, browser_session.user_email)
                 if user_row is not None and not user_row.is_active:
                     return JSONResponse(
                         status_code=403,
@@ -198,16 +211,23 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                             error=ErrorBody(code="account_disabled", message="Account disabled")
                         ).model_dump(),
                     )
-            context_token = current_user_email.set(str(claims["sub"]))
+                if user_row is None:
+                    return JSONResponse(
+                        status_code=401,
+                        content=ErrorResponse(
+                            error=ErrorBody(code="unauthorized", message="Unknown session owner")
+                        ).model_dump(),
+                    )
+            context_token = current_user_email.set(user_row.email)
             request.state.user = AuthenticatedUser(
-                email=str(claims["sub"]),
-                role=str(claims.get("role", "user")),
-                name=claims.get("name"),
-                auth_type="cookie",
+                email=user_row.email,
+                role=user_row.role,
+                name=user_row.name,
+                auth_type="session",
             )
-            request.state.claims = claims
+            request.state.browser_session_id = browser_session.session_id
             if api_rate_limiter is not None and not await api_rate_limiter.allow(
-                user_key=str(claims["sub"]),
+                user_key=user_row.email,
                 path=request.url.path,
                 method=request.method,
             ):