dnotifier 1.0.0__tar.gz

dnotifier-1.0.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.venv/
+venv/
+publish_dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

dnotifier-1.0.0/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 1.0.0
+
+* Initial Python SDK release with feature parity to JS and Dart SDKs.
+* WebSocket and HTTP transport, binary framing, chunking, AI pipeline, RAG documents, chat history, session logging, and workflows.
+* Production endpoints at `api.dnotifier.com`.
+* Publish pipeline: minify + PyArmor obfuscation for PyPI distributions.

dnotifier-1.0.0/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) DNotifier. All rights reserved.
+
+This software and associated documentation files (the "Software") are the
+property of DNotifier. Unauthorized copying, modification, distribution, or
+use of the Software, in whole or in part, is strictly prohibited without
+express written permission from DNotifier.

dnotifier-1.0.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: dnotifier
+Version: 1.0.0
+Summary: Real-time notification and messaging SDK for Python. WebSocket & HTTP, auth, binary frames, AI, RAG, and workflows.
+Project-URL: Homepage, https://dnotifier.com
+Project-URL: Documentation, https://dnotifier.gitbook.io/product-docs
+Project-URL: Repository, https://github.com/smartguy6666/dnotifier-sdk
+Author: DNotifier
+License: Proprietary
+License-File: LICENSE
+Keywords: ai,dnotifier,messaging,notifications,rag,realtime,sdk,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pyarmor>=8.5; extra == 'dev'
+Requires-Dist: python-minifier>=2.9; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DNotifier Python SDK
+
+**DNotifier** is a real-time notification and messaging SDK for **Python 3.9+**. It supports **WebSocket** and **HTTP** transports, **binary streaming**, framed packets, an **AI pipeline**, **knowledge-base (RAG)** APIs, optional **session logging**, and **multi-step workflows** with agents and observability.
+
+---
+
+## Features
+
+- WebSocket and HTTP transport
+- Secure authentication handshake
+- Real-time messaging (text and binary)
+- Large payloads with automatic chunking and reassembly
+- AI: `send_ai`, `fetch_ai_history`, semantic `search`
+- Knowledge base: add, update, get, list, delete, and search documents
+- Chat history fetch and delete
+- Optional SDK session logging (`logs=True`)
+- Workflows: named agents, sequential pipelines, dashboard observability
+- Plan limits from auth (`get_plan_limits`)
+
+---
+
+## Installation
+
+```bash
+pip install dnotifier
+```
+
+---
+
+## Quick start
+
+```python
+import asyncio
+from dnotifier import DNotifier
+
+async def main():
+    notifier = DNotifier(
+        app_id="your-app-id",
+        secret="your-app-secret",
+        transport="ws",  # or "http"
+        user_id="user-123",
+        on_connected=lambda: print("Connected"),
+        on_message=lambda msg: print(msg.payload.to_json()),
+        on_disconnected=lambda **kw: print("Disconnected", kw),
+    )
+
+    await notifier.connect()
+
+    await notifier.send(
+        sender_id="user-123",
+        receiver_id="user-456",
+        data={"type": "text", "text": "Hello from DNotifier"},
+    )
+
+    await notifier.disconnect()
+
+asyncio.run(main())
+```
+
+---
+
+## Connection options
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `app_id` | `str` | Your DNotifier application id |
+| `secret` | `str` | Application secret |
+| `transport` | `"ws"` \| `"http"` | WebSocket for realtime; HTTP for RPC-style AI/RAG |
+| `user_id` | `str` | End-user or agent id for auth and routing |
+| `logs` | `bool` | Enable SDK session logging (default `False`) |
+| `url` | `str` | WebSocket URL override (default production `wss://api.dnotifier.com/ecs/ws`) |
+| `on_connected` | `callable` | Called after successful connect |
+| `on_message` | `callable` | Called for each incoming message |
+| `on_disconnected` | `callable` | Called on disconnect (`code`, `reason`) |
+
+---
+
+## API overview
+
+| Method | Description |
+|--------|-------------|
+| `connect()` | Authenticate and open transport |
+| `disconnect()` | Close WebSocket connection |
+| `send(...)` | Send realtime message |
+| `send_binary(...)` | Send binary payload (WebSocket) |
+| `send_ai(...)` | Send to AI pipeline |
+| `fetch_ai_history(...)` | Fetch AI conversation history |
+| `delete_ai_history_message(...)` | Delete one AI history entry |
+| `fetch_chat_history(...)` | Request chat history |
+| `delete_chat_history_message(...)` | Delete one chat message |
+| `search(...)` | Semantic / vector search |
+| `add_document(...)` | Add RAG document |
+| `update_document(...)` | Update RAG document |
+| `delete_document(...)` | Delete RAG document |
+| `list_documents(...)` | List RAG documents |
+| `get_document(...)` | Get RAG document + chunks |
+| `get_plan_limits()` | Plan limits from last auth |
+| `run_workflow(...)` | Run a registered workflow |
+
+---
+
+## Workflows
+
+```python
+from dnotifier import DNotifier, Workflow, define_agent
+
+researcher = define_agent(
+    name="researcher",
+    run=lambda ctx: ctx.send_ai(message=ctx.input, label="Research"),
+)
+
+workflow = Workflow(
+    name="qa-pipeline",
+    observability=True,
+    entry=lambda ctx: ctx.run_agent("researcher"),
+)
+workflow.register_agent("researcher", researcher)
+
+async def main():
+    notifier = DNotifier(...)
+    await notifier.connect()
+    result = await notifier.run_workflow(workflow=workflow, input_data="What is RAG?")
+    print(result)
+```
+
+---
+
+## Development
+
+From `dnotifier-python-sdk/`:
+
+```bash
+pip install -e ".[dev]"
+python -c "from dnotifier import DNotifier; print(DNotifier)"
+```
+
+---
+
+## Publishing (maintainers)
+
+The published PyPI wheel is **minified and encrypted** so source logic is not shipped in readable form (same approach as the JS and Dart SDKs).
+
+```bash
+# Prepare minified + PyArmor-encrypted package in publish_dist/
+python scripts/minify_for_publish.py
+
+# Bump version, build wheel, upload to PyPI
+python scripts/publish_prod.py
+```
+
+---
+
+## License
+
+Proprietary — see [LICENSE](LICENSE).

dnotifier-1.0.0/README.md

