For AI agents: a documentation index is available at the root level at /llms.txt and /llms-full.txt. Append /llms.txt to any URL for a page-level index, or .md for the markdown version of any page.
Logo
DeveloperAcademyCommunityStatus
ReferenceGuides
ReferenceGuides
  • Agent Studio
    • Overview
    • Quickstart Guides
    • Core Concepts
    • Conversation Process
    • Actions
      • LLM Actions
      • Built-in Actions
      • HTTP Actions
        • HTTP Action Data Bank
        • Event streaming (SSE) and XML responses
        • HTTP Action Files
        • HTTP Action Troubleshooting
        • Data Mapper in HTTP Actions
        • HTTP -> LDAP Actions
        • Optional Query Parameters in HTTP Actions
      • Script Actions
      • Compound Actions
    • Connectors
    • System Triggers
    • Agent Architect
    • Cookbooks
    • Development and Testing
    • AI Agent Marketplace
    • Developer Tools
  • Agentic AI
    • LLM Fundamentals
    • The Agentic Reasoning Engine
    • Memory Constructs
    • Conversational Context
    • Guardrails
    • Grounding and Hallucinations
    • Continuous Learning
    • LLMs & SLMs
    • Steerability Tools
    • Multilingual Support
  • Core Platform
    • User Identity
    • Moveworks Agent (On-Prem)
    • Approvals Engine
    • Entity Catalog
    • Moveworks Data Objects
    • Security Information and Event Management (SIEM) Logs Overview
DeveloperAcademyCommunityStatus
On this page
  • What to expect at runtime
  • Server‑Sent Events (text/event-stream)
  • Aggregate chunked messages into one string
  • Troubleshooting SSE
  • XML responses
  • Option A: Simple extraction with DSL (for a few tags)
  • Option B: Parse XML in a Script Action (BeautifulSoup)
  • Best practices
Agent StudioActionsHTTP Actions

Event streaming (SSE) and XML responses

Handle text/event-stream and XML payloads in HTTP Actions. Learn how streams terminate, aggregate data: chunks safely, and parse XML outputs.

||View as Markdown|
Was this page helpful?
Edit this page
Previous

HTTP Action Files

Learn how to handle file uploads in HTTP Actions using multipart/form-data encoding and the File tab mapping system.

Next
Built with

HTTP Actions can call APIs that return either streaming Server‑Sent Events (SSE) or XML. This guide explains how SSE responses terminate and how the HTTP Action behaves, how to aggregate data: event chunks into a single output, common pitfalls, and simple approaches for XML parsing.

XML Support

Moveworks converts all XML responses to JSON automatically at the HTTP action layer, so XML responses can be used easily in conversational processes and compound actions.

This also allows XML responses from on-prem systems (via the Moveworks Agent) to be used.

What to expect at runtime

  • Blocking, not live streaming: HTTP Actions do not surface partial chunks. They buffer the response and return it only after the server closes the connection.
  • Termination matters: If the SSE endpoint never closes the connection (e.g., test endpoints that stream forever), the action will remain in “Processing” until a timeout.
  • Timeouts and limits:
    • Requests time out after ~60 seconds of inactivity.

Server‑Sent Events (text/event-stream)

  • Request setup:
    • Add header: Accept: text/event-stream.
    • Configure the HTTP Action normally (no special streaming toggle is required).
  • Response shape: The action captures the raw SSE payload as a single text block under your output_key. Typical shape:
data: {"thread_id": "...", "date": "2025-11-11T20:37:49.053856Z"}
data: {"chunk": "..."}
data: {"chunk": "..."}
  • Reserved keys: Avoid naming your HTTP Action output_key as result or data to prevent collisions. Use something like action_output.

Aggregate chunked messages into one string

In a Compound Action, set the HTTP Action output_key to action_output, then map the aggregated text plus any metadata:

1steps:
2  - action:
3      action_name: chat_stream
4      output_key: action_output
5      headers:
6        Accept: text/event-stream
7  - return:
8      output_mapper:
9        thread_id: >
10          data.action_output
11            .$TRIM()
12            .$SPLIT("\n\n")[0]
13            .$REPLACE("^data: ", "")
14            .$PARSE_JSON()
15            .thread_id
16        date: >
17          data.action_output
18            .$TRIM()
19            .$SPLIT("\n\n")[0]
20            .$REPLACE("^data: ", "")
21            .$PARSE_JSON()
22            .date
23        text: >
24          data.action_output
25            .$TRIM()
26            .$SPLIT("\n\n")
27            .$MAP(x => x.$REPLACE("^data: ", "").$PARSE_JSON().chunk)
28            .$CONCAT(" ", true)

Notes:

  • SSE frames are delimited by a blank line (\n\n).
  • You must strip the data: prefix on each frame before parsing JSON ($REPLACE("^data: ", "")).
  • Some servers emit heartbeats like : keep-alive. Filter them out if present, e.g.:
1text: >
2  data.action_output
3    .$TRIM()
4    .$SPLIT("\n\n")
5    .$FILTER(line => !line.$STARTS_WITH(":"))
6    .$MAP(x => x.$REPLACE("^data: ", "").$PARSE_JSON().chunk)
7    .$CONCAT(" ", true)

The following mapping aggregates SSE frames by converting the raw stream into a JSON array, then parsing once. This is useful when frames are well‑formed JSON objects and delimited by blank lines:

1steps:
2  - action:
3      output_key: action_output
4      action_name: test_stream
5  - return:
6      output_mapper:
7        thread_id: >
8          $CONCAT(["[",data.action_output.$REPLACE("data: ", ",").$TRIM()[1:],"]"], "").$PARSE_JSON()[0].thread_id
9        date: >
10          $CONCAT(["[",data.action_output.$REPLACE("data: ", ",").$TRIM()[1:],"]"], "").$PARSE_JSON()[0].date
11        text: 
12          EVAL():
13            expression: $CONCAT(x, " ")
14            args: 
15                x:
16                  MAP():
17                    items: >
18                      $CONCAT(["[",data.action_output.$REPLACE("data: ", ",").$TRIM()[1:],"]"], "").$PARSE_JSON()[1:]
19                    converter: item.chunk

How it works:

  • Replaces each data: prefix with a comma, then drops the leading comma via [1:].
  • Wraps the result in brackets to form a JSON array and parses it once.
  • Pulls metadata from the first element and concatenates chunk fields from the rest.

Troubleshooting SSE

  • Action stuck in Processing: Your endpoint likely never closes. Test against an endpoint that terminates; many demo SSE servers are intentionally infinite.
  • Invalid JSON errors: Parse line‑by‑line. The raw SSE payload is not a single JSON object.
  • Large responses: If you concatenate many chunks, consider truncating or summarizing upstream to stay within reasonable sizes.

XML responses

  • Prefer JSON when possible: If the API supports it, send Accept: application/json and/or use a JSON variant of the endpoint.
  • When XML is unavoidable:
    • The HTTP Action stores the raw XML in your output_key (e.g., action_output).
    • There is no built‑in XML parser in the output mapper; use either simple string/regex extraction for a few fields or a Script Action for robust parsing.

Option A: Simple extraction with DSL (for a few tags)

For basic cases you can extract values using $MATCH, $REPLACE, etc. Example (extract <status>):

1status: >
2  data.action_output
3    .$MATCH("<status>.*?</status>", true)[0]
4    .$REPLACE("</?status>", "", true)
5    .$TRIM()

Option B: Parse XML in a Script Action (BeautifulSoup)

Use a Python Script Action after the HTTP Action to convert XML to JSON‑like text you can parse back in the mapper.

  1. HTTP Action: set output_key: action_output.

  2. Script Action:

  • Input argument xml_body mapped from data.action_output.
  • Output key xml_parsed.
  • Code:
1import json
2from bs4 import BeautifulSoup
3
4# xml_body is the input argument
5soup = BeautifulSoup(xml_body, "xml")
6
7result = {
8    "status": (soup.find("status").get_text(strip=True) if soup.find("status") else None),
9    "id": (soup.find("id").get_text(strip=True) if soup.find("id") else None),
10    "message": (soup.find("message").get_text(strip=True) if soup.find("message") else None),
11}
12
13# Return a JSON string for downstream mapping
14json.dumps(result)
  1. Return step: parse the script output and expose fields:
1steps:
2  - action:
3      action_name: xml_api
4      output_key: action_output
5      headers:
6        Accept: application/xml
7  - script:
8      language: python
9      input_args:
10        xml_body: data.action_output
11      output_key: xml_parsed
12      code: |
13        import json
14        from bs4 import BeautifulSoup
15        soup = BeautifulSoup(xml_body, "xml")
16        result = {
17            "status": (soup.find("status").get_text(strip=True) if soup.find("status") else None),
18            "id": (soup.find("id").get_text(strip=True) if soup.find("id") else None),
19            "message": (soup.find("message").get_text(strip=True) if soup.find("message") else None),
20        }
21        json.dumps(result)
22  - return:
23      output_mapper:
24        status: data.xml_parsed.$PARSE_JSON().status
25        id: data.xml_parsed.$PARSE_JSON().id
26        message: data.xml_parsed.$PARSE_JSON().message

Best practices

  • Use a safe output_key: Avoid result and data. Prefer action_output, xml_parsed, etc.
  • Keep payloads small: Summarize upstream or stop early to keep response sizes manageable.
  • Validate in Postman first: Confirm the endpoint closes the stream and returns the expected format before configuring in Agent Studio.
  • Log and test: Use the Test button and check logs if mapping fails.