agent-framework-declarative 1.0.3__tar.gz → 1.0.4__tar.gz

{agent_framework_declarative-1.0.3 → agent_framework_declarative-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-declarative
-Version: 1.0.3
+Version: 1.0.4
 Summary: Declarative specification support for Microsoft Agent Framework.
 Author-email: Microsoft <af-support@microsoft.com>
 Requires-Python: >=3.10

{agent_framework_declarative-1.0.3 → agent_framework_declarative-1.0.4}/agent_framework_declarative/_workflows/_declarative_base.py

@@ -1084,6 +1084,8 @@ class DeclarativeActionExecutor(Executor):
         Follows .NET's DefaultTransform pattern - accepts any input type:
         - dict/Mapping: Used directly as workflow.inputs
         - str: Converted to {"input": value}
+        - Message: Starts a fresh run (e.g. from DevUI), with text and ID
+          surfaced through Inputs.input and System.LastMessage*.
         - list[Message]: Treated as the agent-facing message contract
           (e.g. from WorkflowAgent / as_agent()). The prior conversation
           history is stored in ``Conversation.messages``/
@@ -1113,26 +1115,18 @@ class DeclarativeActionExecutor(Executor):
         if isinstance(trigger, dict):
             # Structured inputs - use directly
             state.initialize(trigger)  # type: ignore
-        elif isinstance(trigger, list) and all(isinstance(m, Message) for m in trigger):  # pyright: ignore[reportUnknownVariableType]
-            # list[Message] (e.g. from WorkflowAgent / as_agent()).
-            messages_list = cast(list[Message], trigger)
-
-            # Detect continuation: if the workflow's shared state already
-            # carries declarative data from a prior turn (because the host
-            # restored a checkpoint and dispatched this run with
-            # reset_context=False), we MUST NOT call state.initialize() -
-            # that would wipe Conversation.messages, Local.*, System.* etc.
-            # Instead, treat the trigger as the new turn's user input only:
-            # update Inputs.input, append the new user message to existing
-            # Conversation history, and refresh System.LastMessage*.
-            #
-            # Continuation = declarative state already exists in the workflow's
-            # shared state (either left over in-memory from a prior turn on
-            # the same instance, or restored from a checkpoint just before
-            # this run). In that case state.initialize() would wipe Local.*,
-            # System.*, Conversation.* etc., destroying the cross-turn
-            # context we're trying to preserve.
-            is_continuation = state.is_initialized()
+        elif isinstance(trigger, Message) or (
+            isinstance(trigger, list) and all(isinstance(m, Message) for m in trigger)  # pyright: ignore[reportUnknownVariableType]
+        ):
+            # Message (e.g. from DevUI) or list[Message] (e.g. from WorkflowAgent / as_agent()).
+            messages_list = [trigger] if isinstance(trigger, Message) else cast(list[Message], trigger)
+
+            # Preserve the existing list[Message] continuation contract used
+            # by WorkflowAgent. A bare Message starts a fresh run: DevUI can
+            # reuse this workflow instance across unrelated conversations.
+            # State left on the instance is not evidence of session ownership.
+            # Explicit checkpoint/HIL restores use the runner's resume path.
+            is_continuation = not isinstance(trigger, Message) and state.is_initialized()
 
             # Locate the trailing user message in the trigger.
             last_user_index = -1

{agent_framework_declarative-1.0.3 → agent_framework_declarative-1.0.4}/agent_framework_declarative/_workflows/_executors_control_flow.py

@@ -400,6 +400,7 @@ class JoinExecutor(DeclarativeActionExecutor):
         self,
         trigger: dict[str, Any]
         | str
+        | Message
         | list[Message]
         | ActionTrigger
         | ActionComplete

{agent_framework_declarative-1.0.3 → agent_framework_declarative-1.0.4}/agent_framework_declarative/_workflows/_http_handler.py

@@ -24,6 +24,7 @@ import asyncio
 from collections.abc import Awaitable, Callable, Mapping
 from dataclasses import dataclass, field
 from typing import Any, Protocol, runtime_checkable
+from urllib.parse import parse_qsl, quote, urlencode, urlsplit, urlunsplit
 
 import httpx
 
@@ -173,16 +174,56 @@ class DefaultHttpRequestHandler:
                 # callers (not just the YAML executor) get sensible defaults.
                 headers["Content-Type"] = info.body_content_type or "text/plain"
 
-        params: Mapping[str, str] | None = info.query_parameters or None
-
-        response = await client.request(
+        # Compose the query as raw bytes rather than routing it through ``params=``.
+        # Anything that reaches ``httpx.QueryParams`` -- ``params=`` or the client's own
+        # ``AsyncClient.params`` merge -- is decoded and re-encoded. Measured against
+        # httpx 0.28.1, that rewrites ``%20`` in a value as ``+``, expands a bare
+        # ``download`` into ``download=``, and reorders interleaved duplicates
+        # (``x=1&y=2&x=3`` becomes ``x=1&x=3&y=2``), all of it even when nothing needed
+        # merging. Base64 and ``%3A`` round-trip unchanged, so a signature is not
+        # rewritten by itself, but any scheme that signs a value holding an encoded
+        # space is, and a server that distinguishes ``download`` from ``download=`` or
+        # reads repeated keys positionally sees a different request either way.
+        # Building the query here and writing it back over the request's ``raw_path``
+        # keeps the caller's bytes exactly as given.
+        raw = urlsplit(info.url)
+
+        # ``query_parameters`` append rather than replace, so a URL carrying
+        # ``filter=region&filter=status`` plus ``{"filter": "tenant"}`` sends all three,
+        # matching the .NET handler. Client-level params are defaults only: they apply
+        # for a key absent from both request-level sources.
+        explicit_pairs = [(key, value) for key, value in info.query_parameters.items() if key]
+        request_keys = {key for key, _ in parse_qsl(raw.query, keep_blank_values=True)}
+        request_keys.update(key for key, _ in explicit_pairs)
+        client_defaults = [(key, value) for key, value in client.params.multi_items() if key not in request_keys]
+
+        query_segments: list[str] = []
+        if raw.query:
+            query_segments.append(raw.query)
+        # ``quote_via=quote`` keeps spaces as ``%20`` instead of ``+``, so appended
+        # parameters are encoded the same way the preserved URL query is.
+        for pairs in (explicit_pairs, client_defaults):
+            if pairs:
+                query_segments.append(urlencode(pairs, quote_via=quote))
+        query = "&".join(segment for segment in query_segments if segment)
+
+        # Build without the query so the client's params merge has nothing to clobber --
+        # it drops the URL's query outright -- then overwrite the query httpx composed
+        # with ours. The fragment stays on the built URL; httpx does not send it.
+        request = client.build_request(
             method=info.method,
-            url=info.url,
-            params=params,
+            url=urlunsplit((raw.scheme, raw.netloc, raw.path, "", raw.fragment)),
             headers=headers or None,
             content=content,
             timeout=timeout,
         )
+        # Reuse httpx's own path encoding and replace only the query part of ``raw_path``.
+        raw_path = request.url.raw_path.split(b"?", 1)[0]
+        if query:
+            raw_path += b"?" + _encode_query(query)
+        request.url = request.url.copy_with(raw_path=raw_path)
+
+        response = await client.send(request)
 
         # Preserve multi-value headers (e.g. multiple Set-Cookie) as list[str].
         # Normalize names to lowercase so lookups are consistent and case
@@ -231,6 +272,23 @@ class DefaultHttpRequestHandler:
         await self.aclose()
 
 
+#: Characters a query string may carry literally: RFC 3986 sub-delims plus ``:@/?``, the
+#: square brackets many APIs use in key names, and ``%`` so escapes already in the
+#: caller's URL are left alone instead of being double-encoded. Everything legal stays
+#: as authored and only bytes that cannot appear in a URL get escaped.
+_QUERY_SAFE = "!$&'()*+,;=:@/?%[]~"
+
+
+def _encode_query(query: str) -> bytes:
+    """Return *query* as URL-safe bytes without disturbing what is already valid.
+
+    A caller can hand us a URL whose query holds non-ASCII text -- ``?q=café`` -- which
+    cannot go on the wire as-is. Percent-encoding only the characters that need it keeps
+    an already-valid query byte-identical, which is the point of composing it by hand.
+    """
+    return quote(query, safe=_QUERY_SAFE).encode("ascii")
+
+
 def _has_header(headers: Mapping[str, str], name: str) -> bool:
     """Case-insensitive header presence check."""
     needle = name.lower()

{agent_framework_declarative-1.0.3 → agent_framework_declarative-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ description = "Declarative specification support for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.3"
+version = "1.0.4"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -33,7 +33,7 @@ dev = [
 ]
 
 [tool.uv]
-prerelease = "if-necessary-or-explicit"
+prerelease = "if-necessary"
 environments = [
     "sys_platform == 'darwin'",
     "sys_platform == 'linux'",