JEP-0142: Workgroups

Matt Tucker

Email: matt@jivesoftware.com
JID: jivematt@jabber.org

Iain Shigeoka

Email: iain.shigeoka@messaginglogic.com
JID: smirk@jabber.org

1. Introduction
2. Terminology
3. Roles and Responsibilities
4. User Protocol
5. Agent Protocol
6. Implementation Notes
7. Security Considerations
8. IANA Considerations
9. Jabber Registrar Considerations
10. XML Schema
11. Acknowledgements
Notes
Revision History

1.1 Overview

This JEP documents a protocol that provides a service allowing users to contact a representative of an organization or workgroup without knowing the address of a particular member of that organization or workgroup. This functionality is similar to an 'email alias' with the addition of queuing pending communication requests and quality of service negotiation to accommodate the real-time nature of IM/chat. Although this protocol is generic enough to handle many use cases, specific features have been added that make it particularly suitable for customer support environments.

1.2 Motivation

This protocol addresses the need of starting a private XMPP conversation with a qualified member of a workgroup. In a standard XMPP exchange of messages, users either connect directly to another user for a one on one conversation, or connect to a chat room for a conversation between many people. The current protocols do not allow users to initiate a private conversation with any person playing a particular role in an organization or workgroup.

For example, a customer has a question and needs to talk to a support representative. The conversation is private and therefore cannot be conducted in a well-known chat room. Using the workgroup protocol, the user requests a chat with support@workgroup.company.com. The chat request is put into a queue and the server routes the chat request to individual support representatives in the support@workgroup.company.com workgroup. The support representative can accept or reject the chat request. Once the request is accepted, the conversation takes place through standard XMPP messaging protocols.

1.3 Concepts

The namespace governing this protocol is "http://jabber.org/protocol/workgroup". This namespace relies on the <iq/> element for execution, and uses the <presence/> element for announcing status updates.

This protocol depends on Service Discovery for reporting and announcing available workgroup services. However, support for service discovery is entirely optional and workgroup services may be made known through other means (e.g. web pages, word of mouth, etc).

The end result of a workgroup interaction is to negotiate and route a user and workgroup member (a.k.a. agent) to an appropriate chat room for a chat conversation using the multi-user chat (MUC) protocol. However, multi-user chat essentially 'takes over' when the workgroup protocol successfully completes so there is no overlap between the two protocols. It is recommended that groupchat implementations support basic groupchat (a.k.a. Groupchat 1.0) for maximum client compatibility.

1.4 Prerequisites

There are no requirements for supporting the workgroup protocol beyond XMPP Core [1] and Multi-User Chat [2]. Support for Data Forms [3] is optional if users need to submit additional data before joining (see User Join section of this document).

3.1 Roles

The workgroup protocol involves three distinct participants that fill the following roles:

User - The user requests a private conversation with a member of a workgroup. For examples throughout the rest of this JEP the user will be represented by the address user@server.com/home.
Service - The workgroup service receives and sends messages using the workgroup address. The workgroup address represents a general contact address which allows users to find workgroup members to talk to without the need to know any particular workgroup member's individual address. The workgroup service manages the interactions between users and agents. For examples throughout the rest of this JEP the service will be represented by the address support@workgroup.company.com, representing a common scenario of a workgroup offering customer support for an organization.
Agent - The agent is a member of the workgroup and can carry out conversations with users on behalf of their workgroup organization or company. For examples throughout the rest of this JEP two agent addresses will be used: alice@company.com/work and bob@company.com/work.

Note: A service MAY contain several queues to help organize, route and handle incoming user chat requests. Implementations supporting multiple queues in a workgroup will respond differently to requests, and send different status information for each queue. Workgroup queues are identified by a unique resource name: e.g. support@workgroup.company.com/platinum-plan or support@workgroup.company.com/xmpp-products. Implementation should gracefully handle services with only one queue (using support@workgroup.company.com) or multiple queues. Users should only be aware of one workgroup (users should never see workgroup queue resource names).

3.2 Responsibilities

Each participant is responsible for certain behaviors in the workgroup protocol.

Users should:

Know the status of the workgroup queue before requesting a conversation. This information allows users to see if the workgroup is available, and how long a wait they may have before a chat is initiated.
Know the status of their request while in the request queue.
Are able to cancel a chat request at any time.

Workgroup agents should:

Know the status of the workgroup queue(s).
Be able to accept or reject chat requests.
Indicate their availability for handling workgroup chats.

The workgroup service:

Controls the workgroup request queue(s).
Manages the updating of queue status information.
Determines how users are queued and how queue requests are routed to workgroup members. The queue routing algorithm is beyond the scope of this JEP and left to implementers (simple round-robin, priority based, rules based, etc).
Maintains its presence, indicating the availability of the workgroup service.

4.1 User States

Users join the workgroup queue to wait for a chat with an agent. Once they have joined the queue, they may receive zero or more status updates from the workgroup service informing them of their status in the queue. Users have the option to cancel their chat request at any time.

When an agent is ready to chat with the user, the user will be sent a standard XMPP groupchat invitation to a chat room. Receipt of the invitation indicates that the user is no longer in the queue and that they should join the chat room using the standard XMPP groupchat protocol in order to converse with an agent. Groupchat is used because it offers several advantages in workgroup conversations including:

Allowing more than one agent to join the conversation (useful for bringing in experts to join the conversation).
Allowing managers to monitor conversations for quality of service.
Creates a simple way of determining what is in a 'conversation' for logging and gathering other statistical information about the conversation.
Allows a convenient mechanism for bringing 'chatbot' services into the conversation (e.g. answering FAQ, etc).