@@ -0,0 +1,155 @@
+# DNotifier Python SDK
+
+**DNotifier** is a real-time notification and messaging SDK for **Python 3.9+**. It supports **WebSocket** and **HTTP** transports, **binary streaming**, framed packets, an **AI pipeline**, **knowledge-base (RAG)** APIs, optional **session logging**, and **multi-step workflows** with agents and observability.
+
+---
+
+## Features
+
+- WebSocket and HTTP transport
+- Secure authentication handshake
+- Real-time messaging (text and binary)
+- Large payloads with automatic chunking and reassembly
+- AI: `send_ai`, `fetch_ai_history`, semantic `search`
+- Knowledge base: add, update, get, list, delete, and search documents
+- Chat history fetch and delete
+- Optional SDK session logging (`logs=True`)
+- Workflows: named agents, sequential pipelines, dashboard observability
+- Plan limits from auth (`get_plan_limits`)
+
+---
+
+## Installation
+
+```bash
+pip install dnotifier
+```
+
+---
+
+## Quick start
+
+```python
+import asyncio
+from dnotifier import DNotifier
+
+async def main():
+    notifier = DNotifier(
+        app_id="your-app-id",
+        secret="your-app-secret",
+        transport="ws",  # or "http"
+        user_id="user-123",
+        on_connected=lambda: print("Connected"),
+        on_message=lambda msg: print(msg.payload.to_json()),
+        on_disconnected=lambda **kw: print("Disconnected", kw),
+    )
+
+    await notifier.connect()
+
+    await notifier.send(
+        sender_id="user-123",
+        receiver_id="user-456",
+        data={"type": "text", "text": "Hello from DNotifier"},
+    )
+
+    await notifier.disconnect()
+
+asyncio.run(main())
+```
+
+---
+
+## Connection options
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `app_id` | `str` | Your DNotifier application id |
+| `secret` | `str` | Application secret |
+| `transport` | `"ws"` \| `"http"` | WebSocket for realtime; HTTP for RPC-style AI/RAG |
+| `user_id` | `str` | End-user or agent id for auth and routing |
+| `logs` | `bool` | Enable SDK session logging (default `False`) |
+| `url` | `str` | WebSocket URL override (default production `wss://api.dnotifier.com/ecs/ws`) |
+| `on_connected` | `callable` | Called after successful connect |
+| `on_message` | `callable` | Called for each incoming message |
+| `on_disconnected` | `callable` | Called on disconnect (`code`, `reason`) |
+
+---
+
+## API overview
+
+| Method | Description |
+|--------|-------------|
+| `connect()` | Authenticate and open transport |
+| `disconnect()` | Close WebSocket connection |
+| `send(...)` | Send realtime message |
+| `send_binary(...)` | Send binary payload (WebSocket) |
+| `send_ai(...)` | Send to AI pipeline |
+| `fetch_ai_history(...)` | Fetch AI conversation history |
+| `delete_ai_history_message(...)` | Delete one AI history entry |
+| `fetch_chat_history(...)` | Request chat history |
+| `delete_chat_history_message(...)` | Delete one chat message |
+| `search(...)` | Semantic / vector search |
+| `add_document(...)` | Add RAG document |
+| `update_document(...)` | Update RAG document |
+| `delete_document(...)` | Delete RAG document |
+| `list_documents(...)` | List RAG documents |
+| `get_document(...)` | Get RAG document + chunks |
+| `get_plan_limits()` | Plan limits from last auth |
+| `run_workflow(...)` | Run a registered workflow |
+
+---
+
+## Workflows
+
+```python
+from dnotifier import DNotifier, Workflow, define_agent
+
+researcher = define_agent(
+    name="researcher",
+    run=lambda ctx: ctx.send_ai(message=ctx.input, label="Research"),
+)
+
+workflow = Workflow(
+    name="qa-pipeline",
+    observability=True,
+    entry=lambda ctx: ctx.run_agent("researcher"),
+)
+workflow.register_agent("researcher", researcher)
+
+async def main():
+    notifier = DNotifier(...)
+    await notifier.connect()
+    result = await notifier.run_workflow(workflow=workflow, input_data="What is RAG?")
+    print(result)
+```
+
+---
+
+## Development
+
+From `dnotifier-python-sdk/`:
+
+```bash
+pip install -e ".[dev]"
+python -c "from dnotifier import DNotifier; print(DNotifier)"
+```
+
+---
+
+## Publishing (maintainers)
+
+The published PyPI wheel is **minified and encrypted** so source logic is not shipped in readable form (same approach as the JS and Dart SDKs).
+
+```bash
+# Prepare minified + PyArmor-encrypted package in publish_dist/
+python scripts/minify_for_publish.py
+
+# Bump version, build wheel, upload to PyPI
+python scripts/publish_prod.py
+```
+
+---
+
+## License
+
+Proprietary — see [LICENSE](LICENSE).

dnotifier-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dnotifier"
+version = "1.0.0"
+description = "Real-time notification and messaging SDK for Python. WebSocket & HTTP, auth, binary frames, AI, RAG, and workflows."
+readme = "README.md"
+license = { text = "Proprietary" }
+requires-python = ">=3.9"
+authors = [{ name = "DNotifier" }]
+keywords = ["dnotifier", "websocket", "realtime", "notifications", "sdk", "messaging", "ai", "rag"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Communications",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "httpx>=0.27.0",
+  "websockets>=12.0",
+]
+
+[project.urls]
+Homepage = "https://dnotifier.com"
+Documentation = "https://dnotifier.gitbook.io/product-docs"
+Repository = "https://github.com/smartguy6666/dnotifier-sdk"
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2",
+  "twine>=5.0",
+  "python-minifier>=2.9",
+  "pyarmor>=8.5",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dnotifier"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src" = ""
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src/dnotifier",
+  "/README.md",
+  "/LICENSE",
+  "/CHANGELOG.md",
+]

dnotifier-1.0.0/src/dnotifier/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+from.dnotifier import DNotifier,DNotifierMessage,DNotifierMessageMetadata,DNotifierPlanLimits
+from.utils.payload import Payload
+from.workflow import Agent,Workflow,WorkflowContext,WorkflowError,WorkflowRunner,define_agent
+__version__='1.0.0'
+__all__=['DNotifier','DNotifierMessage','DNotifierMessageMetadata','DNotifierPlanLimits','Payload','Agent','define_agent','Workflow','WorkflowContext','WorkflowRunner','WorkflowError','__version__']

dnotifier-1.0.0/src/dnotifier/config/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+from.endpoints import DNotifierEndpoints
+__all__=['DNotifierEndpoints']

dnotifier-1.0.0/src/dnotifier/config/endpoints.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+BASE_HOST='https://api.dnotifier.com'
+_WS_HOST=BASE_HOST.replace('http','ws',1)
+LOG_HOST=f"{BASE_HOST}/ecs"
+WORKFLOW_SDK_BASE=f"{LOG_HOST}/api/v1/log/sdk/workflow"
+class DNotifierEndpoints:
+	base_host=BASE_HOST;ws_url=f"{_WS_HOST}/ecs/ws";rpc_send_url=f"{BASE_HOST}/rpc/v1/message/send";auth_url=f"{BASE_HOST}/ecs/api/v1/sdk/auth";log_host=LOG_HOST;add_log_url=f"{LOG_HOST}/api/v1/log/sdk/add-log";update_log_status_url=f"{LOG_HOST}/api/v1/log/sdk/update-log-status";add_session_step_url=f"{LOG_HOST}/api/v1/log/sdk/add-session-step";workflow_register_url=f"{WORKFLOW_SDK_BASE}/workflows";workflow_executions_url=f"{WORKFLOW_SDK_BASE}/executions";workflow_steps_url=f"{WORKFLOW_SDK_BASE}/steps"
+	@staticmethod
+	def workflow_execution_url(execution_id):return f"{WORKFLOW_SDK_BASE}/executions/{execution_id}"
+	@staticmethod
+	def workflow_execution_complete_url(execution_id):return f"{WORKFLOW_SDK_BASE}/executions/{execution_id}/complete"
+	@staticmethod
+	def workflow_execution_steps_url(execution_id):return f"{WORKFLOW_SDK_BASE}/executions/{execution_id}/steps"

