dnotifier 1.0.0__tar.gz → 1.0.2__tar.gz

{dnotifier-1.0.0 → dnotifier-1.0.2}/CHANGELOG.md

@@ -5,4 +5,3 @@
 * 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 → dnotifier-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dnotifier
-Version: 1.0.0
+Version: 1.0.2
 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
@@ -155,31 +155,6 @@ async def main():
 
 ---
 
-## 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 → dnotifier-1.0.2}/README.md

@@ -125,31 +125,6 @@ async def main():
 
 ---
 
-## 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 → dnotifier-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dnotifier"
-version = "1.0.0"
+version = "1.0.2"
 description = "Real-time notification and messaging SDK for Python. WebSocket & HTTP, auth, binary frames, AI, RAG, and workflows."
 readme = "README.md"
 license = { text = "Proprietary" }
@@ -53,3 +53,8 @@ include = [
   "/LICENSE",
   "/CHANGELOG.md",
 ]
+exclude = [
+  "/examples",
+  "/scripts",
+  "/tests",
+]

{dnotifier-1.0.0 → dnotifier-1.0.2}/src/dnotifier/config/endpoints.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-BASE_HOST='https://api.dnotifier.com'
+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"

{dnotifier-1.0.0 → dnotifier-1.0.2}/src/dnotifier/dnotifier.py

@@ -1,22 +1,26 @@
 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
+_g='content'
+_f='content or text is required'
+_e='saveHistory'
+_d='agent_name'
+_c='aiEnabled'
+_b='limits'
+_a='currentPacket'
+_Z='totalPackets'
+_Y='_responseData'
+_X='recordId'
+_W='record_id is required'
+_V='record_id'
+_U='messageId'
+_T='receivers'
+_S='future'
+_R='loop'
+_Q='text'
+_P='ai'
+_O='sender_id required'
+_N='handle'
+_M=False
+_L=True
 _K='Not connected'
 _J='id'
 _I='code'
@@ -40,6 +44,9 @@ 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
+from.workflow.remote_agent_client import DEFAULT_TIMEOUT_MS,bare_user_id,is_remote_agent_reply,send_remote_agent_error
+from.workflow.remote_agent_protocol import REMOTE_AGENT_OP_ERROR,REMOTE_AGENT_OP_INVOKE,is_remote_agent_envelope
+from.workflow.observability import create_workflow_observability
 _DEFAULT_WS_URL=DNotifierEndpoints.ws_url
 _DEFAULT_AUTH_URL=DNotifierEndpoints.auth_url
 _DEFAULT_HTTP_URL=DNotifierEndpoints.rpc_send_url
@@ -48,7 +55,7 @@ class DNotifierMessageMetadata:id:Optional[str];sender:str;timestamp:int;type:Op
 @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 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=_M;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)
@@ -58,10 +65,10 @@ 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):
+	def __init__(A,app_id,secret,transport,user_id,logs=_M,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
+		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=_M;A.ai_enabled=_M;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;A._remote_agent_pending={};A._wait_for_message_waiters=[];A._workflow_listeners=[]
 		if B=='ws':A._ws=WebsocketTransport()
 		elif B=='http':A._http=HttpTransport(_DEFAULT_HTTP_URL)
 		else:raise ValueError('transport must be "ws" or "http"')
@@ -69,31 +76,31 @@ class DNotifier:
 		A=response
 		if not isinstance(A,dict):return A
 		if _D in A and _G in A:return A
-		B=A.get(_V)
+		B=A.get(_Y)
 		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')))
+			if E==400:raise RuntimeError(str(D.get(_Y,'Authentication failed')))
 			raise RuntimeError('Authentication failed.')
-		C=D.get(_V)
+		C=D.get(_Y)
 		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
+		A.current_model=C.get('current_model');F=C.get(_b)or{};A.ai_enabled=bool(F.get(_c));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=_L;A.on_connected();return _L
 		B=A._ws
 		if B is _A:raise RuntimeError('WebSocket transport not initialized')
-		G=_L;H={}
+		G=_M;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()
+					if I=='102'and prefix_id(A.app_id,A.user_id)in S:G=_L;A.is_connected=_L;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}"
+				F=int(B.get(_Z)or 1);J=int(B.get(_a)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))
@@ -109,35 +116,90 @@ class DNotifier:
 				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
+			B=A.is_connected;A.is_connected=_M
 			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 L(err):A.is_connected=_M;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:_Q,_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 _L