The user's states and packet exchanges that cause state transitions are shown below:

              +-------+
              | Start |<------+
              +-------+       |
                  |           |
                  | Join      |
                  v           |
             +---------+      |
      +----->| Queued  |      |
      |      +---------+      |
      | Status |  |  | Depart |
      +--------+  |  +--------+
                  |
                  | Invite
                  v
            +-----------+
            | Chat room |
            +-----------+

4.2 User Packet Exchanges

Packets are exchanged between the user and service to trigger state changes in the user. These packet exchanges are described next.

4.2.1 User Join Protocol

This section describes the packet exchange allowing users to join a workgroup service queue. This protocol MUST be supported by compliant implementations.

Example 1. Transactions

User                          Service
  |        Join Request          |
  |----------------------------->|
  |                              |
  |        Join Response         |
  |<-----------------------------|
  |                              |

The user sends a join request to the workgroup service in order to join the workgroup queue. The workgroup service may either accept or reject the request. A user session (e.g. user@server.com/home) may only have one active join request. Subsequent, simultaneous joins will result in an error (see error section).

Some workgroups require that the user submit certain information before the user is allowed to join. In these cases, the workgroup will reject the initial join request with a <not-acceptable/> error. The user should then use the Data Forms (JEP-0004) [4] protocol within iq-join-queue to obtain a form, and submit it to join the queue.

Example 2. Request Element

U: <iq to='service-jid' from='user-jid' id='id1' type='set'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <queue-notifications/>
U:   </join-queue>
U: </iq>

The request may contain meta-data to help the service determine queuing of the user or Data Forms data when submitting form information. There is one optional standard workgroup sub-element of <join-queue>:

<queue-notifications/> - if present, indicates the user would like to receive user status updates about their state in the queue.

A successful join results in a success response:

Example 3. Response Element

S: <iq to='user-jid' from='service-jid' id='id1' type='result'>
S: </iq>

If the user indicated interest in their queue status information, the supported status updates will be sent by the server. Compliant implementations do not have to support any status update types. Status updates requested by the user and supported by the server will be pushed to the user by the service until the user departs or is invited to a chat room.

4.2.1.1 Error Conditions

Table 1:

Condition	Description
<not-authorized/>	The user is not authorized to join the queue. A determination of who has permission to join a queue is left to implementations.
<item-not-found/>	The address the user requests a chat with does not exist or is not a workgroup. Compliant workgroup service implementations MUST NOT return this error if the requested address is a valid workgroup.
<not-acceptable/>	The user must submit valid form data (using the Data Forms protocol [4]) before joining the queue. Note that this error is sent when user tries to join, or if the user submits form data that is not filled out correctly.
<conflict/>	The user has already joined the queue.
<service-unavailable/>	The workgroup is valid but not accepting new join-queue requests.

4.2.1.2 Example

The following protocol flows show an example of a user successfully joining a workgroup queue for support@workgroup.company.com.

Example 4. Successful Join

U: <iq type='set'
U:     from='user@server.com/home'
U:       to='support@workgruop.company.com'
U:       id='id1'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <queue-notifications/>
U:   </join-queue>
U: </iq>
S: <iq type='result'
S:     from='support@workgroup.company.com'
S:     to='user@server.com/home'
S:     id='id1'>
S: </iq>

The following XML is another example where meta-data is sent by the user to assist the workgroup server in queuing and routing (naturally, the custom namespace that qualified the <crm/> element in this example would be defined outside the context of this specification).

Example 5. Join With Meta-Data

U: <iq type='set'
U:     from='user@server.com/home'
U:       to='support@workgroup.company.com'
U:       id='id2'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <crm xmlns="http://www.company.com/xmpp/workgroup">
U:       <customer-id>the24th498onth</customer-id>
U:       <referrer>
U:         http://www.company.com/portal/
U:       </referrer>
U:       <product>Widget 1.0</product>
U:     </crm>
U:     < queue-notifications/>
U:   </join-queue>
U: </iq>
S: <iq type='result'
S:     from='support@workgroup.company.com'
S:       to='user@server.com/home'
S:       id='id2'/>

Finally an example of a required form submission before a user is allowed to the workgroup queue for support@workgroup.company.com. The data form in this example is trivial; please see the Data Forms specification [4] for a complete data form example. The example begins as normal, but the workgroup returns a <not-acceptable/> error.

Example 6. Join With Form

U: <iq type='set'
U:     from='user@server.com/home'
U:       to='support@workgroup.company.com'
U:       id='id1'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <queue-notifications/>
U:   </join-queue>
U: </iq>
S: <iq type='error'
S:     from='support@workgroup.company.com'
S:       to='user@server.com/home'
S:       id='id1'>
S:   <error code='406' type='modify'>
S:     <not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
S:   </error>
S: </iq>

The <not-acceptable/> error indicates that a data form is required. The user requests the required data form from the workgroup.

Example 7. Join With Form (2)

U: <iq type='get'
U:     from='user@server.com/home'
U:       to='support@workgroup.company.com'
U:       id='id2'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'/>
U: </iq>
S: <iq type='result'
S:     from='support@workgroup.company.com'
S:       to='user@server.com/home'
S:       id='id2'>
S:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
S:     <x xmlns='jabber:iq:data' type='form'>
S:       <title>Support.com Chat Customer Information</title>
S:       <instructions>Welcome to support.com! Please provide us with
S:         some information about yourself so we can serve you better.
S:       </instructions>
S:       <field type='text-single' label='First Name' var='first' />
S:       <field type='text-single' label='Last Name' var='last' />
S:       <field type='list-single' label='Contract Type'
var='contract_type'>
S:         <value>0</value>
S:         <option label='None'><value>0</value></option>
S:         <option label='Bronze'><value>1</value></option>
S:         <option label='Silver'><value>2</value></option>
S:         <option label='Gold'><value>3</value></option>
S:       </field>
S:     </x>
S:   </join-queue>
S: </iq>

