workflow-exec-engine 0.0.2__py3-none-any.whl

workflow_engine/client/extension_interceptor.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""A2A Extension interceptor - injects A2A-Extensions HTTP header.
+
+Reads the agent's declared extensions from AgentCard.capabilities.extensions[].uri
+and sets the A2A-Extensions header so the server knows which extensions
+the client supports.
+"""
+
+from typing import List
+from loguru import logger
+
+try:
+    from a2a.client.interceptors import ClientCallInterceptor, BeforeArgs, AfterArgs
+    from a2a.client.client import ClientCallContext
+    from a2a.extensions.common import HTTP_EXTENSION_HEADER, get_requested_extensions
+    _A2A_AVAILABLE = True
+except ImportError:
+    _A2A_AVAILABLE = False
+
+
+class ExtensionInterceptor(ClientCallInterceptor if _A2A_AVAILABLE else object):
+    """Injects A2A extension URIs from AgentCard into HTTP headers."""
+
+    def __init__(self, extension_uris: List[str]):
+        self._uris = list(extension_uris) if extension_uris else []
+
+    async def before(self, args: BeforeArgs) -> None:
+        if not self._uris:
+            return
+        if args.context is None:
+            args.context = ClientCallContext()
+        if args.context.service_parameters is None:
+            args.context.service_parameters = {}
+        # Only advertise extensions that are actually present in this message's metadata.
+        # Java SDK's ExtensionInterceptor.filterActiveExtensions does the same: it inspects
+        # the payload (message metadata) and only includes URIs that appear as keys.
+        payload = args.payload if hasattr(args, "payload") else None
+        active_uris = []
+        if isinstance(payload, dict):
+            for uri in self._uris:
+                if uri in payload:
+                    active_uris.append(uri)
+        elif hasattr(payload, "message") and hasattr(payload.message, "metadata"):
+            meta = payload.message.metadata
+            meta_keys = set(meta.keys()) if meta else set()
+            for uri in self._uris:
+                if uri in meta_keys:
+                    active_uris.append(uri)
+        if not active_uris:
+            return
+        existing = args.context.service_parameters.get(HTTP_EXTENSION_HEADER, "")
+        existing_values = [existing] if existing else []
+        merged = sorted(get_requested_extensions([*existing_values, *active_uris]))
+        extension_value = ",".join(merged)
+        args.context.service_parameters[HTTP_EXTENSION_HEADER] = extension_value
+        args.context.service_parameters["x-a2a-extensions"] = extension_value
+        logger.info(f"[Extensions] Set {HTTP_EXTENSION_HEADER}={extension_value}")
+
+    async def after(self, args: AfterArgs) -> None:
+        pass

workflow_engine/client/extension_sender.py

@@ -0,0 +1,203 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""ExtensionSender -- one-shot pre-positioning facade over A2ATransport.
+
+Single responsibility: send Authorization-T / Notification-T (and any
+other one-shot extension) messages to agents BEFORE the workflow starts.
+Bypasses Task-T prompt generation and the Negotiation-T auto-loop, and
+does not emit events through the global EventCallback (the returned
+result is the callback).
+
+Kept separate from WorkflowEngineClient so a caller that only wants to
+pre-position is not forced to hold a workflow-machinery facade.
+"""
+
+from typing import Dict, Any, Optional, Callable
+import asyncio
+from loguru import logger
+
+from workflow_engine.client.a2a_transport import A2ATransport
+from workflow_engine.client.extensions import A2ATExtension
+from workflow_engine.core.models import SendMessageResult
+
+
+class ExtensionSender:
+    """One-shot extension message sender built on a shared A2ATransport."""
+
+    def __init__(self, transport: A2ATransport):
+        self._transport = transport
+
+    @property
+    def transport(self) -> A2ATransport:
+        return self._transport
+
+    def get_a2at_client(self):
+        return self._transport.get_a2at_client()
+
+    async def send_extension_message(
+        self,
+        agent_name: str,
+        instruction: str,
+        natural_language_input: str,
+        extension: A2ATExtension,
+    ) -> SendMessageResult:
+        """Send a one-shot extension message for pre-positioning.
+
+        The metadata value is generated by the A2A-T SDK (LLM + prompt
+        template) from the natural-language input; if the SDK cannot
+        generate, the input text is used as-is.
+
+        For NOTIFICATION_T, automatically routes to a long-lived SSE stream
+        (subscription stays open). The returned result contains the
+        subscription confirmation.
+        """
+        agent_card = self._transport.get_card(agent_name)
+        if not agent_card:
+            raise RuntimeError(f"Agent not found: {agent_name}")
+        metadata_value = await asyncio.to_thread(
+            self._generate_extension_prompt, extension, natural_language_input
+        )
+        if not metadata_value:
+            metadata_value = natural_language_input
+            logger.info(f"[ExtensionSender] SDK prompt generation unavailable for {agent_name} ({extension.display_name}), using input as metadata")
+        logger.info(f"[ExtensionSender] sendExtensionMessage to {agent_name}: extension={extension.display_name}, metadataValue={len(metadata_value)} chars")
+        metadata = {extension.uri: metadata_value}
+        client = self._transport.create_a2a_client(agent_card)
+        send_req = self._transport.build_send_request(instruction, None, metadata)
+
+        if extension == A2ATExtension.NOTIFICATION_T:
+            logger.info(f"[ExtensionSender] Notification-T auto-routed to long-lived SSE stream")
+            await self._transport.consume_notification_stream(
+                client, send_req, event_callback=None, agent_name=agent_name
+            )
+            return SendMessageResult(
+                text="Subscribed", task=None,
+                metadata=metadata, task_state="TASK_STATE_WORKING",
+            )
+
+        response_text, last_task, last_meta, task_state = (
+            await self._transport.consume_stream(client, send_req)
+        )
+        if response_text is None and last_task is not None:
+            response_text = str(last_task)
+        result = SendMessageResult(
+            text=response_text or "", task=last_task,
+            metadata=last_meta, task_state=task_state,
+        )
+        logger.info(f"[ExtensionSender] Extension response from {agent_name}: state={result.task_state}")
+        return result
+
+    async def send_authorization(
+        self, agent_name: str, instruction: str, natural_language_input: str,
+    ) -> SendMessageResult:
+        """Convenience for Authorization-T pre-positioning."""
+        return await self.send_extension_message(
+            agent_name, instruction, natural_language_input, A2ATExtension.AUTHORIZATION_T)
+
+    async def send_notification(
+        self, agent_name: str, instruction: str, natural_language_input: str,
+        event_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+    ) -> SendMessageResult:
+        """Notification-T pre-positioning with long-lived SSE subscription.
+
+        Always opens a long-lived SSE stream. The returned
+        ``SendMessageResult`` contains the subscription confirmation.
+        Subsequent events pushed by the agent (e.g. recovery results) are
+        forwarded to ``event_callback`` as dicts containing ``agent``,
+        ``type``, ``state``, ``text``, ``metadata``, etc.
+
+        When ``event_callback`` is ``None``, the stream stays open and
+        events are logged at INFO level but not forwarded.
+
+        The background stream task is stored on the sender instance and
+        can be cancelled via ``cancel_notification_streams()``.
+        """
+        agent_card = self._transport.get_card(agent_name)
+        if not agent_card:
+            raise RuntimeError(f"Agent not found: {agent_name}")
+        metadata_value = await asyncio.to_thread(
+            self._generate_extension_prompt, A2ATExtension.NOTIFICATION_T, natural_language_input
+        )
+        if not metadata_value:
+            metadata_value = natural_language_input
+            logger.info(f"[ExtensionSender] SDK prompt generation unavailable for {agent_name} (Notification-T), using input as metadata")
+        metadata = {A2ATExtension.NOTIFICATION_T.uri: metadata_value}
+        client = self._transport.create_a2a_client(agent_card)
+        send_req = self._transport.build_send_request(instruction, None, metadata)
+
+        logger.info(f"[ExtensionSender] sendNotification to {agent_name}: long-lived SSE, callback={'yes' if event_callback else 'no'}")
+        bg_task = await self._transport.consume_notification_stream(
+            client, send_req, event_callback, agent_name
+        )
+        if not hasattr(self, '_notification_tasks'):
+            self._notification_tasks = []
+        self._notification_tasks.append(bg_task)
+        return SendMessageResult(
+            text="Subscribed", task=None,
+            metadata=metadata, task_state="TASK_STATE_WORKING",
+        )
+
+    def cancel_notification_streams(self):
+        """Cancel all active Notification-T background streams."""
+        tasks = getattr(self, '_notification_tasks', [])
+        for t in tasks:
+            if not t.done():
+                t.cancel()
+        tasks.clear()
+        logger.info("[ExtensionSender] All notification streams cancelled")
+
+    # ------------------------------------------------------------------
+    # Extension prompt generation dispatch
+    # ------------------------------------------------------------------
+
+    def _generate_extension_prompt(self, extension, natural_language_input):
+        """Dispatch to the SDK extension-specific prompt generation."""
+        if extension == A2ATExtension.TASK_T:
+            return self.generate_prompt_text(natural_language_input)
+        if extension == A2ATExtension.NEGOTIATION_T:
+            return self.generate_negotiation_prompt(natural_language_input)
+        if extension == A2ATExtension.AUTHORIZATION_T:
+            return self.generate_authorization_prompt(natural_language_input)
+        if extension == A2ATExtension.NOTIFICATION_T:
+            return self.generate_notification_prompt(natural_language_input)
+        return ''
+
+    def generate_prompt_text(self, natural_language_input: str) -> str:
+        """Generate structured Task-T prompt text from natural-language input."""
+        a2at_client = self._transport.get_a2at_client()
+        if not a2at_client:
+            return ''
+        try:
+            prompt_result = a2at_client.generate_task_prompt(natural_language_input)
+            if hasattr(prompt_result, 'success') and prompt_result.success:
+                text = getattr(prompt_result, 'prompt_text', None)
+                if text:
+                    return text
+            else:
+                failure = getattr(prompt_result, 'failure', None)
+                if failure:
+                    logger.warning('[ExtensionSender] SDK Task-T prompt generation failed: ' + str(getattr(failure, 'message', '')))
+        except Exception as e:
+            logger.warning('[ExtensionSender] SDK Task-T prompt generation error: ' + str(e))
+        return ''
+
+    def generate_negotiation_prompt(self, natural_language_input: str) -> str:
+        """Generate Negotiation-T prompt text. Reserved for SDK support."""
+        if not self._transport.get_a2at_client():
+            return ''
+        return ''
+
+    def generate_authorization_prompt(self, natural_language_input: str) -> str:
+        """Generate Authorization-T prompt text. Reserved for SDK support."""
+        if not self._transport.get_a2at_client():
+            return ''
+        return ''
+
+    def generate_notification_prompt(self, natural_language_input: str) -> str:
+        """Generate Notification-T prompt text. Reserved for SDK support."""
+        if not self._transport.get_a2at_client():
+            return ''
+        return ''