dnotifier-1.0.0/src/dnotifier/dnotifier.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+_c='content'
+_b='content or text is required'
+_a='saveHistory'
+_Z='aiEnabled'
+_Y='limits'
+_X='currentPacket'
+_W='totalPackets'
+_V='_responseData'
+_U='recordId'
+_T='record_id is required'
+_S='record_id'
+_R='messageId'
+_Q='receivers'
+_P='text'
+_O='ai'
+_N='sender_id required'
+_M=True
+_L=False
+_K='Not connected'
+_J='id'
+_I='code'
+_H='appId'
+_G='data'
+_F='timestamp'
+_E='token'
+_D='metadata'
+_C='type'
+_B='sender'
+_A=None
+import asyncio,json,time,uuid
+from dataclasses import dataclass
+from typing import Any,Callable,Optional
+from.config.endpoints import DNotifierEndpoints
+from.transport.http_transport import HttpTransport
+from.transport.websocket_transport import WebsocketTransport
+from.utils.buffer import to_bytes
+from.utils.frame import frame_packet
+from.utils.id import prefix_id
+from.utils.logs import LogsClient
+from.utils.payload import Payload
+from.workflow import Agent,Workflow,WorkflowContext,WorkflowError,WorkflowRunner,define_agent
+_DEFAULT_WS_URL=DNotifierEndpoints.ws_url
+_DEFAULT_AUTH_URL=DNotifierEndpoints.auth_url
+_DEFAULT_HTTP_URL=DNotifierEndpoints.rpc_send_url
+@dataclass
+class DNotifierMessageMetadata:id:Optional[str];sender:str;timestamp:int;type:Optional[str]=_A
+@dataclass
+class DNotifierMessage:metadata:DNotifierMessageMetadata;payload:Payload
+@dataclass
+class DNotifierPlanLimits:messages_hard_limit:Optional[int]=_A;max_ai_requests_per_month:int=0;max_ai_words_per_month:int=0;knowledge_base_max_words:int=0;ai_enabled:bool=_L;max_users:Optional[int]=_A;max_rows_per_user:Optional[int]=_A
+class _ChunkEntry:
+	def __init__(A,total_packets):B=total_packets;A.total_packets=B;A.chunks=[_A]*B
+def _merge_chunks(chunks):return b''.join(chunks)
+def _random_uuid():return str(uuid.uuid4())
+OnConnected=Callable[[],_A]
+OnMessage=Callable[[DNotifierMessage],_A]
+OnDisconnected=Callable[...,_A]
+class DNotifier:
+	Agent=Agent;define_agent=staticmethod(define_agent);Workflow=Workflow;WorkflowContext=WorkflowContext;WorkflowRunner=WorkflowRunner;WorkflowError=WorkflowError
+	def __init__(A,app_id,secret,transport,user_id,logs=_L,url=_DEFAULT_WS_URL,on_connected=_A,on_message=_A,on_disconnected=_A):
+		E=user_id;D=secret;C=app_id;B=transport
+		if not C or not D or not B or not E:raise ValueError('app_id, secret, transport, and user_id are required')
+		A.app_id=C;A.secret=D;A.user_id=E;A.url=url;A.on_connected=on_connected or(lambda:_A);A.on_message=on_message or(lambda _msg:_A);A.on_disconnected=on_disconnected or(lambda**A:_A);A.is_connected=_L;A.ai_enabled=_L;A.message_size_limit=32768;A._logs_enabled=bool(logs);A._logs_client=LogsClient(enabled=A._logs_enabled,app_id=A.app_id);A._auth_response=_A;A.auth_token=_A;A.current_model=_A;A._ws=_A;A._http=_A
+		if B=='ws':A._ws=WebsocketTransport()
+		elif B=='http':A._http=HttpTransport(_DEFAULT_HTTP_URL)
+		else:raise ValueError('transport must be "ws" or "http"')
+	def _normalize_rpc_response(C,response):
+		A=response
+		if not isinstance(A,dict):return A
+		if _D in A and _G in A:return A
+		B=A.get(_V)
+		if isinstance(B,dict)and _D in B and _G in B:return B
+		return A
+	async def connect(A):
+		I=HttpTransport(_DEFAULT_AUTH_URL);D=await I.send({_H:A.app_id,'appSecret':A.secret,'userID':A.user_id});E=D.get('_responseCode')
+		if E is not _A and E!=200:
+			if E==400:raise RuntimeError(str(D.get(_V,'Authentication failed')))
+			raise RuntimeError('Authentication failed.')
+		C=D.get(_V)
+		if not isinstance(C,dict):raise RuntimeError('Authentication failed: invalid response')
+		A._auth_response=C;A.auth_token=C.get(_E)
+		if not A.auth_token:raise RuntimeError('Authentication failed: no token')
+		A.current_model=C.get('current_model');F=C.get(_Y)or{};A.ai_enabled=bool(F.get(_Z));A.message_size_limit=int(F.get('messageSizeKB',32))*1024;A._logs_client.configure(token=A.auth_token,model=A.current_model)
+		if A._http is not _A:A.is_connected=_M;A.on_connected();return _M
+		B=A._ws
+		if B is _A:raise RuntimeError('WebSocket transport not initialized')
+		G=_L;H={}
+		def J(chunk):
+			R='300';N=chunk;nonlocal G
+			try:
+				O=N.get(_D)or{};E=N.get(_G);B=O.get('packet')or O;I=str(B.get(_I,''));S=str(B.get(_B,''))
+				if not G:
+					if I=='102'and prefix_id(A.app_id,A.user_id)in S:G=_M;A.is_connected=_M;A.on_connected()
+					return
+				F=int(B.get(_W)or 1);J=int(B.get(_X)or 1);P=B.get(_J);D=str(P)if P else _A;K=D or f"{B.get(_B)}_{B.get(_F)}_{F}"
+				if F==1 or not D:
+					if I==R and D:
+						try:L=Payload(E).to_json();asyncio.create_task(A._logs_client.complete_ai_logging(session_id=D,response=L))
+						except Exception as M:print(f"Session step completion failed: {M}")
+					A._emit_message(B,E);return
+				C=H.get(K)
+				if C is _A or C.total_packets!=F:C=_ChunkEntry(F);H[K]=C
+				if J<1 or J>F:return
+				T=E if isinstance(E,bytes)else to_bytes(E);C.chunks[J-1]=T
+				if any(A is _A for A in C.chunks):return
+				H.pop(K,_A);Q=_merge_chunks([A for A in C.chunks if A is not _A])
+				if I==R and D:L=Payload(Q).to_json();asyncio.create_task(A._logs_client.complete_ai_logging(session_id=D,response=L))
+				A._emit_message(B,Q)
+			except Exception as M:print(f"Packet error: {M}")
+		def K(code=_A,reason=_A):
+			B=A.is_connected;A.is_connected=_L
+			if B:A.on_disconnected(code=code,reason=reason or'Disconnected')
+		def L(err):A.is_connected=_L;A.on_disconnected(code=500,reason=str(err))
+		B.on_message=J;B.on_close=K;B.on_error=L;await B.connect(A.url);M={_C:_P,_I:101,_H:A.app_id,_B:prefix_id(A.app_id,A.user_id),_F:int(time.time()*1000),_E:A.auth_token};N=to_bytes(json.dumps({_E:A.auth_token}));await B.send_binary(frame_packet(M,N));return _M
+	def _emit_message(B,packet,data):A=packet;B.on_message(DNotifierMessage(metadata=DNotifierMessageMetadata(id=A.get(_J),sender=str(A.get(_B,'')),timestamp=int(A.get(_F)or 0),type=A.get(_C)or A.get(_B)),payload=Payload(data)))
+	def get_plan_limits(C):
+		if not C.is_connected:raise RuntimeError(_K)
+		A=(C._auth_response or{}).get(_Y)
+		if not isinstance(A,dict):return
+		B=bool(A.get(_Z));D=A.get('ai_limits')or{};F=A.get('knowledge_base_limits')or{};E=A.get('db_storage_limits')or{};return DNotifierPlanLimits(messages_hard_limit=A.get('messagesHardLimit'),max_ai_requests_per_month=int(D.get('maxRequestsPerMonth',0))if B else 0,max_ai_words_per_month=int(D.get('maxAIWordsPerMonth',0))if B else 0,knowledge_base_max_words=int(F.get('maxWords',0))if B else 0,ai_enabled=B,max_users=E.get('maxUsers'),max_rows_per_user=E.get('maxRowsPerUser'))
+	async def send(A,sender_id,data,receiver_id=_A,receiver_ids=_A,save_history=_M):
+		I=receiver_ids;H=receiver_id;G=sender_id
+		if not A.is_connected:raise RuntimeError(_K)
+		if not G:raise ValueError(_N)
+		if not H and not I:raise ValueError('receiver_id or receiver_ids required')
+		K=I or[H];B=to_bytes(json.dumps(data));D=A.message_size_limit or 32768;C=_random_uuid();E={_J:C,_C:_P,_I:200,_W:1,_X:1,_H:A.app_id,_B:prefix_id(A.app_id,G),_Q:[prefix_id(A.app_id,B)for B in K if B],_F:int(time.time()*1000),_E:A.auth_token,_a:save_history}
+		if A._http is not _A:return await A._http.send({_D:E,_G:data})
+		F=A._ws
+		if F is _A:raise RuntimeError('WebSocket not available')
+		if len(B)<=D:await F.send_binary(frame_packet(E,B));return C
+		J=[B[A:A+D]for A in range(0,len(B),D)];L=len(J)
+		for(M,N)in enumerate(J):O={**E,_J:C,_W:L,_X:M+1};await F.send_binary(frame_packet(O,N))
+		return C
+	async def send_ai(A,sender_id,message,save_history=_M,session_id=_A):
+		E=session_id;D=message;C=sender_id
+		try:
+			if not A.is_connected:raise RuntimeError(_K)
+			if not C:raise ValueError(_N)
+			B=E or _random_uuid();F={_J:B,_C:_O,_I:300,_H:A.app_id,_B:prefix_id(A.app_id,C),'receiverId':prefix_id(A.app_id,C),_F:int(time.time()*1000),_E:A.auth_token,_a:save_history};await A._logs_client.start_ai_logging(session_id=B,prompts=D,is_existing_session=bool(E))
+			if A._http is not _A:G=await A._http.send({_D:F,_G:D});await A._logs_client.complete_ai_logging(session_id=B,response=G);return A._normalize_rpc_response(G)
+			if A._ws is not _A:H=to_bytes(json.dumps(D));await A._ws.send_binary(frame_packet(F,H))
+			return B
+		except Exception as I:print(f"error in send_ai: {I}");return
+	async def fetch_ai_history(A,sender_id):
+		B=sender_id
+		if not A.is_connected:raise RuntimeError(_K)
+		if not B:raise ValueError(_N)
+		C={_J:_random_uuid(),_C:_O,_I:301,_H:A.app_id,_B:prefix_id(A.app_id,B),_F:int(time.time()*1000),_E:A.auth_token}
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:C,_G:{}}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(C,to_bytes('{}')))
+	async def fetch_chat_history(A,sender_id,receiver_ids):
+		C=receiver_ids;B=sender_id
+		if not A.is_connected:raise RuntimeError(_K)
+		if not B:raise ValueError(_N)
+		if not C:raise ValueError('receiver_ids required')
+		D={_J:_random_uuid(),_C:_P,_I:201,_H:A.app_id,_B:prefix_id(A.app_id,B),_Q:[prefix_id(A.app_id,B)for B in C],_F:int(time.time()*1000),_E:A.auth_token}
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:D,_G:{}}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(D,to_bytes('{}')))
+	async def delete_ai_history_message(A,sender_id,message_id):
+		B=message_id
+		if not A.is_connected:raise RuntimeError(_K)
+		C={_J:_random_uuid(),_C:_O,_I:302,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_F:int(time.time()*1000),_E:A.auth_token,_R:B};D={_R:B}
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:C,_G:D}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(C,to_bytes(json.dumps(D))))
+	async def delete_chat_history_message(A,sender_id,message_id):
+		B=message_id
+		if not A.is_connected:raise RuntimeError(_K)
+		C={_J:_random_uuid(),_C:_P,_I:202,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_Q:[],_F:int(time.time()*1000),_E:A.auth_token,_R:B};D={_R:B}
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:C,_G:D}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(C,to_bytes(json.dumps(D))))
+	async def search(A,sender_id,query,limit=_A,min_similarity=_A,filterby_source=_A):
+		F=filterby_source;E=min_similarity;D=limit;C=query
+		if not A.is_connected:raise RuntimeError(_K)
+		if not C:raise ValueError('query required')
+		G={_J:_random_uuid(),_C:_O,_I:303,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_F:int(time.time()*1000),_E:A.auth_token};B={'query':C}
+		if D is not _A:B['limit']=D
+		if E is not _A:B['minSimilarity']=E
+		if F is not _A:B['filterbySource']=F
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:G,_G:B}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(G,to_bytes(json.dumps(B))))
+	async def add_document(G,sender_id,record_id=_A,content=_A,text=_A,doc_type=_A,metadata=_A,**H):
+		D=metadata;C=doc_type;B=content;E=(record_id or H.get(_S)or'').strip();F=B if B is not _A else text or''
+		if not E:raise ValueError(_T)
+		if not str(F).strip():raise ValueError(_b)
+		A={_U:E,_c:str(F)}
+		if C is not _A:A[_C]=str(C)
+		if D:A[_D]=D
+		return await G._send_document_rpc(sender_id,306,A)
+	async def update_document(G,sender_id,record_id=_A,content=_A,text=_A,doc_type=_A,metadata=_A,**H):
+		D=metadata;C=doc_type;B=content;E=(record_id or H.get(_S)or'').strip();F=B if B is not _A else text or''
+		if not E:raise ValueError(_T)
+		if not str(F).strip():raise ValueError(_b)
+		A={_U:E,_c:str(F)}
+		if C is not _A:A[_C]=str(C)
+		if D:A[_D]=D
+		return await G._send_document_rpc(sender_id,307,A)
+	async def delete_document(B,sender_id,record_id=_A,**C):
+		A=(record_id or C.get(_S)or'').strip()
+		if not A:raise ValueError(_T)
+		return await B._send_document_rpc(sender_id,308,{_U:A})
+	async def list_documents(E,sender_id,limit=_A,offset=_A,doc_type=_A,**F):
+		D=doc_type;C=offset;B=limit;A={}
+		if B is not _A:A['limit']=B
+		if C is not _A:A['offset']=C
+		if D is not _A:A[_C]=str(D)
+		return await E._send_document_rpc(sender_id,309,A)
+	async def get_document(B,sender_id,record_id=_A,**C):
+		A=(record_id or C.get(_S)or'').strip()
+		if not A:raise ValueError(_T)
+		return await B._send_document_rpc(sender_id,310,{_U:A})
+	async def _send_document_rpc(A,sender_id,code,data):
+		B=sender_id
+		if not A.is_connected:raise RuntimeError(_K)
+		if not B:raise ValueError(_N)
+		C={_J:_random_uuid(),_C:_O,_I:code,_H:A.app_id,_B:prefix_id(A.app_id,B),_F:int(time.time()*1000),_E:A.auth_token}
+		if A._http is not _A:return A._normalize_rpc_response(await A._http.send({_D:C,_G:data}))
+		if A._ws is not _A:await A._ws.send_binary(frame_packet(C,to_bytes(json.dumps(data))))
+	async def send_binary(A,sender_id,receiver_ids,buffer,msg_type='binary'):
+		B=buffer
+		if not A.is_connected:raise RuntimeError(_K)
+		if not B:raise ValueError('buffer is required')
+		C={_C:msg_type,_I:202,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_Q:[prefix_id(A.app_id,B)for B in receiver_ids],_F:int(time.time()*1000),_E:A.auth_token}
+		if A._ws is _A:raise RuntimeError('Binary send requires WebSocket transport')
+		await A._ws.send_binary(frame_packet(C,B))
+	async def send_with_openai(A,sender_id,message,**B):
+		if not A.ai_enabled:raise RuntimeError('AI is not enabled for this subscription.')
+		return await A.send_ai(sender_id=sender_id,message=message)
+	async def run_workflow(A,workflow,input_data,sender_id=_A):
+		if not A.is_connected:raise RuntimeError(_K)
+		B=WorkflowRunner(notifier=A,sender_id=sender_id or A.user_id,workflow=workflow);return await B.run(input_data=input_data)
+	async def disconnect(A):
+		if A._ws is not _A:await A._ws.close()
+		A.is_connected=_L

