trigix-node-sdk 0.1.0__tar.gz

trigix_node_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 北京祺智科技有限公司
+
+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.

trigix_node_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: trigix-node-sdk
+Version: 0.1.0
+Summary: Write and serve custom Trigix workflow nodes over HTTP.
+Author-email: 北京祺智科技有限公司 <managecode@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/bj-qizhi/trigix
+Project-URL: Repository, https://github.com/bj-qizhi/trigix
+Project-URL: Documentation, https://github.com/bj-qizhi/trigix/tree/master/sdk/python
+Keywords: trigix,workflow,automation,nodes,sdk,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: httpx>=0.27.0; extra == "test"
+Dynamic: license-file
+
+# Trigix Node SDK (Python)
+
+Write a custom Trigix workflow node as a Python function and serve it over HTTP.
+No changes to the Trigix executor are required — the executor calls your node
+like any other.
+
+## Quick start
+
+```bash
+pip install trigix-node-sdk
+# or from this repo: pip install -e sdk/python
+uvicorn examples.greeter:app --port 9000
+```
+
+```python
+from trigix_node_sdk import node, create_app
+
+@node(slug="greet", label="Greeter",
+      config_schema={"type": "object",
+                     "properties": {"name": {"type": "string"}}})
+def greet(config, input, node_outputs):
+    name = config.get("name") or input.get("name", "world")
+    return {"greeting": f"Hello, {name}!"}
+
+app = create_app()
+```
+
+Then in Trigix → **Custom Nodes**, register:
+- **slug**: `greet`
+- **endpoint**: `http://your-host:9000/nodes/greet`
+- **config schema**: copy from `GET /manifest`
+
+Add a **Custom** node to a workflow, pick `greet`, and it runs your code.
+
+## The contract
+
+The executor POSTs to `/nodes/<slug>`:
+
+```json
+{ "node_id": "n1", "config": { "name": "Ada" },
+  "input_json": "{\"...\":\"...\"}", "node_outputs": { "prev": "{...}" } }
+```
+
+Your handler `def handler(config, input, node_outputs) -> dict` receives the
+parsed `input` and returns a JSON-serializable dict. The server wraps it as:
+
+```json
+{ "output_json": "{\"greeting\":\"Hello, Ada!\"}" }
+```
+
+Downstream nodes reference your output via `{{node_id.field}}`.
+
+## Discovery
+
+`GET /manifest` lists every registered node (slug, label, description,
+config schema, endpoint) so it can be registered in Trigix in one step.
+
+## Security
+
+Custom nodes run in your own process, isolated from the Trigix core. Run the
+node service on a trusted network; the executor reaches it by URL. (WASM-based
+in-process isolation for untrusted nodes is a planned future option.)

trigix_node_sdk-0.1.0/README.md

@@ -0,0 +1,62 @@
+# Trigix Node SDK (Python)
+
+Write a custom Trigix workflow node as a Python function and serve it over HTTP.
+No changes to the Trigix executor are required — the executor calls your node
+like any other.
+
+## Quick start
+
+```bash
+pip install trigix-node-sdk
+# or from this repo: pip install -e sdk/python
+uvicorn examples.greeter:app --port 9000
+```
+
+```python
+from trigix_node_sdk import node, create_app
+
+@node(slug="greet", label="Greeter",
+      config_schema={"type": "object",
+                     "properties": {"name": {"type": "string"}}})
+def greet(config, input, node_outputs):
+    name = config.get("name") or input.get("name", "world")
+    return {"greeting": f"Hello, {name}!"}
+
+app = create_app()
+```
+
+Then in Trigix → **Custom Nodes**, register:
+- **slug**: `greet`
+- **endpoint**: `http://your-host:9000/nodes/greet`
+- **config schema**: copy from `GET /manifest`
+
+Add a **Custom** node to a workflow, pick `greet`, and it runs your code.
+
+## The contract
+
+The executor POSTs to `/nodes/<slug>`:
+
+```json
+{ "node_id": "n1", "config": { "name": "Ada" },
+  "input_json": "{\"...\":\"...\"}", "node_outputs": { "prev": "{...}" } }
+```
+
+Your handler `def handler(config, input, node_outputs) -> dict` receives the
+parsed `input` and returns a JSON-serializable dict. The server wraps it as:
+
+```json
+{ "output_json": "{\"greeting\":\"Hello, Ada!\"}" }
+```
+
+Downstream nodes reference your output via `{{node_id.field}}`.
+
+## Discovery
+
+`GET /manifest` lists every registered node (slug, label, description,
+config schema, endpoint) so it can be registered in Trigix in one step.
+
+## Security
+
+Custom nodes run in your own process, isolated from the Trigix core. Run the
+node service on a trusted network; the executor reaches it by URL. (WASM-based
+in-process isolation for untrusted nodes is a planned future option.)