+	def _emit_message(B,packet,data):A=packet;C=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));B._dispatch_inbound_message(C)
+	def _dispatch_inbound_message(B,msg):
+		O='agentName';N='output';M='state';I='correlationId';F=msg
+		try:A=F.payload.to_json()
+		except Exception:A=_A
+		if is_remote_agent_envelope(A)and is_remote_agent_reply(A):
+			E=B._remote_agent_pending.get(A.get(I))
+			if E:
+				G=E[_R];C=E[_S]
+				if E.get(_N)is not _A:E[_N].cancel()
+				B._remote_agent_pending.pop(A.get(I),_A)
+				if A.get('op')==REMOTE_AGENT_OP_ERROR:
+					def P():
+						if not C.done():C.set_exception(WorkflowError((A.get('error')or{}).get('message')or'Remote agent failed',agent_name=E.get(_d)))
+					G.call_soon_threadsafe(P)
+				else:
+					J=A.get(M);Q={N:A.get(N),M:J if isinstance(J,dict)else _A}
+					def R():
+						if not C.done():C.set_result(Q)
+					G.call_soon_threadsafe(R)
+				return
+		if is_remote_agent_envelope(A)and A.get('op')==REMOTE_AGENT_OP_INVOKE:
+			K=next((B for B in B._workflow_listeners if B.has_local_agent(A.get(O))),_A)
+			if K is not _A:asyncio.create_task(K._handle_remote_invoke(B,F,A));return
+			D=A.get('replyTo')
+			if not isinstance(D,str)or not D.strip():D=bare_user_id(B.app_id,F.metadata.sender)
+			else:D=D.strip()
+			L=A.get(I)
+			if L and D:asyncio.create_task(send_remote_agent_error(B,sender_id=B.user_id,receiver_id=D,correlation_id=str(L),message=f"Agent not hosted: {A.get(O)}"))
+			return
+		if is_remote_agent_envelope(A):return
+		if B._wait_for_message_waiters:
+			H=B._wait_for_message_waiters.pop(0)
+			if H.get(_N)is not _A:H[_N].cancel()
+			G=H[_R];C=H[_S]
+			def S():
+				if not C.done():C.set_result(F)
+			G.call_soon_threadsafe(S);return
+		B.on_message(F)
+	def _await_remote_agent_reply(D,correlation_id,*,timeout_ms=DEFAULT_TIMEOUT_MS,agent_name=_A):
+		F=timeout_ms;E=correlation_id;A=agent_name;C=asyncio.get_running_loop();B=C.create_future()
+		def G():
+			C=D._remote_agent_pending.pop(E,_A)
+			if C and not B.done():B.set_exception(WorkflowError(f"Remote agent timed out after {F}ms"+(f": {A}"if A else''),agent_name=A))
+		H=C.call_later(F/1e3,G);D._remote_agent_pending[E]={_S:B,_R:C,_N:H,_d:A};return B
+	async def _wait_for_inbound_message(C,*,timeout_ms=_A):
+		D=timeout_ms;E=DEFAULT_TIMEOUT_MS if D is _A else D;B=asyncio.get_running_loop();A=B.create_future()
+		def G():
+			try:C._wait_for_message_waiters.remove(F)
+			except ValueError:pass
+			if not A.done():A.set_exception(WorkflowError(f"wait_for_message timed out after {E}ms"))
+		H=B.call_later(E/1e3,G);F={_S:A,_R:B,_N:H};C._wait_for_message_waiters.append(F);return await A
+	def _register_workflow_listener(A,workflow):
+		B=workflow
+		if B not in A._workflow_listeners:A._workflow_listeners.append(B)
+	def _unregister_workflow_listener(A,workflow):A._workflow_listeners=[A for A in A._workflow_listeners if A is not workflow]
 	def get_plan_limits(C):
 		if not C.is_connected:raise RuntimeError(_K)
-		A=(C._auth_response or{}).get(_Y)
+		A=(C._auth_response or{}).get(_b)
 		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):
+		B=bool(A.get(_c));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=_L):
 		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 G:raise ValueError(_O)
 		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}
+		K=I or[H];B=to_bytes(json.dumps(data));D=A.message_size_limit or 32768;C=_random_uuid();E={_J:C,_C:_Q,_I:200,_Z:1,_a:1,_H:A.app_id,_B:prefix_id(A.app_id,G),_T:[prefix_id(A.app_id,B)for B in K if B],_F:int(time.time()*1000),_E:A.auth_token,_e: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))
+		for(M,N)in enumerate(J):O={**E,_J:C,_Z:L,_a: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):
+	async def send_ai(A,sender_id,message,save_history=_L,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 not C:raise ValueError(_O)
+			B=E or _random_uuid();F={_J:B,_C:_P,_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,_e: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
@@ -145,60 +207,60 @@ class DNotifier:
 	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 not B:raise ValueError(_O)
+		C={_J:_random_uuid(),_C:_P,_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 B:raise ValueError(_O)
 		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}
+		D={_J:_random_uuid(),_C:_Q,_I:201,_H:A.app_id,_B:prefix_id(A.app_id,B),_T:[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}
+		C={_J:_random_uuid(),_C:_P,_I:302,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_F:int(time.time()*1000),_E:A.auth_token,_U:B};D={_U: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}
+		C={_J:_random_uuid(),_C:_Q,_I:202,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_T:[],_F:int(time.time()*1000),_E:A.auth_token,_U:B};D={_U: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}
+		G={_J:_random_uuid(),_C:_P,_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)}
+		D=metadata;C=doc_type;B=content;E=(record_id or H.get(_V)or'').strip();F=B if B is not _A else text or''
+		if not E:raise ValueError(_W)
+		if not str(F).strip():raise ValueError(_f)
+		A={_X:E,_g: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)}
+		D=metadata;C=doc_type;B=content;E=(record_id or H.get(_V)or'').strip();F=B if B is not _A else text or''
+		if not E:raise ValueError(_W)
+		if not str(F).strip():raise ValueError(_f)
+		A={_X:E,_g: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})
+		A=(record_id or C.get(_V)or'').strip()
+		if not A:raise ValueError(_W)
+		return await B._send_document_rpc(sender_id,308,{_X: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
@@ -206,21 +268,21 @@ class DNotifier:
 		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})