dnotifier-1.0.0/src/dnotifier/transport/__init__.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+from.http_transport import HttpTransport
+from.websocket_transport import WebsocketTransport
+__all__=['HttpTransport','WebsocketTransport']

dnotifier-1.0.0/src/dnotifier/transport/http_transport.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+import json
+from typing import Any,Optional
+import httpx
+from..config.endpoints import DNotifierEndpoints
+class HttpTransport:
+	def __init__(A,url,headers=None):A.url=url;A.headers=headers or{}
+	async def send(B,payload):
+		async with httpx.AsyncClient(timeout=6e1)as C:
+			A=await C.post(B.url,headers={'Content-Type':'application/json',**B.headers},content=json.dumps(payload))
+			if A.status_code>=400:raise RuntimeError(f"DNotifier HTTP error: {A.text}")
+			return A.json()
+	def send_binary(A):raise RuntimeError('Binary is not supported over HTTP yet')

dnotifier-1.0.0/src/dnotifier/transport/websocket_transport.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+_A=None
+import asyncio
+from typing import Any,Callable,Optional
+import websockets
+from..utils.frame import decode_packet
+class WebsocketTransport:
+	def __init__(A):A._ws=_A;A._listen_task=_A;A.on_message=_A;A.on_close=_A;A.on_error=_A
+	async def connect(A,url):A._ws=await websockets.connect(url);A._listen_task=asyncio.create_task(A._listen());return True
+	async def _listen(A):
+		try:
+			assert A._ws is not _A
+			async for C in A._ws:
+				E=C if isinstance(C,bytes)else C.encode('utf-8');D=decode_packet(E)
+				if D and A.on_message:A.on_message(D)
+		except websockets.ConnectionClosed as B:
+			if A.on_close:A.on_close(code=B.code,reason=B.reason or'Disconnected')
+		except Exception as B:
+			if A.on_error:A.on_error(B)
+			if A.on_close:A.on_close(code=500,reason=str(B))
+	async def send_binary(A,buffer):
+		if not A._ws or A._ws.close_code is not _A:raise RuntimeError('WebSocket not connected')
+		await A._ws.send(buffer)
+	def is_open(A):return A._ws is not _A and A._ws.close_code is _A
+	async def close(A):
+		if A._listen_task and not A._listen_task.done():
+			A._listen_task.cancel()
+			try:await A._listen_task
+			except asyncio.CancelledError:pass
+		if A._ws:await A._ws.close();A._ws=_A

