# Create response (streaming)

POST https://api.moveworks.ai/rest/v1beta1/conversations/{conversation_id}/responses/stream
Content-Type: application/json

Creates a response and streams updates in real-time via Server-Sent Events (SSE). This provides a real-time alternative to creating a response and polling the GetResponse endpoint.

Reference: https://help.moveworks.com/api-reference/beta-conversations-api/responses/create-response-stream

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: conversations-api
  version: 1.0.0
paths:
  /conversations/{conversation_id}/responses/stream:
    post:
      operationId: create-response-stream
      summary: Create response (streaming)
      description: >-
        Creates a response and streams updates in real-time via Server-Sent
        Events (SSE). This provides a real-time alternative to creating a
        response and polling the GetResponse endpoint.
      tags:
        - subpackage_responses
      parameters:
        - name: conversation_id
          in: path
          description: A base-62 identifier prefixed by a short resource type
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            JWT bearer token authentication. Obtain an access token from the
            Moveworks auth endpoint and include it in the Authorization header
            as 'Bearer <token>'.
          required: true
          schema:
            type: string
        - name: Assistant-Name
          in: header
          description: >-
            The Moveworks assistant identifier that was configured for your
            organization.
          required: true
          schema:
            type: string
        - name: Accept
          in: header
          description: Must be set to `text/event-stream` to receive Server-Sent Events
          required: true
          schema:
            $ref: >-
              #/components/schemas/ConversationsConversationIdResponsesStreamPostParametersAccept
      responses:
        '200':
          description: Server-Sent Events stream of response updates
          content:
            text/event-stream:
              schema:
                $ref: '#/components/schemas/ResponseStreamEvent'
        '400':
          description: Bad request - Invalid input parameters
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InputRequiredErrorResponse'
        '401':
          description: Unauthorized - Invalid or missing authentication
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedErrorResponse'
        '403':
          description: Forbidden - Invalid assistant
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ForbiddenErrorResponse'
        '404':
          description: Not found - Resource does not exist
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NotFoundErrorResponse'
        '429':
          description: Rate limit exceeded
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RateLimitExceededErrorResponse'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalErrorResponse'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateResponseStreamRequest'
servers:
  - url: https://api.moveworks.ai/rest/v1beta1
