toposync-ext-ai 0.1.0__tar.gz

toposync_ext_ai-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+.DS_Store
+.env
+.venv
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+
+node_modules/
+yarn.lock
+.pnp.cjs
+.pnp.loader.mjs
+.yarn/
+dist/
+build/
+.parcel-cache/
+
+.toposync-data/
+.toposync-processor-data
+toposync-data/
+
+*.log
+
+*.ignore.md
+ignore/
+
+# Playwright
+test-results/
+playwright-report/
+yolo*.pt
+
+# Streaming extension engines are downloaded at runtime.
+extensions/streaming/src/toposync_ext_streaming/bin/mediamtx/**/mediamtx*
+extensions/streaming/src/toposync_ext_streaming/bin/ffmpeg/**/ffmpeg*
+
+# Vision model artifacts are provisioned locally and must not be committed.
+extensions/vision/models/
+
+*.temporary.*

toposync_ext_ai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mateus Calza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

toposync_ext_ai-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: toposync-ext-ai
+Version: 0.1.0
+Summary: Toposync first-party extension: AI-assisted image operators and provider routing.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: litellm<2,>=1.74
+Requires-Dist: pillow<13,>=10
+Requires-Dist: toposync-core>=0.3.6
+Description-Content-Type: text/markdown
+
+# Toposync AI Extension
+
+First-party extension for AI-assisted pipeline operators.
+
+This first phase focuses on image workflows:
+
+- `ai.smart_crop`: locates an object/region from a natural-language description and crops the frame.
+- `ai.condition_filter`: evaluates a natural-language visual condition and emits packets only when it matches.
+
+The extension is designed around local-first usage. Ollama is the default provider target, with
+`qwen3-vl:30b` as the initial high-quality local vision recommendation. Cloud providers can be
+added through provider profiles and explicit fallback chains.

toposync_ext_ai-0.1.0/README.md

@@ -0,0 +1,12 @@
+# Toposync AI Extension
+
+First-party extension for AI-assisted pipeline operators.
+
+This first phase focuses on image workflows:
+
+- `ai.smart_crop`: locates an object/region from a natural-language description and crops the frame.
+- `ai.condition_filter`: evaluates a natural-language visual condition and emits packets only when it matches.
+
+The extension is designed around local-first usage. Ollama is the default provider target, with
+`qwen3-vl:30b` as the initial high-quality local vision recommendation. Cloud providers can be
+added through provider profiles and explicit fallback chains.

toposync_ext_ai-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "toposync-ext-ai"
+version = "0.1.0"
+description = "Toposync first-party extension: AI-assisted image operators and provider routing."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = [
+  "toposync-core>=0.3.6",
+  "httpx>=0.27",
+  "litellm>=1.74,<2",
+  "pillow>=10,<13",
+]
+
+[project.entry-points."toposync.extensions"]
+ai = "toposync_ext_ai.plugin:AiExtension"
+
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/toposync_ext_ai"]

toposync_ext_ai-0.1.0/src/toposync_ext_ai/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

toposync_ext_ai-0.1.0/src/toposync_ext_ai/catalog.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from .constants import DEFAULT_OLLAMA_MODEL
+
+
+BUILTIN_MODEL_CATALOG: list[dict[str, Any]] = [
+    {
+        "id": "ollama_qwen3_vl_30b",
+        "provider": "ollama",
+        "model": DEFAULT_OLLAMA_MODEL,
+        "name": "Qwen3-VL 30B",
+        "recommendation": "best_local_quality",
+        "tasks": ["image_region", "image_condition"],
+        "capabilities": ["vision", "structured_json", "bbox", "boolean_filter"],
+        "input_modalities": ["text", "image"],
+        "local": True,
+        "estimated_size": "20GB",
+        "min_ollama_version": "0.12.7",
+        "last_verified_at": "2026-05-02",
+        "notes": "Initial high-quality local recommendation for image reasoning through Ollama.",
+    },
+    {
+        "id": "ollama_qwen3_vl_8b",
+        "provider": "ollama",
+        "model": "qwen3-vl:8b",
+        "name": "Qwen3-VL 8B",
+        "recommendation": "lighter_local",
+        "tasks": ["image_region", "image_condition"],
+        "capabilities": ["vision", "structured_json", "bbox", "boolean_filter"],
+        "input_modalities": ["text", "image"],
+        "local": True,
+        "estimated_size": "6.1GB",
+        "min_ollama_version": "0.12.7",
+        "last_verified_at": "2026-05-02",
+        "notes": "Lighter local fallback when the 30B variant is too heavy for the machine.",
+    },
+]
+
+
+def list_builtin_model_catalog() -> list[dict[str, Any]]:
+    return deepcopy(BUILTIN_MODEL_CATALOG)