dnotifier-1.0.0/src/dnotifier/utils/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from.buffer import to_bytes
+from.frame import decode_packet,frame_packet
+from.id import prefix_id
+from.logs import LogsClient
+from.payload import Payload
+__all__=['to_bytes','decode_packet','frame_packet','prefix_id','LogsClient','Payload']

dnotifier-1.0.0/src/dnotifier/utils/buffer.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+def to_bytes(data):
+	B='utf-8';A=data
+	if isinstance(A,bytes):return A
+	if isinstance(A,str):return A.encode(B)
+	if isinstance(A,(dict,list)):import json;return json.dumps(A).encode(B)
+	return bytes(A)

dnotifier-1.0.0/src/dnotifier/utils/frame.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+_A='utf-8'
+import json,struct
+from typing import Any,Optional
+_internal_buffer=bytearray()
+def _write_u32_be(buf,offset,val):struct.pack_into('>I',buf,offset,val&4294967295)
+def _read_u32_be(buf,offset):return struct.unpack_from('>I',buf,offset)[0]
+def frame_packet(metadata,data_buffer):E=data_buffer;B=json.dumps(metadata).encode(_A);D=E if isinstance(E,bytes)else bytes(E);C=bytearray(4+len(B)+4+len(D));A=0;_write_u32_be(C,A,len(B));A+=4;C[A:A+len(B)]=B;A+=len(B);_write_u32_be(C,A,len(D));A+=4;C[A:A+len(D)]=D;return bytes(C)
+def decode_packet(chunk):
+	B=chunk;global _internal_buffer
+	try:
+		if isinstance(B,memoryview):B=B.tobytes()
+		_internal_buffer.extend(B);A=0
+		if len(_internal_buffer)<4:return
+		C=_read_u32_be(_internal_buffer,A);A+=4
+		if len(_internal_buffer)<A+C:return
+		H=bytes(_internal_buffer[A:A+C]);G=json.loads(H.decode(_A));A+=C
+		if len(_internal_buffer)<A+4:return
+		D=_read_u32_be(_internal_buffer,A);A+=4
+		if len(_internal_buffer)<A+D:return
+		E=bytes(_internal_buffer[A:A+D]);A+=D;_internal_buffer=_internal_buffer[A:];F=E
+		if G.get('type')=='text':
+			try:F=json.loads(E.decode(_A))
+			except(json.JSONDecodeError,UnicodeDecodeError):F=E
+		return{'metadata':G,'data':F}
+	except Exception as I:print(f"decode_packet error: {I}");return

dnotifier-1.0.0/src/dnotifier/utils/id.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+def prefix_id(app_id,user_id):
+	A=user_id
+	if':'in A:return A
+	return f"{app_id}:{A}"