After presenting the form to the user and gathering the form data, the user submits the form data to the workgroup and the workgroup accepts it. The user is now in the queue.

Example 8. Join With Form (3)

U: <iq type='set'
U:     from='user@server.com/home'
U:       to='support@workgroup.company.com'
U:       id='id3'>
U:   <join-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <queue-notifications/>
U:     <x xmlns='jabber:iq:data' type='submit'>
U:       <field var='first'><value>John</value></field>
U:       <field var='last'><value>Doe</value></field>
U:       <field var='contract_type'><value>2</value></field>
U:     </x>
U:   </join-queue>
U: </iq>
S: <iq type='result'
S:     from='support@workgroup.company.com'
S:       to='user@server.com/home'
S:       id='id3' />

4.2.2 User Depart Protocol

Describes the packet exchange allowing users to depart a workgroup service queue, or for a workgroup service to remove a user from the workgroup queue. This protocol MUST be supported by compliant implementations.

The user no longer wishes to be in the queue and issues a depart queue command.

Example 9. Transactions

Requester                     Service
  |        Depart Request        |
  |----------------------------->|
  |        Depart Response       |
  |<-----------------------------|
  |                              |

The service notifies the user that they have been removed from the workgroup queue.

Example 10. Transactions (2)

User                          Service
  |        Depart Message        |
  |<-----------------------------|
  |                              |

Example 11. Depart Request

U: <iq from='user-jid' to='service-jid' id='id1' type='set'>
U:   <depart-queue xmlns='http://jabber.org/protocol/workgroup'/>
U: </iq>

In the typical case, the sender is the user departing the queue. However, it is possible for other users (system administrators for example) to request that another user be removed from the queue. In this case, the jid of the user who is departing is included in the depart request:

Example 12. Depart Request With JID

U: <iq from='admin-jid' to='service-jid' id='id1' type='set'>
U:   <depart-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <jid>user-jid</jid>
U:   </depart-queue>
U: </iq>

It is expected that implementations will determine who is allowed to remove other users from the queue based on an implementation specific permissions model. These administrator depart requests may result in <not-authorized/> errors (see error section). A user removing their own queue entry MUST NOT receive unauthorized errors (the workgroup service may not refuse to allow a user to depart the queue).

The sender of the depart request receives a successful result packet:

Example 13. Depart Request

S: <iq from='service-jid' to=user-jid' id='id1' type='result'/>

And the user who is departing receives a depart message (the user may not have been the sender of the request):

Example 14. Depart Message

S: <message from='service-jid' to='user-jid'>
S:    <depart-queue xmlns='http://jabber.org/protocol/workgroup'/>
S: </message>

The user will not be in the queue after a response is received unless the error response code is <not-authorized/>.

4.2.2.1 Error Conditions

Table 2:

Condition	Description
<not-authorized/>	The sender did not have permission to remove the user from the queue. This error code MUST NOT be used when a user is removing their queue entry.
<item-not-found/>	The user was not in the queue.

4.2.2.2 Example

A user leaves the workgroup queue support@workgroup.company.com.

Example 15. User Departs

U: <iq from='user@server.com/home'
U:       to='support@workgroup.company.com'
U:       id='id1'
U:     type='set'>
U:   <depart-queue xmlns='http://jabber.org/protocol/workgroup'/>
U: </iq>
S: <iq from='support@workgoup.company.com'
S:     to='user@server.com/home'
S:     id='id1'
S:     type='result'/>
S: <message from='support@workgroup.company.com' to='user@server.com/home'>
S:    <depart-queue xmlns='http://jabber.org/protocol/workgroup'/>
S: </message>

An administrator removes a user from the workgroup queue support@workgroup.company.com. Notice that the depart-queue message is sent to the user that has left the queue.

Example 16. Administrator Removes User

U: <iq from='admin@company.com/work'
U:       to='support@workgroup.company.com'
U:       id='id1'
U:     type='set'>
U:   <depart-queue xmlns='http://jabber.org/protocol/workgroup'>
U:     <jid>user@server.com/home</jid>
U:   </depart-queue>
U: </iq>
S: <iq from='support@workgroup.company.com'
S:     to='admin@company.com/work'
S:     id='id1'
S:     type='result'/>
S: <message from='support@workgroupcompany.com' to='user@server.com/home'>
S:    <depart-queue xmlns='http://jabber.org/protocol/workgroup'/>
S: </message>

4.2.3 User Status Update Protocol

Describes the packet exchange for updating users on their queue status. This protocol MAY be supported by compliant implementations.

Example 17. Transactions

User                          Service
  |      User Status Push        |
  |<-----------------------------|
  |                              |
  |     User Status Request      |
  |----------------------------->|
  |     User Status Response     |
  |<-----------------------------|
  |                              |

The workgroup service pushes updates to the user as their queue status changes and the user may request their queue status at any time.

4.2.3.1 User Status Updates

User status updates are contained in a <queue-status/> element that updates the user on their queue position and estimated time. The position contained in a <position> sub-element is a non-negative integer indicating the number of queue entries that must be routed to an agent before the user is routed to an agent. A position of 0 (zero) indicates the user is currently being routed. Clients may use this information to display the current queue position to the user.