toposync_ext_ai-0.1.0/src/toposync_ext_ai/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+EXTENSION_ID = "com.toposync.ai"
+DEFAULT_OLLAMA_HOST = "http://localhost:11434"
+DEFAULT_PROFILE_ID = "local_qwen3_vl_quality"
+DEFAULT_OLLAMA_PROVIDER_ID = "ollama_local"
+DEFAULT_OLLAMA_MODEL = "qwen3-vl:30b"

toposync_ext_ai-0.1.0/src/toposync_ext_ai/extension.json

@@ -0,0 +1,13 @@
+{
+  "schema_version": 1,
+  "id": "com.toposync.ai",
+  "name": "AI",
+  "version": "0.1.0",
+  "requires_core_version": ">=0.3.6",
+  "frontend": {
+    "kind": "module-federation",
+    "remote_entry": "remoteEntry.js",
+    "scope": "ai",
+    "module": "./activate"
+  }
+}

toposync_ext_ai-0.1.0/src/toposync_ext_ai/pipelines/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .operators import register_ai_pipeline_operators
+
+__all__ = ["register_ai_pipeline_operators"]

toposync_ext_ai-0.1.0/src/toposync_ext_ai/pipelines/image_utils.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def image_size(image: Any) -> tuple[int, int] | None:
+    shape = getattr(image, "shape", None)
+    if shape and len(shape) >= 2:
+        try:
+            return int(shape[1]), int(shape[0])
+        except Exception:
+            return None
+    size = getattr(image, "size", None)
+    if isinstance(size, tuple) and len(size) >= 2:
+        try:
+            return int(size[0]), int(size[1])
+        except Exception:
+            return None
+    return None
+
+
+def normalize_bbox01(value: Any) -> tuple[float, float, float, float] | None:
+    if not isinstance(value, (list, tuple)) or len(value) < 4:
+        return None
+    try:
+        x1, y1, x2, y2 = [float(value[i]) for i in range(4)]
+    except Exception:
+        return None
+    x1 = max(0.0, min(1.0, x1))
+    y1 = max(0.0, min(1.0, y1))
+    x2 = max(0.0, min(1.0, x2))
+    y2 = max(0.0, min(1.0, y2))
+    if x2 <= x1 or y2 <= y1:
+        return None
+    return x1, y1, x2, y2
+
+
+def expand_bbox01(
+    bbox01: tuple[float, float, float, float],
+    *,
+    padding_ratio: float,
+) -> tuple[float, float, float, float]:
+    x1, y1, x2, y2 = bbox01
+    pad = max(0.0, float(padding_ratio or 0.0))
+    if pad <= 0:
+        return bbox01
+    width = max(0.0, x2 - x1)
+    height = max(0.0, y2 - y1)
+    px = width * pad
+    py = height * pad
+    return (
+        max(0.0, x1 - px),
+        max(0.0, y1 - py),
+        min(1.0, x2 + px),
+        min(1.0, y2 + py),
+    )
+
+
+def bbox01_to_px(
+    bbox01: tuple[float, float, float, float],
+    *,
+    width: int,
+    height: int,
+) -> tuple[int, int, int, int]:
+    x1, y1, x2, y2 = bbox01
+    left = int(round(max(0.0, min(1.0, x1)) * width))
+    top = int(round(max(0.0, min(1.0, y1)) * height))
+    right = int(round(max(0.0, min(1.0, x2)) * width))
+    bottom = int(round(max(0.0, min(1.0, y2)) * height))
+    right = max(left + 1, min(width, right))
+    bottom = max(top + 1, min(height, bottom))
+    return left, top, right, bottom
+
+
+def crop_bbox01(
+    image: Any,
+    *,
+    bbox01: tuple[float, float, float, float],
+    min_crop_size_px: int,
+) -> Any | None:
+    size = image_size(image)
+    if size is None:
+        return None
+    width, height = size
+    if width <= 1 or height <= 1:
+        return None
+    left, top, right, bottom = bbox01_to_px(bbox01, width=width, height=height)
+    if (right - left) < int(min_crop_size_px) or (bottom - top) < int(min_crop_size_px):
+        return None
+
+    if hasattr(image, "crop") and callable(image.crop):
+        return image.crop((left, top, right, bottom))
+
+    try:
+        cropped = image[top:bottom, left:right]
+    except Exception:
+        return None
+    copy = getattr(cropped, "copy", None)
+    if callable(copy):
+        try:
+            return copy()
+        except Exception:
+            return cropped
+    return cropped