components:
  schemas:
    ConversationsConversationIdResponsesStreamPostParametersAccept:
      type: string
      enum:
        - text/event-stream
      title: ConversationsConversationIdResponsesStreamPostParametersAccept
    UserInput:
      type: object
      properties:
        text:
          type: string
          description: User message text
      required:
        - text
      title: UserInput
    CreateResponseStreamRequest:
      type: object
      properties:
        input:
          $ref: '#/components/schemas/UserInput'
          description: User input message
      required:
        - input
      title: CreateResponseStreamRequest
    StreamEventType:
      type: string
      enum:
        - RESPONSE_CREATED
        - RESPONSE_IN_PROGRESS
        - RESPONSE_OUTPUT_DELTA
        - RESPONSE_COMPLETED
        - RESPONSE_FAILED
        - ERROR
      description: Response streaming event type
      title: StreamEventType
    ResponseStatus:
      type: string
      enum:
        - CREATED
        - IN_PROGRESS
        - COMPLETED
        - FAILED
      description: Response processing status
      title: ResponseStatus
    MessageOutputItemType:
      type: string
      enum:
        - MESSAGE
      description: Output item type discriminator
      title: MessageOutputItemType
    ActorType:
      type: string
      enum:
        - USER
        - ASSISTANT
      description: Message actor type
      title: ActorType
    PlainTextContentItemType:
      type: string
      enum:
        - PLAIN_TEXT
      description: Content type discriminator
      title: PlainTextContentItemType
    PlainTextContent:
      type: object
      properties:
        text:
          type: string
          description: Plain text content
      required:
        - text
      title: PlainTextContent
    CommonmarkTextContentItemType:
      type: string
      enum:
        - COMMONMARK_TEXT
      description: Content type discriminator
      title: CommonmarkTextContentItemType
    CommonmarkTextContent:
      type: object
      properties:
        text:
          type: string
          description: Commonmark-formatted text content
      required:
        - text
      title: CommonmarkTextContent
    MarkdownTextContentItemType:
      type: string
      enum:
        - MARKDOWN_TEXT
      description: Content type discriminator
      title: MarkdownTextContentItemType
    MarkdownTextContent:
      type: object
      properties:
        text:
          type: string
          description: >-
            Raw markdown text content. Used when Minerva's chat response
            `is_commonmark` is not set.
      required:
        - text
      title: MarkdownTextContent
    Content:
      oneOf:
        - type: object
          properties:
            type:
              $ref: '#/components/schemas/PlainTextContentItemType'
              description: Content type discriminator
            plain_text:
              $ref: '#/components/schemas/PlainTextContent'
          required:
            - type
            - plain_text
          description: PLAIN_TEXT variant
        - type: object
          properties:
            type:
              $ref: '#/components/schemas/CommonmarkTextContentItemType'
              description: Content type discriminator
            commonmark_text:
              $ref: '#/components/schemas/CommonmarkTextContent'
          required:
            - type
            - commonmark_text
          description: COMMONMARK_TEXT variant
        - type: object
          properties:
            type:
              $ref: '#/components/schemas/MarkdownTextContentItemType'
              description: Content type discriminator
            markdown_text:
              $ref: '#/components/schemas/MarkdownTextContent'
          required:
            - type
            - markdown_text
          description: MARKDOWN_TEXT variant
      discriminator:
        propertyName: type
      description: Message content with type discriminator
      title: Content
    CitationLocation:
      type: object
      properties:
        offset:
          type: integer
          description: >-
            Zero-based character position in the assistant message where the
            citation should be inserted
      required:
        - offset
      title: CitationLocation
    Attribute:
      type: object
      properties:
        key:
          type: string
          description: Attribute name
        value:
          type: string
          description: Attribute value
      required:
        - key
        - value
      description: >-
        Key-value pair for citation display metadata. This is an opaque
        structure that contains rendering hints specific to each citation.
        Clients should not make assumptions about the keys or values present, as
        they may vary based on citation type and context.
      title: Attribute
    Display:
      type: object
      properties:
        title:
          $ref: '#/components/schemas/Content'
          description: Primary heading/identifier with type discriminator
        body:
          $ref: '#/components/schemas/Content'
          description: Body/description content with type discriminator
        attributes:
          type: array
          items:
            $ref: '#/components/schemas/Attribute'
          description: >-
            Opaque key-value metadata for citation display. These attributes
            contain implementation-specific rendering hints and should be
            treated as a black-box by clients. The structure and values may vary
            between citations and should not be relied upon for business logic.
      title: Display
    Citation:
      type: object
      properties:
        location:
          $ref: '#/components/schemas/CitationLocation'
        url:
          type: string
          format: uri
          description: URL to the entity
        display:
          $ref: '#/components/schemas/Display'
      required:
        - location
      title: Citation
    Message:
      type: object
      properties:
        message_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        conversation_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        response_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        actor:
          $ref: '#/components/schemas/ActorType'
        content:
          $ref: '#/components/schemas/Content'
        citations:
          type:
            - array
            - 'null'
          items:
            $ref: '#/components/schemas/Citation'
          description: Entity citations (assistant messages only)
        created_at:
          type: string
          format: date-time
          description: Creation timestamp (ISO 8601)
      required:
        - message_id
        - conversation_id
        - response_id
        - actor
        - content
        - created_at
      title: Message
    ReasoningMessageOutputItemType:
      type: string
      enum:
        - REASONING_MESSAGE
      description: Output item type discriminator
      title: ReasoningMessageOutputItemType
    ReasoningMessage:
      type: object
      properties:
        reasoning_message_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        conversation_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        response_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        content:
          $ref: '#/components/schemas/Content'
        created_at:
          type: string
          format: date-time
          description: Creation timestamp (ISO 8601)
      required:
        - reasoning_message_id
        - conversation_id
        - response_id
        - content
        - created_at
      title: ReasoningMessage
    OutputItem:
      oneOf:
        - type: object
          properties:
            type:
              $ref: '#/components/schemas/MessageOutputItemType'
              description: Output item type discriminator
            message:
              $ref: '#/components/schemas/Message'
          required:
            - type
            - message
          description: MESSAGE variant
        - type: object
          properties:
            type:
              $ref: '#/components/schemas/ReasoningMessageOutputItemType'
              description: Output item type discriminator
            reasoning_message:
              $ref: '#/components/schemas/ReasoningMessage'
          required:
            - type
            - reasoning_message
          description: REASONING_MESSAGE variant
      discriminator:
        propertyName: type
      description: Output item wrapper with type discriminator
      title: OutputItem
    Response:
      type: object
      properties:
        response_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        conversation_id:
          type: string
          description: A base-62 identifier prefixed by a short resource type
        status:
          $ref: '#/components/schemas/ResponseStatus'
        created_at:
          type: string
          format: date-time
          description: Creation timestamp (ISO 8601)
        completed_at:
          type:
            - string
            - 'null'
          format: date-time
          description: Completion timestamp (ISO 8601), null if not completed
        outputs:
          type: array
          items:
            $ref: '#/components/schemas/OutputItem'
          description: Output items
      required:
        - response_id
        - conversation_id
        - status
        - created_at
      title: Response
    ResponseCreatedData:
      type: object
      properties:
        event_type:
          $ref: '#/components/schemas/StreamEventType'
        sequence_number:
          type: integer
          description: >-
            Sequential event number in stream. Monotonically increasing counter
            starting at 1.
        response:
          $ref: '#/components/schemas/Response'
          description: Newly created response object with CREATED status
      required:
        - event_type
        - sequence_number
        - response
      description: Data for RESPONSE_CREATED event - response initially created
      title: ResponseCreatedData
    ResponseInProgressData:
      type: object
      properties:
        event_type:
          $ref: '#/components/schemas/StreamEventType'
        sequence_number:
          type: integer
          description: >-
            Sequential event number in stream. Monotonically increasing counter
            starting at 1.
        response:
          $ref: '#/components/schemas/Response'
          description: Response object with IN_PROGRESS status
      required:
        - event_type
        - sequence_number
        - response
      description: Data for RESPONSE_IN_PROGRESS event - response processing update
      title: ResponseInProgressData
    ResponseOutputDeltaData:
      type: object
      properties:
        event_type:
          $ref: '#/components/schemas/StreamEventType'
        sequence_number:
          type: integer
          description: >-
            Sequential event number in stream. Monotonically increasing counter
            starting at 1.
        output:
          $ref: '#/components/schemas/OutputItem'
          description: Output item delta (message or reasoning message)
      required:
        - event_type
        - sequence_number
        - output
      description: Data for RESPONSE_OUTPUT_DELTA event - new output item generated
      title: ResponseOutputDeltaData
    ResponseCompletedData:
      type: object
      properties:
        event_type:
          $ref: '#/components/schemas/StreamEventType'
        sequence_number:
          type: integer
          description: >-
            Sequential event number in stream. Monotonically increasing counter
            starting at 1.
        response:
          $ref: '#/components/schemas/Response'
          description: Final response object with COMPLETED status and all outputs
      required:
        - event_type
        - sequence_number
        - response
      description: Data for RESPONSE_COMPLETED event - response successfully completed
      title: ResponseCompletedData
    ResponseFailedData:
      type: object
      properties:
        event_type:
          $ref: '#/components/schemas/StreamEventType'
        sequence_number:
          type: integer
          description: >-
            Sequential event number in stream. Monotonically increasing counter
            starting at 1.
        response:
          $ref: '#/components/schemas/Response'
          description: Response object with FAILED status and error details
      required:
        - event_type
        - sequence_number
        - response
      description: Data for RESPONSE_FAILED event - response processing failed
      title: ResponseFailedData
    Error:
      type: object
      properties:
        code:
          type: string
          description: Machine-readable error code
        message:
          type: string
          description: Human-readable error message
      required:
        - code
        - message
      title: Error
    StreamingErrorData:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/Error'
          description: Error details
      required:
        - error
      description: Data for ERROR event - error that occurs mid-stream
      title: StreamingErrorData
    ResponseStreamData:
      oneOf:
        - $ref: '#/components/schemas/ResponseCreatedData'
        - $ref: '#/components/schemas/ResponseInProgressData'
        - $ref: '#/components/schemas/ResponseOutputDeltaData'
        - $ref: '#/components/schemas/ResponseCompletedData'
        - $ref: '#/components/schemas/ResponseFailedData'
        - $ref: '#/components/schemas/StreamingErrorData'
      description: Event data payload (structure depends on event type)
      title: ResponseStreamData
    ResponseStreamEvent:
      type: object
      properties:
        event:
          $ref: '#/components/schemas/StreamEventType'
        data:
          $ref: '#/components/schemas/ResponseStreamData'
      required:
        - event
        - data
      description: A server-sent event containing response update content
      title: ResponseStreamEvent
    InputRequiredErrorResponseErrorCode:
      type: string
      enum:
        - INVALID_INPUT
      title: InputRequiredErrorResponseErrorCode
    InputRequiredErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/InputRequiredErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: InputRequiredErrorResponseError
    InputRequiredErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/InputRequiredErrorResponseError'
      required:
        - error
      description: Error response for missing required input field
      title: InputRequiredErrorResponse
    UnauthorizedErrorResponseErrorCode:
      type: string
      enum:
        - UNAUTHORIZED
      title: UnauthorizedErrorResponseErrorCode
    UnauthorizedErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/UnauthorizedErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: UnauthorizedErrorResponseError
    UnauthorizedErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/UnauthorizedErrorResponseError'
      required:
        - error
      description: Error response for unauthorized access
      title: UnauthorizedErrorResponse
    ForbiddenErrorResponseErrorCode:
      type: string
      enum:
        - FORBIDDEN
      title: ForbiddenErrorResponseErrorCode
    ForbiddenErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/ForbiddenErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: ForbiddenErrorResponseError
    ForbiddenErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/ForbiddenErrorResponseError'
      required:
        - error
      description: Error response for forbidden access
      title: ForbiddenErrorResponse
    NotFoundErrorResponseErrorCode:
      type: string
      enum:
        - NOT_FOUND
      title: NotFoundErrorResponseErrorCode
    NotFoundErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/NotFoundErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: NotFoundErrorResponseError
    NotFoundErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/NotFoundErrorResponseError'
      required:
        - error
      description: Error response for resource not found
      title: NotFoundErrorResponse
    RateLimitExceededErrorResponseErrorCode:
      type: string
      enum:
        - RATE_LIMIT_EXCEEDED
      title: RateLimitExceededErrorResponseErrorCode
    RateLimitExceededErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/RateLimitExceededErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: RateLimitExceededErrorResponseError
    RateLimitExceededErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/RateLimitExceededErrorResponseError'
      required:
        - error
      description: Error response for rate limit exceeded
      title: RateLimitExceededErrorResponse
    InternalErrorResponseErrorCode:
      type: string
      enum:
        - INTERNAL_ERROR
      title: InternalErrorResponseErrorCode
    InternalErrorResponseError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/InternalErrorResponseErrorCode'
        message:
          type: string
      required:
        - code
        - message
      title: InternalErrorResponseError
    InternalErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/InternalErrorResponseError'
      required:
        - error
      description: Error response for internal server error
      title: InternalErrorResponse
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        JWT bearer token authentication. Obtain an access token from the
        Moveworks auth endpoint and include it in the Authorization header as
        'Bearer <token>'.

```

## SDK Code Examples

```python
import requests

url = "https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream"

payload = { "body": { "input": { "text": "Who does John Doe report to?" } } }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"body":{"input":{"text":"Who does John Doe report to?"}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream"

	payload := strings.NewReader("{\n  \"body\": {\n    \"input\": {\n      \"text\": \"Who does John Doe report to?\"\n    }\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"body\": {\n    \"input\": {\n      \"text\": \"Who does John Doe report to?\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"body\": {\n    \"input\": {\n      \"text\": \"Who does John Doe report to?\"\n    }\n  }\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream', [
  'body' => '{
  "body": {
    "input": {
      "text": "Who does John Doe report to?"
    }
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": {\n    \"input\": {\n      \"text\": \"Who does John Doe report to?\"\n    }\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["body": ["input": ["text": "Who does John Doe report to?"]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.moveworks.ai/rest/v1beta1/conversations/conv_32bt7BMLhLyVzTUjfi35N/responses/stream")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```