machinaos 0.0.78 → 0.0.80

package/server/nodes/document/{embedding_generator.py → embedding_generator/__init__.py}

@@ -21,7 +21,9 @@ class EmbeddingGeneratorParams(BaseModel):
         description="Model name (provider-specific). HuggingFace: BAAI/bge-*. OpenAI: text-embedding-3-small.",
     )
     batch_size: int = Field(
-        default=32, ge=1, le=256,
+        default=32,
+        ge=1,
+        le=256,
         description="Number of texts per embedding batch.",
     )
     api_key: str = Field(
@@ -73,26 +75,31 @@ class EmbeddingGeneratorNode(ActionNode):
 
         if not chunks:
             return EmbeddingGeneratorOutput(
-                embeddings=[], embedding_count=0, dimensions=0, chunks=[],
-                provider=provider, model=model,
+                embeddings=[],
+                embedding_count=0,
+                dimensions=0,
+                chunks=[],
+                provider=provider,
+                model=model,
             )
 
-        texts = [c.get('content', '') if isinstance(c, dict) else str(c) for c in chunks]
+        texts = [c.get("content", "") if isinstance(c, dict) else str(c) for c in chunks]
 
-        if provider == 'huggingface':
+        if provider == "huggingface":
             try:
                 from langchain_huggingface import HuggingFaceEmbeddings
             except ImportError:
                 raise NodeUserError(
-                    "HuggingFace embeddings unavailable. "
-                    "pip install langchain-huggingface sentence-transformers",
+                    "HuggingFace embeddings unavailable. " "pip install langchain-huggingface sentence-transformers",
                 )
             embedder = HuggingFaceEmbeddings(model_name=model)
-        elif provider == 'openai':
+        elif provider == "openai":
             from langchain_openai import OpenAIEmbeddings
+
             embedder = OpenAIEmbeddings(model=model, api_key=api_key)
-        elif provider == 'ollama':
+        elif provider == "ollama":
             from langchain_ollama import OllamaEmbeddings
+
             embedder = OllamaEmbeddings(model=model)
         else:
             raise NodeUserError(f"Unknown provider: {provider}")

package/server/nodes/document/embedding_generator/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#bd93f9"
+}

package/server/nodes/document/{file_downloader.py → file_downloader/__init__.py}

@@ -56,17 +56,21 @@ class FileDownloaderNode(ActionNode):
     @Operation("download")
     async def download(self, ctx: NodeContext, params: FileDownloaderParams) -> FileDownloaderOutput:
         p = params.model_dump()
-        items = p.get('items') or [{'url': u} for u in p.get('urls', [])]
-        workspace_dir = ctx.raw.get('workspace_dir', '')
-        default_dir = str(Path(workspace_dir) / 'downloads') if workspace_dir else p.get('outputDir', 'downloads')
-        output_dir = Path(p.get('outputDir') or default_dir)
-        max_workers = int(p.get('maxWorkers', 8))
-        skip_existing = p.get('skipExisting', True)
-        timeout = float(p.get('timeout', 60))
+        items = p.get("items") or [{"url": u} for u in p.get("urls", [])]
+        workspace_dir = ctx.raw.get("workspace_dir", "")
+        default_dir = str(Path(workspace_dir) / "downloads") if workspace_dir else p.get("outputDir", "downloads")
+        output_dir = Path(p.get("outputDir") or default_dir)
+        max_workers = int(p.get("maxWorkers", 8))
+        skip_existing = p.get("skipExisting", True)
+        timeout = float(p.get("timeout", 60))
 
         if not items:
             return FileDownloaderOutput(
-                downloaded=0, skipped=0, failed=0, files=[], output_dir=str(output_dir),
+                downloaded=0,
+                skipped=0,
+                failed=0,
+                files=[],
+                output_dir=str(output_dir),
             )
 
         output_dir.mkdir(parents=True, exist_ok=True)
@@ -74,38 +78,44 @@ class FileDownloaderNode(ActionNode):
 
         async def dl(item):
             async with semaphore:
-                url = item.get('url', '') if isinstance(item, dict) else str(item)
+                url = item.get("url", "") if isinstance(item, dict) else str(item)
                 if not url:
-                    return {'status': 'failed', 'error': 'Empty URL'}
-                filename = unquote(Path(urlparse(url).path).name or 'download')
+                    return {"status": "failed", "error": "Empty URL"}
+                filename = unquote(Path(urlparse(url).path).name or "download")
                 file_path = output_dir / filename
                 if skip_existing and file_path.exists():
-                    return {'status': 'skipped', 'path': str(file_path), 'url': url}
+                    return {"status": "skipped", "path": str(file_path), "url": url}
                 try:
                     async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
                         resp = await client.get(url)
                         resp.raise_for_status()
                         file_path.write_bytes(resp.content)
                         return {
-                            'status': 'downloaded', 'path': str(file_path),
-                            'url': url, 'size': len(resp.content), 'filename': filename,
+                            "status": "downloaded",
+                            "path": str(file_path),
+                            "url": url,
+                            "size": len(resp.content),
+                            "filename": filename,
                         }
                 except Exception as e:
-                    return {'status': 'failed', 'url': url, 'error': str(e)}
+                    return {"status": "failed", "url": url, "error": str(e)}
 
         results = await asyncio.gather(*[dl(i) for i in items], return_exceptions=True)
         downloaded, skipped, failed = [], [], []
         for r in results:
             if isinstance(r, Exception):
-                failed.append({'error': str(r)})
-            elif r.get('status') == 'downloaded':
+                failed.append({"error": str(r)})
+            elif r.get("status") == "downloaded":
                 downloaded.append(r)
-            elif r.get('status') == 'skipped':
+            elif r.get("status") == "skipped":
                 skipped.append(r)
             else:
                 failed.append(r)
 
         return FileDownloaderOutput(
-            downloaded=len(downloaded), skipped=len(skipped), failed=len(failed),
-            files=downloaded, output_dir=str(output_dir),
+            downloaded=len(downloaded),
+            skipped=len(skipped),
+            failed=len(failed),
+            files=downloaded,
+            output_dir=str(output_dir),
         )

package/server/nodes/document/file_downloader/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#bd93f9"
+}

package/server/nodes/document/{http_scraper.py → http_scraper/__init__.py}

@@ -58,17 +58,21 @@ class HttpScraperParams(BaseModel):
 
     # Page-mode fields
     start_page: int = Field(
-        default=1, ge=1,
+        default=1,
+        ge=1,
         description="First page number.",
         json_schema_extra={"displayOptions": {"show": {"iteration_mode": ["page"]}}},
     )
     end_page: int = Field(
-        default=10, ge=1,
+        default=10,
+        ge=1,
         description="Last page number (inclusive).",
         json_schema_extra={"displayOptions": {"show": {"iteration_mode": ["page"]}}},
     )
     max_pages: int = Field(
-        default=10, ge=1, le=1000,
+        default=10,
+        ge=1,
+        le=1000,
         description="Safety cap on pages fetched.",
     )
 