toposync_ext_ai-0.1.0/src/toposync_ext_ai/pipelines/operators.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any
+
+from toposync.runtime.pipelines.operator_registry import OperatorRegistry, payload_path_hint
+
+from toposync_ext_ai.constants import EXTENSION_ID
+
+from .runtime import AiConditionFilterRuntime, AiSmartCropRuntime
+from .schemas import AiConditionFilterConfig, AiSmartCropConfig
+
+
+def _ai_expression_hints(*, task: str) -> list[Any]:
+    hints: list[Any] = [
+        payload_path_hint("payload.ai", value_type="object", description="AI annotations attached to the packet."),
+    ]
+    if task == "smart_crop":
+        hints.extend(
+            [
+                payload_path_hint("payload.ai.smart_crop", value_type="object", description="AI smart-crop result."),
+                payload_path_hint("payload.ai.smart_crop.status", value_type="string", description="Smart-crop status."),
+                payload_path_hint("payload.ai.smart_crop.confidence", value_type="number", description="AI region confidence."),
+                payload_path_hint("payload.ai.smart_crop.bbox01", value_type="array", description="Detected normalized region."),
+                payload_path_hint("payload.ai.smart_crop.detections", value_type="array", description="All AI detections used by the smart crop."),
+                payload_path_hint("payload.ai.smart_crop.selected_detection", value_type="object", description="Detection selected by the crop strategy."),
+                payload_path_hint("payload.object_bbox01", value_type="array", description="Primary AI-detected bbox."),
+                payload_path_hint("payload.object_confidence", value_type="number", description="Primary AI-detected confidence."),
+                payload_path_hint("payload.object_category_label", value_type="string", description="Primary AI target label."),
+                payload_path_hint("payload.frame_crop", value_type="object", description="Applied frame crop metadata."),
+            ]
+        )
+    if task == "condition_filter":
+        hints.extend(
+            [
+                payload_path_hint(
+                    "payload.ai.condition_filter",
+                    value_type="object",
+                    description="AI condition-filter result.",
+                ),
+                payload_path_hint(
+                    "payload.ai.condition_filter.matches",
+                    value_type="boolean",
+                    description="Whether the AI condition matched.",
+                ),
+                payload_path_hint(
+                    "payload.ai.condition_filter.confidence",
+                    value_type="number",
+                    description="AI condition confidence.",
+                ),
+            ]
+        )
+    return hints
+
+
+def register_ai_pipeline_operators(registry: OperatorRegistry) -> None:
+    if registry.get("ai.smart_crop") is None:
+        registry.register_operator(
+            operator_id="ai.smart_crop",
+            description=(
+                "AI-guided image crop. Locates a region from a text description, emits a crop artifact, "
+                "and exposes object_bbox01/object_confidence for downstream camera and filter operators."
+            ),
+            config_model=AiSmartCropConfig,
+            inputs=[{"name": "in", "required": True}],
+            outputs=[{"name": "out"}],
+            capabilities=["ai", "vision", "crop", "heavy_compute"],
+            defaults=AiSmartCropConfig().model_dump(),
+            execution_mode="in_event_loop",
+            max_concurrency=1,
+            requires_artifacts=["frame_original"],
+            produces_payload_keys=[
+                "ai",
+                "object_bbox01",
+                "object_confidence",
+                "object_category_label",
+                "detected_object",
+                "detected_objects",
+                "frame_crop",
+            ],
+            produces_artifacts=["ai_crop"],
+            input_modalities=["image"],
+            output_modalities=["image"],
+            expression_hints=_ai_expression_hints(task="smart_crop"),
+            share_strategy="never",
+            owner=EXTENSION_ID,
+            runtime_factory=lambda config, deps: AiSmartCropRuntime(config, deps),
+        )
+
+    if registry.get("ai.condition_filter") is None:
+        registry.register_operator(
+            operator_id="ai.condition_filter",
+            description=(
+                "AI visual condition filter. Evaluates a text condition against the frame and emits only "
+                "matching packets, attaching boolean/confidence metadata."
+            ),
+            config_model=AiConditionFilterConfig,
+            inputs=[{"name": "in", "required": True}],
+            outputs=[{"name": "out"}],
+            capabilities=["ai", "vision", "filter", "heavy_compute"],
+            defaults=AiConditionFilterConfig().model_dump(),
+            execution_mode="in_event_loop",
+            max_concurrency=1,
+            requires_artifacts=["frame_original"],
+            produces_payload_keys=["ai"],
+            input_modalities=["image"],
+            output_modalities=["image"],
+            expression_hints=_ai_expression_hints(task="condition_filter"),
+            share_strategy="never",
+            owner=EXTENSION_ID,
+            runtime_factory=lambda config, deps: AiConditionFilterRuntime(config, deps),
+        )