+		A=(record_id or C.get(_V)or'').strip()
+		if not A:raise ValueError(_W)
+		return await B._send_document_rpc(sender_id,310,{_X: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 not B:raise ValueError(_O)
+		C={_J:_random_uuid(),_C:_P,_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}
+		C={_C:msg_type,_I:202,_H:A.app_id,_B:prefix_id(A.app_id,sender_id),_T:[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):
@@ -229,6 +291,14 @@ class DNotifier:
 	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 resume_workflow_context(B,trace_ctx,*,workflow=_A,input_data=_A,state=_A):
+		G='workflowId';F='executionId';D=state;A=trace_ctx
+		if not A.get(F)or not A.get(G):raise ValueError('trace_ctx requires executionId and workflowId')
+		E=create_workflow_observability(app_id=B.app_id,token=B.auth_token,append_only=_L)
+		async def H(_ctx):0
+		C=workflow or Workflow(name=str(A[G]),observability=_L,entry=H)
+		if C.observability:await E.register_workflow(C)
+		return WorkflowContext(notifier=B,sender_id=B.user_id,workflow=C,input_data=input_data,state=dict(D)if isinstance(D,dict)else{},observability=E if C.observability else _A,execution_id=A.get(F),trace_parent_step_id=A.get('parentStepId'))
 	async def disconnect(A):
 		if A._ws is not _A:await A._ws.close()
-		A.is_connected=_L
+		A.is_connected=_M

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

@@ -0,0 +1,144 @@
+from __future__ import annotations
+_Z='usesTokens'
+_Y='workflowId'
+_X='executionId'
+_W='siblingIndex'
+_V='branchKey'
+_U='apiName'
+_T='message'
+_S='stepId'
+_R='latencyMs'
+_Q='status'
+_P='ok'
+_O='type'
+_N='kind'
+_M='agentName'
+_L='key'
+_K='state'
+_J='error'
+_I='tokensOut'
+_H='tokensIn'
+_G='model'
+_F='output'
+_E='name'
+_D='parentStepId'
+_C='input'
+_B='label'
+_A=None
+import asyncio,json,time
+from typing import Any,TYPE_CHECKING
+from.errors import WorkflowError
+from.graph_parents import format_parent_step_id,resolve_recorded_parent_step_id
+from.remote_agent_client import invoke_remote_agent
+from.remote_agent_protocol import is_remote_agent_ref,remote_receiver_id
+from.step_types import STEP_TYPE_AGENT,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=_A
+	if isinstance(B,dict):
+		C=B.get(E)
+		if isinstance(C,dict):A=C.get(F)
+		if A is _A:A=B.get(F)
+	if not isinstance(A,dict):return{_H:0,_I:0,_G:_A}
+	G=A.get('prompt_tokens')or A.get('input_tokens')or A.get(_H)or 0;H=A.get('completion_tokens')or A.get('output_tokens')or A.get('total_tokens')or A.get(_I)or 0;D=_A
+	if isinstance(B,dict):
+		C=B.get(E)
+		if isinstance(C,dict):D=C.get(_G)
+		if D is _A:D=A.get(_G)
+	return{_H:G,_I:H,_G:D}
+def _snapshot(value):
+	A=value
+	try:
+		if A is _A:return
+		return json.loads(json.dumps(A,default=str))
+	except(TypeError,ValueError):return str(A)
+def _api_input(opts):
+	if not opts:return
+	B={_B,'dependsOn','parentStepIds',_V,_W,_D,_C};A={A:C for(A,C)in opts.items()if A not in B};return A if A else _A
+def _normalize_run_agents_spec(spec):
+	D=spec
+	if isinstance(D,list):
+		A=[]
+		for(F,B)in enumerate(D):
+			if isinstance(B,str):A.append({_E:B,_C:_A,_L:str(F)})
+			elif isinstance(B,dict)and B.get(_E):A.append({_E:B[_E],_C:B.get(_C),_L:str(F)})
+			else:raise WorkflowError('run_agents entry requires name')
+		return A
+	if isinstance(D,dict):
+		A=[]
+		for(E,C)in D.items():
+			if isinstance(C,dict)and _E in C:A.append({_E:C[_E],_C:C.get(_C),_L:E})
+			else:A.append({_E:E,_C:C,_L:E})
+		return A
+	raise WorkflowError('run_agents expects a list or dict spec')
+class WorkflowContext:
+	def __init__(A,notifier,sender_id,workflow,input_data,state=_A,observability=_A,execution_id=_A,agent_name=_A,entry_step_id=_A,trace_parent_step_id=_A):F=entry_step_id;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 _A else{};A._observability=D;A._execution_id=E;A._observability_enabled=bool(B.observability and D and E);A.agent_name=agent_name;A._entry_step_id=F;A._chain_head_step_id=F;A._trace_parent_step_id=trace_parent_step_id;A._current_step_id=_A;A.root_step_id=_A;A._terminal_step_ids=[]
+	def get_end_parent_step_id(A):
+		if A._terminal_step_ids:return format_parent_step_id(A._terminal_step_ids)
+		if A._entry_step_id:return A._entry_step_id
+	def _mark_terminal_steps(A,step_ids):
+		if A._current_step_id:return
+		A._terminal_step_ids=[str(A)for A in step_ids if A is not _A and str(A).strip()]
+	def _resolve_parent_step_id(A,options=_A):
+		B=options;B=B or{}
+		if _D in B:return B[_D]
+		if A._current_step_id:return A._current_step_id
+		if A._trace_parent_step_id:return A._trace_parent_step_id
+		if A._chain_head_step_id:return A._chain_head_step_id
+		if A._entry_step_id:return A._entry_step_id
+	def export_trace_context(A):return{_X:A._execution_id,_Y:A.workflow.name,_D:A._current_step_id or A._chain_head_step_id or A._trace_parent_step_id or A._entry_step_id}
+	async def _invoke_sdk_api(A,api_name,invoke,meta=_A):
+		D=api_name;B=meta;B=B or{};H=int(time.time()*1000);E=_P;C=_A;F=_A;G=to_log_step_type(D)
+		try:C=await invoke();return C
+		except Exception as I:E=_J;F={_T:str(I)};raise
+		finally:
+			if A._observability_enabled and A._observability and A._execution_id:J=_usage_from_response(C)if B.get(_Z)else{_H:0,_I:0,_G:_A};K=A.agent_name or D;await A._observability.record_step(A._execution_id,{_U:D,_M:A.agent_name,_N:K,_O:G,_B:B.get(_B)or G,_Q:E,_R:int(time.time()*1000)-H,_D:format_parent_step_id(A._current_step_id),**J,_C:_snapshot(B.get(_C)),_F:_snapshot(C),_K:_snapshot(A.state),_J:F})
+	async def _run_agent_observed(A,name,*,input_data=...,depends_on=_A,parent_step_ids=_A,branch_key=_A,sibling_index=_A,parent_step_id=...,timeout_ms=_A):
+		J=input_data;F=parent_step_id;C=name;D=A.workflow.get_agent_registration(C)
+		if not D:raise WorkflowError(f"Agent not found: {C}")
+		G=A.input if J is...else J;K={}
+		if F is not...:K[_D]=F
+		P=resolve_recorded_parent_step_id(parent_step_id=F if F is not...else...,parent_step_ids=parent_step_ids,depends_on=depends_on,resolve_parent=lambda:A._resolve_parent_step_id(K));B=A._observability.allocate_step_id()if A._observability_enabled and A._observability else _A;Q=int(time.time()*1000);H=_P;E=_A;L=_A
+		try:
+			if is_remote_agent_ref(D):
+				assert isinstance(D,dict);M=_A
+				if A._execution_id:M={_X:A._execution_id,_Y:A.workflow.name,_D:B or A._current_step_id or A._chain_head_step_id or A._trace_parent_step_id or A._entry_step_id}
+				N=await invoke_remote_agent(notifier=A.notifier,sender_id=A.sender_id,receiver_id=remote_receiver_id(D),agent_name=C,input_data=G,state=A.state,trace=M,timeout_ms=timeout_ms);O=N.get(_K)
+				if isinstance(O,dict):A.state.update(O)
+				E=N.get(_F);return{_F:E,_S:B}
+			R=D;I=WorkflowContext(notifier=A.notifier,sender_id=A.sender_id,workflow=A.workflow,input_data=G,state=A.state,observability=A._observability,execution_id=A._execution_id,agent_name=C,entry_step_id=A._entry_step_id,trace_parent_step_id=A._trace_parent_step_id);I._current_step_id=B;E=await R.run(I)
+			if B:I.root_step_id=B
+			return{_F:E,_S:B}
+		except Exception as S:H=_J;L={_T:str(S)};raise
+		finally:
+			if A._observability_enabled and A._observability and A._execution_id and B:
+				await A._observability.record_step(A._execution_id,{'id':B,_D:P,_V:branch_key,_W:sibling_index,_M:C,_N:C,_O:STEP_TYPE_AGENT,_B:C,_Q:H,_R:int(time.time()*1000)-Q,_C:_snapshot(G),_F:_snapshot(E),_K:_snapshot(A.state),_J:L});A.root_step_id=B
+				if H==_P and not A._current_step_id:A._chain_head_step_id=B
+	async def run_agent(A,name,input_data=_A,*,depends_on=_A,parent_step_ids=_A,branch_key=_A,sibling_index=_A,parent_step_id=...,timeout_ms=_A):
+		B=input_data;C=await A._run_agent_observed(name,input_data=...if B is _A else B,depends_on=depends_on,parent_step_ids=parent_step_ids,branch_key=branch_key,sibling_index=sibling_index,parent_step_id=parent_step_id,timeout_ms=timeout_ms);D=C.get(_S)
+		if D and not A._current_step_id:A._mark_terminal_steps([D])
+		return C[_F]
+	async def wait_for_message(B,*,timeout_ms=_A):
+		A=getattr(B.notifier,'_wait_for_inbound_message',_A)
+		if not callable(A):raise WorkflowError('wait_for_message requires a DNotifier instance')
+		return await A(timeout_ms=timeout_ms)
+	async def run_agents(B,spec,*,parent_step_id=...,label=_A):
+		I='stepIds';H='results';A=parent_step_id;M=label;D=_normalize_run_agents_spec(spec);E={}
+		if A is not...:E[_D]=A
+		J=resolve_recorded_parent_step_id(parent_step_id=A if A is not...else...,resolve_parent=lambda:B._resolve_parent_step_id(E))
+		async def K(entry,index):A=entry;return await B._run_agent_observed(A[_E],input_data=A[_C]if A[_C]is not _A else...,parent_step_id=J,sibling_index=index)
+		F=await asyncio.gather(*[K(B,A)for(A,B)in enumerate(D)]);G=[A[_F]for A in F];C=[A[_S]for A in F];B._mark_terminal_steps(C)
+		if isinstance(spec,list):return{H:G,I:C}
+		L={B[_L]:G[A]for(A,B)in enumerate(D)};return{H:L,I:C}
+	async def send_ai(B,**A):return await B._invoke_sdk_api('sendAI',lambda:B.notifier.send_ai(sender_id=B.sender_id,**A),{_B:A.get(_B),_C:A.get(_T)or _api_input(A),_Z: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),{_B:B.get(_B),_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),{_B:B.get(_B),_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),{_B:B.get(_B),_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),{_B:B.get(_B),_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),{_B:B.get(_B),_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),{_B:B.get(_B),_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),{_B:B.get(_B),_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(_O))if A.get(_O)else STEP_TYPE_CUSTOM;D=A.get(_D);await B._observability.record_step(B._execution_id,{**A,_U:A.get(_U)or A.get(_N),_M:A.get(_M)or B.agent_name,_N:A.get(_M)or B.agent_name or A.get(_N)or'custom',_O:C,_B:A.get(_B)or C,_H:A.get(_H,0),_I:A.get(_I,0),_G:A.get(_G),_R:A.get(_R,0),_Q:A.get(_Q,_P),_J:A.get(_J),_D:format_parent_step_id(D)if D is not _A else format_parent_step_id(B._current_step_id),_C:_snapshot(A.get(_C)),_F:_snapshot(A.get(_F)),_K:_snapshot(A[_K]if _K in A else B.state)})

dnotifier-1.0.2/src/dnotifier/workflow/graph_parents.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+_A=None
+from collections.abc import Callable,Sequence
+from typing import Any
+def format_parent_step_id(value):
+	A=value
+	if A is _A:return
+	if isinstance(A,(list,tuple)):B=[str(A).strip()for A in A if A is not _A and str(A).strip()];return','.join(B)if B else _A
+	C=str(A).strip();return C or _A
+def resolve_graph_parent_step_id(step):
+	B=step;A=B.get('parentStepIds')or B.get('dependsOn')
+	if isinstance(A,Sequence)and not isinstance(A,(str,bytes))and len(A)>0:return format_parent_step_id(A)
+	return format_parent_step_id(B.get('parentStepId'))
+def resolve_recorded_parent_step_id(*,parent_step_id=...,parent_step_ids=_A,depends_on=_A,resolve_parent=_A):
+	C=resolve_parent;B=parent_step_ids;A=parent_step_id;D=B if B else depends_on
+	if D:return format_parent_step_id(D)
+	if A is not...:return format_parent_step_id(A)
+	if C is not _A:return format_parent_step_id(C())

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+_C='workflowId'
+_B='executionId'
+_A=None
+from datetime import datetime,timezone
+from typing import TYPE_CHECKING,Any
+from.graph_parents import resolve_graph_parent_step_id
+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=_A,client=_A,append_only=False):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;A._append_only=append_only
+	def allocate_step_id(A):return short_id('step')
+	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,_C: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
+		if A._append_only:raise RuntimeError('start_execution is not allowed in append-only workflow observability mode')
+		C=short_id('exec');D=datetime.now(timezone.utc).isoformat()
+		try:await A.client.create_execution({'id':C,'appId':A.app_id,_C:B[_C],E:B[E],F:B.get(F),G:D})
+		except Exception:pass
+		A._step_counter=0;return{_B:C,G:D}
+	async def record_step(C,execution_id,step):
+		K='branchKey';J='siblingIndex';I='executedAt';H='kind';F='apiName';E='agentName';D=execution_id;A=step
+		if not D:return A
+		C._step_counter+=1;L=A.get('id')or C.allocate_step_id();G=resolve_step_type(A);M=A.get(E)or A.get(H)or A.get(F);N=resolve_graph_parent_step_id(A);B={**A,'id':L,_B:D,I:A.get(I)or datetime.now(timezone.utc).isoformat(),F:A.get(F),E:A.get(E),H:M,'type':G,'step_type':G,'parentStepId':N,J:A.get(J),K:A.get(K)};B.pop('dependsOn',_A);B.pop('parentStepIds',_A)
+		try:await C.client.add_step(D,B)
+		except Exception:pass
+		return B
+	async def complete_execution(B,params):
+		H='result';G='error';F='stepCount';E='durationMs';D='endedAt';C='status';A=params
+		if B._append_only:return
+		if not A.get(_B):return
+		try:await B.client.update_execution(A[_B],{C:A[C],D:A[D],E:A[E],F:A[F],G:A.get(G),H:A.get(H)})
+		except Exception:pass
+	def get_step_count(A):return A._step_counter
+def create_workflow_observability(app_id,token=_A,append_only=False):return WorkflowObservability(app_id=app_id,token=token,append_only=append_only)

dnotifier-1.0.2/src/dnotifier/workflow/remote_agent_client.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+_B=False
+_A=None
+import uuid
+from typing import Any,TYPE_CHECKING
+from.errors import WorkflowError
+from.remote_agent_protocol import REMOTE_AGENT_OP_ERROR,REMOTE_AGENT_OP_RESULT,create_error_envelope,create_invoke_envelope,create_result_envelope
+if TYPE_CHECKING:from..dnotifier import DNotifier
+DEFAULT_TIMEOUT_MS=120000
+def bare_user_id(app_id,prefixed_sender):
+	A=prefixed_sender
+	if not A or not isinstance(A,str):return''
+	B=f"{app_id}:"
+	if A.startswith(B):return A[len(B):]
+	C=A.find(':')
+	if C>=0:return A[C+1:]
+	return A
+def is_remote_agent_reply(data):return isinstance(data,dict)and data.get('op')in(REMOTE_AGENT_OP_RESULT,REMOTE_AGENT_OP_ERROR)
+async def invoke_remote_agent(*,notifier,sender_id,receiver_id,agent_name,input_data=_A,state=_A,trace=_A,timeout_ms=_A):
+	E=timeout_ms;D=receiver_id;C=sender_id;B=agent_name;A=notifier
+	if not getattr(A,'is_connected',_B):raise WorkflowError('Remote agent invoke requires a connected notifier')
+	if not D:raise WorkflowError(f'Remote agent "{B}" is missing receiver_id')
+	F=str(uuid.uuid4());G=create_invoke_envelope(correlation_id=F,agent_name=B,input_data=input_data,state=state,trace=trace,reply_to=C);H=A._await_remote_agent_reply(F,timeout_ms=E if E is not _A else DEFAULT_TIMEOUT_MS,agent_name=B);await A.send(sender_id=C,receiver_id=D,data=G,save_history=_B);return await H
+async def send_remote_agent_result(notifier,*,sender_id,receiver_id,correlation_id,output=_A,state=_A):await notifier.send(sender_id=sender_id,receiver_id=receiver_id,data=create_result_envelope(correlation_id=correlation_id,output=output,state=state),save_history=_B)
+async def send_remote_agent_error(notifier,*,sender_id,receiver_id,correlation_id,message):await notifier.send(sender_id=sender_id,receiver_id=receiver_id,data=create_error_envelope(correlation_id=correlation_id,message=message),save_history=_B)

dnotifier-1.0.2/src/dnotifier/workflow/remote_agent_protocol.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+_F='receiverId'
+_E='receiver_id'
+_D='correlationId'
+_C='op'
+_B='__dnotifier'
+_A=None
+from typing import Any
+REMOTE_AGENT_KIND='dnotifier.remoteAgent'
+REMOTE_AGENT_OP_INVOKE='invoke'
+REMOTE_AGENT_OP_RESULT='result'
+REMOTE_AGENT_OP_ERROR='error'
+def is_remote_agent_envelope(data):A=data;return isinstance(A,dict)and A.get(_B)==REMOTE_AGENT_KIND and isinstance(A.get(_C),str)
+def is_remote_agent_ref(value):
+	C=False;A=value
+	if not isinstance(A,dict):return C
+	if callable(getattr(A,'run',_A)):return C
+	B=A.get(_E)or A.get(_F);return isinstance(B,str)and B.strip()!=''
+def remote_receiver_id(value):A=value;B=A.get(_E)or A.get(_F);return str(B).strip()
+def create_invoke_envelope(*,correlation_id,agent_name,reply_to,input_data=_A,state=_A,trace=_A):return{_B:REMOTE_AGENT_KIND,_C:REMOTE_AGENT_OP_INVOKE,_D:correlation_id,'agentName':agent_name,'input':input_data,'state':state,'trace':trace,'replyTo':reply_to}
+def create_result_envelope(*,correlation_id,output=_A,state=_A):return{_B:REMOTE_AGENT_KIND,_C:REMOTE_AGENT_OP_RESULT,_D:correlation_id,'output':output,'state':state}
+def create_error_envelope(*,correlation_id,message):return{_B:REMOTE_AGENT_KIND,_C:REMOTE_AGENT_OP_ERROR,_D:correlation_id,'error':{'message':message}}

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

@@ -0,0 +1,36 @@
+from __future__ import annotations
+_A=None
+import json,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
+from.step_types import STEP_TYPE_END,STEP_TYPE_ENTRY
+if TYPE_CHECKING:from..dnotifier import DNotifier;from.workflow import Workflow
+def _snapshot(value):
+	A=value
+	try:
+		if A is _A:return
+		return json.loads(json.dumps(A,default=str))
+	except(TypeError,ValueError):return str(A)
+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):
+		a='result';Z='parentStepId';Y='latencyMs';X='label';W='kind';V='type';U='startedAt';T='input';N='error';M='state';L='status';K='executionId';G=input_data;F='ok';H={};B=_A;C=_A;O=_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);Q=await B.start_execution({'workflowId':A.workflow.name,'userId':A.sender_id,T:G});C=Q[K];O=Q[U]
+		R=_A
+		if B and C:b=await B.record_step(C,{V:STEP_TYPE_ENTRY,W:'entry',X:A.workflow.name,L:F,Y:0,Z:_A,T:_snapshot(G),M:_snapshot(H)});R=b.get('id')
+		I=WorkflowContext(notifier=A.notifier,sender_id=A.sender_id,workflow=A.workflow,input_data=G,state=H,observability=B,execution_id=C,entry_step_id=R);E=_A;D=F;J=_A
+		try:E=await A.workflow.entry(I)
+		except Exception as c:D=N;J={'message':str(c)};raise
+		finally:
+			if B and C:await B.record_step(C,{V:STEP_TYPE_END,W:'end',X:A.workflow.name,L:D,Y:int(time.time()*1000)-P,Z:I.get_end_parent_step_id(),'output':_snapshot(E if D==F else _A),M:_snapshot(I.state),N:J});d=datetime.now(timezone.utc).isoformat();e=B.get_step_count();await B.complete_execution({K:C,L:D,'endedAt':d,'durationMs':int(time.time()*1000)-P,'stepCount':e,N:J,a:E if D==F else _A,U:O})
+		S={a:E,M:H}
+		if C:S[K]=C
+		return S

{dnotifier-1.0.0 → dnotifier-1.0.2}/src/dnotifier/workflow/step_types.py

@@ -10,7 +10,11 @@ _C='fetchAIHistory'
 _B='search'
 _A='sendAI'
 STEP_TYPE_AGENT='Agent'
+STEP_TYPE_PARALLEL='Parallel'
+STEP_TYPE_ENTRY='Entry'
+STEP_TYPE_END='End'
 STEP_TYPE_CUSTOM='Custom'
+STRUCTURAL_STEP_TYPES=[STEP_TYPE_AGENT,STEP_TYPE_PARALLEL,STEP_TYPE_ENTRY,STEP_TYPE_END,STEP_TYPE_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}
@@ -30,11 +34,12 @@ def resolve_api_name(step):
 	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)