The queue time status is contained in a <time/> sub-element that updates the user with the estimated time until they will be routed to an agent. The time is a non-negative integer indicating the estimated number of seconds remaining before being routed. Services should send this update at regular intervals. We recommend every 15 seconds, but the best solution will depend on application dependent factors and the service may decide to send updates at any interval or never (relying on the client to request the information). User clients should assume the estimated time counts down at a rate of one second per second between status updates. Clients may use this information to display the running estimated time to the user.

A server 'push' occurs asynchronously to client:

Example 18. User Status Push

S: <message to='user-jid' from='service-jid'>
S:   <queue-status xmlns='http://jabber.org/protocol/workgroup'>
S:     <position>4</position>
S:     <time>60</time>
S:   </queue-status>
S: </message>

Alternately the client may poll their position:

Example 19. User Status Poll

U: <iq to='service-jid' from='user-jid' id='id1' type='get'>
U:   <queue-status xmlns='http://jabber.org/protocol/workgroup'/>
U: </iq>
S: <iq to='user-jid' from='service-jid' id='id1' type='result'>
S:   <queue-status xmlns='http://jabber.org/protocol/workgroup'>
S:     <position>4</position>
S:     <time>60</time>
S:   </queue-status>
S: </iq>

4.2.3.2 Error Conditions

Table 3:

Condition	Description
<not-authorized/>	Sent by the server to the user in response to a status query only if the user is not a member of the queue.
<feature-not-implemented/>	Sent only if status updates are not implemented in either the client or server.

4.2.4 User Invite Protocol

This section describes the packet exchange for inviting a queued user to a chat room for conversation with an agent. This protocol MUST be supported by compliant implementations.

Example 20. Transactions

User                          Service
  |          User Invite         |
  |<-----------------------------|
  |                              |

The server sends a standard JEP-0045 groupchat invitation to the user to begin their conversation with an agent.

User invitations use JEP-0045 standard multi-user chat invitations. The invitation indicates that the user is no longer in the workgroup queue. The user MUST NOT receive any more user queue status updates once they receive an invitation.

In order to match invitations to join requests, all invitations should carry meta data in the workgroup namespace in the 'workgroup' element with the JID of the workgroup as an attribute. The typical meta-data fragment would appear as:

Example 21. Invitation Meta-Data

<workgroup xmlns='http://jabber.org/protocol/workgroup' jid='support@workgroup.company.com'/>

4.2.4.1 Error Conditions

There are no valid error conditions for user invitations.

4.2.4.2 Example

An invitation from the server on behalf of the support@server.com workgroup:

Example 22. An Invitation

S: <message
S:     from='roomname@chatserver.company.com'
S:     to='user@server.com/home'>
S:   <x xmlns='http://jabber.org/protocol/muc#user'>
S:     <invite from='support@workgroup.company.com'>
S:       <reason>
S:        You have been invited to chat with a support@workgroup.company.com agent.
S:       </reason>
S:     </invite>
S:   </x>
S:   <x jid='roomname@chatserver.company.com' xmlns='jabber:x:conference'/>
S:   <workgroup xmlns='http://jabber.org/protocol/workgroup'
S:       jid='support@workgroup.company.com'/>
S: </message>

5.1 Agent States

Agents join a workgroup to indicate they are capable of handling conversations with users. Agent membership in the workgroup is expected to be a long term, persistent relationship similar to roster membership. For example, a customer support agent may join the support@workgroup.company.com workgroup when they begin working at company.com and will only depart when they leave that position. The wide variety of relationships, processes and permissions associated with joining and leaving workgroups lies outside the scope of this JEP.

Once an agent has joined a workgroup they will receive workgroup status updates to inform them of the status of other members of the workgroup. Agents are responsible for updating the workgroup service with their presence so the service can intelligently route chat requests to the 'best' agent. Workgroup agent presence uses standard XMPP presence packets with optional meta-data to help routing of chat requests to agents. Some meta-data will be standard and defined later in this JEP. It is expected that other deployment specific meta-data will also be needed to make routing decisions.

The general agent workgroup state diagram is shown below:

            +-----------+
      +---->| Workgroup |<-----+
      |     +-----------+      |
      |        |     |Agent    |
      | Status |     |Presence |
      +--------+     +---------+

Once an agent has joined a workgroup and is available, the agent will receive offers to chat with users by the workgroup service. Chat offers will be made to the agent and the agent has the opportunity to accept or reject each offer. The workgroup service may also revoke an offer. For example, a service may revoke chat offers if the offer is not responded to within a certain period of time to ensure fast responses to user chat requests.

Once an offer has been accepted, the agent must wait for a standard groupchat invitation from the workgroup service. The workgroup service may revoke the offer at this stage of the protocol as well. This enables workgroup services to send offers to several agents in parallel, and choose the 'best' agent that accepts. A diagram showing the agent workgroup sub-states and transitions is shown below:

              +-------+
              | Start |<---------+
              +-------+          |
                  |              |
                  | Offer        |
                  v              |
            +---------------+    |
            | Offer Pending |    |
            +---------------+    |
                 |  |  | Revoke  |
                 |  |  +-------->|
                 |  | Reject     |
          Accept |  +----------->|
                 v               |
            +--------------+     |
            | Chat Pending |     |
            +--------------+     |
                 |   | Revoke    |
          Invite |   +-----------+
                 V
              +-----------+
              | Chat room |
              +-----------+

5.2 Agent Packet Exchanges

Packets are exchanged between the agent and service to trigger state changes in the agent client. These packet exchanges are described next.

