ltcai 1.7.0 → 2.1.0

package/latticeai/api/marketplace.py

@@ -0,0 +1,81 @@
+"""Marketplace foundation API (local templates only)."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+
+class TemplateImportRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+class TemplateInstallRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+def create_marketplace_router(
+    *,
+    store,
+    catalog,
+    require_user: Callable[[Request], str],
+    gate_read: Callable[[Request], Optional[str]],
+    gate_write: Callable[[Request], Optional[str]],
+    workspace_graph: Callable[[], Any],
+) -> APIRouter:
+    from latticeai.core.marketplace import MarketplaceError
+
+    router = APIRouter()
+
+    @router.get("/marketplace/templates")
+    async def list_templates(request: Request, kind: Optional[str] = None):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.list_templates(kind=kind)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.get("/marketplace/templates/{kind}/{template_id}/export")
+    async def export_template(kind: str, template_id: str, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.export_template(kind, template_id)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/import")
+    async def import_template(req: TemplateImportRequest, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return {"template": catalog.import_template(req.data)}
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/install")
+    async def install_template(req: TemplateInstallRequest, request: Request):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            installed = catalog.install_template(
+                req.data,
+                store=store,
+                user_email=user or None,
+                workspace_id=scope,
+                graph=workspace_graph(),
+            )
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"installed": installed}
+
+    @router.get("/marketplace/templates/registry")
+    async def template_registry(request: Request):
+        require_user(request)
+        gate_read(request)
+        return {"registry": store.list_template_registry()}
+
+    return router

package/latticeai/api/plugins.py

@@ -0,0 +1,115 @@
+"""Plugin SDK API router (v2).
+
+Surfaces the :class:`latticeai.core.plugins.PluginRegistry` over HTTP using the
+same router-factory convention as the rest of ``latticeai.api`` (server_app
+constructs the dependencies and passes them in; this module never imports the
+app). New paths are namespaced under ``/plugins/registry`` and friends so they
+do not collide with the pre-existing ``/plugins/directory`` marketplace routes.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+
+class PluginActionRequest(BaseModel):
+    plugin_id: str
+    enabled: Optional[bool] = None
+    version: Optional[str] = None
+
+
+class PluginValidateRequest(BaseModel):
+    manifest: Dict[str, Any] = {}
+
+
+class PluginExecuteRequest(BaseModel):
+    plugin_id: str
+    action: str
+    args: Dict[str, Any] = {}
+
+
+def create_plugins_router(
+    *,
+    registry,
+    require_user: Callable[[Request], str],
+    require_admin: Callable[[Request], Any],
+    append_audit_event: Callable[..., None],
+    register_skill: Optional[Callable[[str, str], Any]] = None,
+    plugin_runners_factory: Optional[Callable[[], Dict[str, Callable[..., Any]]]] = None,
+    ui_file_response: Optional[Callable[[Path], Any]] = None,
+    static_dir: Optional[Path] = None,
+) -> APIRouter:
+    from latticeai.core.plugins import validate_manifest
+
+    router = APIRouter()
+
+    @router.get("/plugins/sdk")
+    async def plugins_sdk_page(request: Request):
+        require_user(request)
+        if ui_file_response is None or static_dir is None:
+            raise HTTPException(status_code=404, detail="Plugin SDK UI not available.")
+        page = static_dir / "plugins.html"
+        if not page.exists():
+            raise HTTPException(status_code=404, detail="Plugin SDK UI not found.")
+        return ui_file_response(page)
+
+    @router.get("/plugins/registry")
+    async def plugins_registry(request: Request):
+        require_user(request)
+        return registry.catalog()
+
+    @router.get("/plugins/registry/{plugin_id}")
+    async def plugin_detail(plugin_id: str, request: Request):
+        require_user(request)
+        manifest = registry.get_manifest(plugin_id)
+        if manifest is None:
+            raise HTTPException(status_code=404, detail=f"Plugin not found: {plugin_id}")
+        state = registry.store.list_plugin_registry().get(plugin_id, {}) if registry.store else {}
+        return {"plugin": manifest.public(), "registry": state}
+
+    @router.post("/plugins/validate")
+    async def plugin_validate(req: PluginValidateRequest, request: Request):
+        require_user(request)
+        manifest, errors = validate_manifest(req.manifest)
+        return {"ok": not errors, "errors": errors, "manifest": manifest.public() if manifest else None}
+
+    @router.post("/plugins/install")
+    async def plugin_install(req: PluginActionRequest, request: Request):
+        admin_email, _ = require_admin(request)
+        try:
+            result = registry.install(req.plugin_id, register_skill=register_skill)
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        append_audit_event("plugin_install", user_email=admin_email, plugin=req.plugin_id)
+        return result
+
+    @router.post("/plugins/uninstall")
+    async def plugin_uninstall(req: PluginActionRequest, request: Request):
+        admin_email, _ = require_admin(request)
+        result = registry.uninstall(req.plugin_id)
+        append_audit_event("plugin_uninstall", user_email=admin_email, plugin=req.plugin_id)
+        return result
+
+    @router.post("/plugins/enable")
+    async def plugin_enable(req: PluginActionRequest, request: Request):
+        require_user(request)
+        return {"plugin": registry.set_enabled(req.plugin_id, True)}
+
+    @router.post("/plugins/disable")
+    async def plugin_disable(req: PluginActionRequest, request: Request):
+        require_user(request)
+        return {"plugin": registry.set_enabled(req.plugin_id, False)}
+
+    @router.post("/plugins/execute")
+    async def plugin_execute(req: PluginExecuteRequest, request: Request):
+        current_user = require_user(request)
+        runners = plugin_runners_factory() if plugin_runners_factory else {}
+        result = registry.execute_action(req.plugin_id, req.action, req.args, runners=runners)
+        append_audit_event("plugin_execute", user_email=current_user, plugin=req.plugin_id, action=req.action, status=result.status)
+        return result.as_dict()
+
+    return router