+	B=step.get('type')
+	if B is not None and str(B).strip():
+		A=str(B).strip()
+		if A in STRUCTURAL_STEP_TYPES:return A
+		if A in LOG_TYPE_BY_API.values():return A
+		return to_log_step_type(A)
 	C=resolve_api_name(step)
 	if C:return to_log_step_type(C)
 	return STEP_TYPE_CUSTOM

dnotifier-1.0.2/src/dnotifier/workflow/workflow.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+_A=None
+from typing import Any,Awaitable,Callable,TYPE_CHECKING,Union
+from.agent import Agent
+from.errors import WorkflowError
+from.remote_agent_protocol import is_remote_agent_ref,remote_receiver_id
+if TYPE_CHECKING:from..dnotifier import DNotifier;from.context import WorkflowContext
+WorkflowEntry=Callable[['WorkflowContext'],Awaitable]
+AgentRegistration=Union[Agent,dict[str,Any]]
+def _normalize_description(description):
+	A=description
+	if A is _A 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 _A
+class Workflow:
+	def __init__(A,name,entry,description=_A,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;A._listen_notifier=_A
+	def register_agent(C,name,agent):
+		B=name;A=agent
+		if not B or not isinstance(B,str):raise WorkflowError('Agent registration name is required')
+		if is_remote_agent_ref(A):assert isinstance(A,dict);C._agents[B]={'receiver_id':remote_receiver_id(A)};return C
+		if not A or not callable(getattr(A,'run',_A)):raise WorkflowError(f'Invalid agent for "{B}" (expected Agent or {{"receiver_id": ...}})')
+		C._agents[B]=A;return C
+	def register_agents(A,agents):
+		for(B,C)in agents.items():A.register_agent(B,C)
+		return A
+	def get_agent(B,name):
+		A=B._agents.get(name)
+		if A is _A or is_remote_agent_ref(A):return
+		return A
+	def get_agent_registration(A,name):return A._agents.get(name)
+	def has_local_agent(A,name):return A.get_agent(name)is not _A
+	def listen(A,notifier):
+		B=notifier
+		if B is _A:raise WorkflowError('workflow.listen requires a DNotifier instance')
+		if A._listen_notifier is not _A and A._listen_notifier is not B:A._listen_notifier._unregister_workflow_listener(A)
+		A._listen_notifier=B;B._register_workflow_listener(A);return A
+	async def _handle_remote_invoke(D,notifier,msg,data):
+		O='input';N='trace';C=data;A=notifier;from.context import WorkflowContext as P;from.observability import create_workflow_observability as Q;from.remote_agent_client import bare_user_id as R,send_remote_agent_error as I,send_remote_agent_result as S;G=C.get('agentName');E=C.get('correlationId');B=C.get('replyTo')
+		if not isinstance(B,str)or not B.strip():T=getattr(getattr(msg,'metadata',_A),'sender',_A);B=R(A.app_id,T)
+		else:B=B.strip()
+		if not E or not B:return
+		if not D.has_local_agent(str(G)):await I(A,sender_id=A.user_id,receiver_id=B,correlation_id=str(E),message=f"Agent not hosted: {G}");return
+		J={};K=C.get('state')
+		if isinstance(K,dict):J=dict(K)
+		H=_A;F=C.get(N)if isinstance(C.get(N),dict)else _A;L=F.get('executionId')if F else _A
+		if L and D.observability:H=Q(app_id=A.app_id,token=A.auth_token,append_only=True);await H.register_workflow(D)
+		M=P(notifier=A,sender_id=A.user_id,workflow=D,input_data=C.get(O),state=J,observability=H,execution_id=L,trace_parent_step_id=F.get('parentStepId')if F else _A)
+		try:U=await M.run_agent(str(G),input_data=C.get(O));await S(A,sender_id=A.user_id,receiver_id=B,correlation_id=str(E),output=U,state=M.state)
+		except Exception as V:await I(A,sender_id=A.user_id,receiver_id=B,correlation_id=str(E),message=str(V))

{dnotifier-1.0.0 → dnotifier-1.0.2}/src/dnotifier/workflow/workflow_observability_client.py

@@ -32,9 +32,15 @@ class WorkflowObservabilityClient:
 		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)}