5.2.1 Agent Presence Protocol

Describes the packet exchange allowing agents to update a workgroup with their current presence. This protocol MUST be supported by compliant implementations.

Example 23. Transactions

Agent                         Service
  |       Presence Update        |
  |----------------------------->|
  |                              |

The agent must inform the workgroup of its presence by sending it a presence update packet. Agent presence updates use standard XMPP presence with optional meta-data. However, there must always be an agent-status workgroup sub-element in the presence packet to indicate that the presence update relates to agent workgroup presence. Agent workgroup presence is designed to allow a separation between the agent's normal XMPP presence (server-managed via rosters) and their presence with the workgroup.

Example 24. Presence Update

U: <presence from='agent-jid' to='service-jid'>
U:   <agent-status xmlns='http://jabber.org/protocol/workgroup'>
U:     <max-chats>count</max-chats>
U:   </agent-status>
U: </presence>

Agent presence updates use standard XMPP presence packets and should contain the normal sub elements as needed (e.g. <show/>, <status/>, etc) and can be of type='unavailable' to indicate the agent is not available for workgroup routing or for receiving workgroup agent updates. The standard XMPP show states have specific meaning within the context of the workgroup protocol:

chat - Indicates the agent is available to chat (is idle and ready to handle more conversations).
away - The agent is busy (possibly with other chats). The agent may still be able to handle other chats but an offer rejection is likely.
xa - The agent is physically away from their terminal and should not have a chat routed to them.
dnd - The agent is busy and should not be disturbed. However, special case, or extreme urgency chats may still be offered to the agent although offer rejection or offer timeouts are highly likely.

Agents may also wish to embed meta-data to help the workgroup service route chat requests. The optional meta-data value in the workgroup namespace is:

<max-chats> - The maximum number of chats the agent can handle. If a presence is sent to the workgroup that does not contain the max-chats value, the "default setting" will be assumed. The value of the default setting for an agent is up to an implementation. [5]

5.2.1.1 Error Conditions

There are no valid error conditions for presence updates.

5.2.1.2 Example

An agent (alice) becomes available to the workgroup support@workgroup.company.com.

Example 25. Agent Becomes Available

U: <presence from='alice@company.com/work'
U:             to='support@workgroup.company.com'>
U:   <show>chat</show>
U:   <agent-status xmlns='http://jabber.org/protocol/workgroup'>
U:     <max-chats>3</max-chats>
U:   </agent-status>
U: </presence>

5.2.2 Workgroup Status Update Protocol

This section describes the packet exchange used to update agents on the status of the workgroup. This protocol MAY be supported by compliant implementations.

After an agent announces their presence to the workgroup, they will begin receiving presence updates from the workgroup. All fields are optional:

Example 26. Notify-Agent Status Type

S: <presence to='agent-jid' from='service-jid'>
S:   <notify-agents xmlns='http://jabber.org/protocol/workgroup'>
S:     <available>count</available>
S:     <current-chats>count</current-chats>
S:     <max-chats>count</max-chats>
S:   </notify-agents>
S: </presence>

The defined sub-elements of <notify-agents> are:

<available> - The total number of agents available in the workgroup.
<current-chats> - The current total number of chats being handled by agents in the workgroup.
<max-chats> - The maximum number of simultaneous conversations that can be handled by agents in the workgroup.

5.2.2.1 Error Conditions

There are no valid error conditions for notify workgroup updates.

5.2.2.2 Example

An agent (alice) receives an update from workgroup support@workgroup.company.com.

Example 27. Agent Recives Update

S: <presence to='alice@company.com/work' from='support@wokgroup.company.com'>
S:   <notify-agents xmlns='http://jabber.org/protocol/workgroup'>
S:     <available>2</available>
S:     <current-chats>2</current-chats>
S:     <max-chats>7</max-chats>
S:   </notify-agents>
S: </presence>

5.2.3 Queue Status Update Protocol

This section describes the packet exchange used to update agents on the status of the workgroup queue. This protocol MAY be supported by compliant implementations.

After an agent announces their presence to the workgroup, they will begin receiving presence updates from the workgroup with an overview and details on the queue status.

The <notify-queue/> element updates the agent with a summary of the status of the workgroup queue. All fields are optional:

Example 28. Notify-Queue Status Type

S: <presence to='agent-jid' from='service-jid'>
S:   <notify-queue xmlns='http://jabber.org/protocol/workgroup'>
S:     <count>count</count>
S:     <oldest>YYYYMMDDTHH:mm:ss</oldest>
S:     <time>average-time-to-chat</time>
S:     <status>open</status>
S:   </notify-queue>
S: </presence>

The defined sub-elements of <notify-queue> are:

<count> - The total number of users in the workgroup queue.
<oldest> - The date and time in UTC the oldest member of the queue joined.
<time> - The average time in seconds that a user is in the queue before they are routed to an agent for handling.
<status> - The status of the queue. Queues may be active (requests are being routed and handled by agents) but not accepting new requests for handling. Typical reasons for this state include the queue is shutting down but finishing processing users in the queue, or because the queue has too many requests and should not accept more request until the existing requests are handled. The status field MUST contain one of the following values:
- open - the queue is active and accepting new chat requests
- active - the queue is active but NOT accepting new chat requests
- closed - the queue is NOT active and NOT accepting new chat requests

The <notify-queue-details/> element updates the agent with details of the workgroup queue. All fields are optional:

Example 29. Notify-Queue-Details Status Type

