crewplus 0.3.1__tar.gz → 0.3.2__tar.gz

{crewplus-0.3.1 → crewplus-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.3.1
+Version: 0.3.2
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/your-org/crewplus-base/issues
 Requires-Python: <4.0,>=3.11
 Requires-Dist: langchain<1.0.0,>=0.3.25
 Requires-Dist: langchain-openai>=0.3.24
-Requires-Dist: google-genai>=1.21.1
+Requires-Dist: google-genai>=1.51.0
 Requires-Dist: anthropic[vertex]>=0.76.0
 Requires-Dist: langchain-milvus<0.3.0,>=0.2.1
 Requires-Dist: langfuse<4.0.0,>=3.1.3

{crewplus-0.3.1 → crewplus-0.3.2}/crewplus/services/gemini_chat_model.py

@@ -257,6 +257,17 @@ class GeminiChatModel(BaseChatModel):
     max_tokens: Optional[int] = Field(default=None, description="Maximum tokens to generate")
     top_p: Optional[float] = Field(default=None, description="Top-p sampling parameter")
     top_k: Optional[int] = Field(default=None, description="Top-k sampling parameter")
+
+    # Thinking configuration. All optional: when none of the three is set, no
+    # thinking_config is sent at all and the model's own default applies.
+    # Gemini 3.x takes thinking_level, Gemini 2.5 takes thinking_budget; sending
+    # both is rejected by the API, so _build_thinking_config picks one by model family.
+    thinking_level: Optional[str] = Field(
+        default=None, description="MINIMAL/LOW/MEDIUM/HIGH, Gemini 3.x only")
+    thinking_budget: Optional[int] = Field(
+        default=None, description="Thinking token budget, Gemini 2.5 only")
+    include_thoughts: Optional[bool] = Field(
+        default=None, description="Whether thought parts are returned in the response")
     
     # Vertex AI specific configuration
     use_vertex_ai: bool = Field(default=False, description="Use Vertex AI instead of Google AI Platform")
@@ -804,6 +815,33 @@ class GeminiChatModel(BaseChatModel):
             except Exception as e:
                 self.logger.error(f"Failed to process message part at index {i}: {part_spec}. Error: {e}", exc_info=True)
 
+    def _build_thinking_config(self) -> Optional[types.ThinkingConfig]:
+        """Builds the thinking config for the current model family.
+
+        Gemini 3.x accepts ``thinking_level`` (MINIMAL/LOW/MEDIUM/HIGH), Gemini 2.5
+        accepts ``thinking_budget`` (an integer). Passing both is rejected by the
+        service, so the parameter for the other family is ignored rather than being
+        an error -- that is what lets a single model config entry serve both
+        generations, so switching models only means changing deployment_name.
+
+        Returns None when nothing is configured, in which case the caller omits
+        thinking_config entirely and the model's default behaviour applies.
+        """
+        is_gemini3 = self.model_name.startswith("gemini-3")
+        kwargs: Dict[str, Any] = {}
+
+        value = self.thinking_level if is_gemini3 else self.thinking_budget
+        if value is not None:
+            if is_gemini3:
+                kwargs["thinking_level"] = str(value).upper()
+            else:
+                kwargs["thinking_budget"] = int(value)
+
+        if self.include_thoughts is not None:
+            kwargs["include_thoughts"] = self.include_thoughts
+
+        return types.ThinkingConfig(**kwargs) if kwargs else None
+
     def _prepare_generation_config(
         self,
         messages: List[BaseMessage],
@@ -826,6 +864,12 @@ class GeminiChatModel(BaseChatModel):
         if stop:
             config_params["stop_sequences"] = stop
 
+        # Omit thinking_config entirely when nothing is configured, so the model
+        # default applies instead of us pinning a tier.
+        thinking_config = self._build_thinking_config()
+        if thinking_config is not None:
+            config_params["thinking_config"] = thinking_config
+
         # Handle system instructions
         system_prompts = [msg.content for msg in messages if isinstance(msg, SystemMessage) and msg.content]
         if system_prompts:

{crewplus-0.3.1 → crewplus-0.3.2}/crewplus/services/model_load_balancer.py

@@ -57,6 +57,13 @@ class ModelLoadBalancer:
         "code_execution": None,
         "url_context": None,
     }
+
+    # Gemini thinking parameters. Passed through only when present in the model
+    # config, so an entry that omits them leaves the model fields at None and no
+    # thinking_config reaches the API. GeminiChatModel picks thinking_level for
+    # Gemini 3.x and thinking_budget for Gemini 2.5, ignoring the other one.
+    GEMINI_THINKING_KEYS = ("thinking_level", "thinking_budget", "include_thoughts")
+
     def __init__(self,
                  config_path: Optional[str] = "config/models_config.json",
                  config_data: Optional[Dict] = None,
@@ -267,6 +274,9 @@ class ModelLoadBalancer:
                 kwargs['temperature'] = model_config['temperature']
             if 'max_tokens' in model_config:
                 kwargs['max_tokens'] = model_config['max_tokens']
+            for key in self.GEMINI_THINKING_KEYS:
+                if key in model_config:
+                    kwargs[key] = model_config[key]
             if disable_streaming:
                 kwargs['disable_streaming'] = True
             return GeminiChatModel(**kwargs)
@@ -334,6 +344,9 @@ class ModelLoadBalancer:
                     kwargs['temperature'] = model_config['temperature']
                 if 'max_tokens' in model_config:
                     kwargs['max_tokens'] = model_config['max_tokens']
+                for key in self.GEMINI_THINKING_KEYS:
+                    if key in model_config:
+                        kwargs[key] = model_config[key]
                 if disable_streaming:
                     kwargs['disable_streaming'] = True
                 return GeminiChatModel(**kwargs)

crewplus-0.3.2/crewplus/services/runtime_model_factory.py

@@ -0,0 +1,400 @@
+import hashlib
+import json
+import logging
+import random
+import time
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from langchain_openai import AzureOpenAIEmbeddings, ChatOpenAI, OpenAIEmbeddings
+
+from .azure_chat_model import TracedAzureChatOpenAI
+from .claude_chat_model import ClaudeChatModel
+from .gemini_chat_model import GeminiChatModel
+from .oai_claude_chat_model import OAIClaudeChatModel
+
+
+class RuntimeModelConfigError(ValueError):
+    """Raised when a runtime model policy is missing required fields."""
+
+
+def _first_present(data: Dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        value = data.get(key)
+        if value is not None and value != "":
+            return value
+    return None
+
+
+def _credentials(config: Dict[str, Any]) -> Dict[str, Any]:
+    creds = config.get("credentials") or {}
+    if not isinstance(creds, dict):
+        raise RuntimeModelConfigError("model credentials must be a dictionary")
+    return creds
+
+
+def _api_key(config: Dict[str, Any]) -> str:
+    creds = _credentials(config)
+    value = _first_present(config, "api_key", "apiKey") or _first_present(creds, "api_key", "apiKey")
+    if not value:
+        raise RuntimeModelConfigError("model apiKey is required")
+    return str(value)
+
+
+def _provider_type(config: Dict[str, Any]) -> str:
+    provider = _first_present(config, "providerType", "provider_type", "provider")
+    if not provider:
+        raise RuntimeModelConfigError("model providerType is required")
+    return str(provider).strip().lower().replace("-", "_")
+
+
+def _model_id(config: Dict[str, Any]) -> str:
+    value = _first_present(config, "modelId", "model_id", "model", "modelName", "model_name")
+    if not value:
+        raise RuntimeModelConfigError("modelId is required")
+    return str(value)
+
+
+def _deployment_name(config: Dict[str, Any]) -> str:
+    return str(_first_present(config, "deploymentName", "deployment_name", "deployment") or _model_id(config))
+
+
+def _base_url(config: Dict[str, Any]) -> Optional[str]:
+    value = _first_present(config, "baseUrl", "base_url", "apiBase", "api_base", "azureEndpoint", "azure_endpoint")
+    return str(value).rstrip("/") if value else None
+
+
+def _api_version(config: Dict[str, Any]) -> Optional[str]:
+    value = _first_present(config, "apiVersion", "api_version", "openaiApiVersion", "openai_api_version")
+    return str(value) if value else None
+
+
+def _dimensions(config: Dict[str, Any]) -> Optional[int]:
+    value = _first_present(config, "dimensions", "embeddingDimensions", "embedding_dims")
+    if value is None:
+        return None
+    return int(value)
+
+
+def _with_v1(base_url: str) -> str:
+    normalized = base_url.rstrip("/")
+    if normalized.endswith("/v1"):
+        return normalized
+    return f"{normalized}/v1"
+
+
+def model_config_fingerprint(config: Dict[str, Any]) -> str:
+    """Return a stable fingerprint that avoids storing secrets in cache keys."""
+    redacted = dict(config)
+    creds = _credentials(config) if isinstance(config.get("credentials"), dict) else {}
+    if creds:
+        secret_payload = json.dumps(creds, sort_keys=True, default=str)
+        redacted["credentials"] = {
+            "secret_hash": hashlib.sha256(secret_payload.encode("utf-8")).hexdigest()
+        }
+    payload = json.dumps(redacted, sort_keys=True, default=str)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+class RuntimeModelFactory:
+    """
+    Creates model instances from runtime dictionaries without modifying the
+    process-wide ModelLoadBalancer or environment variables.
+    """
+
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.logger = logger or logging.getLogger(__name__)
+        self._cache: Dict[str, Any] = {}
+
+    def create_embedding_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "embedding", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_embedding(model_config)
+        return self._cache[cache_key]
+
+    def create_vision_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "vision", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_chat_model(model_config)
+        return self._cache[cache_key]
+
+    def create_chat_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "chat", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_chat_model(model_config)
+        return self._cache[cache_key]
+
+    def _cache_key(self, scope: str, capability: str, model_config: Dict[str, Any]) -> str:
+        tenant = _first_present(model_config, "tenantId", "tenant_id") or scope
+        connection_id = _first_present(model_config, "connectionId", "connection_id") or "no-connection"
+        return f"{tenant}:{connection_id}:{capability}:{model_config_fingerprint(model_config)}"
+
+    def _instantiate_embedding(self, model_config: Dict[str, Any]):
+        provider = _provider_type(model_config)
+        model = _model_id(model_config)
+        api_key = _api_key(model_config)
+        dimensions = _dimensions(model_config)
+
+        if provider in {"azure_openai", "azure_openai_embeddings"}:
+            api_version = _api_version(model_config)
+            base_url = _base_url(model_config)
+            if not api_version:
+                raise RuntimeModelConfigError("apiVersion is required for Azure OpenAI embeddings")
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Azure OpenAI embeddings")
+
+            kwargs = {
+                "model": model,
+                "azure_deployment": _deployment_name(model_config),
+                "openai_api_version": api_version,
+                "api_key": api_key,
+                "azure_endpoint": base_url,
+                "chunk_size": int(model_config.get("chunk_size", 16)),
+                "request_timeout": int(model_config.get("request_timeout", 60)),
+                "max_retries": int(model_config.get("max_retries", 2)),
+            }
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return AzureOpenAIEmbeddings(**kwargs)
+
+        if provider == "openai":
+            kwargs = {"model": model, "api_key": api_key}
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return OpenAIEmbeddings(**kwargs)
+
+        if provider == "openai_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for OpenAI-compatible embeddings")
+            kwargs = {"model": model, "api_key": api_key, "base_url": _with_v1(base_url)}
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return OpenAIEmbeddings(**kwargs)
+
+        raise RuntimeModelConfigError(f"Unsupported runtime embedding provider: {provider}")
+
+    def _instantiate_chat_model(self, model_config: Dict[str, Any]):
+        provider = _provider_type(model_config)
+        model = _model_id(model_config)
+        api_key = _api_key(model_config) if provider not in {"vertex_google", "vertex_anthropic", "vertex_ai"} else None
+        temperature = float(model_config.get("temperature", 0.0))
+        max_tokens = model_config.get("max_tokens")
+        disable_streaming = bool(model_config.get("disable_streaming", False))
+
+        if provider == "azure_openai":
+            api_version = _api_version(model_config)
+            base_url = _base_url(model_config)
+            if not api_version:
+                raise RuntimeModelConfigError("apiVersion is required for Azure OpenAI models")
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Azure OpenAI models")
+            kwargs = {
+                "azure_deployment": _deployment_name(model_config),
+                "openai_api_version": api_version,
+                "azure_endpoint": base_url,
+                "openai_api_key": api_key,
+                "temperature": temperature,
+            }
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return TracedAzureChatOpenAI(**kwargs)
+
+        if provider == "openai":
+            kwargs = {"model": model, "openai_api_key": api_key, "temperature": temperature}
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ChatOpenAI(**kwargs)
+
+        if provider == "openai_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for OpenAI-compatible models")
+            kwargs = {
+                "model": model,
+                "openai_api_key": api_key,
+                "base_url": _with_v1(base_url),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ChatOpenAI(**kwargs)
+
+        if provider == "google":
+            kwargs = {
+                "google_api_key": api_key,
+                "model_name": _deployment_name(model_config),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return GeminiChatModel(**kwargs)
+
+        if provider in {"vertex_google", "vertex_ai"}:
+            project_id = _first_present(model_config, "projectId", "project_id", "gcpProjectId", "gcp_project_id")
+            location = _first_present(model_config, "location", "region", "gcpRegion", "gcp_region")
+            if not project_id or not location:
+                raise RuntimeModelConfigError("projectId and location are required for Vertex AI models")
+            kwargs = {
+                "use_vertex_ai": True,
+                "model_name": _deployment_name(model_config).split("@")[0],
+                "project_id": str(project_id),
+                "location": str(location),
+                "temperature": temperature,
+            }
+            service_account_file = _first_present(model_config, "serviceAccountFile", "service_account_file")
+            if service_account_file:
+                kwargs["service_account_file"] = str(service_account_file)
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return GeminiChatModel(**kwargs)
+
+        if provider == "vertex_anthropic":
+            project_id = _first_present(model_config, "projectId", "project_id", "gcpProjectId", "gcp_project_id")
+            location = _first_present(model_config, "location", "region", "gcpRegion", "gcp_region")
+            if not project_id or not location:
+                raise RuntimeModelConfigError("projectId and location are required for Vertex Anthropic models")
+            kwargs = {
+                "model_name": _deployment_name(model_config).split("@")[0],
+                "project_id": str(project_id),
+                "location": str(location),
+                "temperature": temperature,
+            }
+            service_account_file = _first_present(model_config, "serviceAccountFile", "service_account_file")
+            if service_account_file:
+                kwargs["service_account_file"] = str(service_account_file)
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ClaudeChatModel(**kwargs)
+
+        if provider == "anthropic_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Anthropic-compatible models")
+            kwargs = {
+                "model_name": _deployment_name(model_config),
+                "use_custom_endpoint": True,
+                "api_key": api_key,
+                "base_url": base_url,
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ClaudeChatModel(**kwargs)
+
+        if provider == "custom_openai":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for custom OpenAI-compatible Claude models")
+            kwargs = {
+                "model": _deployment_name(model_config),
+                "api_key": api_key,
+                "base_url": _with_v1(base_url),
+                "capabilities_config": model_config.get("capabilities", {}),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["streaming"] = False
+            return OAIClaudeChatModel(**kwargs)
+
+        raise RuntimeModelConfigError(f"Unsupported runtime chat provider: {provider}")
+
+
+class RuntimeModelPool:
+    """Selects runtime models from a capability-specific model pool."""
+
+    RETRYABLE_STATUS_MARKERS = ("429", "408", "500", "502", "503", "504", "timeout", "temporarily", "rate limit")
+
+    def __init__(
+        self,
+        factory: Optional[RuntimeModelFactory] = None,
+        logger: Optional[logging.Logger] = None,
+        cooldown_seconds: int = 60,
+        max_cooldown_seconds: int = 300,
+    ):
+        self.factory = factory or RuntimeModelFactory(logger=logger)
+        self.logger = logger or logging.getLogger(__name__)
+        self.cooldown_seconds = cooldown_seconds
+        self.max_cooldown_seconds = max_cooldown_seconds
+        self._cooldowns: Dict[str, float] = {}
+        self._failures: Dict[str, int] = {}
+
+    def select_model(self, policy: Dict[str, Any], capability: str) -> Dict[str, Any]:
+        candidates = self._active_candidates(policy, capability)
+        strategy = str((policy.get(capability) or {}).get("selectionStrategy") or policy.get("selectionStrategy") or "random")
+        if strategy == "weighted_random":
+            return self._weighted_random(candidates)
+        return random.choice(candidates)
+
+    def get_model(self, policy: Dict[str, Any], capability: str, *, cache_scope: str = "runtime") -> Tuple[Any, Dict[str, Any]]:
+        selected = self.select_model(policy, capability)
+        if capability == "embedding":
+            model = self.factory.create_embedding_model(selected, cache_scope=cache_scope)
+        elif capability == "vision":
+            model = self.factory.create_vision_model(selected, cache_scope=cache_scope)
+        else:
+            model = self.factory.create_chat_model(selected, cache_scope=cache_scope)
+        return model, selected
+
+    def report_success(self, model_key: str) -> None:
+        self._failures.pop(model_key, None)
+
+    def report_failure(self, model_key: str, error: Exception) -> None:
+        self._failures[model_key] = self._failures.get(model_key, 0) + 1
+        if self.is_retryable_error(error):
+            retry_after = self._retry_after_seconds(error)
+            cooldown = retry_after if retry_after is not None else self.cooldown_seconds
+            cooldown = min(cooldown, self.max_cooldown_seconds)
+            self._cooldowns[model_key] = time.time() + cooldown
+
+    def model_key(self, model_config: Dict[str, Any]) -> str:
+        connection_id = _first_present(model_config, "connectionId", "connection_id") or "no-connection"
+        return f"{connection_id}:{_provider_type(model_config)}:{_deployment_name(model_config)}:{model_config_fingerprint(model_config)}"
+
+    def is_retryable_error(self, error: Exception) -> bool:
+        text = str(error).lower()
+        return any(marker in text for marker in self.RETRYABLE_STATUS_MARKERS)
+
+    def _active_candidates(self, policy: Dict[str, Any], capability: str) -> List[Dict[str, Any]]:
+        section = policy.get(capability) or {}
+        models = section.get("models")
+        if not isinstance(models, list) or not models:
+            raise RuntimeModelConfigError(f"No runtime models configured for capability: {capability}")
+
+        now = time.time()
+        active = [model for model in models if self._cooldowns.get(self.model_key(model), 0) <= now]
+        return active or models
+
+    def _weighted_random(self, candidates: Iterable[Dict[str, Any]]) -> Dict[str, Any]:
+        items = list(candidates)
+        weights = [max(float(item.get("weight", 1) or 1), 0.0) for item in items]
+        if not any(weights):
+            return random.choice(items)
+        return random.choices(items, weights=weights, k=1)[0]
+
+    def _retry_after_seconds(self, error: Exception) -> Optional[int]:
+        retry_after = getattr(error, "retry_after", None)
+        if retry_after is None:
+            response = getattr(error, "response", None)
+            headers = getattr(response, "headers", None)
+            if headers:
+                retry_after = headers.get("Retry-After") or headers.get("retry-after")
+        if retry_after is None:
+            return None
+        try:
+            return int(float(retry_after))
+        except (TypeError, ValueError):
+            return None

{crewplus-0.3.1 → crewplus-0.3.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "crewplus"
-version = "0.3.01"
+version = "0.3.2"
 description = "Base services for CrewPlus AI applications"
 authors = [
     { name = "Tim Liu", email = "tim@opsmateai.com" },
@@ -16,7 +16,7 @@ requires-python = ">=3.11,<4.0"
 dependencies = [
     "langchain>=0.3.25, <1.0.0",
     "langchain-openai>=0.3.24",
-    "google-genai>=1.21.1",
+    "google-genai>=1.51.0",
     "anthropic[vertex]>=0.76.0",
     "langchain-milvus (>=0.2.1,<0.3.0)",
     "langfuse (>=3.1.3,<4.0.0)",

crewplus-0.3.2/tests/output/drawing_ingestion/gpt-5.4_run1.md

@@ -0,0 +1,88 @@
+Technical drawing page content extraction
+
+Main drawing
+- Assembly drawing of a rotating shaft support arrangement.
+- A long horizontal shaft is shown mounted between two pedestal-like supports on a base plate.
+- Left side: a support with a small side block/retainer and several numbered callouts.
+- Right side: a sectional view through the support and bearing arrangement, heavily hatched to indicate cut material.
+- A centerline runs horizontally through the shaft.
+- Section indicator text near the sectional view: A-A, h/rechts
+- Visible dimensions:
+  - 150
+  - 51
+
+Numbered callouts visible on drawing
+- Left support area:
+  - 11
+  - 1
+  - 5
+  - 12
+  - 13
+- Right sectional support area:
+  - 2
+  - 7
+  - 8
+  - 9
+  - 4
+  - 10
+  - 3
+- Base area:
+  - 6
+
+Bill of materials / parts list table
+Columns visible:
+- Pos.
+- St.
+- Benennung
+- Norm / Maße / Werkstoff
+- Zeichnungs-Nr.
+
+Rows extracted as visible:
+- 13 | 4 | Unterlegscheibe | HB 200 | 
+- 12 | 4 | Sechskantschr. MGS | 8.8, M20x30 | 
+- 11 | 4 | Flachrundschr. MGS | 8.8, M10x55 | 
+- 10 | 2 | Unterlegscheibe | HB 200 | 
+- 9 | 3 | Zylinderschr. MGS | M8x25 | 
+- 8 | 3 | Unterlegscheibe | HB 200 | 
+- 7 | 2 | Paßfeder | 18x11x90, PRK 6x6x61 | 
+- 6 | 1 | Platte | 1650-06 | 
+- 5 | 2 | Lagerbock | Stahl, ST37M | 
+- 4 | 3 | Büchse | | VKT-071004-B
+- 3 | 2 | Radkranz | | VKT-071004-A/4
+- 2 | 1 | Nabe | | VKT-071004-A/3
+- 1 | 2 | Nabensicherung | | VKT-071004-A/2
+
+Title block / metadata
+- Maßstab: 1:1
+- Format: A3
+- Werkstoff / material field: St
+- Benennung / title:
+  - RFL-Lin
+  - rotating shaft - Assembly
+- Zeichnungs-Nr. / drawing number:
+  - VKT-071005-A
+
+Revision / issue table
+- Gez. / date fields visible but handwritten/typed entries are faint.
+- Name visible: MKT
+- Datum visible in one field: 04/18
+- Aenderung durchgefuehrt / geprueft o.ä. field present at lower left title area.
+- Freimaß / tolerance or standards field present but not fully legible.
+
+Detailed image/diagram description
+- The page is a monochrome engineering drawing sheet with a border and title block.
+- The assembly consists of a cylindrical shaft supported by two tapered or trapezoidal pedestals fixed to a rectangular base plate.
+- The left support is shown externally. A side-mounted fastening arrangement appears to include a flat-head or round-head screw, washer, and retaining/nabensicherung component. A pedestal labeled by callout 5 sits on the base plate 6. Above it is a wheel/ring-like component mounted on the shaft.
+- The right support is shown in cross-section. The section reveals:
+  - A central shaft passing vertically through the cut assembly view.
+  - A hub/nabe around the shaft.
+  - A radial key/Paßfeder between shaft and hub.
+  - A large outer ring/radkranz surrounding the hub area.
+  - Bushings/büchsen and washers stacked near the top.
+  - Multiple screws entering from the top and side to secure the components.
+  - The hatched regions indicate the cut metallic parts of the support and surrounding structure.
+- The shaft extends across the page between the two supports and appears aligned along a dashed centerline.
+- The base plate is a long rectangular member beneath both supports, with one horizontal dimension of 150 shown between support-related reference points.
+- The sectional support at right includes a top clamping/cover region with bolts and washers, and an internal fit around the shaft that suggests a keyed hub or wheel mounting.
+- Number balloons point to nearly all major components, corresponding to the parts list.
+- The drawing is rotated relative to normal reading orientation in the provided image; the title block and parts list are on the right side when viewed as provided.