+	async def add_step(V,execution_id,step):
+		U='branchKey';T='siblingIndex';S='parentStepId';R='state';Q='output';P='tokensOut';O='tokensIn';N='latencyMs';M='executedAt';L='label';K='kind';G=execution_id;F='model';D='apiName';C='agentName';A=step;H=resolve_step_type(A);W=A.get(C)or A.get(K)or A.get(D);B={_B:A[_B],_I:G,K:W,L:A.get(L),'type':H,'step_type':H,_C:A.get(_C),M:A.get(M),N:A.get(N,0),O:A.get(O,0),P:A.get(P,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}
+		if A.get(F):B[F]=str(A[F])
+		set_json_column(B,_F,A.get(_F));set_json_column(B,Q,A.get(Q));set_json_column(B,R,A.get(R));set_json_column(B,_G,A.get(_G));I=A.get(S)
+		if I:B[S]=I
+		E=A.get(T)
+		if E is not _A and E!='':B[T]=E
+		J=A.get(U)
+		if J:B[U]=J
+		await V._post(DNotifierEndpoints.workflow_execution_steps_url(G),B);return{'ok':True}

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

@@ -1,68 +0,0 @@
-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/observability.py

@@ -1,36 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/workflow.py

@@ -1,28 +0,0 @@
-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)