S: <presence to='agent-jid' from='service-jid'>
S:   <notify-queue-details xmlns='http://jabber.org/protocol/workgroup'>
S:     <user jid='user-jid'>
S:       <position>pos</position>
S:       <time>estimated-time</time>
S:       <join-time>YYYYMMDDTHH:mm:SS</join-time>
S:     </user>
S:   </notify-queue-details>
S: </presence>

An update may contain one or more <user> entries (one per user in the queue). The defined sub-elements of <user> are:

<position> - The user's zero-based position in the queue.
<time> - Estimated time in seconds remaining before the user is routed to an agent.
<join-time> - The date and time the user joined the queue in UTC.

5.2.3.1 Error Conditions

There are no valid error conditions for workgroup queue status updates.

5.2.3.2 Example

An agent receives an update from workgroup support@workgroup.company.com.

Example 30. Agent Receives Updates

S: <presence to='alice@company.com/work' from='support@workgroup.company.com'>
S:   <notify-queue xmlns='http://jabber.org/protocol/workgroup'>
S:     <count>1</count>
S:     <oldest>20050208T10:00:00</oldest>
S:     <time>30</time>
S:     <status>open</status>
S:   </notify-queue>
S: </presence>
S: <presence to='alice@company.com/work' from='support@workgroup.company.com'>
S:   <notify-queue-details xmlns='http://jabber.org/protocol/workgroup'>
S:     <user jid='user@server.com/home'>
S:       <position>1</position>
S:       <time>5</time>
S:       <join-time>20050208T10:00:00</join-time>
S:     </user>
S:   </notify-queue-details>
S: </presence>

5.2.4 Agent Status Update Protocol

This section describes the packet exchange used to update agents on the status of other agents in the workgroup. This protocol MAY be supported by compliant implementations.

Example 31. Transactions

Agent                         Service
  |    Request Agent Status      |
  |----------------------------->|
  |         Agent List           |
  |<-----------------------------|
  |                              |
  |     Agent Presence Pushes    |
  |<-----------------------------|

The workgroup service pushes presence updates to the agent as the presence of other agents changes. This will only occur after an agent has requested to receive other agents' information. The server will continue to send presence updates until the agent sends an unavailable presence to the server. This protocol is similar to the standard XMPP roster workflow.

To receive presence updates for other agents in the workgroup, the agent sends an agent info request to the workgroup:

Example 32. Request Element

U: <iq to='support@workgroup.company.com' from='alice@company.com/work' id='id1' type='get'>
U:   <agent-status-request xmlns='http://jabber.org/protocol/workgroup'/>
U: </iq>

The workgroup will then reply with a list of all agents in the workgroup (excluding the agent making the request):

Example 33. Response Element

S: <iq to='alice@company.com/work' from='support@workgroup.company.com' id='id1' type='result'>
S:   <agent-status-request xmlns='http://jabber.org/protocol/workgroup'>
S:     <agent jid="bob@company.com" />
S:   </agent-status-request>
S: </iq>

The server will then push presence packets for other agents as their presence changes. All fields in the <agent-status> child stanza are optional, but an <agent-status> child stanza must be present:

Example 34. Agent Status Update

S: <presence to='alice@company.com/work' from='bob@company.com/work'>
S:   <agent-status xmlns='http://jabber.org/protocol/workgroup'>
S:       <current-chats>2</current-chats>
S:       <max-chats>4</max-chats>
S:   </agent-status>
S: </presence>

The defined sub-elements of <agent-status> are:

<current-chats> - The number of conversations currently being handled by the agent.
<max-chats> - The maximum number of simultaneous conversations the agent can handle.

5.2.4.1 Error Conditions

There are no valid error conditions for agent status updates.

5.2.5 Agent Offer Protocol

This section describes the packet exchange involved in a service offering a chat to an agent. This protocol MUST be supported by compliant implementations.

Example 35. Transactions

Agent                         Service
  |         Offer Request        |
  |<-----------------------------|
  |         Offer Response       |
  |----------------------------->|
  |                              |

The agent is offered a chat with a user. A successful offer results in the agent owning the offer, but does not mean it has accepted the chat. Accepting an offer is handled by the Agent Accept protocol. The separation between offer and acceptance is made so that agents may receive offers while engaged in other activities (busy with other chats) and accept them at a later time.

Example 36. Offer Request

S: <iq from='service-jid' to='agent-jid' id='id1' type='set'>
S:   <offer xmlns='http://jabber.org/protocol/workgroup' jid='user-jid'>
S:       <timeout>seconds</timeout>
S:   </offer>
S: </iq>

Application specific meta-data will normally be added as a sub-element of <offer> to help agents decide whether to accept or not. An optional <timeout> sub-element may be included indicating the amount of time the offer stands before the service will revoke it.

Example 37. Offer Response

A: <iq from='agent-jid' to='service-jid' id='id1' type='result'/>

The agent may respond only with a successful result.

5.2.5.1 Error Conditions

There are no valid error results for an offer response.

5.2.5.2 Example

An agent is offered a chat with a user. The offer will be revoked in 30 seconds.

Example 38. Agent is Offered a Chat

S: <iq to='alice@company.com/work'
S:     from='support@workgroup.company.com'
S:     id='id1'
S:     type='set'>
S:     <offer xmlns='http://jabber.org/protocol/workgroup' jid='user@server.com/home'>
S:       <timeout>30</timeout>
S:     </offer>
S: </iq>
A: <iq to='support@workgroup.company.com'
A:     from='alice@company.com/work'
A:     id='id1'
A:     type='result'/>

The following is a more typical offer containing meta-data about the user. The offer will be revoked in 30 seconds.