workflow_engine/client/extensions.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""A2A-T extension type constants.
+
+Each constant encapsulates the full extension URI so callers never need to
+hardcode URI strings. Use these with ``WorkflowEngineClient.send_extension_message``.
+"""
+
+from enum import Enum
+
+
+class A2ATExtension(Enum):
+    """A2A-T extension types supported by the workflow execution engine."""
+
+    TASK_T = "https://projects.tmforum.org/a2aproject/telecommunication/extensions/Task-T/v1"
+    NEGOTIATION_T = "https://projects.tmforum.org/a2aproject/telecommunication/extensions/NEGOTIATION-T"
+    AUTHORIZATION_T = "https://projects.tmforum.org/a2aproject/telecommunication/extensions/Authorization-T/v1"
+    NOTIFICATION_T = "https://projects.tmforum.org/a2aproject/telecommunication/extensions/Notification-T/v1"
+
+    @property
+    def uri(self) -> str:
+        """The full extension URI used as metadata key and A2A-Extensions header value."""
+        return self.value
+
+    @property
+    def display_name(self) -> str:
+        """Short display name (e.g. 'Authorization-T')."""
+        return self.name.replace("_", "-")

workflow_engine/client/protocol_logger.py

@@ -0,0 +1,78 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Protocol-level request/response logger.
+
+Mirrors the Java SDK's ProtocolLogger: prints full HTTP headers and
+body content at INFO level for protocol debugging. Enable by setting
+the logging level to INFO for this module.
+"""
+
+import json
+from typing import Any, Dict, Optional
+from loguru import logger
+
+
+def log_request(agent_name: str, endpoint: str,
+                params: Any, headers: Optional[Dict[str, str]] = None) -> None:
+    """Log an outgoing A2A request (headers + body)."""
+    if isinstance(params, str):
+        body = params
+    else:
+        try:
+            body = json.dumps(params, ensure_ascii=False, indent=2, default=str)
+        except Exception:
+            body = str(params)
+    header_lines = []
+    if headers:
+        for k, v in sorted(headers.items()):
+            header_lines.append(f"  {k}: {v if isinstance(v, str) else str(v)[:200]}")
+    header_str = "\n".join(header_lines) if header_lines else "  (none)"
+    logger.info(f">>> [{agent_name}] REQUEST to {endpoint}\n=== Headers ===\n{header_str}\n=== Body ===\n{body}")
+
+
+def log_response(agent_name: str, event_type: str, body: str) -> None:
+    """Log an incoming A2A response (event type + body)."""
+    logger.info(f"<<< [{agent_name}] RESPONSE [{event_type}]\n{body}")
+
+
+def log_response_event(agent_name: str, event: Any) -> None:
+    """Log a structured SSE response event (mirrors Java ProtocolLogger.logResponseEvent).
+
+    Extracts the inner payload from TaskUpdateEvent / MessageEvent wrappers
+    and logs the full JSON for protocol-level debugging.
+    """
+    try:
+        event_type = type(event).__name__
+        payload = _extract_payload(event)
+        if payload is None:
+            logger.info(f"<<< [{agent_name}] RESPONSE [{event_type}]: (no serializable payload)")
+            return
+        if isinstance(payload, str):
+            body = payload
+        else:
+            try:
+                body = json.dumps(payload, ensure_ascii=False, indent=2, default=str)
+            except Exception:
+                body = str(payload)
+        logger.info(f"<<< [{agent_name}] RESPONSE [{event_type}]\n{body}")
+    except Exception as e:
+        logger.warning(f"<<< [{agent_name}] Failed to serialize response event: {e}")
+
+
+def _extract_payload(event: Any) -> Any:
+    """Extract the serializable protocol payload from a ClientEvent."""
+    if hasattr(event, "task"):
+        task = event.task
+        if hasattr(task, "status_updates") and task.status_updates:
+            return task.status_updates[-1]
+        if hasattr(task, "artifacts") and task.artifacts:
+            return task.artifacts[-1]
+        return task
+    if hasattr(event, "message"):
+        return event.message
+    if hasattr(event, "update_event"):
+        return event.update_event
+    return event

