dnotifier 1.0.2__tar.gz → 1.0.4__tar.gz

dnotifier-1.0.4/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 1.0.0
+
+* Initial Python SDK release with feature parity to JS and Dart SDKs.
+* WebSocket and HTTP transport, messaging, AI, RAG documents, chat history, session logging, and workflows.

{dnotifier-1.0.2 → dnotifier-1.0.4}/LICENSE

@@ -4,3 +4,7 @@ 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.
+
+For licensing inquiries, contact DNotifier.
+Website: https://dnotifier.com
+

{dnotifier-1.0.2 → dnotifier-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dnotifier
-Version: 1.0.2
+Version: 1.0.4
 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

{dnotifier-1.0.2 → dnotifier-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dnotifier"
-version = "1.0.2"
+version = "1.0.4"
 description = "Real-time notification and messaging SDK for Python. WebSocket & HTTP, auth, binary frames, AI, RAG, and workflows."
 readme = "README.md"
 license = { text = "Proprietary" }

dnotifier-1.0.4/src/dnotifier/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from.agent_runtime.errors import AgentExecutionError,BackendError,DNotifierAgentError,LLMError,MCPConnectionError,MCPToolError,PermissionDeniedError,ToolExecutionError,ToolNotFoundError,ToolValidationError
+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.3'
+__all__=['DNotifier','DNotifierMessage','DNotifierMessageMetadata','DNotifierPlanLimits','Payload','Agent','define_agent','Workflow','WorkflowContext','WorkflowRunner','WorkflowError','DNotifierAgentError','ToolNotFoundError','ToolValidationError','ToolExecutionError','PermissionDeniedError','MCPConnectionError','MCPToolError','AgentExecutionError','BackendError','LLMError','__version__']

dnotifier-1.0.4/src/dnotifier/agent_runtime/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+_A='backend'
+from typing import Any,Callable,Literal,Optional
+from.backend_client import AgentBackendClient,AgentSync
+from.errors import AgentExecutionError,BackendError,DNotifierAgentError,LLMError,MCPConnectionError,MCPToolError,PermissionDeniedError,ToolExecutionError,ToolNotFoundError,ToolValidationError
+from.mcp.registry import McpRegistry
+from.observability import AgentObservability
+from.runtime import run_agent_loop,run_tool_agent,workflow_trace_from_context
+from.tool_registry import ToolRegistry
+class AgentServices:
+	def __init__(A,*,backend,sync,events,tools,mcp,permission_enforcement):A.backend=backend;A.sync=sync;A.events=events;A.tools=tools;A.mcp=mcp;A.permission_enforcement=permission_enforcement
+	def configure(A,*,token=None,on_agent_event=...):
+		C=on_agent_event;B=token
+		if B is not None:A.backend.configure(token=B)
+		if C is not...:A.events.on_agent_event=C
+def create_agent_services(*,permission_enforcement=_A,on_agent_event=None):E='disabled';A=AgentBackendClient();B=AgentSync(backend=A);C=AgentObservability(backend=A,on_agent_event=on_agent_event);D=ToolRegistry(sync=B);F=McpRegistry(tools=D,sync=B,events=C);return AgentServices(backend=A,sync=B,events=C,tools=D,mcp=F,permission_enforcement=E if permission_enforcement==E else _A)
+__all__=['create_agent_services','run_agent_loop','run_tool_agent','workflow_trace_from_context','AgentServices','DNotifierAgentError','ToolNotFoundError','ToolValidationError','ToolExecutionError','PermissionDeniedError','MCPConnectionError','MCPToolError','AgentExecutionError','BackendError','LLMError']

dnotifier-1.0.4/src/dnotifier/agent_runtime/backend_client.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+_F='server'
+_E='tools'
+_D='name'
+_C='sdkVersion'
+_B='id'
+_A=None
+import asyncio,logging
+from typing import Any,Optional,TYPE_CHECKING
+from..config.endpoints import DNotifierEndpoints
+from..transport.http_transport import HttpTransport
+from.descriptors import to_public_tool
+from.errors import BackendError
+from.ids import agent_backend_id
+if TYPE_CHECKING:from..workflow.agent import Agent
+SDK_VERSION='1.0.3'
+logger=logging.getLogger('dnotifier')
+def _unwrap(body):
+	E='_responseData';D='_responseCode';A=body
+	if isinstance(A,dict)and A.get(D)is not _A:
+		C=int(A[D])
+		if C!=200:
+			B=A.get(E)
+			if not isinstance(B,str):B=str(B or'')
+			raise RuntimeError(B or f"Backend response {C}")
+		return A.get(E,A)
+	return A
+class AgentBackendClient:
+	def __init__(A,*,token=_A,request_timeout_ms=30000):A.token=token;A.request_timeout_ms=request_timeout_ms
+	def configure(B,*,token=_A):
+		A=token
+		if A is not _A:B.token=A
+	async def post(B,url,body):
+		if not B.token:raise BackendError('Agent backend call requires a connected client')
+		C=HttpTransport(url,headers={'authorization':f"{B.token}"},timeout_ms=B.request_timeout_ms)
+		try:return _unwrap(await C.send(body))
+		except BackendError:raise
+		except Exception as A:raise BackendError(str(A)or'Backend request failed',cause=A if isinstance(A,BaseException)else _A)from A
+	async def post_quiet(A,url,body):
+		if not A.token:return
+		try:await A.post(url,body)
+		except Exception:pass
+	async def register_tool(A,tool):await A.post(DNotifierEndpoints.agent_tool_register_url,{**to_public_tool(tool),_C:SDK_VERSION})
+	async def register_mcp_server(C,server):B='transport';A=server;await C.post(DNotifierEndpoints.agent_mcp_server_register_url,{_B:A[_B],_D:A[_D],B:A[B],_C:SDK_VERSION})
+	async def register_mcp_server_tools(A,server_id,tools):await A.post(DNotifierEndpoints.agent_mcp_server_tools_url(server_id),{_E:[to_public_tool(A)for A in tools],_C:SDK_VERSION})
+	async def register_agent(B,agent):G='permissions';F='toolIds';E='mcpServerId';A=agent;C=agent_backend_id(A.name);D=A.tools or[];H=list({A.get(E)for A in D if isinstance(A,dict)and A.get(E)});await B.post(DNotifierEndpoints.agent_register_url,{_B:C,_D:A.name,'description':A.description or'',F:[A[_B]for A in D],'mcpServerIds':H,G:A.permissions or{},_C:SDK_VERSION});await B.post(DNotifierEndpoints.agent_tools_url(C),{F:[A[_B]for A in D]});await B.post(DNotifierEndpoints.agent_permissions_url(C),{G:A.permissions or{}})
+	async def check_permission(B,body):A=await B.post(DNotifierEndpoints.agent_permission_check_url,body);return A if isinstance(A,dict)else{}
+class AgentSync:
+	def __init__(A,*,backend):A.backend=backend;A._tools={};A._servers={};A._agents={};A._lock=asyncio.Lock()
+	def enqueue_tool(A,tool):
+		A._tools[tool[_B]]=tool
+		if A.backend.token:
+			try:B=asyncio.get_running_loop();B.create_task(A._safe_flush())
+			except RuntimeError:pass
+	def enqueue_server(A,server,tools):
+		B=server;A._servers[B[_B]]={_F:B,_E:tools}
+		if A.backend.token:
+			try:C=asyncio.get_running_loop();C.create_task(A._safe_flush())
+			except RuntimeError:pass
+	def enqueue_agent(B,agent):A=agent;B._agents[agent_backend_id(A.name)]=A
+	async def _safe_flush(A):
+		try:await A.flush()
+		except Exception:pass
+	async def flush(A):
+		async with A._lock:await A._flush_once()
+	async def _flush_once(A):
+		if not A.backend.token:return
+		B=0
+		for(E,F)in list(A._tools.items()):
+			try:await A.backend.register_tool(F)
+			except Exception:B+=1
+			A._tools.pop(E,_A)
+		for(C,D)in list(A._servers.items()):
+			try:await A.backend.register_mcp_server(D[_F]);await A.backend.register_mcp_server_tools(C,D[_E])
+			except Exception:B+=1
+			A._servers.pop(C,_A)
+		for(G,H)in list(A._agents.items()):
+			try:await A.backend.register_agent(H)
+			except Exception:B+=1
+			A._agents.pop(G,_A)
+		if B>0:logger.warning('[dnotifier] skipped %s agent-backend register call(s) (routes not available yet)',B)

dnotifier-1.0.4/src/dnotifier/agent_runtime/descriptors.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+from typing import Any
+def to_public_tool(tool):
+	G='provider';F='inputSchema';E='description';D='name';B='mcpServerId';A=tool;C={'id':A['id'],D:A[D],E:A.get(E)or'',F:A.get(F)or{'type':'object'},G:A[G]}
+	if A.get(B):C[B]=A[B]
+	return C

dnotifier-1.0.4/src/dnotifier/agent_runtime/errors.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+_A=None
+from typing import Any,Optional
+class DNotifierAgentError(Exception):
+	def __init__(A,message,*,execution_id=_A,agent_id=_A,tool_id=_A,provider=_A,cause=_A,**C):
+		B=cause;super().__init__(message);A.name='DNotifierAgentError';A.execution_id=execution_id;A.agent_id=agent_id;A.tool_id=tool_id;A.provider=provider
+		if B is not _A:A.__cause__=B
+class ToolNotFoundError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='ToolNotFoundError'
+class ToolValidationError(DNotifierAgentError):
+	def __init__(A,message,fields=_A,issues=_A,**B):C={**(fields or{}),**B};super().__init__(message,**C);A.name='ToolValidationError';A.issues=issues or[]
+class ToolExecutionError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='ToolExecutionError'
+class PermissionDeniedError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='PermissionDeniedError'
+class MCPConnectionError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='MCPConnectionError';A.retryable=False
+class MCPToolError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='MCPToolError'
+class AgentExecutionError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='AgentExecutionError'
+class BackendError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='BackendError'
+class LLMError(DNotifierAgentError):
+	def __init__(A,message,**B):super().__init__(message,**B);A.name='LLMError'

dnotifier-1.0.4/src/dnotifier/agent_runtime/ids.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+import re
+def sanitize_id_part(value):A=re.sub('[^a-z0-9]+','_',str(value).strip().lower());return A.strip('_')
+def local_tool_id(name):
+	A=sanitize_id_part(name)
+	if not A:raise ValueError('Tool name is required')
+	return f"tool_{A}"
+def mcp_tool_id(server_id,tool_name):return f"mcp_{sanitize_id_part(server_id)}_{sanitize_id_part(tool_name)}"
+def mcp_tool_name(server_id,tool_name):return f"{server_id}.{tool_name}"
+def agent_backend_id(name):
+	A=sanitize_id_part(name)
+	if not A:raise ValueError('Agent name is required')
+	return f"agent_{A}"

dnotifier-1.0.4/src/dnotifier/agent_runtime/local_completions.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+_U='toOriginal'
+_T='tool_call_id'
+_S='toSanitized'
+_R='calls'
+_Q='toolCalls'
+_P='choices'
+_O='assistant'
+_N='tool'
+_M='id'
+_L='tokensOut'
+_K='tokensIn'
+_J='arguments'
+_I='type'
+_H='function'
+_G='tool_calls'
+_F='message'
+_E='role'
+_D='model'
+_C='name'
+_B='content'
+_A=None
+import json,logging,re
+from typing import Any,Optional,TYPE_CHECKING
+from.errors import LLMError
+if TYPE_CHECKING:from..dnotifier import DNotifier
+logger=logging.getLogger('dnotifier.agent_runtime')
+def _extract_data_payload(response):
+	A=response
+	if not isinstance(A,dict):return
+	B=A.get('data')
+	if isinstance(B,dict)and not isinstance(B,list):return B
+	return A
+def _extract_content(response):
+	D='text';A=response
+	if A is _A:return''
+	if isinstance(A,str):return A
+	B=_extract_data_payload(A);E=[B.get(_B)if B else _A,(B.get(_F)or{}).get(_B)if B else _A,B.get(D)if B else _A,((B.get(_P)or[{}])[0].get(_F)or{}).get(_B)if B else _A,A.get(_B)if isinstance(A,dict)else _A,(A.get(_F)or{}).get(_B)if isinstance(A,dict)else _A,A.get(D)if isinstance(A,dict)else _A]
+	for C in E:
+		if isinstance(C,str):return C
+	try:return json.dumps(A)
+	except(TypeError,ValueError):return str(A)
+def _extract_assistant_message(response):
+	B=response
+	if not isinstance(B,dict):return
+	C=_extract_data_payload(B);D=[C,(C.get(_P)or[{}])[0].get(_F)if C else _A,C.get(_F)if C else _A,(B.get(_P)or[{}])[0].get(_F),B.get(_F),B]
+	for A in D:
+		if not isinstance(A,dict):continue
+		if isinstance(A.get(_G),list)or isinstance(A.get(_Q),list)or isinstance(A.get(_B),str)or _B in A and A.get(_B)is _A:return A
+def _parse_tool_arguments(raw):
+	A=raw
+	if A is _A or A=='':return{}
+	if isinstance(A,dict):return A
+	if isinstance(A,str):
+		try:
+			B=json.loads(A)
+			if isinstance(B,dict):return B
+			return{}
+		except(TypeError,ValueError,json.JSONDecodeError):return{}
+	return{}
+def parse_native_turn(response):
+	E=response;A=_extract_assistant_message(E);C=_A
+	if A:
+		C=A.get(_G)
+		if C is _A:C=A.get(_Q)
+	if isinstance(C,list)and len(C)>0:
+		F=[]
+		for(H,B)in enumerate(C):B=B or{};D=B.get(_H)if isinstance(B.get(_H),dict)else _A;F.append({_M:B.get(_M)or f"call_{H+1}",_C:(D or{}).get(_C)if D else B.get(_C),_J:_parse_tool_arguments((D or{}).get(_J)if D else B.get(_J))})
+		return{_I:_G,_R:F}
+	if A is not _A and _B in A:G=''if A.get(_B)is _A else str(A[_B])
+	else:G=_extract_content(E)
+	return{_I:_F,_B:G}
+def _usage_from_response(response):
+	D='usage';C=response;B=_extract_data_payload(C);A=_A
+	if B:A=B.get(D)
+	if A is _A and isinstance(C,dict):A=C.get(D)
+	if not isinstance(A,dict):return{_K:0,_L:0,_D:str(B[_D])if B and B.get(_D)is not _A else _A}
+	return{_K:A.get('prompt_tokens')or A.get('input_tokens')or A.get(_K)or 0,_L:A.get('completion_tokens')or A.get('output_tokens')or A.get('total_tokens')or A.get(_L)or 0,_D:str(B[_D])if B and B.get(_D)is not _A else str(A[_D])if A.get(_D)is not _A else _A}
+def to_openai_tool_name(name):A=re.sub('[^a-zA-Z0-9_-]','_',str(name or''));return A or _N
+def build_openai_tool_name_map(tools=_A):
+	D={};C={}
+	for F in tools or[]:
+		A=str((F or{}).get(_C)or'')
+		if not A:continue
+		B=to_openai_tool_name(A);E=2
+		while B in C and C[B]!=A:B=f"{to_openai_tool_name(A)}_{E}";E+=1
+		D[A]=B;C[B]=A
+	return{_S:D,_U:C}
+def to_openai_tools(tools=_A,to_sanitized=_A):
+	D='description';B=tools;E=to_sanitized or build_openai_tool_name_map(B)[_S];C=[]
+	for A in B or[]:C.append({_I:_H,_H:{_C:E.get(A[_C])or to_openai_tool_name(A[_C]),D:A.get(D)or'','parameters':A.get('inputSchema')or{_I:'object','properties':{}}}})
+	return C
+def build_agent_chat_messages(history,to_sanitized=_A):
+	Q='user';L=to_sanitized;K=history;J='system';M=K if isinstance(K,list)else[];N='\n\n'.join(str(A.get(_B)or'').strip()for A in M if isinstance(A,dict)and A.get(_E)==J and str(A.get(_B)or'').strip());D=[]
+	if N:D.append({_E:J,_B:N})
+	for A in M:
+		if not isinstance(A,dict):continue
+		if A.get(_E)==J:continue
+		if A.get(_E)==Q:D.append({_E:Q,_B:str(A.get(_B)or'')});continue
+		if A.get(_E)==_O:
+			E=A.get(_Q)
+			if not isinstance(E,list):E=A.get(_G)
+			if isinstance(E,list)and len(E)>0:
+				I=A.get(_B);R=str(I)if I is not _A and str(I).strip()!=''else'';O=[]
+				for(S,B)in enumerate(E):
+					B=B or{};H=B.get(_H)if isinstance(B.get(_H),dict)else _A;C=(H or{}).get(_C)if H else B.get(_C);F=(H or{}).get(_J)if H else B.get(_J)
+					if not isinstance(F,str):F=json.dumps(F if F is not _A else{})
+					O.append({_M:str(B.get(_M)or f"call_{S+1}"),_I:_H,_H:{_C:((L or{}).get(C)if C else _A)or to_openai_tool_name(C),_J:F}})
+				D.append({_E:_O,_B:R,_G:O});continue
+			D.append({_E:_O,_B:str(A.get(_B)or'')});continue
+		if A.get(_E)==_N:
+			G=A.get('toolCallId')
+			if G is _A:G=A.get(_T)
+			if G is _A or str(G).strip()=='':continue
+			C=A.get(_C);P={_E:_N,_T:str(G),_B:str(A.get(_B)or'')}
+			if C:P[_C]=(L or{}).get(C)or to_openai_tool_name(C)
+			D.append(P)
+	return D
+def describe_chat_message_roles(messages):
+	D=messages;B=[]
+	for(C,A)in enumerate(D if isinstance(D,list)else[]):
+		if not isinstance(A,dict):B.append(f"{C}:<?>");continue
+		if A.get(_E)==_O and isinstance(A.get(_G),list):B.append(f"{C}:assistant(tool_calls={len(A[_G])})");continue
+		if A.get(_E)==_N:B.append(f"{C}:tool(tool_call_id={A.get(_T)or'?'})");continue
+		B.append(f"{C}:{A.get(_E)or'?'}")
+	return' -> '.join(B)
+async def complete_via_send_ai(notifier,body):
+	U=False;T='messages';L=notifier;K='tools';G='agentId';F='executionId';B='provider';A=body;M=A.get(K)if isinstance(A.get(K),list)else[];N=build_openai_tool_name_map(M);O=N[_S];V=N[_U];P=build_agent_chat_messages(A.get(T),O);Q=to_openai_tools(M,O);R=describe_chat_message_roles(P);S={'useKnowledgeBase':U,T:P}
+	if Q:S[K]=Q
+	try:C=await L.send_ai(sender_id=A.get('userId')or getattr(L,'user_id',_A),provider=A.get(B),model=A.get(_D),session_id=A.get('sessionId'),save_history=U,message=S)
+	except Exception as D:raise LLMError(str(D)or'Local sendAI completion failed',execution_id=A.get(F),agent_id=A.get(G),cause=D if isinstance(D,BaseException)else _A)from D
+	if C is _A:raise LLMError('Local sendAI completion returned empty response',execution_id=A.get(F),agent_id=A.get(G))
+	H=_extract_data_payload(C)
+	if H and H.get(_I)=='error':
+		I=H.get(_F)or'sendAI returned an error'
+		if re.search('role [\'\\"]tool[\'\\"].*tool_calls',str(I),re.I):logger.warning('[agent-runtime] sendAI rejected tool history. SDK messages: %s',R);logger.warning('[agent-runtime] If the digest shows assistant(tool_calls=N) immediately before tool(...), the server is likely dropping tool_calls before forwarding to the model.');raise LLMError(f"{I} (sdk messages: {R})",execution_id=A.get(F),agent_id=A.get(G))
+		raise LLMError(str(I),execution_id=A.get(F),agent_id=A.get(G))
+	J=_usage_from_response(C);W=str(A[_D])if A.get(_D)is not _A and str(A[_D]).strip()!=''else _A;X=str(A[B])if A.get(B)is not _A and str(A[B]).strip()!=''else _A;E=parse_native_turn(C)
+	if E[_I]==_G:E[_R]=[{**A,_C:V.get(A.get(_C),A.get(_C))}for A in E.get(_R)or[]]
+	return{**E,_D:J.get(_D)or W,B:X,_K:J[_K],_L:J[_L]}

dnotifier-1.0.4/src/dnotifier/agent_runtime/mcp/client.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+_J='message'
+_I='params'
+_H='2.0'
+_G='method'
+_F='jsonrpc'
+_E=False
+_D='error'
+_C=True
+_B='mcp'
+_A=None
+import json
+from typing import Any,Optional
+import httpx
+from..errors import MCPConnectionError,MCPToolError
+PROTOCOL_VERSION='2025-03-26'
+def _read_json(text):
+	if not text:return{}
+	try:return json.loads(text)
+	except(TypeError,ValueError,json.JSONDecodeError)as A:raise MCPConnectionError('MCP response was not JSON',cause=A)from A
+def _read_sse_json(text):
+	A=[A[5:].strip()for A in text.split('\n')if A.startswith('data:')];A=[A for A in A if A]
+	if not A:return{}
+	C=A[-1]
+	try:return json.loads(C)
+	except(TypeError,ValueError,json.JSONDecodeError)as B:raise MCPConnectionError('MCP event stream was not JSON',provider=_B,cause=B)from B
+def text_from_content(result):
+	B='text';A=result;C=A.get('content')if isinstance(A,dict)else _A;E=C if isinstance(C,list)else[];D='\n'.join(A.get(B)for A in E if isinstance(A,dict)and A.get('type')==B and isinstance(A.get(B),str))
+	if D:return D
+	try:return json.dumps(A if A is not _A else _A,default=str)
+	except(TypeError,ValueError):return str(A)
+class McpHttpClient:
+	def __init__(A,*,endpoint,headers=_A,sdk_version='1.0.3'):A.endpoint=endpoint;A.headers=dict(headers or{});A.sdk_version=sdk_version;A.session_id=_A;A._next_id=1;A._initialized=_E
+	async def connect(A):await A._initialize()
+	async def list_tools(E):
+		D='tools';C=[];A=_A
+		while _C:
+			B=await E._request('tools/list',{'cursor':A}if A else{});F=B.get(D)if isinstance(B.get(D),list)else[];C.extend(F);A=B.get('nextCursor')or _A
+			if not A:break
+		return C
+	async def call_tool(C,name,args,context=_A):
+		B=context;B=B or{};A=await C._request('tools/call',{'name':name,'arguments':args if args is not _A else{}},B.get('signal'))
+		if isinstance(A,dict)and A.get('isError'):raise MCPToolError(text_from_content(A)or f"MCP tool failed: {name}",provider=_B)
+		return A
+	async def _initialize(A):
+		B=await A._post({_F:_H,'id':A._next_id,_G:'initialize',_I:{'protocolVersion':PROTOCOL_VERSION,'capabilities':{},'clientInfo':{'name':'dnotifier-python-sdk','version':A.sdk_version}}},_A);A._next_id+=1
+		if isinstance(B,dict)and B.get(_D):C=B[_D];D=(C.get(_J)if isinstance(C,dict)else _A)or'MCP initialize failed';raise MCPConnectionError(D,provider=_B)
+		A._initialized=_C;await A._post({_F:_H,_G:'notifications/initialized'},_A)
+	async def _request(A,method,params,signal=_A):
+		C=method
+		async def B():
+			F=A._next_id;A._next_id+=1;B=await A._post({_F:_H,'id':F,_G:C,_I:params},signal)
+			if isinstance(B,dict)and B.get(_D):D=B[_D];G=(D.get(_J)if isinstance(D,dict)else _A)or f"MCP {C} failed";raise MCPToolError(G,provider=_B)
+			E=B.get('result')if isinstance(B,dict)else _A;return E if isinstance(E,dict)else{}
+		try:return await B()
+		except Exception as D:
+			if not getattr(D,'retryable',_E):raise
+			A._initialized=_E;A.session_id=_A;await A._initialize();return await B()
+	async def _post(B,payload,signal):
+		H='mcp-session-id';G='content-type';E={'accept':'application/json, text/event-stream',G:'application/json',**B.headers}
+		if B.session_id:E[H]=B.session_id
+		try:
+			async with httpx.AsyncClient(timeout=6e1)as I:A=await I.post(B.endpoint,headers=E,content=json.dumps(payload))
+		except(MCPConnectionError,MCPToolError):raise
+		except Exception as D:C=MCPConnectionError(str(D)or'MCP connection failed',provider=_B,cause=D if isinstance(D,BaseException)else _A);C.retryable=_C;raise C from D
+		F=A.headers.get(H)
+		if F:B.session_id=F
+		if A.status_code==404:C=MCPConnectionError('MCP session expired',provider=_B);C.retryable=_C;raise C
+		if A.status_code>=400:J=A.text;raise MCPConnectionError(J or f"MCP HTTP {A.status_code}",provider=_B)
+		K=A.headers.get(G)or''
+		if'text/event-stream'in K:return _read_sse_json(A.text)
+		return _read_json(A.text)

dnotifier-1.0.4/src/dnotifier/agent_runtime/mcp/registry.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+_J='toolId'
+_I='userId'
+_H='agentId'
+_G='executionId'
+_F='transport'
+_E='mcpServerId'
+_D='name'
+_C='mcp'
+_B=None
+_A='id'
+from typing import Any,Optional,TYPE_CHECKING
+from..errors import MCPConnectionError
+from..ids import mcp_tool_id,mcp_tool_name
+from.client import McpHttpClient,text_from_content
+if TYPE_CHECKING:from..backend_client import AgentSync;from..observability import AgentObservability;from..tool_registry import ToolRegistry
+class McpRegistry:
+	def __init__(A,*,tools,sync,events):A._tools=tools;A._sync=sync;A._events=events;A._connections={}
+	async def connect(B,config):
+		G='http';F='endpoint';A=config
+		if not A or not A.get(_A):raise MCPConnectionError('MCP connection id is required')
+		if not A.get(F):raise MCPConnectionError('MCP endpoint is required',provider=_C)
+		C=A.get(_F)or G
+		if C!=G:raise MCPConnectionError(f'MCP transport "{C}" is not implemented',provider=_C)
+		E=McpHttpClient(endpoint=A[F],headers=A.get('headers')or{});await E.connect();B._events.emit('mcp.connected',{_G:_B,_H:_B,_I:_B,_J:_B,_E:A[_A]});D=McpConnection(id=A[_A],name=A.get(_D)or A[_A],transport=C,client=E,tools=B._tools,sync=B._sync,events=B._events);await D.refresh_tools();B._connections[A[_A]]=D;return D
+	def get(A,connection_id):return A._connections.get(connection_id)
+	def list(A):return list(A._connections.values())
+class McpConnection:
+	def __init__(A,*,id,name,transport,client,tools,sync,events):A.id=id;A.name=name;A.transport=transport;A._client=client;A._registry=tools;A._sync=sync;A._events=events;A._tools=[]
+	def tools(A):return A._tools
+	async def refresh_tools(A):
+		G='provider';F='inputSchema';E='description';H=await A._client.list_tools();A._tools=[]
+		for C in H:B=C.get(_D);D={_A:mcp_tool_id(A.id,B),_D:mcp_tool_name(A.id,B),E:C.get(E)or'',F:C.get(F)or{'type':'object'},G:_C,_E:A.id,'mcpToolName':B,'execute':lambda input_data,context,_name=B:A.call_tool(_name,input_data,context)};A._registry.adopt(D);A._events.emit('mcp.tool.discovered',{_G:_B,_H:_B,_I:_B,_J:D[_A],_E:A.id,G:_C});A._tools.append(D)
+		A._sync.enqueue_server({_A:A.id,_D:A.name,_F:A.transport},A._tools);return A._tools
+	async def call_tool(A,original_name,input_data,context=_B):B=await A._client.call_tool(original_name,input_data,context or{});return text_from_content(B)

dnotifier-1.0.4/src/dnotifier/agent_runtime/observability.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from datetime import datetime,timezone
+from typing import Any,Callable,Optional,TYPE_CHECKING
+from..config.endpoints import DNotifierEndpoints
+if TYPE_CHECKING:from.backend_client import AgentBackendClient
+class AgentObservability:
+	def __init__(A,*,backend,on_agent_event=None):A.backend=backend;A.on_agent_event=on_agent_event
+	def emit(A,event_type,fields):
+		B={'type':event_type,**fields,'at':datetime.now(timezone.utc).isoformat()}
+		try:
+			if A.on_agent_event:A.on_agent_event(B)
+		except Exception:pass
+		try:import asyncio as C;D=C.get_running_loop();D.create_task(A.backend.post_quiet(DNotifierEndpoints.agent_events_url,B))
+		except RuntimeError:pass

dnotifier-1.0.4/src/dnotifier/agent_runtime/permissions.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+_A=None
+from typing import Any,Literal,Optional,TYPE_CHECKING
+from.errors import PermissionDeniedError
+if TYPE_CHECKING:from.backend_client import AgentBackendClient
+async def assert_tool_allowed(*,backend,enforcement,execution_id,agent_id,tool_id,user_id=_A,provider=_A):
+	E=tool_id;D=agent_id;C=execution_id
+	if enforcement=='disabled':return
+	F={'execution_id':C,'agent_id':D,'tool_id':E,'provider':provider}
+	try:A=await backend.check_permission({'executionId':C,'agentId':D,'userId':user_id,'toolId':E,'action':'execute'})
+	except Exception as B:raise PermissionDeniedError('Permission check failed closed',**F,cause=B if isinstance(B,BaseException)else _A)from B
+	if not isinstance(A,dict)or A.get('decision')!='allow':G=(A.get('reason')if isinstance(A,dict)else _A)or'Permission denied';raise PermissionDeniedError(G,**F)

dnotifier-1.0.4/src/dnotifier/agent_runtime/runtime.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+_p='toolCallId'
+_o='byName'
+_n='notifier'
+_m='lastStepId'
+_l='arguments'
+_k='call'
+_j='agentName'
+_i='messages'
+_h='tool'
+_g='metadata'
+_f='agentId'
+_e='observability'
+_d='tool_calls'
+_c='sendAI'
+_b='signal'
+_a='services'
+_Z='sessionId'
+_Y='toolId'
+_X='state'
+_W='latencyMs'
+_V='status'
+_U='label'
+_T='apiName'
+_S='kind'
+_R='trace'
+_Q='round'
+_P='output'
+_O='userId'
+_N='role'
+_M='siblingIndex'
+_L='input'
+_K='parentStepId'
+_J='message'
+_I='mcpServerId'
+_H='content'
+_G='executionId'
+_F='error'
+_E='name'
+_D='type'
+_C='id'
+_B='provider'
+_A=None
+import json,time
+from typing import Any,Optional,TYPE_CHECKING
+from..workflow.ids import short_id
+from..workflow.step_types import STEP_TYPE_TOOL,to_log_step_type
+from.descriptors import to_public_tool
+from.errors import AgentExecutionError,DNotifierAgentError,LLMError,PermissionDeniedError,ToolExecutionError,ToolNotFoundError
+from.ids import agent_backend_id
+from.local_completions import build_agent_chat_messages,build_openai_tool_name_map,complete_via_send_ai,to_openai_tools
+from.permissions import assert_tool_allowed
+from.schema import assert_valid_input
+if TYPE_CHECKING:from..dnotifier import DNotifier;from..workflow.agent import Agent;from..workflow.context import WorkflowContext
+STEP_TYPE_AI_LLM=to_log_step_type(_c)
+TRACE_CONTENT_MAX=8000
+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 _truncate_text(value,max_len=TRACE_CONTENT_MAX):
+	C=value;B=max_len;A=''if C is _A else str(C)
+	if len(A)<=B:return A
+	return f"{A[:B]}…[truncated {len(A)-B} chars]"
+def _trace_llm_input(*,round_num,messages,tools):B='tool_call_id';A=[to_public_tool(A)for A in tools];C=build_openai_tool_name_map(A)['toSanitized'];D=build_agent_chat_messages(messages,C);E=to_openai_tools(A,C);return _snapshot({_Q:round_num,'messageCount':len(D),_i:[{**{_N:A[_N]},**({_H:_truncate_text(A[_H])}if A.get(_H)is not _A else{}),**({_d:A[_d]}if isinstance(A.get(_d),list)else{}),**({B:A[B]}if A.get(B)is not _A else{})}for A in D],'tools':E})
+def _initial_messages(input_data,instructions):
+	E='text';D=instructions;C='user';A=input_data;B=[]
+	if D:B.append({_N:'system',_H:D})
+	if isinstance(A,str):B.append({_N:C,_H:A});return B
+	if isinstance(A,dict):
+		if isinstance(A.get(_i),list):B.extend(A[_i]);return B
+		if isinstance(A.get(E),str):B.append({_N:C,_H:A[E]});return B
+		if isinstance(A.get(_J),str):B.append({_N:C,_H:A[_J]});return B
+	B.append({_N:C,_H:''if A is _A else json.dumps(A,default=str)});return B
+def _result_text(value):
+	A=value
+	if isinstance(A,str):return A
+	try:return json.dumps(A if A is not _A else _A,default=str)
+	except(TypeError,ValueError):return str(A)
+def _parse_arguments(raw,fields):
+	B=fields;A=raw
+	if A is _A or A=='':return{}
+	if isinstance(A,str):
+		try:return json.loads(A)
+		except(TypeError,ValueError,json.JSONDecodeError)as C:raise ToolExecutionError('Tool arguments are not valid JSON',**B,cause=C)from C
+	if isinstance(A,dict):return A
+	raise ToolExecutionError('Tool arguments must be an object',**B)
+def workflow_trace_from_context(ctx):
+	A=ctx
+	if not getattr(A,'_observability_enabled',False)or not getattr(A,'_observability',_A)or not getattr(A,'_execution_id',_A):return
+	return{_e:A._observability,_K:A._current_step_id or A._trace_parent_step_id,_j:A.agent_name}
+async def run_agent_loop(params):
+	k='Completion did not return a message or tool call';j='stop';f='calls';b='%Y-%m-%dT%H:%M:%S.000Z';a='startedAt';Z='llmLatencyMs';Q='finishReason';P='tokensOut';O='tokensIn';H='model';B=params;U=B[_n];C=B['agent'];S=agent_backend_id(C.name);D=B.get(_G)or short_id('exec');V=B.get(_O)
+	if V is _A:V=getattr(U,'user_id',_A)
+	g=B.get(_Z);h=B.get('maxToolRounds')or 8;I=B.get(_R)
+	if not getattr(U,'is_connected',False):raise AgentExecutionError('Not connected',execution_id=D,agent_id=S)
+	c=U._agent_services;c.sync.enqueue_agent(C);await c.sync.flush();d=C.tools or[];l={A[_E]:A for A in d};W=_initial_messages(B.get(_L),C.instructions or C.description or'');K=B.get(_B)
+	if K is _A:K=C.provider
+	L=B.get(H)
+	if L is _A:L=C.model
+	m=set();n=(I or{}).get(_K)if I else _A;M=n;T=_A;F=_A
+	for R in range(h):
+		J=int(time.time()*1000);E=_allocate_trace_step_id(I);X=_trace_llm_input(round_num=R,messages=W,tools=d)
+		try:A=await complete_via_send_ai(U,{_G:D,_f:S,_O:V,_Z:g,_i:W,'tools':[to_public_tool(A)for A in d],_B:K,H:L})
+		except Exception as o:G=int(time.time()*1000)-J;await _record_trace_step({_G:D,_R:I,_K:M,_M:T},{_C:E,_D:STEP_TYPE_AI_LLM,_S:C.name,_T:_c,_U:STEP_TYPE_AI_LLM,_V:_F,_W:G,H:L,_B:K,O:0,P:0,_L:X,_P:_A,_X:_snapshot({_Q:R,Q:_F,Z:G,a:time.strftime(b,time.gmtime(J/1000))}),_F:{_J:str(o)}});F=E or F;raise
+		Y=j if A[_D]==_J else _d;N=_A
+		if A[_D]==_d:
+			i=A.get(f)if isinstance(A.get(f),list)else[]
+			if i:N=[_ensure_unique_tool_call(A,m)for A in i]
+		if A[_D]!=_J and not N:G=int(time.time()*1000)-J;await _record_trace_step({_G:D,_R:I,_K:M,_M:T},{_C:E,_D:STEP_TYPE_AI_LLM,_S:C.name,_T:_c,_U:STEP_TYPE_AI_LLM,_V:_F,_W:G,H:A.get(H)or L,_B:A.get(_B)or K,O:A.get(O)or 0,P:A.get(P)or 0,_L:X,_P:_snapshot(A),_X:_snapshot({_Q:R,Q:_F,Z:G,a:time.strftime(b,time.gmtime(J/1000))}),_F:{_J:k}});F=E or F;raise LLMError(k,execution_id=D,agent_id=S)
+		G=int(time.time()*1000)-J
+		if A[_D]==_J:await _record_trace_step({_G:D,_R:I,_K:M,_M:T},{_C:E,_D:STEP_TYPE_AI_LLM,_S:C.name,_T:_c,_U:STEP_TYPE_AI_LLM,_V:'ok',_W:G,H:A.get(H)or L,_B:A.get(_B)or K,O:A.get(O)or 0,P:A.get(P)or 0,_L:X,_P:_snapshot({_D:A[_D],_H:_truncate_text(A.get(_H)or''),Q:Y}),_X:_snapshot({_Q:R,Q:Y,Z:G,a:time.strftime(b,time.gmtime(J/1000))}),_F:_A});F=E or F;return{_P:A.get(_H)or'',_G:D,Q:j,_m:F}
+		assert N is not _A;W.append({_N:'assistant','toolCalls':N});p=E or M
+		for(q,e)in enumerate(N):r=await _execute_tool_call({_a:c,_f:S,_G:D,_O:V,_Z:g,_b:B.get(_b),_g:B.get(_g),_o:l,_k:e,_R:I,_K:p,_M:q,_Q:R});W.append({_N:_h,_p:e.get(_C),_E:e.get(_E),_H:r})
+		s=int(time.time()*1000)-J;await _record_trace_step({_G:D,_R:I,_K:M,_M:T},{_C:E,_D:STEP_TYPE_AI_LLM,_S:C.name,_T:_c,_U:STEP_TYPE_AI_LLM,_V:'ok',_W:s,H:A.get(H)or L,_B:A.get(_B)or K,O:A.get(O)or 0,P:A.get(P)or 0,_L:X,_P:_snapshot({_D:A[_D],f:[{_C:A.get(_C),_E:A.get(_E),_l:A.get(_l)or{},_M:B}for(B,A)in enumerate(N)],Q:Y}),_X:_snapshot({_Q:R,Q:Y,Z:G,a:time.strftime(b,time.gmtime(J/1000))}),_F:_A});F=E or F;M=E or M;T=len(N)
+	raise AgentExecutionError(f"Agent stopped after {h} tool rounds",execution_id=D,agent_id=S)
+async def run_tool_agent(agent,ctx):
+	A=ctx;B=await run_agent_loop({_n:A.notifier,'agent':agent,_L:A.input,_G:A._execution_id,_O:A.sender_id,_Z:_A,_b:getattr(A,_b,_A),_g:_A,_R:workflow_trace_from_context(A)})
+	if B and B.get(_m):A._last_edge_step_id=B[_m]
+	return B
+def _allocate_trace_step_id(trace):
+	A=trace
+	if not A or not A.get(_e):return
+	C=A[_e];B=getattr(C,'allocate_step_id',_A)
+	if not callable(B):return
+	try:return B()
+	except Exception:return
+def _ensure_unique_tool_call(call,used_ids):
+	C=used_ids;D=call.get(_C);B=str(D).strip()if D is not _A else'';A=B if B and B not in C else _A
+	if not A:A=short_id(_k)
+	C.add(A);return{**call,_C:A}
+async def _record_trace_step(params,step):
+	B=step;A=params;C=A.get(_R)
+	if not C or not C.get(_e)or not A.get(_G):return B.get(_C)
+	try:
+		E=A[_K]if _K in A else C.get(_K);F=A[_M]if _M in A else B.get(_M);D=await C[_e].record_step(A[_G],{**B,_K:E,_j:B.get(_j)or C.get(_j),_M:F})
+		if isinstance(D,dict):return D.get(_C)or B.get(_C)
+		return B.get(_C)
+	except Exception:return B.get(_C)
+def _tool_trace_state(params,extra=_A):B=params;A=extra;C=B.get(_k)or{};A=A or{};return _snapshot({_Y:A.get(_Y),_B:A.get(_B),_I:A.get(_I),_p:C.get(_C),_Q:B.get(_Q),**A})
+async def _execute_tool_call(params):
+	P='tool.failed';O='tool.completed';N='tool.started';K='mcp';B=params;F=B[_k];Q=B[_o];G=B[_G];H=B[_f];A=Q.get(F.get(_E));I={'execution_id':G,'agent_id':H,'tool_id':(A or{}).get(_C),_B:(A or{}).get(_B)}
+	if not A:raise ToolNotFoundError(f"Tool not found: {F.get(_E)or''}",**I)
+	try:D=_parse_arguments(F.get(_l),I);assert_valid_input(A.get('inputSchema'),D,I)
+	except Exception as C:await _record_trace_step(B,{_D:STEP_TYPE_TOOL,_S:A[_E],_T:_h,_U:A[_E],_V:_F,_W:0,_B:A.get(_B),_L:_snapshot(F.get(_l)),_P:_A,_F:{_J:str(C)},_X:_tool_trace_state(B,{_Y:A[_C],_B:A.get(_B),_I:A.get(_I)})});raise
+	try:await assert_tool_allowed(backend=B[_a].backend,enforcement=B[_a].permission_enforcement,execution_id=G,agent_id=H,user_id=B.get(_O),tool_id=A[_C],provider=A.get(_B))
+	except Exception as C:await _record_trace_step(B,{_D:STEP_TYPE_TOOL,_S:A[_E],_T:_h,_U:A[_E],_V:_F,_W:0,_B:A.get(_B),_L:_snapshot(D),_P:_A,_F:{_J:str(C),**({'code':'permission_denied'}if isinstance(C,PermissionDeniedError)else{})},_X:_tool_trace_state(B,{_Y:A[_C],_B:A.get(_B),_I:A.get(_I),'decision':'deny'})});raise
+	R={_G:G,_f:H,_O:B.get(_O),_Z:B.get(_Z),_Y:A[_C],_g:B.get(_g),_b:B.get(_b)};J={_G:G,_f:H,_O:B.get(_O),_Y:A[_C],_I:A.get(_I),_B:A.get(_B)};S=[N,'mcp.tool.started']if A.get(_B)==K else[N]
+	for E in S:B[_a].events.emit(E,J)
+	L=int(time.time()*1000)
+	try:
+		M=await A['execute'](D,R);T=_result_text(M);U=[O,'mcp.tool.completed']if A.get(_B)==K else[O]
+		for E in U:B[_a].events.emit(E,J)
+		await _record_trace_step(B,{_D:STEP_TYPE_TOOL,_S:A[_E],_T:_h,_U:A[_E],_V:'ok',_W:int(time.time()*1000)-L,_B:A.get(_B),_L:_snapshot(D),_P:_snapshot(M),_F:_A,_X:_tool_trace_state(B,{_Y:A[_C],_B:A.get(_B),_I:A.get(_I)})});return T
+	except Exception as C:
+		V=[P,'mcp.tool.failed']if A.get(_B)==K else[P]
+		for E in V:B[_a].events.emit(E,{**J,_J:str(C)})
+		await _record_trace_step(B,{_D:STEP_TYPE_TOOL,_S:A[_E],_T:_h,_U:A[_E],_V:_F,_W:int(time.time()*1000)-L,_B:A.get(_B),_L:_snapshot(D),_P:_A,_F:{_J:str(C),'stack':getattr(C,'__traceback__',_A)},_X:_tool_trace_state(B,{_Y:A[_C],_B:A.get(_B),_I:A.get(_I)})})
+		if isinstance(C,DNotifierAgentError):raise
+		raise ToolExecutionError(str(C)or'Tool execution failed',**I,cause=C if isinstance(C,BaseException)else _A)from C