dnotifier-1.0.0/src/dnotifier/utils/logs.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+_F='tokens'
+_E='prompts'
+_D='updatedAt'
+_C='sessionId'
+_B='status'
+_A=None
+import json
+from datetime import datetime,timezone
+from typing import Any,Optional
+from..config.endpoints import DNotifierEndpoints
+from..transport.http_transport import HttpTransport
+_session_step_tracker={}
+class LogsClient:
+	def __init__(A,enabled=False,app_id=_A,token=_A,model=_A):A.enabled=bool(enabled);A.app_id=app_id;A.token=token;A.model=model
+	def configure(A,enabled=_A,app_id=_A,token=_A,model=_A):
+		E=model;D=token;C=app_id;B=enabled
+		if B is not _A:A.enabled=bool(B)
+		if C is not _A:A.app_id=C
+		if D is not _A:A.token=D
+		if E is not _A:A.model=E
+	def _transport(A,url):B={'authorization':A.token}if A.token else{};return HttpTransport(url,B)
+	async def create_log(A,payload):return await A._transport(DNotifierEndpoints.add_log_url).send(payload)
+	async def update_log(A,payload):return await A._transport(DNotifierEndpoints.update_log_status_url).send(payload)
+	async def add_session_step_log(A,payload):return await A._transport(DNotifierEndpoints.add_session_step_url).send(payload)
+	async def start_ai_logging(A,session_id,prompts,is_existing_session=False):
+		F='createdDate';E='appId';D='InProgress';B=session_id
+		if not A.enabled or not A.token or not A.app_id or not B:return
+		C=datetime.now(timezone.utc).isoformat()
+		if is_existing_session:await A.update_log({_C:B,_B:D,_D:C})
+		else:await A.create_log({E:A.app_id,_C:B,_B:D,'model':A.model,'calls':1,F:C,'step':1})
+		_session_step_tracker[B]={E:A.app_id,_C:B,_F:0,_B:D,_E:prompts,F:C}
+	async def complete_ai_logging(B,session_id,response=_A):
+		K='usage';J='data';I='Completed';C=session_id;A=response
+		if not B.enabled or not B.token or not C:return
+		D=_session_step_tracker.get(C)
+		if not D:return
+		E=datetime.now(timezone.utc).isoformat();await B.update_log({_C:C,_B:I,_D:E});_session_step_tracker.pop(C,_A);L=json.dumps(D.get(_E));F=json.dumps(A);G=0
+		if isinstance(A,dict):
+			H=A.get(J,{}).get(K)if A.get(J)else A.get(K)
+			if isinstance(H,dict):G=H.get('total_tokens',0)or 0
+		await B.add_session_step_log({**D,_E:[L,F],'response':F,_B:I,_D:E,_F:G})

dnotifier-1.0.0/src/dnotifier/utils/payload.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+_B='base64'
+_A='utf-8'
+import base64,json
+from typing import Any,Optional
+class Payload:
+	def __init__(B,buffer):
+		A=buffer
+		if isinstance(A,(list,tuple)):B.buffer=bytes(A)
+		elif isinstance(A,memoryview):B.buffer=A.tobytes()
+		elif isinstance(A,str):B.buffer=A.encode(_A)
+		elif isinstance(A,dict):B.buffer=json.dumps(A).encode(_A)
+		else:B.buffer=bytes(A)
+	def raw(A):return A.buffer
+	def to_string(A,encoding=_A):
+		B=encoding
+		if B==_B:return base64.b64encode(A.buffer).decode('ascii')
+		return A.buffer.decode(B)
+	def to_json(A,encoding=_A):
+		try:return json.loads(A.to_string(encoding))
+		except(json.JSONDecodeError,UnicodeDecodeError):return
+	def to_base64(A):return A.to_string(_B)

dnotifier-1.0.0/src/dnotifier/workflow/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from.agent import Agent,define_agent
+from.context import WorkflowContext
+from.errors import WorkflowError
+from.runner import WorkflowRunner
+from.workflow import Workflow
+__all__=['Agent','define_agent','Workflow','WorkflowContext','WorkflowRunner','WorkflowError']

dnotifier-1.0.0/src/dnotifier/workflow/agent.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+from typing import Awaitable,Callable,TYPE_CHECKING
+from.errors import WorkflowError
+if TYPE_CHECKING:from.context import WorkflowContext
+AgentRun=Callable[['WorkflowContext'],Awaitable]
+class Agent:
+	def __init__(B,name,run):
+		A=name
+		if not A or not isinstance(A,str):raise WorkflowError('Agent name is required')
+		if not callable(run):raise WorkflowError(f'Agent "{A}": run must be a callable')
+		B.name=A;B.run=run
+def define_agent(name,run):return Agent(name=name,run=run)