trigix_node_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trigix-node-sdk"
+version = "0.1.0"
+description = "Write and serve custom Trigix workflow nodes over HTTP."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "北京祺智科技有限公司", email = "managecode@gmail.com" }]
+keywords = ["trigix", "workflow", "automation", "nodes", "sdk", "ai"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = [
+    "fastapi>=0.115.0",
+    "pydantic>=2.0.0",
+    "uvicorn[standard]>=0.30.0",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8.0.0", "httpx>=0.27.0"]
+
+[project.urls]
+Homepage = "https://github.com/bj-qizhi/trigix"
+Repository = "https://github.com/bj-qizhi/trigix"
+Documentation = "https://github.com/bj-qizhi/trigix/tree/master/sdk/python"
+
+[tool.setuptools]
+packages = ["trigix_node_sdk"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

trigix_node_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trigix_node_sdk-0.1.0/tests/test_sdk.py

@@ -0,0 +1,58 @@
+# Copyright © 2026 北京祺智科技有限公司. All rights reserved.
+# https://www.qzso.com/ · managecode@gmail.com
+
+import json
+
+from fastapi.testclient import TestClient
+
+from trigix_node_sdk import create_app, node, run_node
+
+
+@node(slug="upper", label="Uppercase", config_schema={"type": "object"})
+def upper(config, input, node_outputs):
+    return {"out": str(input.get("text", "")).upper()}
+
+
+def test_run_node_parses_input_and_returns_output_json():
+    out = run_node("upper", {}, json.dumps({"text": "hi"}), {})
+    assert json.loads(out) == {"out": "HI"}
+
+
+def test_run_node_tolerates_bad_input_json():
+    out = run_node("upper", {}, "not json", {})
+    assert json.loads(out) == {"out": ""}
+
+
+def test_http_contract_matches_executor():
+    client = TestClient(create_app("http://node:9000"))
+
+    # manifest lists the node with its endpoint
+    manifest = client.get("/manifest").json()
+    slugs = {n["slug"]: n for n in manifest["nodes"]}
+    assert "upper" in slugs
+    assert slugs["upper"]["endpoint"] == "http://node:9000/nodes/upper"
+
+    # the executor contract: {node_id, config, input_json, node_outputs} -> {output_json}
+    resp = client.post(
+        "/nodes/upper",
+        json={"node_id": "n1", "config": {}, "input_json": json.dumps({"text": "abc"}), "node_outputs": {}},
+    )
+    assert resp.status_code == 200
+    assert json.loads(resp.json()["output_json"]) == {"out": "ABC"}
+
+
+def test_unknown_node_returns_404():
+    client = TestClient(create_app())
+    resp = client.post("/nodes/ghost", json={"input_json": "{}"})
+    assert resp.status_code == 404
+
+
+def test_handler_error_returns_500():
+    @node(slug="boom")
+    def boom(config, input, node_outputs):
+        raise ValueError("kaboom")
+
+    client = TestClient(create_app())
+    resp = client.post("/nodes/boom", json={"input_json": "{}"})
+    assert resp.status_code == 500
+    assert "kaboom" in resp.json()["detail"]

trigix_node_sdk-0.1.0/trigix_node_sdk/__init__.py

@@ -0,0 +1,129 @@
+# Copyright © 2026 北京祺智科技有限公司. All rights reserved.
+# https://www.qzso.com/ · managecode@gmail.com
+
+"""Trigix custom node SDK.
+
+Write a workflow node as a plain Python function and serve it over HTTP — no
+changes to the Trigix executor required. Register the node's endpoint in Trigix
+(Custom Nodes settings) and it appears in the workflow editor.
+
+    from trigix_node_sdk import node, create_app
+
+    @node(slug="greet", label="Greeter",
+          config_schema={"type": "object",
+                         "properties": {"name": {"type": "string"}}})
+    def greet(config, input, node_outputs):
+        name = config.get("name") or input.get("name", "world")
+        return {"greeting": f"Hello, {name}!"}
+
+    app = create_app()        # uvicorn module:app --port 9000
+
+The node contract (matches the executor): the runtime POSTs
+``{node_id, config, input_json, node_outputs}`` to ``/nodes/<slug>`` and expects
+``{output_json}``. Your handler receives the parsed ``input`` dict and returns a
+JSON-serializable dict.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from pydantic import BaseModel
+
+Handler = Callable[[dict, dict, dict], Any]
+
+
+class NodeRequest(BaseModel):
+    node_id: str = ""
+    config: dict = {}
+    input_json: str = "{}"
+    node_outputs: dict = {}
+
+
+@dataclass
+class NodeDef:
+    slug: str
+    label: str
+    description: str
+    config_schema: dict
+    handler: Handler
+
+
+_REGISTRY: dict[str, NodeDef] = {}
+
+
+def node(
+    slug: str,
+    label: str | None = None,
+    description: str = "",
+    config_schema: dict | None = None,
+) -> Callable[[Handler], Handler]:
+    """Register a function as a Trigix custom node."""
+
+    def decorator(fn: Handler) -> Handler:
+        _REGISTRY[slug] = NodeDef(
+            slug=slug,
+            label=label or slug,
+            description=description,
+            config_schema=config_schema or {"type": "object"},
+            handler=fn,
+        )
+        return fn
+
+    return decorator
+
+
+def registry() -> dict[str, NodeDef]:
+    return dict(_REGISTRY)
+
+
+def run_node(slug: str, config: dict, input_json: str, node_outputs: dict) -> str:
+    """Execute a registered node and return its ``output_json``. Raises
+    KeyError for an unknown slug."""
+    nd = _REGISTRY[slug]
+    try:
+        input_data = json.loads(input_json or "{}")
+    except (json.JSONDecodeError, TypeError):
+        input_data = {}
+    result = nd.handler(config or {}, input_data, node_outputs or {})
+    return json.dumps(result)
+
+
+def create_app(base_url: str = ""):
+    """Build a FastAPI app serving every registered node plus a discovery
+    manifest. `base_url` is prefixed to the endpoint URLs in the manifest."""
+    from fastapi import FastAPI, HTTPException
+
+    app = FastAPI(title="Trigix Custom Nodes")
+
+    @app.get("/healthz")
+    def healthz() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.get("/manifest")
+    def manifest() -> dict[str, list[dict]]:
+        return {
+            "nodes": [
+                {
+                    "slug": d.slug,
+                    "label": d.label,
+                    "description": d.description,
+                    "config_schema": d.config_schema,
+                    "endpoint": f"{base_url}/nodes/{d.slug}",
+                }
+                for d in _REGISTRY.values()
+            ]
+        }
+
+    @app.post("/nodes/{slug}")
+    def run(slug: str, req: NodeRequest) -> dict[str, str]:
+        if slug not in _REGISTRY:
+            raise HTTPException(status_code=404, detail=f"unknown node '{slug}'")
+        try:
+            return {"output_json": run_node(slug, req.config, req.input_json, req.node_outputs)}
+        except Exception as exc:  # surface handler errors as 500
+            raise HTTPException(status_code=500, detail=f"node '{slug}' failed: {exc}") from exc
+
+    return app

trigix_node_sdk-0.1.0/trigix_node_sdk.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: trigix-node-sdk
+Version: 0.1.0
+Summary: Write and serve custom Trigix workflow nodes over HTTP.
+Author-email: 北京祺智科技有限公司 <managecode@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/bj-qizhi/trigix
+Project-URL: Repository, https://github.com/bj-qizhi/trigix
+Project-URL: Documentation, https://github.com/bj-qizhi/trigix/tree/master/sdk/python
+Keywords: trigix,workflow,automation,nodes,sdk,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: httpx>=0.27.0; extra == "test"
+Dynamic: license-file
+
+# Trigix Node SDK (Python)
+
+Write a custom Trigix workflow node as a Python function and serve it over HTTP.
+No changes to the Trigix executor are required — the executor calls your node
+like any other.
+
+## Quick start
+
+```bash
+pip install trigix-node-sdk
+# or from this repo: pip install -e sdk/python
+uvicorn examples.greeter:app --port 9000
+```
+
+```python
+from trigix_node_sdk import node, create_app
+
+@node(slug="greet", label="Greeter",
+      config_schema={"type": "object",
+                     "properties": {"name": {"type": "string"}}})
+def greet(config, input, node_outputs):
+    name = config.get("name") or input.get("name", "world")
+    return {"greeting": f"Hello, {name}!"}
+
+app = create_app()
+```
+
+Then in Trigix → **Custom Nodes**, register:
+- **slug**: `greet`
+- **endpoint**: `http://your-host:9000/nodes/greet`
+- **config schema**: copy from `GET /manifest`
+
+Add a **Custom** node to a workflow, pick `greet`, and it runs your code.
+
+## The contract
+
+The executor POSTs to `/nodes/<slug>`:
+
+```json
+{ "node_id": "n1", "config": { "name": "Ada" },
+  "input_json": "{\"...\":\"...\"}", "node_outputs": { "prev": "{...}" } }
+```
+
+Your handler `def handler(config, input, node_outputs) -> dict` receives the
+parsed `input` and returns a JSON-serializable dict. The server wraps it as:
+
+```json
+{ "output_json": "{\"greeting\":\"Hello, Ada!\"}" }
+```
+
+Downstream nodes reference your output via `{{node_id.field}}`.
+
+## Discovery
+
+`GET /manifest` lists every registered node (slug, label, description,
+config schema, endpoint) so it can be registered in Trigix in one step.
+
+## Security
+
+Custom nodes run in your own process, isolated from the Trigix core. Run the
+node service on a trusted network; the executor reaches it by URL. (WASM-based
+in-process isolation for untrusted nodes is a planned future option.)

trigix_node_sdk-0.1.0/trigix_node_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_sdk.py
+trigix_node_sdk/__init__.py
+trigix_node_sdk.egg-info/PKG-INFO
+trigix_node_sdk.egg-info/SOURCES.txt
+trigix_node_sdk.egg-info/dependency_links.txt
+trigix_node_sdk.egg-info/requires.txt
+trigix_node_sdk.egg-info/top_level.txt

trigix_node_sdk-0.1.0/trigix_node_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trigix_node_sdk-0.1.0/trigix_node_sdk.egg-info/requires.txt

@@ -0,0 +1,7 @@
+fastapi>=0.115.0
+pydantic>=2.0.0
+uvicorn[standard]>=0.30.0
+
+[test]
+pytest>=8.0.0
+httpx>=0.27.0

trigix_node_sdk-0.1.0/trigix_node_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+trigix_node_sdk