Example 39. Offer Including Meta-Data

S: <iq to='alice@company.com/work'
S:     from='support@workgroup.company.com'
S:     id='id2'
S:     type='set'>
S:     <offer xmlns='http://jabber.org/protocol/workgroup' jid='user@server.com/home'>
S:       <timeout>30</timeout>
S:       <crm xmlns="http://www.company.com/xmpp/workgroup'>
S:         <user-id>423498ae84f</user-id>
S:         <product>Widget 1.0</product>
S:       </crm>
S:     </offer>
S: </iq>
A: <iq to='support@workgroup.company.com'
A:     from='alice@company.com/work'
A:     id='id2'
A:     type='result'/>

5.2.6 Agent Offer Accept/Reject Protocol

This section describes the packet exchange involved in an agent rejecting an offering a chat to a user. This protocol MUST be supported by compliant implementations.

Example 40. Transactions

Agent                         Service
  |  Offer Accept/Reject Request |
  |----------------------------->|
  | Offer Accept/Reject Response |
  |<-----------------------------|
  |                              |

The agent accepts or rejects an offer to chat with a user.

Example 41. Offer Accept Request

A: <iq to='service-jid' from='agent-jid' id='id1' type='set'>
A:   <offer-accept jid='user-jid' xmlns='http://jabber.org/protocol/workgroup' />
A: </iq>

Example 42. Offer Reject Request

A: <iq to='service-jid' from='agent-jid' id='id1' type='set'>
A:   <offer-reject jid='user-jid' xmlns='http://jabber.org/protocol/workgroup'/>
A: </iq>

Example 43. Offer Response

S: <iq to='agent-jid' from='service-jid' id='id1' type='result'/>

The service may respond only with a successful result.

5.2.6.1 Error Conditions

There are no valid error results for an accept/reject offer response.

5.2.6.2 Example

Example 44. Agent Accepts Chat

A: <iq from='alice@company.com/work'
A:       to='support@workgroup.company.com'
A:       id='id3'
A:     type='set'>
A:   <offer-accept jid='user@server.com/home' xmlns='http://jabber.org/protocol/workgroup'/>
A: </iq>
S: <iq from='support@workgroup.company.com'
S:     to='alice@company.com/work'
S:     id='id3'
S:     type='result'/>

5.2.7 Agent Offer Revoke Protocol

This section describes the packet exchange involved in a service revoking an offer to an agent to chat to a user. This protocol MUST be supported by compliant implementations.

Example 45. Transactions

Agent                         Service
  |     Offer Revoke Request     |
  |<-----------------------------|
  |    Offer Revoke Response     |
  |----------------------------->|
  |                              |

The service revokes an earlier offer to chat to a user. Offer revocations typically occur when the original offer times out, or a better agent was found to handle the chat. Note that offer revocations may occur anytime after an offer has been made, and before an invitation is sent (see agent state diagram). In other words, even though an agent has accepted an offer to chat, the agent may still receive an offer revocation (e.g. a better agent was found to handle the chat).

Example 46. Offer Revoke Request

S: <iq from='service-jid' to='agent-jid' id='id1' type='set'>
S:     <offer-revoke jid='user-jid' xmlns='http://jabber.org/protocol/workgroup'>
S:       <reason>
S:         [reason]
S:       </reason>
S:     </offer-revoke>
S: </iq>

The reason element may optionally contain free form text explaining the reason the offer was revoked.

Example 47. Offer Response

A: <iq from='agent-jid' to='service-jid' id='id1' type='result'/>

The agent may respond only with a successful result.

5.2.7.1 Error Conditions

There are no valid error results for an offer response.

5.2.7.2 Example

Example 48. Offer Revoked Due to Timeout

S: <iq to='alice@company.com/work'
S:     from='support@workgroup.company.com'
S:       id='id4'
S:     type='set'>
S:     <offer-revoke xmlns='http://jabber.org/protocol/workgroup' jid='user@server.com/home'>
S:         <reason>
S:           Offer timed out
S:         </reason>
S:     </offer-revoke>
S: </iq>
A: <iq to='support@workgroup.company.com'
A:     from='alice@company.com/work'
A:       id='id4'
A:     type='result'/>

5.2.8 Agent Invite Protocol

This section describes the packet exchange inviting an agent to a chat room for conversation with a user. This protocol MUST be supported by compliant implementations.

Example 49. Transactions

Agent                         Service
  |         Agent Invite         |
  |<-----------------------------|
  |                              |

The server sends a standard JEP-0045 groupchat invitation to the agent to begin their conversation with a user. The invitation follows the same format as shown in the User Invite Protocol.

In order to match invitations to offers, all invitations should carry meta-data in the workgroup namespace in the 'offer' element with the JID of the user as an attribute. The typical meta-data fragment would appear as:

Example 50. Invitation Meta-Data

<offer xmlns='http://jabber.org/protocol/workgroup' jid='user-jid'>

5.2.8.1 Error Conditions

There are no valid error conditions for agent invitations.

5.2.8.2 Example

An invitation from the server on behalf of the support@server.com workgroup:

Example 51. An Invitation

S: <message
S:     from='roomname@chatserver.company.com'
S:     to='alice@company.com/work'>
S:   <x xmlns='http://jabber.org/protocol/muc#user'>
S:     <invite from='support@workgroup.company.com'>
S:       <reason>
S:       Please join the chat room to start your chat with user@server.com.
S:       </reason>
S:     </invite>
S:   </x>
S:   <x jid='roomname@chatserver.company.com' xmlns='jabber:x:conference'/>
S:   <offer xmlns='http://jabber.org/protocol/workgroup' jid='user@server.com/home'/>
S: </message>