workflow_engine/client/sse_normalization.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""SSE response normalization for non-standard agent responses.
+
+Some A2A agents return bare Task or Message objects instead of properly
+wrapped StreamResponse envelopes.  This module patches google.protobuf
+json_format.Parse/ParseDict to coerce such responses into the expected
+StreamResponse shape, mirroring the orchestration center's exec_engine.
+
+Import this module once at startup; the patch is process-global.
+"""
+
+import json as _json
+import google.protobuf.json_format as _json_format
+
+_STREAM_RESPONSE_KEYS = frozenset({"task", "message", "statusUpdate", "artifactUpdate"})
+
+_original_parse = _json_format.Parse
+_original_parse_dict = _json_format.ParseDict
+
+
+def _normalize_stream_response(data: dict) -> dict:
+    """Coerce a non-SSE dict into a StreamResponse-shaped dict."""
+    if _STREAM_RESPONSE_KEYS.intersection(data):
+        return data
+    if "id" in data and "status" in data:
+        return {"task": data}
+    if "artifact" in data and "taskId" in data:
+        return {"artifactUpdate": data}
+    if "status" in data and "taskId" in data:
+        return {"statusUpdate": data}
+    return data
+
+
+def _parse_with_unknown(text, message, ignore_unknown_fields=False, **kwargs):
+    from a2a.types.a2a_pb2 import StreamResponse
+    is_stream = isinstance(message, StreamResponse)
+    if is_stream:
+        try:
+            data = _json.loads(text)
+            if isinstance(data, dict):
+                if not _STREAM_RESPONSE_KEYS.intersection(data):
+                    logger = __import__("loguru").logger
+                    logger.warning(f"[A2A] Non-SSE response from server: {text[:2048]}")
+                data = _normalize_stream_response(data)
+                text = _json.dumps(data)
+        except Exception:
+            pass
+        kwargs["ignore_unknown_fields"] = True
+    return _original_parse(text, message, ignore_unknown_fields=ignore_unknown_fields, **kwargs)
+
+
+def _parse_dict_with_unknown(js, message, *args, **kwargs):
+    from a2a.types.a2a_pb2 import StreamResponse
+    is_stream = isinstance(message, StreamResponse)
+    if is_stream and isinstance(js, dict):
+        js = _normalize_stream_response(js)
+    if not is_stream:
+        return _original_parse_dict(js, message, *args, **kwargs)
+    kwargs.pop("ignore_unknown_fields", None)
+    args = list(args)
+    if args:
+        args[0] = True
+    else:
+        kwargs["ignore_unknown_fields"] = True
+    return _original_parse_dict(js, message, *args, **kwargs)
+
+
+def apply_sse_normalization():
+    """Apply the global Parse/ParseDict patches (idempotent)."""
+    _json_format.Parse = _parse_with_unknown
+    _json_format.ParseDict = _parse_dict_with_unknown

workflow_engine/client/ssl_context.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""SSL context factory for outbound HTTPS calls.
+
+Self-contained - does not depend on the orchestration center's config system.
+Accepts a config dict with SSL parameters, or returns False (skip verification)
+when no config is provided.
+"""
+
+import os
+import ssl
+from typing import Union, Optional
+from loguru import logger
+
+
+def create_ssl_context(
+    verify_server: bool = False,
+    ca_certs_path: Optional[str] = None,
+    cert_path: Optional[str] = None,
+    key_path: Optional[str] = None,
+    key_password: Optional[str] = None,
+    crl_path: Optional[str] = None,
+) -> Union[ssl.SSLContext, bool]:
+    """Build an SSL context for httpx verify parameter.
+
+    Args:
+        verify_server: Whether to verify remote server certificates.
+        ca_certs_path: Path to CA trust store file.
+        cert_path: Path to client certificate (for mTLS).
+        key_path: Path to client private key.
+        key_password: Password for the private key.
+        crl_path: Path to CRL file.
+
+    Returns:
+        ssl.SSLContext if verification enabled, False otherwise.
+    """
+    if not verify_server:
+        logger.warning("Outbound TLS verification disabled. Insecure for production.")
+        return False
+
+    try:
+        ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+
+        if ca_certs_path and os.path.exists(ca_certs_path):
+            ctx.load_verify_locations(ca_certs_path)
+            logger.info(f"Client SSL: loaded CA trust store from {ca_certs_path}")
+        else:
+            logger.warning(f"Client SSL: CA trust store not found at {ca_certs_path}, using system default")
+
+        if cert_path and key_path and os.path.exists(cert_path) and os.path.exists(key_path):
+            try:
+                ctx.load_cert_chain(
+                    certfile=cert_path,
+                    keyfile=key_path,
+                    password=key_password if key_password else None,
+                )
+                logger.info("Client SSL: loaded client identity cert for mTLS")
+            except Exception as e:
+                logger.warning(f"Client SSL: could not load client cert chain: {e}")
+
+        if crl_path and os.path.exists(crl_path):
+            ctx.load_verify_locations(crl_path)
+            ctx.verify_flags |= ssl.VERIFY_CRL_CHECK_LEAF
+            logger.info(f"Client SSL: enabled CRL checking from {crl_path}")
+
+        return ctx
+    except Exception as e:
+        logger.error(f"Failed to build SSL context: {e}. Falling back to no verification.")
+        return False