@@ -92,7 +96,8 @@ class HttpScraperParams(BaseModel):
         json_schema_extra={"displayOptions": {"show": {"use_proxy": [True]}}},
     )
     sticky_duration: int = Field(
-        default=600, ge=1,
+        default=600,
+        ge=1,
         json_schema_extra={
             "displayOptions": {"show": {"use_proxy": [True], "session_type": ["sticky"]}},
         },
@@ -134,26 +139,28 @@ class HttpScraperNode(ActionNode):
 
         iteration_mode = params.iteration_mode
         link_selector = params.link_selector or 'a[href$=".pdf"]'
-        headers_str = params.headers or '{}'
+        headers_str = params.headers or "{}"
         headers = json.loads(headers_str) if isinstance(headers_str, str) and headers_str else {}
 
         urls_to_fetch = []
-        if iteration_mode == 'date':
+        if iteration_mode == "date":
             if not params.start_date or not params.end_date:
                 raise NodeUserError("start_date/end_date required for date mode")
-            placeholder = params.date_placeholder or '{date}'
+            placeholder = params.date_placeholder or "{date}"
             start = datetime.strptime(params.start_date, "%Y-%m-%d")
             end = datetime.strptime(params.end_date, "%Y-%m-%d")
             current = start
             while current <= end:
-                urls_to_fetch.append((
-                    url.replace(placeholder, current.strftime("%Y-%m-%d")),
-                    {'date': current.isoformat()},
-                ))
+                urls_to_fetch.append(
+                    (
+                        url.replace(placeholder, current.strftime("%Y-%m-%d")),
+                        {"date": current.isoformat()},
+                    )
+                )
                 current += timedelta(days=1)
-        elif iteration_mode == 'page':
+        elif iteration_mode == "page":
             for page in range(params.start_page, params.end_page + 1):
-                urls_to_fetch.append((url.replace('{page}', str(page)), {'page': page}))
+                urls_to_fetch.append((url.replace("{page}", str(page)), {"page": page}))
         else:
             urls_to_fetch.append((url, {}))
 
@@ -161,6 +168,7 @@ class HttpScraperNode(ActionNode):
         if params.use_proxy:
             try:
                 from services.proxy.service import get_proxy_service
+
                 proxy_svc = get_proxy_service()
                 if proxy_svc and proxy_svc.is_enabled():
                     proxy_url = await proxy_svc.get_proxy_url(url, params.model_dump())
@@ -177,16 +185,18 @@ class HttpScraperNode(ActionNode):
                 try:
                     response = await client.get(fetch_url, headers=headers)
                     response.raise_for_status()
-                    soup = BeautifulSoup(response.text, 'html.parser')
+                    soup = BeautifulSoup(response.text, "html.parser")
                     for el in soup.select(link_selector):
-                        href = el.get('href', '')
+                        href = el.get("href", "")
                         if href:
-                            items.append({
-                                'url': urljoin(fetch_url, href),
-                                'text': el.get_text(strip=True),
-                                'source_url': fetch_url,
-                                **meta,
-                            })
+                            items.append(
+                                {
+                                    "url": urljoin(fetch_url, href),
+                                    "text": el.get_text(strip=True),
+                                    "source_url": fetch_url,
+                                    **meta,
+                                }
+                            )
                 except Exception as e:
                     errors.append(f"{fetch_url}: {e}")
 

package/server/nodes/document/http_scraper/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#bd93f9"
+}

package/server/nodes/document/{text_chunker.py → text_chunker/__init__.py}

@@ -45,33 +45,38 @@ class TextChunkerNode(ActionNode):
     @Operation("chunk")
     async def chunk(self, ctx: NodeContext, params: TextChunkerParams) -> TextChunkerOutput:
         from langchain_text_splitters import (
-            MarkdownTextSplitter, RecursiveCharacterTextSplitter,
+            MarkdownTextSplitter,
+            RecursiveCharacterTextSplitter,
         )
 
         p = params.model_dump()
-        documents = p.get('documents') or ([{'content': p.get('text', '')}] if p.get('text') else [])
-        chunk_size = int(p.get('chunkSize', 1000))
-        chunk_overlap = int(p.get('chunkOverlap') or p.get('overlap', 200))
-        strategy = p.get('strategy', 'recursive')
+        documents = p.get("documents") or ([{"content": p.get("text", "")}] if p.get("text") else [])
+        chunk_size = int(p.get("chunkSize", 1000))
+        chunk_overlap = int(p.get("chunkOverlap") or p.get("overlap", 200))
+        strategy = p.get("strategy", "recursive")
 
         if not documents:
             return TextChunkerOutput(chunks=[], chunk_count=0)
 
-        if strategy == 'markdown':
+        if strategy == "markdown":
             splitter = MarkdownTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
         else:
             splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
 
         chunks = []
         for doc in documents:
-            content = doc.get('content', '') if isinstance(doc, dict) else str(doc)
-            source = doc.get('source', 'input') if isinstance(doc, dict) else 'input'
+            content = doc.get("content", "") if isinstance(doc, dict) else str(doc)
+            source = doc.get("source", "input") if isinstance(doc, dict) else "input"
             if not content:
                 continue
             for i, chunk_text in enumerate(splitter.split_text(content)):