9.1 Protocol Namespaces

Upon advancement of this JEP to a status of Draft, the Jabber Registrar [7] shall add 'http://jabber.org/protocol/workgroup' to its registry of protocol namespaces.

9.2 Service Discovery Category/Type

Service Discovery support is optional for Workgroup compliant implementations. Workgroup services that do support Service Discovery MUST:

Use the <identity> category="collaboration".
Use the <identity> type="workgroup".
Use the <feature> var="http://jabber.org/protocol/workgroup".

An example of discovery browsing is included. Notice how probing starts at the server (company.com) revealing the workgroup service by it's JID (workgroup.company.com) and a simple, human friendly name ("Company.com Live Assistant"). It is only during the discovery probing of the service that it is identified as a workgroup using the <identity> and <feature> tags. Finally individual workgroups (support and sales) can be discovered on the Workgroup service. When individual workgroups are probed, the <identity> and <feature> tags are again presented to identify them as workgroups along with (optional) associated meta-data.

Example 52. Workgroup Service Discovery

U: <iq to="company.com" from="user@server.com/home" id="id1" type="get">
U:     <query xmlns="http://jabber.org/protocol/disco#items"/>
U: </iq>
S: <iq from="company.com" to="user@server.com/home" id="id1" type="result">
S:    <query xmlns="http://jabber.org/protocol/disco#items">
S:        <item jid="workgroup.company.com" name="Company.com Live Assistant"/>
S:    </query>
S: </iq>

U: <iq to="workgroup.company.com" from="user@server.com/home" id="id2" type="get">
U:    <query xmlns="http://jabber.org/protocol/disco#info"/>
U: </iq>
S: <iq from="workgroup.company.com" to="user@server.com/home" id="i2" type="result">
S:    <query xmlns="http://jabber.org/protocol/disco#info">
S:        <identity category="collaboration" name="Live Assistant" type="workgroup"/>
S:        <feature var="http://jabber.org/protocol/workgroup"/>
S:        <feature var="http://jabber.org/protocol/disco#info"/>
S:    </query>
S: </iq>

U: <iq to="workgroup.company.com"from="user@server.com/home" id="id3" type="get">
U:     <query xmlns="http://jabber.org/protocol/disco#items"/>
U: </iq>
S: <iq from="workgroup.company.com" to="user@server.com/home" id="id3" type="result">
S:     <query xmlns="http://jabber.org/protocol/disco#items">
S:         <item jid="support@workgroup.company.com" name="Company.com Support Live Assistant"/>
S:         <item jid="sales@workgroup.company.com" name="Company.com Sales Live Assistant"/>
S:     </query>
S: </iq>

U: <iq to="support@workgroup.company.com"from="user@server.com/home" id="id4" type="get">
U:     <query xmlns="http://jabber.org/protocol/disco#info"/>
U: </iq>
S: <iq from="support@workgroup.company.com" to="user@server.com/home" id="id4" type="result">
S:     <query xmlns="http://jabber.org/protocol/disco#info">
S:         <identity category="collaboration" name="demo" type="workgroup"/>
S:         <feature var="http://jabber.org/protocol/disco#info"/>
S:         <x xmlns="jabber:x:data" type="result">
S:             <field var="FORM_TYPE" type="hidden">
S:                 <value>http://jabber.org/protocol/workgroup#workgroupinfo</value>
S:             </field>
S:             <field var="workgroup#description" label="Description">
S:                 <value>Company.com Support Workgroup</value>
S:             </field>
S:             <field var="workgroup#online" label="Status">
S:                 <value>ready</value>
S:             </field>
S:         </x>
S:     </query>
S: </iq>

9.3 Service Discovery Features

Discovery of support for this JEP can be done using the 'http://jabber.org/protocol/workgroup' namespace. Individual workgroups SHOULD provide information when queried about the status of the room, such as expected wait time.

Example 53. Registry Submission

<var>
  <name>http://jabber.org/protocol/workgroup</name>
  <desc>Workgroup namespace</desc>
  <doc>JEP-0142</doc>
</var>

1. RFC 3920: Extensible Messaging and Presence Protocol (XMPP): Core <http://www.ietf.org/rfc/rfc3920.txt>.

2. JEP-0045: Multi-User Chat <http://www.jabber.org/jeps/jep-0045.html>.

3. JEP-0004: Data Forms <http://www.jabber.org/jeps/jep-0004.html>.

4. RFC 2119: Key words for use in RFCs to Indicate Requirement Levels <http://www.ietf.org/rfc/rfc2119.txt>.

5. The max-chats value sent from agent to workgroup service is a 'hint' or recommended value. The workgroup service is not obliged to accept this value. The actual max-chats value for the agent will be sent to the agent via the next Agent Status Update. This allows administrators to constrain agent behavior in order to enforce company policy, quality assurance, etc.

6. The Internet Assigned Numbers Authority (IANA) is the central coordinator for the assignment of unique parameter values for Internet protocols, such as port numbers and URI schemes. For further information, see <http://www.iana.org/>.

7. The Jabber Registrar maintains a list of reserved Jabber protocol namespaces as well as registries of parameters used in the context of protocols approved by the Jabber Software Foundation. For further information, see <http://www.jabber.org/registrar/>.

Version 0.2 (2005-02-28)

General re-organization, refined agent status protocol, removed queue-notification element from join request replies, user status pushes now use a message instead of IQ. (mt/is)

Version 0.1 (2004-08-10)

Initial version. (mt/is)