workflow_engine/client/stub_engine_client.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Stub WorkflowEngineClient for testing.
+
+Mirrors the Java SDK's StubWorkflowEngineClient. Records all sends
+and returns canned responses. Useful for unit tests that need to
+verify the workflow engine dispatches correctly without real A2A.
+"""
+
+from typing import Any, Dict, List, Optional
+from workflow_engine.core.models import SendMessageResult
+from workflow_engine.control.control_points import EventType
+
+
+class StubWorkflowEngineClient:
+    """Minimal stub that records sends and returns canned text.
+
+    Implements the workflow-send surface only (send_message). The
+    pre-positioning surface (send_extension_message) lives on
+    ExtensionSender in production; tests that need to stub it can
+    subclass ExtensionSender or build a transport-backed stub.
+    """
+
+    def __init__(self):
+        self.sent: List[tuple] = []
+        self._control_point = None
+        self._event_callback = None
+
+    async def send_message(self, agent_name: str, message: str,
+                           context_id: Optional[str] = None,
+                           metadata: Optional[Dict[str, Any]] = None) -> SendMessageResult:
+        self.sent.append((agent_name, message))
+        return SendMessageResult(
+            text=f"OK from {agent_name}", task_state="COMPLETED")
+
+    def set_control_point(self, control_point):
+        self._control_point = control_point
+
+    def set_event_callback(self, callback):
+        self._event_callback = callback
+
+    def register_handler(self, handler):
+        pass
+
+    @property
+    def agent_names(self) -> List[str]:
+        return []
+
+    def update_agent_cards(self, agent_cards: List[Any]):
+        pass
+
+    def get_a2at_client(self):
+        return None
+
+    def get_card(self, agent_name: str):
+        return None
+
+    async def close(self):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

workflow_engine/control/__init__.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+from workflow_engine.control.control_points import (
+    ControlPoint,
+    EventCallback, EventType, NegotiationStrategy, DefaultControlPoint,
+)
+
+__all__ = ["ControlPoint",
+           "EventCallback", "EventType",
+           "NegotiationStrategy", "DefaultControlPoint"]