-                chunks.append({
-                    'source': source, 'chunk_index': i,
-                    'content': chunk_text, 'length': len(chunk_text),
-                })
+                chunks.append(
+                    {
+                        "source": source,
+                        "chunk_index": i,
+                        "content": chunk_text,
+                        "length": len(chunk_text),
+                    }
+                )
 
         return TextChunkerOutput(chunks=chunks, chunk_count=len(chunks))

package/server/nodes/document/text_chunker/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#bd93f9"
+}

package/server/nodes/document/{vector_store.py → vector_store/__init__.py}

@@ -30,7 +30,9 @@ class VectorStoreParams(BaseModel):
         json_schema_extra={"displayOptions": {"show": {"operation": ["query"]}}},
     )
     top_k: int = Field(
-        default=5, ge=1, le=100,
+        default=5,
+        ge=1,
+        le=100,
         json_schema_extra={"displayOptions": {"show": {"operation": ["query"]}}},
     )
     ids: Optional[list] = Field(
@@ -72,48 +74,51 @@ async def _chroma_op(operation: str, params: Dict[str, Any], collection: str) ->
     except ImportError:
         raise NodeUserError("ChromaDB unavailable. pip install chromadb")
 
-    persist_dir = params.get('persist_dir', './data/vectors')
+    persist_dir = params.get("persist_dir", "./data/vectors")
     client = chromadb.PersistentClient(path=persist_dir)
     coll = client.get_or_create_collection(name=collection)
 
-    if operation == 'store':
-        embeddings = params.get('embeddings', [])
-        chunks = params.get('chunks', [])
+    if operation == "store":
+        embeddings = params.get("embeddings", [])
+        chunks = params.get("chunks", [])
         if not embeddings:
             return {"stored_count": 0, "collection_count": coll.count()}
         ids = [str(uuid.uuid4()) for _ in embeddings]
-        docs = [c.get('content', '') if isinstance(c, dict) else str(c) for c in chunks]
+        docs = [c.get("content", "") if isinstance(c, dict) else str(c) for c in chunks]
         while len(docs) < len(embeddings):
-            docs.append('')
+            docs.append("")
         metas = [
-            {'source': c.get('source', 'unknown'), 'chunk_index': c.get('chunk_index', i)}
-            if isinstance(c, dict) else {'source': 'input', 'chunk_index': i}
+            {"source": c.get("source", "unknown"), "chunk_index": c.get("chunk_index", i)}
+            if isinstance(c, dict)
+            else {"source": "input", "chunk_index": i}
             for i, c in enumerate(chunks)
         ]
         while len(metas) < len(embeddings):
-            metas.append({'source': 'unknown', 'chunk_index': len(metas)})
+            metas.append({"source": "unknown", "chunk_index": len(metas)})
         await asyncio.to_thread(coll.add, ids=ids, embeddings=embeddings, documents=docs, metadatas=metas)
         return {"stored_count": len(embeddings), "collection_count": coll.count()}
 
-    if operation == 'query':
-        query_emb = params.get('query_embedding', [])
-        top_k = int(params.get('top_k', 5))
+    if operation == "query":
+        query_emb = params.get("query_embedding", [])
+        top_k = int(params.get("top_k", 5))
         if not query_emb:
             return {"matches": []}
         results = coll.query(query_embeddings=[query_emb], n_results=top_k)
         matches = []
-        if results['ids'] and results['ids'][0]:
-            for i in range(len(results['ids'][0])):
-                matches.append({
-                    'id': results['ids'][0][i],
-                    'document': results['documents'][0][i] if results['documents'] else '',
-                    'metadata': results['metadatas'][0][i] if results['metadatas'] else {},
-                    'distance': results['distances'][0][i] if results.get('distances') else None,
-                })
+        if results["ids"] and results["ids"][0]:
+            for i in range(len(results["ids"][0])):
+                matches.append(
+                    {
+                        "id": results["ids"][0][i],
+                        "document": results["documents"][0][i] if results["documents"] else "",
+                        "metadata": results["metadatas"][0][i] if results["metadatas"] else {},
+                        "distance": results["distances"][0][i] if results.get("distances") else None,
+                    }
+                )
         return {"matches": matches}
 
-    if operation == 'delete':
-        ids = params.get('ids', [])
+    if operation == "delete":
+        ids = params.get("ids", [])
         if ids:
             await asyncio.to_thread(coll.delete, ids=ids)
         return {"deleted": True, "count": len(ids)}
@@ -128,12 +133,12 @@ async def _qdrant_op(operation: str, params: Dict[str, Any], collection: str) ->
     except ImportError:
         raise NodeUserError("Qdrant client unavailable. pip install qdrant-client")
 
-    url = params.get('qdrant_url', 'http://localhost:6333')
+    url = params.get("qdrant_url", "http://localhost:6333")
     client = QdrantClient(url=url)
 
-    if operation == 'store':
-        embeddings = params.get('embeddings', [])
-        chunks = params.get('chunks', [])
+    if operation == "store":
+        embeddings = params.get("embeddings", [])
+        chunks = params.get("chunks", [])
         if not embeddings:
             return {"stored_count": 0}
         vec_size = len(embeddings[0])
@@ -150,32 +155,35 @@ async def _qdrant_op(operation: str, params: Dict[str, Any], collection: str) ->
                 c = chunks[i]
                 if isinstance(c, dict):
                     payload = {
-                        'content': c.get('content', ''),
-                        'source': c.get('source', 'unknown'),
-                        'chunk_index': c.get('chunk_index', i),
+                        "content": c.get("content", ""),
+                        "source": c.get("source", "unknown"),
+                        "chunk_index": c.get("chunk_index", i),
                     }
                 else:
-                    payload = {'content': str(c), 'source': 'input', 'chunk_index': i}
+                    payload = {"content": str(c), "source": "input", "chunk_index": i}
             points.append(PointStruct(id=str(uuid.uuid4()), vector=emb, payload=payload))
         await asyncio.to_thread(client.upsert, collection_name=collection, points=points)
         return {"stored_count": len(embeddings)}
 
-    if operation == 'query':
-        query_emb = params.get('query_embedding', [])
-        top_k = int(params.get('top_k', 5))
+    if operation == "query":
+        query_emb = params.get("query_embedding", [])
+        top_k = int(params.get("top_k", 5))
         if not query_emb:
             return {"matches": []}
         results = await asyncio.to_thread(
-            client.search, collection_name=collection, query_vector=query_emb, limit=top_k,
+            client.search,
+            collection_name=collection,
+            query_vector=query_emb,
+            limit=top_k,
         )
-        return {"matches": [
-            {'id': str(r.id), 'document': r.payload.get('content', ''),
-             'metadata': r.payload, 'score': r.score}
-            for r in results
-        ]}
-
-    if operation == 'delete':
-        ids = params.get('ids', [])
+        return {
+            "matches": [
+                {"id": str(r.id), "document": r.payload.get("content", ""), "metadata": r.payload, "score": r.score} for r in results
+            ]
+        }
+
+    if operation == "delete":
+        ids = params.get("ids", [])
         if ids:
             await asyncio.to_thread(client.delete, collection_name=collection, points_selector=ids)
         return {"deleted": True, "count": len(ids)}
@@ -186,16 +194,16 @@ async def _qdrant_op(operation: str, params: Dict[str, Any], collection: str) ->
 async def _pinecone_op(operation: str, params: Dict[str, Any], collection: str) -> Dict[str, Any]:
     from pinecone import Pinecone
 
-    api_key = params.get('pinecone_api_key', '')
+    api_key = params.get("pinecone_api_key", "")
     if not api_key:
         raise NodeUserError("Pinecone API key required")
 
     pc = Pinecone(api_key=api_key)
     index = pc.Index(collection)
 
-    if operation == 'store':
-        embeddings = params.get('embeddings', [])
-        chunks = params.get('chunks', [])
+    if operation == "store":
+        embeddings = params.get("embeddings", [])
+        chunks = params.get("chunks", [])
         if not embeddings:
             return {"stored_count": 0}
         vectors = []
@@ -205,33 +213,41 @@ async def _pinecone_op(operation: str, params: Dict[str, Any], collection: str)
                 c = chunks[i]
                 if isinstance(c, dict):
                     meta = {
-                        'content': c.get('content', ''),
-                        'source': c.get('source', 'unknown'),
-                        'chunk_index': c.get('chunk_index', i),
+                        "content": c.get("content", ""),
+                        "source": c.get("source", "unknown"),
+                        "chunk_index": c.get("chunk_index", i),
                     }
                 else:
-                    meta = {'content': str(c), 'source': 'input', 'chunk_index': i}
-            vectors.append({'id': str(uuid.uuid4()), 'values': emb, 'metadata': meta})
+                    meta = {"content": str(c), "source": "input", "chunk_index": i}
+            vectors.append({"id": str(uuid.uuid4()), "values": emb, "metadata": meta})
         await asyncio.to_thread(index.upsert, vectors=vectors)
         return {"stored_count": len(embeddings)}
 
-    if operation == 'query':
-        query_emb = params.get('query_embedding', [])
-        top_k = int(params.get('top_k', 5))
+    if operation == "query":
+        query_emb = params.get("query_embedding", [])
+        top_k = int(params.get("top_k", 5))
         if not query_emb:
             return {"matches": []}
         results = await asyncio.to_thread(
-            index.query, vector=query_emb, top_k=top_k, include_metadata=True,
+            index.query,
+            vector=query_emb,
+            top_k=top_k,
+            include_metadata=True,
         )
-        return {"matches": [
-            {'id': m.id,
-             'document': m.metadata.get('content', '') if m.metadata else '',
-             'metadata': m.metadata or {}, 'score': m.score}
-            for m in results.matches
-        ]}
-
-    if operation == 'delete':
-        ids = params.get('ids', [])
+        return {
+            "matches": [
+                {
+                    "id": m.id,
+                    "document": m.metadata.get("content", "") if m.metadata else "",
+                    "metadata": m.metadata or {},
+                    "score": m.score,
+                }
+                for m in results.matches
+            ]
+        }
+
+    if operation == "delete":
+        ids = params.get("ids", [])
         if ids:
             await asyncio.to_thread(index.delete, ids=ids)
         return {"deleted": True, "count": len(ids)}
@@ -261,19 +277,19 @@ class VectorStoreNode(ActionNode):
         p = params.model_dump()
         operation = params.operation
         backend_raw = params.backend
-        backend = 'chroma' if backend_raw in ('chroma', 'chromadb') else backend_raw
+        backend = "chroma" if backend_raw in ("chroma", "chromadb") else backend_raw
         collection = params.collection_name
 
-        if backend == 'chroma':
+        if backend == "chroma":
             result = await _chroma_op(operation, p, collection)
-        elif backend == 'qdrant':
+        elif backend == "qdrant":
             result = await _qdrant_op(operation, p, collection)
-        elif backend == 'pinecone':
+        elif backend == "pinecone":
             result = await _pinecone_op(operation, p, collection)
         else:
             raise NodeUserError(f"Unknown backend: {backend_raw}")
 
-        result['backend'] = backend
-        result['collection_name'] = collection
-        result['operation'] = operation
+        result["backend"] = backend
+        result["collection_name"] = collection
+        result["operation"] = operation
         return VectorStoreOutput(**result)

package/server/nodes/document/vector_store/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#bd93f9"
+}

package/server/nodes/email/__init__.py

@@ -1,11 +1,18 @@
 """Plugins for the 'email' palette group.
 
-Self-registers the trigger filter builder for ``emailReceive`` so the
-central ``services/event_waiter.py`` carries no plugin-specific code.
+Self-registers:
+  - The trigger filter builder for ``emailReceive`` so
+    ``services/event_waiter.py`` carries no plugin-specific code.
+  - ``emailReceive`` into ``services.deployment.canary_registry`` so the
+    Temporal-durable ``TriggerListenerWorkflow`` path activates when
+    ``event_framework_enabled`` is on (default-true post-2026-05-15).
 """
 
+from services.deployment.canary_registry import register_canary_trigger_type
 from services.event_waiter import register_filter_builder
 
+from ._events import dispatch_email_received  # noqa: F401 — re-export
 from ._filters import build_filter as build_email_filter
 
 register_filter_builder("emailReceive", build_email_filter)
+register_canary_trigger_type("emailReceive", "com.machinaos.email.message.received")