dnotifier-1.0.0/src/dnotifier/workflow/context.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+_P='usesTokens'
+_O='message'
+_N='output'
+_M='latencyMs'
+_L='status'
+_K='apiName'
+_J='type'
+_I='kind'
+_H='agentName'
+_G='error'
+_F='tokensOut'
+_E='tokensIn'
+_D='model'
+_C='input'
+_B=None
+_A='label'
+import json,time
+from typing import Any,TYPE_CHECKING
+from.errors import WorkflowError
+from.step_types import STEP_TYPE_CUSTOM,to_log_step_type
+if TYPE_CHECKING:from..dnotifier import DNotifier;from.observability import WorkflowObservability;from.workflow import Workflow
+def _usage_from_response(response):
+	F='usage';E='data';B=response;A=_B
+	if isinstance(B,dict):
+		C=B.get(E)
+		if isinstance(C,dict):A=C.get(F)
+		if A is _B:A=B.get(F)
+	if not isinstance(A,dict):return{_E:0,_F:0,_D:_B}
+	G=A.get('prompt_tokens')or A.get('input_tokens')or A.get(_E)or 0;H=A.get('completion_tokens')or A.get('output_tokens')or A.get('total_tokens')or A.get(_F)or 0;D=_B
+	if isinstance(B,dict):
+		C=B.get(E)
+		if isinstance(C,dict):D=C.get(_D)
+		if D is _B:D=A.get(_D)
+	return{_E:G,_F:H,_D:D}
+def _snapshot(value):
+	A=value
+	try:
+		if A is _B:return
+		return json.loads(json.dumps(A,default=str))
+	except(TypeError,ValueError):return str(A)
+def _api_input(opts):
+	if not opts:return
+	A={A:B for(A,B)in opts.items()if A!=_A};return A if A else _B
+class WorkflowContext:
+	def __init__(A,notifier,sender_id,workflow,input_data,state=_B,observability=_B,execution_id=_B,agent_name=_B):E=execution_id;D=observability;C=state;B=workflow;A.notifier=notifier;A.sender_id=sender_id;A.workflow=B;A.input=input_data;A.state=C if C is not _B else{};A._observability=D;A._execution_id=E;A._observability_enabled=bool(B.observability and D and E);A.agent_name=agent_name
+	async def _invoke_sdk_api(A,api_name,invoke,meta=_B):
+		D=api_name;B=meta;B=B or{};H=int(time.time()*1000);E='ok';C=_B;F=_B;G=to_log_step_type(D)
+		try:C=await invoke();return C
+		except Exception as I:E=_G;F={_O:str(I)};raise
+		finally:
+			if A._observability_enabled and A._observability and A._execution_id:J=_usage_from_response(C)if B.get(_P)else{_E:0,_F:0,_D:_B};K=A.agent_name or D;await A._observability.record_step(A._execution_id,{_K:D,_H:A.agent_name,_I:K,_J:G,_A:B.get(_A)or G,_L:E,_M:int(time.time()*1000)-H,**J,_C:_snapshot(B.get(_C)),_N:_snapshot(C),_G:F})
+	async def run_agent(A,name,input_data=_B):
+		C=input_data;B=name;D=A.workflow.get_agent(B)
+		if not D:raise WorkflowError(f"Agent not found: {B}")
+		E=C if C is not _B else A.input;F=WorkflowContext(notifier=A.notifier,sender_id=A.sender_id,workflow=A.workflow,input_data=E,state=A.state,observability=A._observability,execution_id=A._execution_id,agent_name=B);return await D.run(F)
+	async def send_ai(B,**A):return await B._invoke_sdk_api('sendAI',lambda:B.notifier.send_ai(sender_id=B.sender_id,**A),{_A:A.get(_A),_C:A.get(_O)or _api_input(A),_P:True})
+	async def fetch_ai_history(A,**B):return await A._invoke_sdk_api('fetchAIHistory',lambda:A.notifier.fetch_ai_history(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def search(A,**B):return await A._invoke_sdk_api('search',lambda:A.notifier.search(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def add_document(A,**B):return await A._invoke_sdk_api('addDocument',lambda:A.notifier.add_document(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def update_document(A,**B):return await A._invoke_sdk_api('updateDocument',lambda:A.notifier.update_document(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def delete_document(A,**B):return await A._invoke_sdk_api('deleteDocument',lambda:A.notifier.delete_document(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def list_documents(A,**B):return await A._invoke_sdk_api('listDocuments',lambda:A.notifier.list_documents(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def get_document(A,**B):return await A._invoke_sdk_api('getDocument',lambda:A.notifier.get_document(sender_id=A.sender_id,**B),{_A:B.get(_A),_C:_api_input(B)})
+	async def record_step(B,step):
+		A=step
+		if not B._observability_enabled or not B._observability or not B._execution_id:return
+		C=to_log_step_type(A.get(_J))if A.get(_J)else STEP_TYPE_CUSTOM;await B._observability.record_step(B._execution_id,{**A,_K:A.get(_K)or A.get(_I),_H:A.get(_H)or B.agent_name,_I:A.get(_H)or B.agent_name or A.get(_I)or'custom',_J:C,_A:A.get(_A)or C,_E:A.get(_E,0),_F:A.get(_F,0),_D:A.get(_D),_M:A.get(_M,0),_L:A.get(_L,'ok'),_G:A.get(_G),_C:_snapshot(A.get(_C)),_N:_snapshot(A.get(_N))})

dnotifier-1.0.0/src/dnotifier/workflow/errors.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+class WorkflowError(Exception):
+	def __init__(A,message,agent_name=None,cause=None):super().__init__(message);A.name='WorkflowError';A.agent_name=agent_name;A.cause=cause

dnotifier-1.0.0/src/dnotifier/workflow/ids.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+import uuid
+def random_uuid():return str(uuid.uuid4())
+def short_id(prefix):return f"{prefix}_{random_uuid().replace('-','')[:12]}"

dnotifier-1.0.0/src/dnotifier/workflow/json_payload.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+import json
+from typing import Any
+def to_json_column(value):
+	C='text';A=value
+	if A is None:return
+	if isinstance(A,str):
+		B=A.strip()
+		if not B:return{}
+		if B.startswith('{')or B.startswith('['):
+			try:return json.loads(B)
+			except json.JSONDecodeError:return{C:A}
+		return{C:A}
+	if isinstance(A,(int,float,bool)):return A
+	try:return json.loads(json.dumps(A,default=str))
+	except(TypeError,ValueError):return{C:str(A)}
+def set_json_column(target,key,value):
+	A=to_json_column(value)
+	if A is not None:target[key]=A

dnotifier-1.0.0/src/dnotifier/workflow/observability.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+_B='workflowId'
+_A='executionId'
+from datetime import datetime,timezone
+from typing import TYPE_CHECKING,Any
+from.ids import short_id
+from.step_types import resolve_step_type
+from.workflow_observability_client import WorkflowObservabilityClient
+if TYPE_CHECKING:from.workflow import Workflow
+class WorkflowObservability:
+	def __init__(A,app_id,token=None,client=None):C=token;B=app_id;A.app_id=B;A.token=C;A.client=client or WorkflowObservabilityClient(app_id=B,token=C);A.client.configure(app_id=B,token=C);A._registered_workflow_names=set();A._step_counter=0
+	async def register_workflow(B,workflow):
+		A=workflow
+		if A.name in B._registered_workflow_names:return
+		B._registered_workflow_names.add(A.name)
+		try:await B.client.register_workflow({'appId':B.app_id,_B:A.name,'name':A.name,'description':A.description})
+		except Exception:pass
+	async def start_execution(A,params):
+		G='startedAt';F='input';E='userId';B=params;C=short_id('exec');D=datetime.now(timezone.utc).isoformat()
+		try:await A.client.create_execution({'id':C,'appId':A.app_id,_B:B[_B],E:B[E],F:B.get(F),G:D})
+		except Exception:pass
+		A._step_counter=0;return{_A:C,G:D}
+	async def record_step(B,execution_id,step):
+		I='executedAt';H='kind';E='apiName';D='agentName';C=execution_id;A=step
+		if not C:return A
+		B._step_counter+=1;J=A.get('id')or f"n{B._step_counter}";F=resolve_step_type(A);K=A.get(D)or A.get(H)or A.get(E);G={**A,'id':J,_A:C,I:A.get(I)or datetime.now(timezone.utc).isoformat(),E:A.get(E),D:A.get(D),H:K,'type':F,'step_type':F}
+		try:await B.client.add_step(C,G)
+		except Exception:pass
+		return G
+	async def complete_execution(H,params):
+		G='result';F='error';E='stepCount';D='durationMs';C='endedAt';B='status';A=params
+		if not A.get(_A):return
+		try:await H.client.update_execution(A[_A],{B:A[B],C:A[C],D:A[D],E:A[E],F:A.get(F),G:A.get(G)})
+		except Exception:pass
+	def get_step_count(A):return A._step_counter
+def create_workflow_observability(app_id,token=None):return WorkflowObservability(app_id=app_id,token=token)

dnotifier-1.0.0/src/dnotifier/workflow/runner.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+_A=None
+import time
+from datetime import datetime,timezone
+from typing import Any,TYPE_CHECKING
+from.context import WorkflowContext
+from.errors import WorkflowError
+from.observability import create_workflow_observability
+if TYPE_CHECKING:from..dnotifier import DNotifier;from.workflow import Workflow
+class WorkflowRunner:
+	def __init__(A,notifier,sender_id,workflow):
+		D=workflow;C=sender_id;B=notifier
+		if not B:raise WorkflowError('WorkflowRunner requires a DNotifier instance')
+		if not C:raise WorkflowError('WorkflowRunner requires sender_id')
+		if not D:raise WorkflowError('WorkflowRunner requires a workflow')
+		A.notifier=B;A.sender_id=C;A.workflow=D
+	async def run(A,input_data=_A):
+		O='result';N='error';M='startedAt';G=input_data;F='executionId';H={};B=_A;C=_A;I=_A;P=int(time.time()*1000)
+		if A.workflow.observability:B=create_workflow_observability(app_id=A.notifier.app_id,token=A.notifier.auth_token);await B.register_workflow(A.workflow);J=await B.start_execution({'workflowId':A.workflow.name,'userId':A.sender_id,'input':G});C=J[F];I=J[M]
+		Q=WorkflowContext(notifier=A.notifier,sender_id=A.sender_id,workflow=A.workflow,input_data=G,state=H,observability=B,execution_id=C);D=_A;E='ok';K=_A
+		try:D=await A.workflow.entry(Q)
+		except Exception as R:E=N;K={'message':str(R)};raise
+		finally:
+			if B and C:S=datetime.now(timezone.utc).isoformat();T=B.get_step_count();await B.complete_execution({F:C,'status':E,'endedAt':S,'durationMs':int(time.time()*1000)-P,'stepCount':T,N:K,O:D if E=='ok'else _A,M:I})
+		L={O:D,'state':H}
+		if C:L[F]=C
+		return L

dnotifier-1.0.0/src/dnotifier/workflow/step_types.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+_J='Vector Search'
+_I='semanticSearch'
+_H='getDocument'
+_G='listDocuments'
+_F='deleteDocument'
+_E='updateDocument'
+_D='addDocument'
+_C='fetchAIHistory'
+_B='search'
+_A='sendAI'
+STEP_TYPE_AGENT='Agent'
+STEP_TYPE_CUSTOM='Custom'
+SDK_API_STEP_TYPES=[_A,_C,_B,_D,_E,_F,_G,_H]
+LOG_TYPE_BY_API={_A:'AI-LLM',_C:'AI History',_B:_J,_I:_J,_D:'Document Add',_E:'Document Update',_F:'Document Delete',_G:'Document List',_H:'Document Get','agent':STEP_TYPE_AGENT}
+LEGACY_KIND_TO_API={'ai_call':_A,'vector_call':_B}
+def to_log_step_type(api_name):
+	B=api_name
+	if B is None or not str(B).strip():return STEP_TYPE_CUSTOM
+	A=str(B)
+	if A in LOG_TYPE_BY_API:return LOG_TYPE_BY_API[A]
+	C=A.lower()
+	for(D,E)in LOG_TYPE_BY_API.items():
+		if D.lower()==C:return E
+	return A
+def resolve_api_name(step):
+	B=step.get('kind')
+	if B is None or not str(B).strip():return
+	A=str(B)
+	if A in LEGACY_KIND_TO_API:return LEGACY_KIND_TO_API[A]
+	if A in('agent',_I)or A in SDK_API_STEP_TYPES:return A
+def resolve_step_type(step):
+	A=step.get('type')
+	if A is not None and str(A).strip():
+		B=str(A).strip()
+		if B in LOG_TYPE_BY_API.values():return B
+		return to_log_step_type(B)
+	C=resolve_api_name(step)
+	if C:return to_log_step_type(C)
+	return STEP_TYPE_CUSTOM

dnotifier-1.0.0/src/dnotifier/workflow/workflow.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from typing import Awaitable,Callable,TYPE_CHECKING
+from.agent import Agent
+from.errors import WorkflowError
+if TYPE_CHECKING:from.context import WorkflowContext
+WorkflowEntry=Callable[['WorkflowContext'],Awaitable]
+def _normalize_description(description):
+	A=description
+	if A is None or A=='':return
+	if not isinstance(A,str):raise WorkflowError('Workflow description must be a string')
+	B=A.strip()
+	if len(B)>100:raise WorkflowError('Workflow description must be at most 100 characters')
+	return B if B else None
+class Workflow:
+	def __init__(A,name,entry,description=None,observability=False):
+		C=entry;B=name
+		if not B or not isinstance(B,str):raise WorkflowError('Workflow name is required')
+		if not callable(C):raise WorkflowError('Workflow entry must be a callable')
+		A.name=B.strip();A.description=_normalize_description(description);A.observability=bool(observability);A.entry=C;A._agents={};A._registered_with_observability=False
+	def register_agent(C,name,agent):
+		B=agent;A=name
+		if not A or not isinstance(A,str):raise WorkflowError('Agent registration name is required')
+		if not B or not callable(B.run):raise WorkflowError(f'Invalid agent for "{A}"')
+		C._agents[A]=B;return C
+	def register_agents(A,agents):
+		for(B,C)in agents.items():A.register_agent(B,C)
+		return A
+	def get_agent(A,name):return A._agents.get(name)

dnotifier-1.0.0/src/dnotifier/workflow/workflow_observability_client.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+_J='record'
+_I='executionId'
+_H='stepCount'
+_G='error'
+_F='input'
+_E='workflowId'
+_D='appId'
+_C='status'
+_B='id'
+_A=None
+from typing import Any,TYPE_CHECKING
+from..config.endpoints import DNotifierEndpoints
+from..transport.http_transport import HttpTransport
+from.ids import short_id
+from.json_payload import set_json_column
+from.step_types import resolve_step_type
+class WorkflowObservabilityClient:
+	def __init__(A,app_id=_A,token=_A):A.app_id=app_id;A.token=token
+	def configure(A,app_id=_A,token=_A):
+		C=token;B=app_id
+		if B is not _A:A.app_id=B
+		if C is not _A:A.token=C
+	def _transport(A,url):B={'authorization':A.token}if A.token else{};return HttpTransport(url,B)
+	async def _post(A,url,body):
+		if not A.token:return
+		try:await A._transport(url).send(body)
+		except Exception:pass
+	async def register_workflow(E,payload):
+		D='name';B='description';A=payload;C={_D:A[_D],_E:A[_E],D:A[D]}
+		if A.get(B):C[B]=A[B]
+		await E._post(DNotifierEndpoints.workflow_register_url,C);return{'ok':True}
+	async def create_execution(F,payload):E='startedAt';D='userId';A=payload;C=A.get(_B)or short_id('exec');B={_B:C,_D:A[_D],_E:A[_E],D:A[D],_C:'in_progress',_H:0,E:A[E]};set_json_column(B,_F,A.get(_F));await F._post(DNotifierEndpoints.workflow_executions_url,B);return{_I:C,_J:B}
+	async def update_execution(G,execution_id,patch):F='result';E='durationMs';D='endedAt';C=execution_id;A=patch;B={_B:C,_C:A[_C],D:A[D],E:A[E],_H:A[_H]};set_json_column(B,_G,A.get(_G));set_json_column(B,F,A.get(F));await G._post(DNotifierEndpoints.workflow_execution_complete_url(C),B);return{'ok':True,_J:B}
+	async def add_step(O,execution_id,step):
+		N='output';M='tokensOut';L='tokensIn';K='latencyMs';J='executedAt';I='label';H='kind';F=execution_id;E='model';D='apiName';C='agentName';A=step;G=resolve_step_type(A);P=A.get(C)or A.get(H)or A.get(D);B={_B:A[_B],_I:F,H:P,I:A.get(I),'type':G,'step_type':G,_C:A.get(_C),J:A.get(J),K:A.get(K,0),L:A.get(L,0),M:A.get(M,0)}
+		if A.get(D):B[D]=A[D]
+		if A.get(C):B[C]=A[C]
+		if A.get(E):B[E]=str(A[E])
+		set_json_column(B,_F,A.get(_F));set_json_column(B,N,A.get(N));set_json_column(B,_G,A.get(_G));await O._post(DNotifierEndpoints.workflow_execution_steps_url(F),B);return{'ok':True}