package/latticeai/api/realtime.py

@@ -0,0 +1,91 @@
+"""Realtime Collaboration API router (v2).
+
+Server-Sent-Events stream + presence + activity feed over
+:class:`latticeai.core.realtime.RealtimeBus`. Workspace isolation is enforced by
+resolving each caller's allowed workspace scope before subscribing; single-user
+local mode works with no scope restriction.
+"""
+
+from __future__ import annotations
+
+import secrets
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Set
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+
+class PresenceRequest(BaseModel):
+    client_id: Optional[str] = None
+    workspace_id: Optional[str] = None
+
+
+def create_realtime_router(
+    *,
+    bus,
+    require_user: Callable[[Request], str],
+    get_current_user: Callable[[Request], Optional[str]],
+    allowed_scopes: Callable[[Optional[str]], Optional[Set[str]]],
+    ui_file_response: Optional[Callable[[Path], Any]] = None,
+    static_dir: Optional[Path] = None,
+) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/activity")
+    async def activity_page(request: Request):
+        require_user(request)
+        if ui_file_response is None or static_dir is None:
+            raise HTTPException(status_code=404, detail="Activity UI not available.")
+        page = static_dir / "activity.html"
+        if not page.exists():
+            raise HTTPException(status_code=404, detail="Activity UI not found.")
+        return ui_file_response(page)
+
+    @router.get("/realtime/stream")
+    async def realtime_stream(request: Request):
+        user = require_user(request)
+        scope = allowed_scopes(user or None)
+        sub_id = secrets.token_urlsafe(12)
+        sub = bus.add_subscriber(sub_id, workspace_scope=scope, user=user or None)
+
+        async def event_gen():
+            async for frame in bus.stream(sub):
+                if await request.is_disconnected():
+                    break
+                yield frame
+
+        return StreamingResponse(
+            event_gen(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no", "Connection": "keep-alive"},
+        )
+
+    @router.get("/realtime/feed")
+    async def realtime_feed(request: Request, limit: int = 50):
+        user = require_user(request)
+        scope = allowed_scopes(user or None)
+        return {"events": bus.recent(limit=limit, workspace_scope=scope), "stats": bus.stats()}
+
+    @router.get("/realtime/presence")
+    async def realtime_presence(request: Request):
+        user = require_user(request)
+        scope = allowed_scopes(user or None)
+        return {"presence": bus.presence(workspace_scope=scope), "stats": bus.stats()}
+
+    @router.post("/realtime/presence/join")
+    async def realtime_join(req: PresenceRequest, request: Request):
+        user = require_user(request)
+        client_id = req.client_id or secrets.token_urlsafe(8)
+        record = bus.join(client_id, user=user or None, workspace_id=req.workspace_id)
+        return {"presence": record}
+
+    @router.post("/realtime/presence/leave")
+    async def realtime_leave(req: PresenceRequest, request: Request):
+        require_user(request)
+        if req.client_id:
+            bus.leave(req.client_id)
+        return {"status": "ok"}
+
+    return router

package/latticeai/api/workflow_designer.py

@@ -0,0 +1,216 @@
+"""Workflow Designer API router (v2).
+
+Create / edit / validate / execute / inspect / export / import workflows plus
+run history, layered on :mod:`latticeai.core.workflow_engine` and the existing
+``WorkspaceOSStore`` workflow persistence (so pre-2.0 workflow history is
+preserved). Paths are namespaced under ``/workflows`` to avoid colliding with
+``/workspace/workflows``.
+
+server_app injects a ``build_runners`` callable that returns the executable
+runner map (tool / skill / plugin / agent), which is what lets a workflow
+actually drive plugins, skills, and multi-agent runs.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+
+class WorkflowDefinitionRequest(BaseModel):
+    name: str
+    nodes: List[Dict[str, Any]] = []
+    metadata: Dict[str, Any] = {}
+
+
+class WorkflowUpdateRequest(BaseModel):
+    name: Optional[str] = None
+    nodes: Optional[List[Dict[str, Any]]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class WorkflowRunRequest(BaseModel):
+    inputs: Dict[str, Any] = {}
+
+
+class WorkflowValidateRequest(BaseModel):
+    name: str = "Draft"
+    nodes: List[Dict[str, Any]] = []
+
+
+class WorkflowImportRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+def create_workflow_designer_router(
+    *,
+    store,
+    require_user: Callable[[Request], str],
+    get_current_user: Callable[[Request], Optional[str]],
+    gate_read: Callable[[Request], Optional[str]],
+    gate_write: Callable[[Request], Optional[str]],
+    workspace_graph: Callable[[], Any],
+    build_runners: Callable[[Optional[str], Optional[str]], Dict[str, Callable[..., Any]]],
+    append_audit_event: Callable[..., None],
+    ui_file_response: Optional[Callable[[Path], Any]] = None,
+    static_dir: Optional[Path] = None,
+) -> APIRouter:
+    from latticeai.core.workflow_engine import (
+        WorkflowEngine,
+        validate_definition,
+        export_workflow,
+        import_workflow,
+        WorkflowError,
+    )
+
+    router = APIRouter()
+
+    @router.get("/workflows")
+    async def workflows_page(request: Request):
+        require_user(request)
+        if ui_file_response is None or static_dir is None:
+            raise HTTPException(status_code=404, detail="Workflow Designer UI not available.")
+        page = static_dir / "workflows.html"
+        if not page.exists():
+            raise HTTPException(status_code=404, detail="Workflow Designer UI not found.")
+        return ui_file_response(page)
+
+    @router.get("/workflows/api/definitions")
+    async def list_definitions(request: Request, q: str = ""):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_workflows(query=q, workspace_id=scope)
+
+    @router.post("/workflows/api/definitions")
+    async def create_definition(req: WorkflowDefinitionRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        errors = validate_definition({"name": req.name, "nodes": req.nodes})
+        if errors:
+            raise HTTPException(status_code=400, detail={"validation_errors": errors})
+        workflow = store.create_workflow(
+            name=req.name,
+            steps=[{"action": n.get("type"), "node": n.get("id")} for n in req.nodes],
+            nodes=req.nodes,
+            metadata=req.metadata,
+            user_email=current_user or None,
+            graph=workspace_graph(),
+            workspace_id=scope,
+        )
+        append_audit_event("workflow_created", user_email=current_user, workflow_id=workflow["id"])
+        return {"workflow": workflow}
+
+    @router.get("/workflows/api/definitions/{workflow_id}")
+    async def get_definition(workflow_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"workflow": store.get_workflow(workflow_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow not found: {exc}") from exc
+
+    @router.patch("/workflows/api/definitions/{workflow_id}")
+    async def update_definition(workflow_id: str, req: WorkflowUpdateRequest, request: Request):
+        require_user(request)
+        scope = gate_write(request)
+        if req.nodes is not None:
+            errors = validate_definition({"name": req.name or "wf", "nodes": req.nodes})
+            if errors:
+                raise HTTPException(status_code=400, detail={"validation_errors": errors})
+        try:
+            workflow = store.update_workflow_definition(
+                workflow_id,
+                name=req.name,
+                nodes=req.nodes,
+                metadata=req.metadata,
+                workspace_id=scope,
+            )
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow not found: {exc}") from exc
+        return {"workflow": workflow}
+
+    @router.post("/workflows/api/validate")
+    async def validate_workflow(req: WorkflowValidateRequest, request: Request):
+        require_user(request)
+        errors = validate_definition({"name": req.name, "nodes": req.nodes})
+        return {"ok": not errors, "errors": errors}
+
+    @router.post("/workflows/api/definitions/{workflow_id}/run")
+    async def run_definition(workflow_id: str, req: WorkflowRunRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        try:
+            workflow = store.get_workflow(workflow_id, workspace_id=scope)
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow not found: {exc}") from exc
+        runners = build_runners(current_user or None, scope)
+        engine = WorkflowEngine(runners)
+        result = engine.run(workflow, inputs=req.inputs)
+        run = store.record_workflow_run(
+            workflow_id=workflow_id,
+            name=workflow.get("name") or "workflow",
+            status=result.status,
+            timeline=result.timeline,
+            outputs=result.outputs,
+            user_email=current_user or None,
+            graph=workspace_graph(),
+            workspace_id=scope,
+        )
+        append_audit_event("workflow_run", user_email=current_user, workflow_id=workflow_id, status=result.status)
+        return {"run": run, "result": result.as_dict()}
+
+    @router.get("/workflows/api/definitions/{workflow_id}/runs")
+    async def list_runs(workflow_id: str, request: Request, limit: int = 50):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_workflow_runs(workflow_id=workflow_id, limit=limit, workspace_id=scope)
+
+    @router.get("/workflows/api/runs")
+    async def list_all_runs(request: Request, limit: int = 50):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_workflow_runs(limit=limit, workspace_id=scope)
+
+    @router.get("/workflows/api/runs/{run_id}/replay")
+    async def workflow_run_replay(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"replay": store.replay_workflow_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow run not found: {run_id}") from exc
+
+    @router.get("/workflows/api/export/{workflow_id}")
+    async def export_definition(workflow_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            workflow = store.get_workflow(workflow_id, workspace_id=scope)
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow not found: {exc}") from exc
+        return export_workflow(workflow)
+
+    @router.post("/workflows/api/import")
+    async def import_definition(req: WorkflowImportRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        try:
+            definition = import_workflow(req.data)
+        except WorkflowError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        workflow = store.create_workflow(
+            name=definition["name"],
+            steps=[{"action": n.get("type"), "node": n.get("id")} for n in definition["nodes"]],
+            nodes=definition["nodes"],
+            metadata=definition.get("metadata") or {},
+            user_email=current_user or None,
+            graph=workspace_graph(),
+            workspace_id=scope,
+        )
+        append_audit_event("workflow_imported", user_email=current_user, workflow_id=workflow["id"])
+        return {"workflow": workflow}
+
+    return router

package/latticeai/core/marketplace.py

@@ -0,0 +1,178 @@
+"""Marketplace foundation for local templates.
+
+v2.1 intentionally does not add a cloud marketplace. This module provides the
+portable template shape, metadata, export/import validation, and install hooks
+that a future service can reuse.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+
+MARKETPLACE_VERSION = "2.1.0"
+TEMPLATE_KINDS = ("plugin", "workflow", "agent")
+
+
+class MarketplaceError(Exception):
+    """Raised for invalid template operations."""
+
+
+BUILTIN_TEMPLATES: Dict[str, List[Dict[str, Any]]] = {
+    "plugin": [
+        {
+            "id": "plugin-review-action",
+            "kind": "plugin",
+            "name": "Plugin Review Action",
+            "version": "1.0.0",
+            "description": "A permissioned plugin action template for review workflows.",
+            "metadata": {"category": "review", "installable": True},
+            "files": {
+                "plugin.json": {
+                    "id": "plugin-review-action",
+                    "name": "Plugin Review Action",
+                    "version": "1.0.0",
+                    "lattice_version": ">=2.1.0",
+                    "permissions": ["read_workspace", "run_skills"],
+                    "provides": {"skills": ["review_action"]},
+                }
+            },
+        }
+    ],
+    "workflow": [
+        {
+            "id": "workflow-agent-plugin-review",
+            "kind": "workflow",
+            "name": "Agent Plugin Review Workflow",
+            "version": "1.0.0",
+            "description": "Manual trigger into planner/executor/reviewer, plugin action, and output.",
+            "metadata": {"category": "agent-ops", "installable": True},
+            "definition": {
+                "name": "Agent Plugin Review Workflow",
+                "nodes": [
+                    {"id": "trigger", "type": "trigger", "name": "Manual start", "config": {"trigger": "manual"}, "next": "agent"},
+                    {"id": "agent", "type": "agent", "name": "Plan and execute", "config": {"goal": "Run agent platform review", "roles": ["planner", "executor", "reviewer"]}, "next": "plugin"},
+                    {"id": "plugin", "type": "plugin", "name": "Plugin action", "config": {"plugin": "hello-world", "action": "run_skill", "args": {}}, "next": "output"},
+                    {"id": "output", "type": "output", "name": "Output", "config": {}, "next": None},
+                ],
+                "metadata": {"template_id": "workflow-agent-plugin-review"},
+            },
+        }
+    ],
+    "agent": [
+        {
+            "id": "agent-planner-executor-reviewer",
+            "kind": "agent",
+            "name": "Planner Executor Reviewer",
+            "version": "1.0.0",
+            "description": "Default bounded planning, execution, review, and retry template.",
+            "metadata": {"category": "agent-ops", "installable": True},
+            "definition": {
+                "roles": ["planner", "executor", "reviewer"],
+                "max_retries": 2,
+                "constraints": ["workspace scoped", "no secret leakage", "replayable timeline"],
+            },
+        }
+    ],
+}
+
+
+def _normalize_kind(kind: str) -> str:
+    value = str(kind or "").strip().lower()
+    if value not in TEMPLATE_KINDS:
+        raise MarketplaceError(f"unknown template kind: {kind}")
+    return value
+
+
+class TemplateCatalog:
+    """Local template catalog with export/import/install primitives."""
+
+    def __init__(self, templates: Optional[Dict[str, List[Dict[str, Any]]]] = None):
+        self.templates = templates or BUILTIN_TEMPLATES
+
+    def list_templates(self, kind: Optional[str] = None) -> Dict[str, Any]:
+        kinds = [_normalize_kind(kind)] if kind else list(TEMPLATE_KINDS)
+        templates = []
+        for item_kind in kinds:
+            templates.extend(deepcopy(self.templates.get(item_kind, [])))
+        return {
+            "marketplace_version": MARKETPLACE_VERSION,
+            "kinds": list(TEMPLATE_KINDS),
+            "templates": templates,
+            "total": len(templates),
+        }
+
+    def get_template(self, kind: str, template_id: str) -> Dict[str, Any]:
+        item_kind = _normalize_kind(kind)
+        for template in self.templates.get(item_kind, []):
+            if template.get("id") == template_id:
+                return deepcopy(template)
+        raise MarketplaceError(f"template not found: {item_kind}/{template_id}")
+
+    def export_template(self, kind: str, template_id: str) -> Dict[str, Any]:
+        template = self.get_template(kind, template_id)
+        return {
+            "lattice_template_export": MARKETPLACE_VERSION,
+            "kind": template["kind"],
+            "template": template,
+            "metadata": {
+                "exported_from": "local",
+                "template_id": template_id,
+                "template_version": template.get("version"),
+            },
+        }
+
+    def import_template(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        if not isinstance(payload, dict):
+            raise MarketplaceError("template import payload must be an object")
+        template = deepcopy(payload.get("template") or payload)
+        kind = _normalize_kind(template.get("kind") or payload.get("kind"))
+        if not template.get("id"):
+            raise MarketplaceError("template missing id")
+        if not template.get("name"):
+            raise MarketplaceError("template missing name")
+        template["kind"] = kind
+        template.setdefault("version", "1.0.0")
+        template.setdefault("metadata", {})
+        template["metadata"] = {**template["metadata"], "imported": True}
+        return template
+
+    def install_template(
+        self,
+        template: Dict[str, Any],
+        *,
+        store: Any,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        graph: Any = None,
+    ) -> Dict[str, Any]:
+        imported = self.import_template(template)
+        kind = imported["kind"]
+        installed: Dict[str, Any] = {
+            "kind": kind,
+            "template_id": imported["id"],
+            "name": imported["name"],
+            "version": imported.get("version", "1.0.0"),
+        }
+        if kind == "workflow":
+            definition = imported.get("definition") or {}
+            workflow = store.create_workflow(
+                name=definition.get("name") or imported["name"],
+                steps=[{"action": node.get("type"), "node": node.get("id")} for node in definition.get("nodes", [])],
+                nodes=definition.get("nodes", []),
+                metadata={**(definition.get("metadata") or {}), "template_id": imported["id"]},
+                user_email=user_email,
+                graph=graph,
+                workspace_id=workspace_id,
+            )
+            installed["workflow_id"] = workflow["id"]
+        registry = store.mark_template_installed(
+            kind=kind,
+            template_id=imported["id"],
+            version=imported.get("version", "1.0.0"),
+            metadata=imported.get("metadata") or {},
+            workspace_id=workspace_id,
+        )
+        installed["registry"] = registry
+        return installed