]> The JSON format for vCon - Conversation Data Container SIPez LLC
dan.ietf@sipez.com
Applications and Real-Time Virtualized Conversations conversation vcon CDR call detail record call meta data call recording email thread text conversation video recording video conference conference recording vCon is a standardized framework for the exchange of conversational data. Conversations, which may involve one or more participants, occur across a wide variety of modes and application platforms. This document defines a JSON format for representing conversational data, encompassing metadata, conversation media, related documents, and analysis. The goal of this standard is to provide an abstracted, platform-independent data format for conversations, regardless of the mode or application platform. By doing so, it facilitates the integration and seamless exchange of conversational data across application platforms, enterprises, and trust boundaries. About This Document The latest revision of this draft can be found at . Status information for this document may be found at . Discussion of this document takes place on the Virtualized Conversations Working Group mailing list (), which is archived at . Subscribe at . Source for this draft and an issue tracker can be found at .
Introduction This document specifies the vCon (Conversational Data Exchange) standard, which defines a unified format for representing and exchanging conversational data across different communication platforms and modalities. The goal of vCon is to provide a standardized, platform-agnostic structure for capturing and sharing conversational information, allowing for seamless integration between systems, enterprises, and trust boundaries.
Purpose of vCon The vCon standard enables the abstraction of conversation data, making it easier to integrate communication platforms with external services, including post-conversation analysis tools, customer support systems, and business intelligence platforms. By defining a consistent data format, vCon ensures interoperability across various platforms, regardless of the communication mode - whether text, audio, video, or other formats. The vCon format captures the essential components of a conversation, including metadata, media content, related documents, and post-conversation analysis. This abstraction simplifies data exchange, enables AI-driven analysis, and supports model training and testing.
Extending the vCon Schema In addition to the core vCon schema, this document provides a framework for extending the vCon format to support specialized use cases. The vCon schema can be customized to address the needs of specific industries or applications, such as:
  • Contact Centers: Adding specific metadata related to customer service interactions, case management, and priority tracking.
  • Messaging Platforms: Supporting the integration of different message formats, including SMS, email, and chat, group concepts, along with platform-specific information.
  • ECRIT (Emergency Communication) Centers: Extending the schema to capture critical data such as location, urgency, and incident details for emergency communications.
The ability to add extensions ensure that vCon remains flexible and adaptable, enabling its use in a wide range of domains while maintaining a consistent format for data exchange.
Benefits of vCon The vCon standard offers several key benefits:
  • Interoperability: A consistent data format for conversational data facilitates integration across diverse platforms and systems.
  • AI-Driven Analysis: By capturing data in a structured format, vCon enables the application of AI analysis such as sentiment analysis, categorization, transcription, and decision-making.
  • Data Automation: The vCon format simplifies the automation of processes involving conversational data, improving efficiency and reducing the risk of errors.
  • Enterprise Integration: The ability to integrate conversation data with third-party tools and services enhances the value of conversations by providing deeper insights and driving business decisions.
Scope of the Document This document defines the core structure and schema for vCon as a JSON format. Detailed specifications for the various parameters and the extension framework will be provided in subsequent sections. The primary focus is on creating a flexible, extensible standard for the exchange of conversational data that can be easily adopted across industries, use cases, and communication technologies.
Conventions and Definitions The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 when, and only when, they appear in all capitals, as shown here.
Terminology
  • analysis - analysis, transformations, summary, sentiment, or translation typically of the dialog data
  • contributor - a party that generated, or potentially generated, any part of the Dialog Content of a Dialog Object
  • conversation - an exchange of communication using text, audio or video medium between at least one human and one or more bots or humans
  • de-identification - removal of all information that could identify a party in a conversation. This includes PII as well as audio and video recordings. Voice recordings might be re-vocalized with a different speaker.
  • dialog - the captured conversation in its original form (e.g. text, audio or video)
  • encrypted form - encrypted JWE document with the JWS signed vCon form contained in the ciphertext
  • file - a data block either included or referenced in a vCon
  • object - JSON object containing key and value pairs
  • parameter - JSON key and value pair
  • party - an observer, facilitator or participant to the conversation, either passive or active, which may be a contributor, a receiver, both or neither (e.g. the organizer of a conference)
  • payload - the contents or bytes that make up a file
  • PII - Personal Identifiable Information
  • PII masked - may include voice recordings, but PII is removed from transcripts and recordings (audio and video).
  • receiver - a party to which any part of the dialog in a session was sent and potentially received
  • regex - a regular expression, a sequence of characters that defines a search pattern used to match, locate or validate strings of text
  • vCon - container for conversational information
  • vCon instance - a vCon populated with data for a specific conversation
  • vCon instance version - a single version of an instance of a conversation, which may be modified to redact or amend additional information forming a subsequent vCon instance version
  • vCon syntax version - the version for the data syntax used for form a vCon
  • signed form - JWS signed document with the unsigned vCon form contained in the payload
JSON Notation For the ease of documentation, the convention for notation used in this document is copied from sections 1.1-1.5 of .
  • Date - A string that MUST have the form of an date string as defined for the Date type in section 1.4 of .
  • "*" - The type is undefined; the value can be any JSON type, although permitted values may be constrained by the context of the value, as defined in section 1.1 of .
  • "String" - a JSON string type.
  • "UnsignedInt" - a positive JSON integer as defined in section 1.3 of .
  • "UnsignedFloat" - a positive JSON floating point number containing a decimal point as defined in section 6 of .
  • "Mediatype" - A "String" value that MUST be of the following form as defined in section 5.1 of : type "/" subtype
  • "ContentHash" - The string token value is generated using the same approach used in section 6 of . The relevant text is copied here for convenience and to remove the normative dependency. The hash string token values are formed from combining a string that defines the crypto algorithm used to generate the digest along with the Base64Url Encoded value of the SHA-512 hash, as defined in section 6.3 and 6.4 , of the body of the content at the given url. The hash algorithm is identified by "sha512". SHA-512 is part of the SHA-2 set of cryptographic hash functions defined by the US National Institute of Standards and Technology (NIST). Implementations MAY support additional recommended hash algorithms in ; that is, the hash algorithm has "Yes" in the "Recommended" column of the IANA registry. Hash algorithm identifiers MUST use only lowercase letters, and they MUST NOT contain hyphen characters. The character following the algorithm string MUST be a hyphen character, "-", or ASCII 45. The subsequent characters are the Base64Url encoded (see Section 2 ) digest of a canonicalized and concatenated string or binary data based on the JSON pointer referenced elements of "rcd" claim or the URI referenced content contained in the claim.
  • "SessionId" - An object with the String parameters: "local" and "remote". The String values of these parameters are UUIDs as defined in section 5 of as "local-uuid" and "remote-uuid". This is designed to also work with the H.323 correlated which refers to them as "Sender-UUID" and "Recipient-UUID". { "local": String, "remote": String }
  • "A[]" and array of values of type A.
All parameters are assumed to be mandatory unless otherwise noted. Objects or arrays with no or null values MAY be excluded from the vCon.
Inline Files Objects that contain a file or data inline (i.e. within the vCon) MUST have the parameters: body and encoding. JSON does not support binary data values. For this reason inline files MUST be Base64url (see Section 2 ) encoded to be included as a valid JSON string value if they are not already valid JSON strings.
body The body parameter contains the payload of the file to be included inline. Depending upon the data in the file, it may require encoding to be represented as a valid JSON value.
  • body: "*"
encoding The encoding parameter describes the type of encoding, if any, that was performed to represent the file payload as the value of the body parameter. If the body parameter is provided and is not an empty string, the encoding parameter MUST be provided. In the interest of being tolerant for interoperability, if the encoding value is not provided, applications can attempt to derive the encoding token value based upon the mediatype parameter or filename extension if either is provided.
  • encoding: "String"
The string MUST have the value of one of the following tokens or a value defined in a vCon extension:
  • "base64url": The payload of the file has been Base64Url encoded and provided as the string value of the body parameter.
  • "json": The value of the body parameter is a JSON value (object, array, number, string, or one of the literals true, false, or null) as defined in .
  • "none": The payload of the file is a valid JSON string and can be included without modification as the string value to the body parameter.
A vCon extension which defines an additional encoding value also defines the form of the body parameter value for that encoding, either a string or another JSON value. An Object with an encoding which is not recognized cannot be decoded and is handled as described in . Such an extension is Incompatible, and its name is listed in the critical parameter, if a vCon cannot be processed correctly when the Object is ignored.
Externally Referenced Files Files and data stored externally from the vCon MUST be "signed" to ensure that they have not been modified. Objects that refer to a file which is externally stored from the vCon MUST have the parameters: url, content_hash. These parameters are defined in the following subsections. The values and format of the hashes are defined in type: ContentHash. The use of hash for ensuring that the externally referenced data or file has not been modified, is defined in this document. Other methods of ensuring integrity may be added in the future.
url The url value contains the URL where the externally referenced file is stored. HTTPS MUST be used for retrieval to protect the privacy of the contents of the file.
  • url: "String"
content_hash The integrity of externally referenced files are protected using a hash of the external content. The algorithm and hash value are contained in the content_hash parameter. The value of the content_hash can be a single token or an array of tokens if multiple hash algorithms are desired to be provided. The SHA-512 algorithm MUST be supported. Other algorithms MAY be included. The algorithm used for signing the externally referenced file is defined in section 6.3 and 6.4 of .
  • content_hash: "ContentHash" | "ContentHash[]"
Extending vCon vCon provides a means to extend the schema defined in this document. A vCon extension can define new parameters at any level of the schema. It can also define additional allowed values for an existing parameter, such as a new token for a type parameter. It can also define new Objects, which appear as the value of a new parameter or as the elements of a new array parameter. It can also redefine the semantics of or deprecate existing parameters. A vCon extension is defined in its own document. In addition to the standard sections of an Internet-Draft, a vCon extension document MUST also contain the following sections.
  • Extension Name: State the registered extensions token name for the extension. The name MUST appear in the extensions parameter of any vCon which uses the extension; state whether and under what conditions the name also appears in the critical parameter. This is the name registered in the vCon Extensions Names Registry and the name against which implementations determine whether they support the extension.
  • Parameter Definitions: Define each new parameter, the level of the schema at which it appears, its value type, and its semantics. For any existing parameter whose meaning or permitted values are redefined, state the new semantics and values. For any value added to the allowed values of an existing parameter, define the value and its semantics and state which parameters apply when the value is used. For each new Object, define the parameters of the Object in the same manner. For each new Object, a new parameter names registry SHOULD be requested from IANA with the parameters of the new Object as its initial values (see ). For any deprecated parameter, state what is to be used in its stead and the migration approach. Use the snake case naming convention for all parameter names, as opposed to camel case. Register each new parameter in the appropriate Object registry with IANA. Register each new value in the appropriate registry with IANA, where one exists.
  • Compatibility Considerations: Describe how the extension behaves in the presence of implementations that do not support it. Identify the parameters and semantics the extension introduces or changes, and explain for each why an implementation that does not recognize the extension can continue to process the vCon correctly by ignoring the additions, or state the conditions under which that holds. A value added to the allowed values of an existing parameter is not recognized by an implementation that does not support the extension, and by default the Object which contains it is ignored. For any such value, describe the effect of the Object being ignored and state whether this makes the extension Incompatible. An extension that is Compatible under all conditions states so explicitly and justifies that claim.
  • Incompatibility Considerations: Demonstrate either that the extension introduces no incompatibilities, or enumerate each incompatibility that it does introduce. For each incompatibility, state the processing that is affected, for example redaction versus transcription, whether the extension name is therefore required in the critical parameter, and the behavior required of implementations that do not support the extension. An extension that claims to be Compatible uses this section to show why no incompatibility exists.
  • Privacy and Integrity Considerations: Describe how the extension's parameters interact with redaction and de-identification, including whether any of them can carry party-identifying data or PII and how a redactor is expected to handle them. In particular, state whether the string redaction feature of the vCon will work to redact any sensitive information, or if there is additional extension-specific redaction capabilities needed.
State whether the extension introduces any new external content references, and if so, the integrity mechanism that protects them, such as . A markdown template for a vCon extension document containing these sections is referenced in vCon Extension Template. Extensions to the vCon schema can be classified into two categories:
  • Compatible: These extensions introduce additional data or fields without altering the meaning or structure of existing elements. Implementations that do not recognize these extensions can safely ignore them while maintaining valid processing of the vCon.
  • Incompatible: These extensions modify existing semantics or schema definitions in ways that render a vCon incompatible with implementations that do not support the extension. Interpreting such a vCon correctly requires explicit awareness of the extension.
Wherever feasible, extensions SHOULD be designed as Compatible to preserve compatibility with existing implementations. The question of Compatible vs Incompatible is a little subjective. A transcriber for vCon can be fairly tolerant of changes adding new parameters or objects to a vCon. In these cases a transcriber will likely only need to look at the critical extensions. On the other hand, a redactor must be aware of the implications of all parameters in the vCon to be sure to redact all of the objective information. If an extension adds information which cannot be removed by the vCon string redaction feature, this may make the extension incompatible. A redactor which needs a 100% guarantee that it can redact everything, perhaps should reject vCons with any extension that it does not support. Others, may choose to accept them, assuming the string redaction is sufficient. However, when Incompatible extensions are necessary, the names of all such extensions MUST be listed in the critical parameter of the vCon. This allows implementations to determine whether they are capable of processing the vCon safely and accurately. Implementations that encounter a vCon containing an Incompatible extension listed in the critical parameter, but do not support that extension, MUST NOT process the vCon except to reject it or report unsupported content. A parameter may contain a token value which an implementation does not recognize, such as a type defined in an extension which the implementation does not support. If an unsupported extension is listed in the critical parameter, the vCon is not processed as described above. Otherwise, the implementation SHOULD ignore the Object which contains the unrecognized value and continue to process the rest of the vCon. An ignored Object remains in its array so that the indexes which reference Objects in that array are not changed.
vCon JSON Object The JSON form of a vCon is contained in a JSON object in one of three forms:
  • unsigned
  • signed
  • encrypted
The unsigned form of the vCon has a single top level object. This top level vCon object is also contained as described in the signed and encrypted forms of the vCon. The selection of the JSON format enables interchange between application and lower layers of the network stack, critical for enablement of analysis of conversations. The signed form of vCon is defined in using to provide integrity and proof of the conversation data. The encrypted form of vCon is defined in using to provide complete privacy of the conversational data. Partial privacy or data minimization can be provided for a vCon using the techniques outlined in Redaction Techniques.
Unsigned Form of vCon Object The unsigned form of the top level vCon object is necessary as in many cases, a vCon will be partially constructed and in process as conversation data is collected. This may change while the conversation is in progress or on-going. The vCon may start with only meta data and party information, then progress to contain dialog information. It may then get analysis added or it could be passed to another security domain for analysis. A vCon in the unsigned form SHOULD contain at least one of the parties, dialog, analysis or attachments parameters. A vCon may be constructed across several security domains. When a vCon is to be exported from one security domain to another, it SHOULD be signed or encrypted by the domain that constructed it. The subsequent domain may have need to redact or amend data to the vCon. Alternatively the originating domain may want to redact the vCon before providing it to another domain. The second or subsequent domain, MAY modify the prior vCon instance version and when complete or exporting to another security domain, it SHOULD sign or encrypt the new vCon instance version. The new vCon instance version SHOULD refer to the prior vCon instance version via the redacted_from () or amended_from () parameters - see Redaction Techniques.
vCon JSON Object Keys and Values The keys and values for the top level vCon JSON object are defined in the following subsections.
vcon The "vcon" parameter is DEPRECATED as of the publication of this document as an RFC. The "vcon" parameter was used to differentiate schema changes to the vCon core container when incompatibilities were created in Internet-Draft versions. The extension mechanism replaces the need for schema versioning. The vcon parameter was used to contain the syntactic version of the JSON format used in the vCon. (see Non-Upward Compatible Changes to the vCon Container)
  • vcon: "String"
For syntax defined in this document, the string MUST have the value: "0.5.0"
uuid The for the vCon is used to refer to it when privacy or security may not allow for inclusion or URL reference to a vCon. The UUID value MUST be globally unique. All vCon documents MUST have the uuid parameter and value set.
  • uuid: "String"
The value of the string SHOULD be generated using the version 8 UUID defined in which is generated identically to a version 7 UUID with the exception that:
  • rand_b/custom_c is generated from the high 62 bits of the SHA-1 hash of the FQHN string
  • the variant and version fields are set as described for version 8 UUID
The DNS name string used in generating the uuid value SHOULD be the same FQHN, or a subdomain to allow for more distributed generation of UUIDs, as would used in the signing certificate as they are the same domains of uniqueness.
extensions The vCon schema can be extended through the definition of new extensions. The extensions parameter MUST contain the list of names of all vCon extensions which define any parameters, Objects or parameter values used in the vCon that are not defined in this core vCon schema document. Each extension name listed in the critical parameter MUST also be listed in the extensions parameter (see ).
  • extensions: "String[]" (optional, MUST be present if any vCon extension is used)
critical Implementations that include extensions which are incompatible with the core vCon schema MUST list the names of those extensions in the critical parameter. A vCon that includes a critical parameter indicates that correct interpretation of the vCon requires explicit support for the listed extensions. An implementation that does not recognize or support the extensions listed in the critical parameter MUST NOT attempt to process or operate on the vCon, except to reject it or report unsupported content.
  • critical: "String[]" (optional, MUST be present if any Incompatible vCon extension is used)
created_at The created_at parameter provides the creation time of this vcon, which MUST be present, and should not change once the vcon object is created.
  • created_at: "Date"
updated_at The updated_at parameter provides the last modified time of this vcon, which MAY be present. For unsigned forms, the updated_at of the vcon object SHOULD be updated as it is modified. For signed forms of the vCon object, the updated_at contains the time when this vcon was last signed. Future updates MUST first set the updated_at to the new signing time as the vcon object is signed again.
  • updated_at: "Date"
subject The subject or the topic of the conversation is provided in the subject parameter. This parameter is optional as not all conversations have a defined subject. Email threads and prescheduled calls and video conferences typically have a subject which can be captured here. The subject may also be derived from analysis of the dialog.
  • subject: "String" (optional)
The string value of the subject parameter is a free formed JSON string with no constrained syntax.
redacted_from A redacted vCon SHOULD provide a reference to the unredacted or prior, less redacted, vCon instance version of itself. The purpose of the Redacted_from Object is to provide the reference to the unredacted or less redacted version of the vCon from which this vCon was derived. For privacy reasons, it may be necessary to redact a vCon to construct another vCon without the PII. This allows the non-PII portion of the vCon to still be analyzed or used in a broader scope. The Redacted_from Object SHOULD contain the uuid parameter and MAY include the url, content_hash parameters (see Externally Referenced Files). If a reference to the unredacted vCon is provided in the url parameter, the access to that URL MUST be restricted to only those who should be allowed to see the identity or PII for the redacted vCon. Redaction techniques are discussed in more detail in Redaction Techniques. The assurance of the accuracy of the redaction is made by the entity that creates the redaction which SHOULD sign the redacted version of the vCon.
  • redacted_from: "Redacted_from" (optional, mutually exclusive with amended_from parameter)
Redacted_from Object A Redacted_from Object contains the following parameters:
  • uuid: "String"
The value contains the uuid string value of the unredacted/prior vCon instance version. The absence of a value for uuid indicates that the less redacted version of this vCon is not available or does not exist.
  • type: "String"
The value of the redacted type parameter is used to indicate the type of redaction that was performed on this vCon relative to the less redacted version referenced by the redacted uuid parameter. This should indicate the type of information that was redacted, and has the same set of values defined for the type field of the redacted_string object. The the location of the referenced vCon MAY be provided as defined in Externally Referenced Files by including url and content_hash. content_hash MUST be included if url is provided.
  • url: "String"
  • content_hash: "ContentHash" | "ContentHash[]"
The following diagram illustrates an example partial JSON object tree for a redacted vCon. The top level object is a JWS signed vCon which contains a vCon in the unsigned form in the payload parameter. The second level object is the redacted vcon which refers to the encrypted unredacted vCon in it's redacted_from parameter. Note that the redacted vCon references the JWE encrypted vCon by UUID and may reference it by URL. The JWE encrypted unredacted vCon contains the signed version of the unredacted vCon in the ciphertext parameter. The signed unredacted vCon contains the unredacted vCon in the unsigned form in it's payload parameter.
redacted vCon object tree | JWE uuid-|-- uuid in unprotected Encrypted signed | | unredacted vCon: | cyphertext-|--- JWS signed --------------- / unredacted vCon / in cyphertext /-------------------/ parameter / / ------------- Signed -> |JWS uuid-|-- unredacted vCon uuid in header unredacted vcon: | | | payload-|-- unsigned unredacted vCon ------------- \ in payload \ ---------- -->| vCon | Unsigned unredacted vCon: | | ---------- ]]>
amended_from A signed or encrypted vCon cannot be modified without invalidating it. In these cases, to allow for adding of additional information a new vCon instance version MUST be created. The prior vCon instance version is referenced by the Amended_from Object. The vCon with amended data contains all of the data that is in the referenced vCon with the exception of data that is amended. That is to say that the newer version of the vCon is a deep copy of the prior version with the amended and additional data added to it. The prior vCon instance version SHOULD be referenced via the uuid of the prior vCon instance version, and MAY include the url and content_hash parameters (see Externally Referenced Files).
  • amended_from: "Amended_from" (optional, mutually exclusive with redacted_from parameter)
Amended_from Object The Amended_from Object contains the following parameters:
  • uuid: "String" (optional if external reference provided)
The value contains the uuid string value of the prior vCon instance version, to which this vCon's amendments were applied. The prior vCon instance version may be the original vCon, a redacted vCon, or a previously amended vCon. The location of the referenced vCon MAY be provided, as defined in Externally Referenced Files by including url and content_hash. content_hash MUST be provided if url is provided.
  • url: "String"
  • content_hash: "ContentHash" | "ContentHash[]"
The following figure illustrates an example partial JSON object tree for an amended vCon. The top level object is the JWS signed amended vCon which contains the unsigned form of the vCon in its payload parameter. The second level object is the amended vCon with additional conversational data (e.g. analysis data). It refers to the prior vCon instance version in its amended parameter. Note: the amended_from parameter may refer to the prior vCon instance version via URL. The amended vCon in this figure refers to the JWS signed version of the vCon, which in turn contains the original vCon in unsigned form in its payload parameter.
amended vCon object tree | JWS uuid-|-- original vCon uuid in header signed | | original vCon: | payload-|--- payload parameter ------------ / contains unsigned / original vCon ------------- / Original vCon: |vCon |<-- | | | parties | | dialog | ------------- ]]>
sessions Objects Array A vCon can contain a single conversation, several conversations, sub-conversations or side bar conversations. The Session Object is used to group dialog Objects into sets of dialog to represent those conversations. A Session Object can "contain" other Session Objects by reference. A simple conversation has only 1 Session Object for all of the Dialogs. At least one Session Object MUST exist if the Events array or the Dialog array contain objects. TODO: Session Object required if Attachments is not empty too?
  • sessions: "Session[]" (optional)
The value of the sessions parameter is an array of Session Objects. Examples of where multiple Session Objects are used to show the topology of the conversation and dialog include:
Call Transfer A customer calls into a contact center, which results in a call to a bot, that call gets transferred to an agent, the agent has a consultation with a supervisor, the customer gets transferred to the supervisor. From the customer's perspective this was one call. In reality it was 3 different calls. This may be represented as Session Object which references 3 other Session Object:
  • The original call with the bot
  • the call between the agent and the supervisor
  • The call resulting from the transfer of the customer to the supervisor
Dialog per Stream Some call recorders create a separate single channel recording for each leg or stream in the call, each resulting in a Dialog Object. To show that those Dialog Objects are all in the same call or conversation, we create a Session Object which refers to all of the Dialog Objects that were a part of it.
Dialog per Talk Spurt Some call recorders create separate single channel recordings for each contiguous talk spurt for a Party or stream. This may result in several Dialogs for some of the parties in the call. In this case we need the Session Object to indicate which Dialogs compose the call or conversation. We also need the Session Object to declare the start and duration of the call, as each Dialog Object only defines the start and duration of its talk spurt.
Agent Coaching In contact centers, an agent talking to a customer may be monitored by a supervisor. In this scenario, the customer and the agent can hear each other, the agent and the supervisor can hear each other, but the customer cannot hear the supervisor, the supervisor can hear both the customer and the agent. In the simple case, we have 3 Dialog Objects and 2 Session Objects. Dialog Objects containing:
  • The customer talking
  • The agent talking
  • The supervisor talking
Session Objects referencing Session and Dialog Objects:
  • The top level Session Object which references the following Session Objects
  • The customer Session which references the customer and agent dialog recordings
  • The supervisor Session which references the customer, the agent and supervisor dialog recordings
AI Agent A conversation may occur between an AI agent and a human. That AI agent in turn may converse with other AI agents, to fulfill a response to the human. This can recurse such that the second tier AI agents talk to 3rd tier AI agents or even other humans and so on. The top level Session object might represent the conversation between the human and the top level AI agent. That top level Session Object would refer to other Session Objects for the second tier AI agent conversations. Those Session Objects may refer to Session Objects for the 3rd tier AI agent conversations and so on. This example describes how both human to AI agent as well as AI agent to AI agent conversations can be captured in a vCon.
parties Objects Array The name, identity or contact information of all of the parties involved with the conversation are included in the parties object array. Whether the parties were observers, passive or active participants in the conversation, they each are included as a Party Object in the parties array.
  • parties: "Party[]" (optional)
The value of the parties parameter is an array of Party Objects.
events Objects Array All events which occur related to this vCon are included in this array of Event Objects. Event Objects MAY appear in any order in the events array and are not required to be in chronological order. Events may be in non-chronological order because of network or consolidation delays. The time parameter of each Event Object is used to determine the sequence in which the events occurred.
  • events: "Event[]" (optional)
The value of the events parameter is an array of Event Objects.
dialog Objects Array The actual conversation which occurred over text, audio or video that was captured, is contained in the dialog Objects Array.
  • dialog: "Dialog[]" (optional)
The value of the dialog parameter is an array of Dialog Objects. It should be noted that the Dialog Objects may not be sorted in chronological order. They are in the order that they were added. It is the applications responsibility to sort dialog and transcriptions if they are needed in chronological order.
analysis Objects Array Analysis, which is performed on the conversational data, is stored in the analysis Objects array.
  • analysis: "Analysis[]" (optional)
The value of the analysis parameter is an array of Analysis Objects.
attachments Objects Array Ancillary documents, discussed, presented, referenced or related to the conversation may be stored in the attachments array. It should be noted that the Attachment Objects may not be sorted in chronological order. They are in the order that they were added.
  • attachments: "Attachment[]" (optional)
The value of the attachments parameter is an array of Attachment Objects.
redacted_strings Objects Array A vCon can contain sensitive information in string values in many places. A text dialog containing chat messages or emails might contain a person's first name, or a street address, or an account number. Events, like a tool call made by an AI agent - can contain an account ID or social security number. The vCon format provides a general purpose solution for redacting sensitive information from any string in the object. Any string which has a substring containing sensitive information can be replaced by "_REDACTED_REF#", where the value of # is a positive integer which uniquely identifies the substring that was replaced. Within the redacted_strings array there will be a member that contains a matching reference, along with meta-data about the redaction, such as the type of information that was redacted. The redacted_strings array is defined as:
  • redacted_strings: "Redacted_string[]" (optional)
Where the Redacted_string object is defined in Redacted_string Object. As an example, consider the following simplified event, which contains a tool call that has an account ID in it. Several mandatory parameters have been omitted for ease of understanding: You can see that this contains a sensitive account ID. Here is a version that is now redacted. There will then be an entry in the redacted_strings array like this: Implementations created a vCon that perform this kind of string redaction MUST include an entry in the redacted_strings array for every unique substring value they redact. A single vCon MUST NOT have more than 99999 such substrings redacted, to provide an upper bound on the integer value and to allow bounded regex parsing. Furthermore, a processor of the VCON MUST validate that - for each instance of the regular expression "_REDACTED_REF\d{1,5}$" it finds in the vCon, there is a corresponding entry in the redacted_strings array whose ref value matches the reference digit sequence. If there is no match, then it means the substring was not actually redacted, and the literal substring value is actually whatever matched "_REDACTED_REF\d{1,5}$" for that reference ID. This can happen if a user were to literally type a chat message or email like, "Yeah I'm going to try to break vcon by typing __REDACTED_REF_3 hah hah hah!". This redaction technique allows vCon to have a way of redacting information from strings anywhere, including future extensions to vCon. This means, unless an extension might convey sensitive information in a way for which string redaction is insufficient, it will not need any specific redaction capability defined.
Session Object The Session Object is used to show the scope for conversational dialog and events. It provides the ability to group dialog and events into sub-conversation. A Session Object can contain by reference other Session Objects to create a nesting or tree relationship with child session(s). It can also support peer relationships to group in logical sequences of evolution of a conversation. For example a conference may split into break out sessions and then merge back together as one conference again.
start The start parameter indicates when this session was started. The start parameter SHOULD be present. The start of the session may be before or after the start of the Dialog and Event Objects which are part of this session (see ). For example it could be the scheduled start time for a conference where everyone shows up late.
  • start: "Date"
The value of the start parameter is the date and time at which the session started.
duration The duration parameter contains the duration in seconds of the session. The start and duration parameters together define the time period of the session, which includes its start and end. The time period of the session need not include the entire time period of the Dialog and Event Objects that are part of this session. Dialog Content of a Dialog Object which is outside of the time period of the session SHOULD be considered to not be part of that session. Whether or how an application renders Dialog Content outside of the time period of the session is an application choice. This allows a session to be scoped to part of a recording without having to split the recording into separate Dialog Objects. For example, a Session Object may be added to a vCon to mark up the portion of a conversation which is of interest, saving a consumer of the vCon from having to listen to or review the whole conversation. Such a Session Object may be a child or a peer of the Session Object for the whole conversation (see ). Dialog Objects referenced by the session may also be entirely outside of the time period of the session. For example, a recording Dialog Object of the opening of a call may be entirely before the time period of a session which marks up a later portion of that call. A "text" type Dialog Object is part of the session in its entirety if any part of the time period given by its start and duration is within the time period of the session. This is because the Dialog Content of a "text" type Dialog Object has no time stamps by which it could be divided. A vCon extension may define a form of text Dialog Content with time stamps at a finer granularity, such as per word, along with how it is scoped by the time period of a session. An "incomplete" type Dialog Object is likewise part of the session in its entirety if any part of the time period given by its start and duration is within the time period of the session. Event Objects which are part of this session are part of the session even if they are outside of the time period of the session. For example, it may be important to know that a party dropped out of the conversation before the start of the session. If the duration parameter is not present, the time period of the session has no end. In this case, all of the Dialog Content of the Dialog Objects referenced by the session which is at or after the start of the session is part of the session.
  • duration: "UnsignedInt" | "UnsignedFloat" (optional)
The value MUST be the session duration in seconds.
parties The Session Object parties parameter references the Party Objects from the parties Array that are the receivers of the dialog in this session. The parties parameter SHOULD be present. A party is a receiver if they potentially received any part of the dialog that was exchanged in this session. This is not a guarantee that they received any part of the dialog, only that some part of any dialog in this session was sent to them. The contributors to the dialog in this session are indicated in the Dialog Object parties parameter of each of the Dialog Objects that are part of this session. A contributor is not necessarily a receiver. For example, an automated announcement or prompt player contributes to the dialog, but does not receive any of it. A contributor that did not potentially receive any part of the dialog in this session SHOULD NOT be included in the Session Object parties parameter. The originator of the session MAY be included in the Session Object parties parameter even if it is not a receiver (see ). To determine what part(s) of the dialog that a party potentially heard or received, the Event Objects may provide data as to when a party joined, dropped out, went on or off hold.
  • parties: "UnsignedInt[]"
The value of the parties parameter is an array of the indices into the parties Object array to the Party Objects that are the receivers of the dialog in the session.
originator The originator party for this session. For email and text, this is the sender of the first message. For audio and video calls, this is the calling party. For a scheduled meeting or conference, this is the organizer, the party that scheduled or created the meeting. The organizer may be a party that never joins the conference; such a party may still be included in the parties array. The organizer is distinct from the party acting as host or controller of the conference at any point during the meeting; identifying the host or controller is out of scope for this document. It is implied that the first party in the Session Object parties list is the originator of the session. If the originator is not known, an empty Party Object (see Party Object) may be used as the first party or as the party referenced by the originator parameter. The originator parameter is only provided if the first party of the Session Object parties list is NOT the originator.
  • originator: "UnsignedInt" (optional)
The originator value is the index into the parties Objects Array, to the party that originated the session.
session_id The MAY be included for the session if it applies to all of the Dialog Objects in the session.
  • session_id: "SessionId" (optional)
The value of the session_id parameter is a single SessionId Object (see ). A which applies to only some of the parties or Dialog Objects in the session is captured in the session_id parameter of the Dialog Object.
sessions A Session Object may refer to other Session Objects in one of several different relationships using the Session_Reference Object.
  • sessions: "Session_Reference[]" (optional)
The sessions parameter is an array of Session Reference Objects. The sessions parameter can be used to create a tree or graph of session. A Session Reference Object also labels the relationship between this Session Object and the reference one. Event Objects are not inherited through these relationships; an Event Object applies only to the Session Objects listed in its sessions parameter (see ).
dialog All Dialog Objects SHOULD be referenced by at least one of the Session Objects in a vCon. The dialog parameter in the Session Object is an array of Dialog Object indices to the dialog Object array.
  • dialog: "UnsignedInt[]" (optional)
The value of the Session Object dialog parameter is an array of indices to the dialog in the Dialog Object array which are part of this session.
Session_Reference Object A Session Reference Object specifies the relationship from one Session Object to another.
session The session parameter is used to define a relationship from one session to another.
  • session: "UnsignedInt"
The session parameter value is an index into the sessions Object Array for the session that is referenced. The session parameter MUST be provided.
type The type parameter specifies a specific type of relationship to the reference session.
  • type: "String"
The string MUST have the value of one of the following tokens or a value defined in a vCon extension:
  • "child" - a session contained within this session
  • "peer" - a session that occurred in parallel or overlapping this session
  • "precursor" - a session that occurred before and leading up to this session
  • "breakout" - a separate session that included some subset of the parties in this session and typically overlapping with this session
The handling of a Session_Reference Object with a type which is not recognized is described in . TODO: other types?
description The description parameter is used to better describe the relationship to the referenced Session Object.
  • description: "String" (optional)
The value of the description parameter is a free form text description of the relationship. TODO: alternative name: relation? The description parameter is an open text String.
Event Object Events occur during a conversation which are important to capture in a vCon, but which are not part of the content of the conversation. An Event Object captures one such occurrence. An event is a point in time occurrence, unlike a Dialog Object which captures the actual conversation over some duration. A period of time, such as the time that a party was on hold, is captured by a pair of Event Objects and not by a duration. Every Event Object has a type and the time at which the event occurred. Depending upon its type, an Event Object also references the session(s) in which it occurred, the party to which it relates, or the Dialog Object to which it relates. Each Event Object occurs within the scope of one or more Session Objects, referenced either directly by its sessions parameter, or through the Dialog Object referenced by its dialog parameter. The following types of events are defined in this document:
  • party event types - a change in the participation of a party in a session (see )
  • key event types - a key or button was pressed or released (see )
  • transfer event types - a transfer operation and the relationship between the sessions involved (see )
  • channel contributors event type - a change in the party(s) contributing to a channel of a recording (see )
Additional event types may be defined in a vCon extension (see ). The parameters which are present in an Event Object depend upon the type of the event. The event types are described first in the subsections of the type parameter (see ). The parameters which apply to each event type are summarized in . The parameters which are specific to an event type are defined in the subsections which follow.
type The type parameter indicates the type of event that occurred.
  • type: "String"
The string token for the event MUST be one of the tokens defined in the following subsections or in a vCon extension. The handling of an Event Object with a type which is not recognized is described in .
Party Event Types Participants in a session may not all join and leave at the same time. The party event types support the capturing of the information when parties join, drop, go on hold or mute and unmute. Party events may also be used to determine which parties were present or potentially received dialog from other parties in the conversation. The party parameter references the party that joined, dropped, was put on or taken off hold or was muted or unmuted. The following party event types are defined:
  • "join" - when the party joins the session
  • "drop" - when the party drops out of the session
  • "hold" - when the party is put on hold
  • "unhold" - when the party is taken off hold
  • "mute" - when the party is muted
  • "unmute" - when the party is taken off mute
Key Event Types The key event types capture when a party presses or releases a DTMF or application key or button. The party parameter references the party that pressed or released the key or button. The key or button is identified in the button parameter (see ). The following key event types are defined:
  • "keydown" - when a DTMF or application key/button was pressed
  • "keyup" - when a DTMF or application key/button was released
Transfer Event Types The transfer event types document the roles of three parties and the relationship between two or three sessions. In a transfer operation, the roles of the three parties to a transfer are defined in as:
  • Transferee
  • Transferor
  • Transfer Target
There are two or three calls in which the parties are connected:
  • original call
  • consultative call (optional as this call may not get created)
  • target call
Each of these calls is represented by a Session Object. The following transfer event types are defined:
  • "consultation-start" - when the Transferor starts a consultative call with the Transfer Target
  • "blind-transfer" - when the Transferor transfers the Transferee to the Transfer Target without a consultative call
  • "consultative-transfer" - when the Transferor transfers the Transferee to the Transfer Target following a consultative call
  • "transfer-abandoned" - when the Transferor abandons an attempt to transfer the Transferee without completing the transfer
The "blind-transfer" and "consultative-transfer" type Event Objects do not indicate that the target call succeeded. The following table summarizes the transfer cases, the Event Objects which capture each case and the results.
Case Event Objects Results
Consultative call fails or is not answered consultation-start, transfer-abandoned consultation Session Object references an "incomplete" type Dialog Object
Consultative call succeeds, Transferor does not transfer consultation-start, transfer-abandoned Transferee is not transferred in this attempt
Consultative call succeeds, Transferor transfers, target call succeeds consultation-start, consultative-transfer target Session Object references the Dialog Objects for the target call
Consultative call succeeds, Transferor transfers, target call fails or is not answered consultation-start, consultative-transfer target Session Object references an "incomplete" type Dialog Object
Blind transfer, target call succeeds blind-transfer target Session Object references the Dialog Objects for the target call
Blind transfer, target call fails or is not answered blind-transfer target Session Object references an "incomplete" type Dialog Object
Transferor abandons before a consultative call or transfer transfer-abandoned Transferee is not transferred in this attempt
A "consultative-transfer" or "transfer-abandoned" type Event Object which follows a consultation references the same Session Object in the consultation parameter as the "consultation-start" type Event Object. It is also possible for there to be more than one consultation. This may occur for a number of reasons. Call attempts may fail. The caller may decide the consultation with a party is not the desired transfer target. When a transfer attempt fails or is abandoned, the Transferor may attempt the transfer again. Depending upon the system, a subsequent "consultative-transfer" type Event Object may reference the same consultation Session Object if the consultative call still exists. Alternatively, the Transferor may start another consultative call, which is captured in a new "consultation-start" type Event Object, or may perform a blind transfer. If the target call fails and the Transferor does not attempt the transfer again, no further transfer Event Object is created. More than one transfer may occur in a vCon. After a transfer has completed or failed, additional transfers may be attempted. Each transfer is captured in its own transfer Event Objects. A Session Object may be referenced in more than one transfer event when multiple transfers occur. For example, the Session Object for the target call of one transfer may be the Session Object for the original call of a subsequent transfer. The following figure illustrates the transfer event types and the calls to which they relate.
transfer event states | Consultation | | (session) |<---transfer-abandoned----| (consultation) | +------------------+ +--------------------+ ^ | | ^ : | consultative-transfer | target call : : | blind-transfer | fails : : | | : : | v : : | +--------------------+ : +-------------------------------->| Target call | :..........................................| (target_session) | target call fails +--------------------+ : : target : call v succeeds +--------------------+ | Transferred | +--------------------+ ---- Event Object .... result determined from the target Session Object ]]>
In the transfer event types, the sessions parameter references the Session Object for the original call and the party parameter references the Transferor. The transferee and transfer_target parameters reference the other two parties to the transfer (see and ). The consultation and target_session parameters reference the Session Objects for the consultative call and the target call (see and ). There are scenarios where we know that a transfer has occurred, but we have no information for one or two of the consultation, target or original calls. In this case a placeholder Session Object is created and its index is used for the consultation, target_session or sessions parameter. A placeholder Session Object may contain no parameters or may reference a placeholder Dialog Object. A unique Session Object SHOULD be referenced for each role in the transfer. The transfer event types only capture the roles, operations and events of the parties and the session setup. They do not capture the purpose or reason for the transfer as that is analysis to be captured in the analysis section of the vCon after the conversation has occurred.
Channel Contributors Event Type The channel contributors event type indicates the time at which the party(s) contributing to a channel of a recording Dialog Object change. This supports the channel contributor changes recording topology (see ). For example, a conference bridge may create a recording with fewer channels than there are parties in the conference, and select the party(s) captured on each channel based upon which parties it detects as talking. At times a channel may capture no party at all. The dialog parameter references the recording Dialog Object and the channel parameter identifies the channel in that recording (see and ). The contributors parameter indicates the party(s) contributing to that channel, starting at the time of the event (see ). These parties contribute to the channel until the time of the next channel-contributors Event Object for the same Dialog Object and channel, or until the end of the recording. The contributors at the start of the recording are indicated in the parties parameter of the Dialog Object (see ). The time parameter of a channel-contributors Event Object SHOULD be within the time period given by the start and duration parameters of the referenced Dialog Object. Each channel-contributors Event Object applies to exactly one channel. If the contributors to more than one channel change at the same time, a separate channel-contributors Event Object is used for each channel, each with the same time parameter value. The channel-contributors Event Object MAY be used with a recording Dialog Object in any of the recording topologies (see ), although it may not be useful in some of them, such as talk spurt. It indicates which parties are captured on a channel; it does not indicate that a party joined or dropped from the session. A party may be in the session, but not captured on any channel of the recording. The sessions and party parameters MUST NOT be present in the channel-contributors Event Object (see and ). The following channel contributors event type is defined:
  • "channel-contributors" - when the party(s) contributing to a channel of a recording change
Event Object Parameter Applicability by Type The following tables summarize which Event Object parameters apply to each Event Object type. The parameter definitions in the subsections of this document are definitive; these tables are provided as a summary. The symbols used in the tables are: M the parameter MUST be present, O the parameter is optional, SN the parameter SHOULD NOT be present, X the parameter MUST NOT be present. The following table applies to the party and key event types.
Parameter join, drop, hold, unhold, mute, unmute keydown, keyup
type M M
time M M
sessions M M
party M M
dialog SN SN
channel X X
contributors X X
button X M
transferee X X
transfer_target X X
consultation X X
target_session X X
The following table applies to the transfer event types.
Parameter consultation-start blind-transfer consultative-transfer transfer-abandoned
type M M M M
time M M M M
sessions M (1) M (1) M (1) M (1)
party M (2) M (2) M (2) M (2)
dialog SN SN SN SN
channel X X X X
contributors X X X X
button X X X X
transferee M M M M
transfer_target M M M O
consultation M X M O
target_session X M M X
(1) A single index which references the Session Object for the original call. (2) References the Transferor. The following table applies to the channel contributors event type.
Parameter channel-contributors
type M
time M
sessions X
party X
dialog M
channel M
contributors O (3)
button X
transferee X
transfer_target X
consultation X
target_session X
(3) A null value or the absence of the contributors parameter indicates that no party contributes to the channel.
time The time parameter indicates the time at which this event occurred.
  • time: "Date"
The time parameter MUST be provided as it is used to determine the sequence in which events occurred.
sessions The sessions parameter indicates the session(s) in which this event occurred.
  • sessions: "UnsignedInt" | "UnsignedInt[]" (not used in channel-contributors events)
The value of the sessions parameter is the index, or an array of indices, into the sessions Object array to the Session Object(s) in which this event occurred. The sessions parameter MUST be present in all of the Event Object types defined in this document, except "channel-contributors" type Event Objects, in which it MUST NOT be present. An Event Object applies only to the Session Objects listed in its sessions parameter. An Event Object does not apply to the child or parent Session Objects of the Session Objects listed in its sessions parameter, unless they are also listed (see ). If an Event Object applies to more than one Session Object, each of those Session Objects MUST be listed in its sessions parameter. The session(s) in which a "channel-contributors" type Event Object occurred are the Session Object(s) which reference the Dialog Object referenced by its dialog parameter (see ). For the transfer event types, the value of the sessions parameter MUST be a single index, which references the Session Object for the original call between the Transferee and the Transferor.
party The party parameter indicates the party for this event.
  • party: "UnsignedInt" (not used in channel-contributors events)
The value of the party parameter is the index into the parties Object array to the party for this event. The party parameter MUST be present in all of the Event Object types defined in this document, except "channel-contributors" type Event Objects, in which it MUST NOT be present. The parties contributing to a channel are indicated in the contributors parameter of the "channel-contributors" type Event Object (see ). For the transfer event types, the party parameter references the party that played the role of the Transferor.
dialog The dialog parameter indicates the Dialog Object to which this event relates.
  • dialog: "UnsignedInt" (required for channel-contributors events)
The value of the dialog parameter is the index into the dialog Object array to the Dialog Object to which this event relates. The dialog parameter MUST be present in "channel-contributors" type Event Objects and SHOULD NOT be present in the other Event Object types defined in this document. The Dialog Object referenced by a "channel-contributors" type Event Object MUST be of type "recording". Event Object types defined in a vCon extension may use the dialog parameter, and may allow its value to be an array of indices to Dialog Objects. An implementation SHOULD NOT treat an array value for the dialog parameter as an error in an Event Object type defined in a vCon extension.
channel The channel parameter indicates the channel of the recording to which this event relates.
  • channel: "UnsignedInt" (required for channel-contributors events)
The value of the channel parameter is the index of the channel in the recording of the Dialog Object referenced by the dialog parameter, where 0 is the first channel. The channel index corresponds to the index of the channel in the parties parameter of that Dialog Object (see ). The value MUST be less than the number of channels in the recording. For a single channel recording, the value MUST be 0. The channel parameter MUST be present in "channel-contributors" type Event Objects and MUST NOT be present in the other Event Object types defined in this document.
contributors The contributors parameter indicates the party(s) contributing to the channel, starting at the time of this event.
  • contributors: "UnsignedInt" | "UnsignedInt[]" | null (optional)
The value of the contributors parameter is the index, or an array of indices, into the parties Object array to the Party Objects which contribute to the channel, starting at the time of this event. A null value, or the absence of the contributors parameter, in a "channel-contributors" type Event Object indicates that no party contributes to the channel, starting at the time of this event. The contributors parameter MUST NOT be present in the other Event Object types defined in this document.
button The button parameter indicates the key or button that was pressed or released.
  • button: "String" (required for keydown and keyup events)
The button parameter value is the String value of the DTMF digit, character or string label for the button that was pressed or released. The button parameter MUST be present in "keydown" and "keyup" type Event Objects and MUST NOT be present in other Event Object types.
transferee The transferee parameter indicates the Transferee in the transfer event types.
  • transferee: "UnsignedInt" (required for transfer event types)
The value of the transferee parameter is the index into the parties Object array to the party that played the role of the Transferee. The transferee parameter MUST be present in the transfer event types and MUST NOT be present in other Event Object types. If the Transferee is not known, an empty Party Object (see Party Object) is referenced.
transfer_target The transfer_target parameter indicates the Transfer Target in the transfer event types. Other parties may be part of the Session Object for the target call; the transfer_target parameter identifies the party that was the target of the transfer operation.
  • transfer_target: "UnsignedInt" (required for consultation-start, blind-transfer and consultative-transfer events, optional for transfer-abandoned events)
The value of the transfer_target parameter is the index into the parties Object array to the party that played the role of the Transfer Target. The transfer_target parameter MUST be present in "consultation-start", "blind-transfer" and "consultative-transfer" type Event Objects. If the Transfer Target is not known, an empty Party Object (see Party Object) is referenced. The transfer_target is optional in "transfer-abandoned" type Event Objects in the case where the transfer is abandoned before the target was identified. The transfer_target parameter MUST NOT be present in Event Object types other than the transfer event types.
consultation The consultation parameter indicates the session for the consultative call in the transfer event types.
  • consultation: "UnsignedInt" (required for consultation-start and consultative-transfer events, optional for transfer-abandoned events)
The value of the consultation parameter is the index into the sessions Object array to the Session Object for the consultative call between the Transferor and the Transfer Target. The consultation parameter MUST be present in "consultation-start" and "consultative-transfer" type Event Objects. The consultation parameter is optional in "transfer-abandoned" type Event Objects in the case where the transfer is abandoned without a consultative call. The consultation parameter MUST NOT be present in "blind-transfer" type Event Objects or in Event Object types other than the transfer event types.
target_session The target_session parameter indicates the session for the target call in the transfer event types.
  • target_session: "UnsignedInt" (required for blind-transfer and consultative-transfer events)
The value of the target_session parameter is the index into the sessions Object array to the Session Object
Party Object A Party Object contains information about a specific party or participant in the conversation. The information that is available about the party varies with the context, the communication mode and platform. There are times when no information is available for a party either initially or over the entire life of the vCon. In such situations, it is possible to have a Party Object with no parameters in it. A Party Object SHOULD be created for each participant. This may result in more than one empty Party Object. They are distinct by the order or index in the Party Object array.
tel If the tel URL for the party is known, it can be included in the tel parameter.
  • tel: "String" (optional)
The value of the tel parameter SHOULD be a valid URL. The URL scheme prefix (i.e. "tel:") is optional.
sip The URL for the party can be provided in the sip parameter.
  • sip: "String" (optional) The value of the sip parameter is the addr-spec as defined in section 25.1 of .
stir If the STIR was provided to identify the party, the PASSporT can be included in the stir parameter for the party.
  • stir: "String" (optional)
The string value of the stir parameter contains the in the JWS Compact Serialization form.
mailto If the mailto URL is known for the party, it can be included in the mailto parameter.
  • mailto: "String" (optional)
The value of the mailto parameter is a string containing an email address for the party. It MAY be provided in any common form, such as a bare address or a URL; when a URL is used, the "mailto:" scheme prefix is optional.
name If the party's name is known, it can be included in the name parameter.
  • name: "String" (optional)
The string value of the name parameter is a free form JSON string in which part or all of the party's name can be included. It may be necessary, for privacy reasons, to not identify any information about the party. This MAY be indicated by creating a Party Object with only the name parameter and setting its value to "anonymous". A Party Object SHOULD be create for each anonymous party in the conversation. This is necessary to capture the number of parties and distinction between which party contributed what data or dialog in the conversation. Hence it is possible to have multiple anonymous Party Objects in the vCon. They are distinct by the order or index in the Party Object array.
did If a Decentralized Identifier is known for the party, it can be included in the did parameter.
  • did: "String" (optional)
The value of the did parameter MUST be a valid DID URI that enables verifiable, decentralized digital identity for the party. DIDs are designed to be decoupled from centralized registries and identity providers, allowing the controller of the DID to prove control without requiring permission from other parties. The DID can refer to any subject (person, organization, thing, etc.) as determined by the controller of the DID.
validation Proof of authorization of the communication channel through STIR, login or possession of a device, is often not sufficient proof of the identity of the person at the other end of the communications channel. It is common in call centers to validate the identity of the person on the communication channel through verification of some sort of personal identification information. The methods used, often varies with the situation and is business practices specific. The purpose of the validation parameter, is to allow the validator to save a label or token which identifies the method of identity validation used to identify the person at the other end of the communication channel. For confidentially reasons, it SHOULD NOT contain the data used to validate the name. However it MAY name the data used to validate the name (e.g. "SSN", "DOB", "user ID and password"). It is up to the domain creating the vCon to define the set of tokens or values to be used for the validation parameter.
  • validation: "String" (SHOULD be provided if name parameter is provided)
The value of the validation string MAY be "none" or enterprise or domain defined token or string values.
gmlpos If the geolocation of the party is known, it can be added in the gmlpos parameter. The gmlpos parameter contains the latitude and longitude of the location of the party at the time of the conversation start.
  • gmlpos: "String" (optional)
The gmlpos parameter value contains a string of the same format as the gml:pos element defined in section 3.2 of the PIDF.
civicaddress The the civicaddress parameter value contains a Civicaddress Object which is optional and contains civic address information about the location for the party.
  • civicaddress: "Civicaddress" (optional)
The Civicaddress Object MAY contain any or all of the following parameters: country, a1, a2, a3, a4, a5, a6, prd, pod, sts, hno, hns, lmk, loc, flr, nam, pc as defined in section 2.2.1 of . The values of all of these parameters are of type String. Note that the parameter names MUST be in lower case when contained in the Civicaddress Object even though they are in upper case in .
  • country: "String" (optional)
  • a1: "String" (optional)
  • a2: "String" (optional)
  • a3: "String" (optional)
  • a4: "String" (optional)
  • a5: "String" (optional)
  • a6: "String" (optional)
  • prd: "String" (optional)
  • pod: "String" (optional)
  • sts: "String" (optional)
  • hno: "String" (optional)
  • hns: "String" (optional)
  • lmk: "String" (optional)
  • loc: "String" (optional)
  • flr: "String" (optional)
  • nam: "String" (optional)
  • pc: "String" (optional)
uuid The uuid is a unique identifier for the participant. In a contact center, this is particularly important for the call agent participant, and must be static across interactions to allow correlation with the actual agent configuration provisioned into the systems. The value of the uuid parameter is a free form unique identifier string for the participant. The value is not constrained to the syntax defined in . Operators often have existing methods of generating unique participant identifiers and MAY use any unique string value.
  • uuid: "String" (optional)
type There are different types of parties that participate in or contribute information to a conversation. The type parameter may be used to indicate the type of participant represented by the Party Object.
  • type: "String" (optional)
The value of the type parameter SHOULD be one of the following: "person", "bot", "organization"
org The party may belong to or be an organization. The org parameter is a free form text string for containing the organization identifier.
  • org: "String" (optional)
dept The party may belong to a department with in an organization. The dept parameter is a free form text string for containing the party's department identifier.
  • dept: "String" (optional)
Dialog Object The Dialog object references or contains text, audio or video captured from the conversation. Currently five types of dialog objects are defined in this document:
  • Text based media communications
  • Audio or Video recorded media communications
  • Metadata for failed or incompleted communications
Media captured in a media-based Dialog Object (type text and recording) SHOULD satisfy two constraints: the media is part of the conversation itself, and the media is transcribable. Media is part of the conversation when it is the communication exchanged between the parties, as opposed to a document or item that is referenced, discussed or presented within the conversation. Media that is transcribable can be converted into a textual representation of sequential communication between parties. Text media is already in textual form and is therefore always transcribable. While images such as sunsets, cows, photographs of documents, or application forms may be describable, they are not transcribable in a concise manner and SHOULD NOT be included as Dialog Objects. They SHOULD be included as Attachment Objects. Text and audio may be subject to interpretation, but they are transcribable to a precise dialog representation. Although transcriptions may not always be accurate, there exists a single correct transcription for any given content. Media that is not transcribable SHOULD be included in the vCon as Attachment Objects rather than Dialog Objects. Whether a fax or photograph of a text-based letter belongs in a Dialog Object depends upon its role in the conversation. A letter faxed to the other party as the communication itself, such as a letter faxed to a doctor, is both transcribable and part of the conversation and MAY be included as a Dialog Object. The same letter shared or discussed within some other conversation is referenced material rather than the conversation itself and SHOULD be included as an Attachment Object, even though it is transcribable. Most other faxes and photographs SHOULD be included as Attachment Objects and SHOULD NOT be included as Dialog Objects. Similarly, a musical recording, even if it is in MP3 audio format, SHOULD be included as an Attachment and SHOULD NOT be included as a Dialog Object. It may not always be known at the time of vCon construction whether an image or recording is transcribable. This distinction is important for interoperability. If it is ambiguous as to what belongs in a Dialog Object versus an Attachment Object, interoperability cannot be achieved, as vCon constructors will not be able to consistently determine where content should be placed and users of vCons will not know where content can be found within the vCon. There are situations when little or no information is available for a dialog either initially or over the entire life of the vCon and yet it is known that the dialog occurred. For example this may occur in some call transfer cases where there is nothing known about the consultative call. In such situations, it is possible to have a placeholder Dialog Object which contains only the type parameter and, for the "incomplete" type, the required disposition parameter. As the consultative call is a call, a placeholder Dialog Object for it MUST be of type "recording" if the call was set up, or of type "incomplete" if it was not. There may be more than one placeholder Dialog Object in the vCon. They are distinct by the order or index in the Dialog Object array.
type
  • type: "String" (required, unless the Dialog Object is empty)
The string MUST have the value of either "recording", "text" or "incomplete", or a value defined in a vCon extension. The handling of a Dialog Object with a type which is not recognized is described in . The type parameter MUST be present in all Dialog Objects, unless the Dialog Object is completely empty. An empty Dialog Object ({}) contains no parameters and has no meaning. An empty Dialog Object may be used to hold a position in the dialog array, such that the indices of the other Dialog Objects, and the references to them, do not change. For example, an empty Dialog Object may be inserted as a placeholder for a Dialog Object that is to be filled in later, or may replace a Dialog Object that is removed when a vCon is redacted (see Redaction Techniques) or edited. The semantics of each Dialog Object type are described in the following subsections. The applicability of each of the Dialog Object parameters to each of the types is summarized in .
recording A dialog of type "recording" has Dialog Content that either contains a body or refers to via url, which is a recording of the video and/or audio of a segment of the conversation. A recording of a conversation may be captured using one of a number of topologies. The following recording topologies are supported by the recording Dialog Object:
  • single channel - a single recording Dialog Object with one channel, into which the audio of all of the parties is mixed
  • multi-channel - a single recording Dialog Object with a separate channel for each party or set of parties
  • per party - a separate single channel recording Dialog Object for each party, which starts when the party joins and ends when the party drops
  • talk spurt - a separate recording Dialog Object for each party and each contiguous period in which that party talks, with the silence trimmed out
  • channel contributor changes - a recording Dialog Object in which the party(s) contributing to a channel change over the duration of the recording, for example a conference bridge which records only the parties that it detects as talking (see )
  • segmented - any of the other topologies, in which a recording is stopped and a new recording Dialog Object is started for the same party(s), for example when the recording reaches a maximum duration, such that the recording is a sequence of consecutive recording Dialog Objects
The per party, talk spurt and segmented topologies use more than one recording Dialog Object, which collectively represent the call or session. In these topologies, the Session Object is important in defining which Dialog Objects are part of a conversation, side bar conversation or call segment (see ). This allows a single vCon to contain multiple, clearly defined conversations, side bar conversations or call segments (see ).
text A dialog of type "text" has Dialog Content that either contains a body or refers to via url, which contains a single message from one of the parties.
incomplete A dialog of type "incomplete" captures a call or conversation that failed to be setup to the point of exchanging any conversation. As no conversation was exchanged, an incomplete Dialog Object does not have Dialog Content (see ). An incomplete Dialog Object has a required disposition parameter which indicates why the call or conversation failed (see ).
Dialog Object Parameter Applicability by Type The following table summarizes which Dialog Object parameters apply to each Dialog Object type. The parameter definitions in the subsections of this document are definitive; this table is provided as a summary. The symbols used in the table are defined as follows.
M
The parameter MUST be present.
S
The parameter SHOULD be present.
O
The parameter is optional.
SN
The parameter SHOULD NOT be present.
X
The parameter MUST NOT be present.
Parameter recording text incomplete
type M M M
start S S S
duration O O O
parties S S O
mediatype M (1) M (1) X
filename O O X
body S (2) S (2) X
encoding S (3) S (3) X
url S (2) S (2) X
content_hash S (4) S (4) X
disposition SN SN M
session_id O O O
application O O O
message_id O O X
redacted_segments O SN X
(1) MUST be present for inline Dialog Content; optional for externally referenced Dialog Content when the media type is provided in the Content-Type header; not required when Dialog Content is absent, such as in a placeholder Dialog Object or a redacted vCon. (2) body or url MAY be absent in a redacted vCon. (3) MUST be present when the body parameter is present and is not an empty string (see Inline Files). (4) MUST be present when the url parameter is present (see ).
start The start parameter contains the date and time for the beginning of the captured piece of dialog. The start parameter SHOULD be present unless it is not known. For text it is the time that the party started typing or if not available, then it is the time the text was sent. For audio and video recordings, it is the time which corresponds to the beginning of the recording. It should be noted that Dialog Objects may not be ordered by the value of the start parameter. Dialog Objects in the dialog array are in order that they were added to the vCon and cannot be reordered with out correcting the dialog indices which occur in other Objects in the vCon.
  • start: "Date"
duration The duration parameter contains the duration in seconds of the referenced or included piece of dialog. For text, if known, it is the time duration from when the party started typing to when they completed typing and the text was sent. For recordings, it is the duration of the recording. For an "incomplete" type Dialog Object, the duration parameter may capture the time from the attempt to setup the call or conversation until it failed.
  • duration: "UnsignedInt" | "UnsignedFloat" (optional)
The value MUST be the dialog duration in seconds.
parties The party(s) which generated the text or recording for this piece of dialog are indicated in the parties parameter. These parties are the contributors to the Dialog Object. The receivers of the dialog are indicated in the parties parameter of the Session Object which references this Dialog Object (see ). The parties parameter SHOULD be present in "recording" and "text" type Dialog Objects. The parties parameter is optional for "incomplete" type Dialog Objects, where it indicates the party that attempted to set up the call or conversation (i.e. the caller or originator). The party(s) to which the call or conversation setup was attempted are indicated in the parties parameter of the Session Object which references the "incomplete" type Dialog Object.
  • parties: "UnsignedInt" | "UnsignedInt[]" | ("UnsignedInt" | "UnsignedInt[]" | null)[]
Single channel recordings should have a parties value of the form: "UnsignedInt" or "UnsignedInt[]" where the integer value or array of integer values are the indices to the Party Object(s) in the parties array that contributed to the mix for the single channel recording. The index for the Party Object SHOULD be included even if the indicated party was silent the entire piece of dialog. Multi-channel recordings MUST have a parties value that is an array of the same size as the number of channels in the recording. The values in that array are either an integer or an array of integers which are the indices to the parties that contributed to the mix for the associated channel of the recording. The index for Party Objects SHOULD be included even if the party was silent the entire conversation. If not all channels are used in a recording, such that no parties are recorded on one or more channels, a null placeholder MUST be inserted into the parties array for the corresponding channel. By default, the party(s) indicated in the parties parameter for a channel are the contributors to that channel for the entire duration of the recording. The contributors to a channel may change over the duration of the recording (see the channel contributor changes recording topology in ). Such changes are indicated by channel-contributors Event Objects which reference the Dialog Object and the channel (see ). When one or more channel-contributors Event Objects exist for a channel, the parties parameter for that channel indicates the contributors at the start of the recording. In that case, a null value for the channel indicates that no party contributes to the channel at the start of the recording. If the contributors to a channel change, but the times at which they change are not known, the parties parameter for that channel SHOULD contain all of the parties which contributed to that channel over the duration of the recording, and no channel-contributors Event Object is provided for that channel. Some recording systems represent a single call or session using multiple recording Dialog Objects. This may occur when recordings are periodically segmented or when separate recordings are created for each party and talk spurt. In these cases, a single recording Dialog Object identifies only the parties captured, or potentially captured, in that recording. Other participants are identified only in the recording Dialog Objects in which they are captured or potentially captured. As a result, no single recording Dialog Object necessarily identifies all parties participating in the conversation. The parties parameter of a Dialog Object only references the parties that contributed, or potentially contributed, to the Dialog Content of that Dialog Object. The complete call or session is represented by a Session Object which references the Dialog Objects that are part of it (see ). The parties parameter of the Session Object identifies the receivers of the dialog in the call or session (see ). The start and duration parameters of the Session Object identify the time period of the call or session, which may differ from the time periods of the Dialog Objects which it references (see and ). The originator of the call or session is indicated in the Session Object (see ). In some cases, there may be a separate recording file for each party in a conversation, where only one party is recorded per file. It should be noted that the recordings may be shorter than the collective conference when there is a separate recording per speaker/party. For example the recording(s) of the individual speaker may be trimmed to only the parts where they are actually speaking. In the email context, messages have the headers From, To, Cc and Bcc. The party in the From header is the sender of the message and the contributor to the text Dialog Object. The From header party SHOULD be the only party in the parties parameter for the text Dialog Object. The parties listed in the To, Cc and Bcc headers (if present) are the receivers of the message. The sender is also a receiver of the message, as the sender retains a copy of the message that they sent. The sender and the other receivers SHOULD be included in the parties parameter of the Session Object which references the text Dialog Object (see ). The Bcc parties are private to the sender. The sender SHOULD be allowed to set a policy, through out of band means, as to whether the Bcc parties are included in the vCon. In the absence of such a policy, the Bcc parties MAY be included in a vCon which is for the use of the sender, and SHOULD NOT be included in a vCon which is for broader use. When the Bcc parties are not included in the vCon, they SHOULD NOT be referenced in the Session Object parties parameter. A Party Object SHOULD NOT be included for a Bcc party, unless that party is also the sender or a To or Cc receiver of another message in the vCon. The Bcc header SHOULD also be removed from the Dialog Content, and the Session Objects SHOULD be constructed as if the Bcc parties were not receivers of that message. A vCon which includes the Bcc parties may be redacted to remove them for broader use (see Redaction Techniques). A text Dialog Object should only contain a single message. Each message in an email thread may have a different set of receivers. The set of receivers of a message includes its sender. If all of the messages in the thread have the same set of receivers, a single Session Object which references all of the text Dialog Objects for the thread is sufficient. Otherwise, the thread is represented by a parent Session Object which references a child Session Object for each set of receivers (see ). Each time the set of receivers changes from one message to the next, a new Session Object is created as a child of the Session Object for the email thread. That child Session Object references the text Dialog Object(s) for the message(s) sent to that set of receivers. The parties parameter of each child Session Object contains the receivers of the messages referenced by that child Session Object. The parties parameter of the parent Session Object contains the receivers of all of the messages in the thread.
mediatype The media type for the piece of dialog included or referenced is provided in the mediatype parameter. The mediatype parameter MUST be provided for inline dialog files and MUST be provided if the Content-Type header in the response for the externally referenced URL is not provided. The mediatype parameter is not required when the Dialog Content is absent, such as in a placeholder Dialog Object or when the body and url have been redacted. The mediatype parameter MUST NOT be present in "incomplete" type Dialog Objects as they do not have Dialog Content.
  • mediatype: "Mediatype" (optional for externally referenced files, if absent, this is provided in the Content-Type header)
The media types SHOULD be one of the following strings:
  • "text/plain"
  • "audio/x-wav"
  • "audio/x-mp3"
  • "audio/x-mp4"
  • "audio/ogg"
  • "video/x-mp4"
  • "video/ogg"
  • "multipart/mixed" Note: multi-part will also likely include the boundary parameter
filename It is sometimes useful to preserve the name of the file which originally contained this piece of dialog. This can be done in the filename parameter. The filename parameter MUST NOT be present in "incomplete" type Dialog Objects as they do not have Dialog Content.
  • filename: "String" (optional)
Dialog Content The Dialog Object SHOULD contain the body and encoding parameters or the url and content_hash parameters for all dialog types other than "incomplete" (see Inline Files and Externally Referenced Files). These parameters MUST NOT be present for the "incomplete" dialog type. The exception to this is that the body or url MAY be absent if it is redacted. For inline included dialog:
  • body: "*" (optional in a redacted vCon)
  • encoding: "String"
Alternatively, for externally referenced dialog:
  • url: "String" (optional in a redacted vCon)
  • content_hash: "ContentHash" | "ContentHash[]"
disposition If the dialog type is "incomplete", it MUST have a disposition parameter. If the reason that the call or conversation failed is not known, such as in a placeholder Dialog Object, the disposition value "failed" SHOULD be used. The value of the disposition parameter provides the reason that the "call control" failed. The term: "call control" is used in a loose sense, as there in not always a call involved, to differentiate from a call disposition that an agent may assign to a call to indicate the reason, issue addressed or outcome of a conversation. This latter definition of call disposition is not dialog, but analysis of the conversation and is not included in the dialog portion.
  • disposition: "String" (required for incomplete type Dialog Objects, SHOULD NOT be present for other dialog types)
The value of the disposition parameter MUST be one of the following strings or a value defined in a vCon extension:
  • "no-answer" - a call or connection was attempted, but no one answered or accepted the connection
  • "congestion" - a call or connection was attempted, but was unable to be completed due to system load
  • "failed" - a call or connection was attempted, but failed
  • "busy" - a call or connection was attempted, but the party was busy with another conversation
  • "hung-up" - a call or connection was made, but the party hung-up before any conversation occurred
  • "voicemail-no-message" - a call or connection was made, the voicemail system answered, but no message was left Note: if a message was left with the voicemail system this is no longer an "incomplete" type dialog, it is a "recording" type and the conversation SHOULD be included in the Dialog Content.
The handling of a Dialog Object with a disposition which is not recognized is described in .
session_id The MAY be included for the dialog. If the same applies to all the parties in a dialog, than a single instance of the SessionId Object is provided as the value of session_id. If some parties have a different or no associated for this Dialog Object, then the array structure of the session_id objects MUST correlate to the array structure of the Dialog Object's parties index array. Parties which do not have a associated with this dialog, MUST have an empty object ({}) for the SessionId Object. That an empty Object and not an Object with two "nil UUIDs" as defined in section 7 of . It is also possible that the SessionId Object will not have values for both the local and remote parameters in some conferencing situations (See ). In the case that one end of the does not have a UUID, the "nil UUID" String value SHOULD be used as defined in section 7 of . When a call or session is represented by multiple Dialog Objects, each may capture only a leg or subset of the parties of the call or session; the session_id values on those Dialog Objects follow the party correlation rules above. The Session Object is the appropriate place to capture a session identifier that applies to the call or session as a whole (see ).
  • session_id: "SessionId" | "SessionId[]" | ("SessionId" | "SessionId[]")[] (optional)
application The application parameter is used to capture the application, communication channel or context over which the conversation was held. The conversation mode can be identified by looking at the dialog type. However that does not different between different communication platform service providers or hosting service. For example, the application parameter can be used to identify the web conference hosting service.
  • application: "String" (optional)
message_id Some messaging systems assign a unique message identifier to each message. The message_id parameter is applicable to "recording" and "text" type Dialog Objects and MUST NOT be present in "incomplete" type Dialog Objects. The message_id parameter may be used to label the message for either cross referencing back to the messaging system or to prevent the addition of duplicate messages to the vCon. For example SMTP messages have a message-id in the SMTP header. In the SMTP case a message may exist in multiple mailboxes or tags. When exporting these SMTP messages, the message_id parameter may be used to avoid adding the same message, to the vCon containing the email thread, more than once.
  • message_id: "String" (optional)
redacted_segments One of the ways to perform redaction on audio content is to substitute the segments containing the information with a "beep" sound for audio. For video, specific parts of the video can be blurred out, or the video can be blackened entirely. When this happens, a human can easily discern that redaction has occurred. However, it is not easy for software systems to determine this. There are many cases where we want a piece of software processing a VCON to know that such redaction has happened, where it happened, and which parties content was redacted. For example, a troubleshooting tool might want to call out these segments to a user whose role is to confirm that redaction is working well. The redacted_segments field contains an array of one or more Redacted_segments Objects. This field is optional, but SHOULD be included in a redacted vCon.
  • redacted_segments: "Redacted_segments[]" (optional)
Redacted_segments Object The object contains the following parameters:
  • start: "Date" (required)
The start time of the audiovisual redaction.
  • end: "Date" (required)
The end time of the audiovisual redaction. TODO: should use duration instead of end?
  • parties: "UnsignedInt[]" (optional)
An array of indices into the parties Object array to the parties whose content has been redacted. This is useful when the dialog contains a blend of multiple contributors, and it is desired to indicate which one has been redacted.
Attachment Object Ancillary documents to the conversation are included or referenced in the Attachment Object. There is no constraint on the types files which can be included or referenced. As most modes of communication, that allow the exchange of files, do not constrain the file type, any file type may be included here.
purpose The purpose parameter may be used to provide a text base description of the purpose or point of the attachment. There is no restricted set of values for this description.
  • purpose: "String" (optional)
start The start parameter contains the date and time that the Attachment Object was sent/exchanged. It should be noted that Attachment Objects may not be ordered by the value of the start parameter. Attachment Objects in the attachments array are in order that they were added to the vCon and cannot be reordered with out correcting the attachment indices which may occur in other Objects in the vCon.
  • start: "Date"
party In most conversations, ancillary documents originate from one of the parties involved in the conversation. This party is not necessarily the document's author, but rather the party that distributed the document. The distributing party is identified by the party parameter in the Attachment Object. To provide provenance for the attachment, the party index MUST be specified. The identified party need not be a participant in the conversation itself. For example, an organization that processes or constructs the vCon may add attachments containing information about the conversation. The organization or entity that adds the attachment SHOULD be represented as a Party Object.
  • party: "UnsignedInt"
The value of the party parameter is the index into the Party Object array to the party that contributed the attachment.
dialog Attachments are added as data related to a dialog or a session. The dialog parameter is used to identify the dialog that the attachment is part of.
  • dialog: "UnsignedInt" (optional)
The value of the dialog parameter is the index into the dialog Object array to the Dialog Object to which this Attachment Object relates. At least one of the dialog or session parameters MUST be present (see ).
session Attachments may be related to one or more sessions as opposed to a specific dialog. The session parameter is used to identify the sessions that the attachment is part of.
  • session: "UnsignedInt" | "UnsignedInt[]" (optional)
The value of the session parameter is the index to the session or array of indices to the Session Object array to which this Attachment Object relates. The requirement for the dialog or session parameter to be present is defined in .
mediatype The media type for the included or referenced attachment file is provided in the mediatype parameter. The mediatype parameter MUST be provided for inline attachment files and MUST be provided if the Content-Type header in the response for the externally referenced URL is not provided. The mediatype parameter is not required when the Attachment Content is absent, such as when the body and url have been redacted.
  • mediatype: "Mediatype" (optional for externally referenced files, if absent, this is provided in the Content-Type header)
The mediatype string contains the media type or type of the attached file.
filename It is sometimes useful to preserve the name of the file which originally contained this attachment file. This can be done in the filename parameter.
  • filename: "String" (optional)
The file name string contains an optional name for the attachment file referenced in this Attachment Object.
Attachment Content The Attachment Object SHOULD contain the body and encoding parameters or the url and content_hash parameters (see Inline Files and Externally Referenced Files). The exception to this is that the body or url MAY be absent if it is redacted. For inline included attachments:
  • body: "*"
  • encoding: "String"
Alternatively, for externally referenced attachments:
  • url: "String"
  • content_hash: "ContentHash" | "ContentHash[]"
Analysis Object Analysis is a broad and in some cases developing field. This document does not attempt to suggest a SHOULD support list of types. Nor are formats for analysis data defined in this document. That is for research and specification outside the scope of this document. For this reason the Analysis Object provides multiple ways to define the media type of the analysis file. If a well known media type is defined, it SHOULD be used. For analysis data or files types for which a media type is not defined, the vendor and schema parameters SHOULD be used.
type The type parameter is used to label the semantic type of analysis data.
  • type: "String"
The string value SHOULD be one of the following:
  • "report"
  • "sentiment"
  • "summary"
  • "transcript"
  • "translation"
  • "tts"
dialog Analysis typically pertains to one or more of the Dialog Objects in the dialog array. The dialog parameter is used to indicate which Dialog Objects this analysis was based upon.
  • dialog: "UnsignedInt" | "UnsignedInt[]" (optional)
The value of the dialog parameter is the index to the dialog or array of indices to the Dialog Object array to which this Analysis Object corresponds. At least one of the dialog, sessions, attachment or analysis parameters SHOULD be present to indicate the scope of what was input to the analysis (see , and ). Analysis may also be based upon data which is not contained in the vCon, in which case none of these parameters may apply.
sessions Analysis may pertain to one or more sessions as a whole, as opposed to specific Dialog Objects. The sessions parameter is used to indicate which Session Objects this analysis was based upon.
  • sessions: "UnsignedInt" | "UnsignedInt[]" (optional)
The value of the sessions parameter is the index to the session or array of indices to the Session Object array to which this Analysis Object corresponds.
attachment The analysis may pertain to one or more of the Attachment Objects in the attachment array. The attachment parameter is used to indicate which Attachment Objects this analysis was based upon.
  • attachment: "UnsignedInt" | "UnsignedInt[]" (optional)
The value of the attachment parameter is the index to the attachment or array of indices to the Attachment Object array to which this analysis object corresponds.
analysis The analysis may be derived from one or more of the other Analysis Objects in the analysis array. The analysis parameter is used to indicate which Analysis Objects this analysis was based upon.
  • analysis: "UnsignedInt" | "UnsignedInt[]" (optional)
The value of the analysis parameter is the index to the analysis or array of indices to the Analysis Object array to which this Analysis Object corresponds. An Analysis Object MUST NOT reference itself in the analysis parameter.
mediatype The media type for the included or referenced analysis file is provided in the mediatype parameter. The mediatype parameter SHOULD be provided for inline analysis files and for externally referenced analysis files when the Content-Type header in the response is not provided. A media type may not be defined for the format of the analysis data; in this case the vendor, product and schema parameters SHOULD be used to identify the data format instead.
  • mediatype: "Mediatype" (optional)
The mediatype string contains the media type or type of the analysis file.
filename It is sometimes useful to preserve the name of the file which originally contained this analysis data. This can be done in the filename parameter.
  • filename: "String" (optional)
The file name string contains an optional name for the analysis data file referenced in this Analysis Object.
vendor There may not be a IANA registered media type for the file format containing the analysis data. Even if a media type is defined, it is often useful to keep a record of the vendor that produced the software that produced the analysis. Different implementations perform differently and knowing the implementation can be useful in interpreting the analysis. For this reason, the vendor or product name is provided in the vendor parameter. The vendor parameter is provided even when the mediatype parameter fully identifies the data format, as a record of the implementation that generated or provided the analysis.
  • vendor: "String"
The vendor string value contains the vendor or product name of the software which generated this analysis.
product As the vendor may have more than one product, the product parameter may be used to differentiate it from other products which may have different schemas of analysis data.
  • product: "String" (optional)
schema The same vendor or software product may produce different formats or data for the same analysis. The schema parameter allows the data format, schema or configuration used to generate the analysis to be saved with the included or referenced analysis data.
  • schema: "String" (optional)
The schema string contains a token or label for the data format or schema for the analysis data. As the vendor name may not be specific enough to identify the format of the analysis, the schema value is provide to differentiate from potentially multiple data formats for analysis provided by the same vendor or software.
Analysis Content The Analysis Object SHOULD contain the body and encoding parameters or the url and content_hash parameters (see Inline Files and Externally Referenced Files). The exception to this is that the body or url MAY be absent if it is redacted. If the Analysis Object contains or references content, sufficient information to interpret the format of that content SHOULD be provided in the Analysis Object. The mediatype parameter identifies the syntax of the content. Some media types, such as "text/vtt", fully identify the data format. Generic media types, such as "application/json" or "text/csv", identify only the syntax and not the schema of the data within it. When the mediatype parameter is absent or does not fully identify the data format, the schema parameter, together with the vendor and product parameters, SHOULD identify the data format. For externally referenced content, the media type may also be provided by the Content-Type header in the response (see ). For inline included analysis:
  • body: "*"
  • encoding: "String"
Alternatively, for externally referenced analysis:
  • url: "String"
  • content_hash: "ContentHash" | "ContentHash[]"
Redacted_string Object The redacted string object provides information about a string which was redacted from the vCon.
Ref
  • ref: "UnsignedInt" (required)
The reference to the string which was redacted, which will be present elsewhere in the document. This is always between 1 and 99999.
Type
  • type: "String" (optional)
The type of string information which was redacted. This is an extensible string enumeration. The following values are defined, representing the most common forms of sensitive information redacted from conversations:
  • GOVT_ID_NUM: A government issued identifier, such as a social security number, passport number, drivers license number, taxpayer ID, and o on.
  • FIN_ID_NUM: A financial institution identifier, such as a bank account number, a routing number, a wire number, PIN codes, and so on.
  • MED_ID_NUM: A medical identifier, such as a patient ID
  • BIOMETRIC: A string containing biometric data, typically in some encoded form for representation. Examples would include a fingerprint, retina scan, or face geometry.
  • AUTH_DATA: Data used for a user to authenticate themselves, such as a password, digital certificate, or security questions or answers.
  • CONTACT_INFO: Full name, email, physical mailing address, phone numbers, and so on.
  • LOC_INFO: Zip code, GPS location data, IP addresses, MAC addresses
  • EMPL_INFO: Work information, such as a job title, job code, salary, and so on.
  • BELIEF_INFO: Religious preference, political party or preference, sexual orientation
  • UNSPECIFIED: Used when the type is not known, not specified, or not able to be determined.
TODO: add IANA registry. Other values can be used, in which case an implementation not familiar with the value treats it as UNSPECIFIED. Absence of this field is also the same as UNSPECIFIED.
Orig
  • orig: "String" (optional)
The original, unredacted value of the string. This is useful in applications of vCons where the desired property is not data redaction, but data identification. This may allow downstream vCon processors to perform the redaction (which is as simple as removing the "orig" field), or to allow redaction in the user interface (for example, a first name in a transcript is not shown to the user unless they right-click and elect to reveal the information). It is also useful for downstream data processing applications which generate analytics and create aggregates off of this information.
Redaction Techniques vCon has many ways in which sensitive information can be redacted from a vCon. This section summarizes them. Whenever any of these redaction techniques are employed, the redacted_from element SHOULD be added to the vCon referencing its prior, unredacted version. Data which is to be completely removed from the redacted version, that is contained in a JSON array in the unredacted vCon, SHOULD create an empty placeholder such that object array indices do not change for the rest of the elements of the array. If an element is removed entirely, all indexes to that array MUST be revised.
Recording Content Removal If an audio recording, or a text chat, contains sensitive information, the offending Dialog Content (either the body or the url) can be removed from the vCon. Note that, in this case, the Dialog object itself is still present with its meta-data, such as the start and end times. It is RECOMMENDED that the Dialog Content is removed - rather than removing the entire Dialog object itself. Doing so requires the Dialog array to be reindexed and all references to it updated. It also obscures the fact that redaction was performed, which may confuse downstream processors or players.
Participant Information Hiding It may be desired to hide the fact that a participant was present in a conversation. In that case, the simplest approach is to remove all of their attributes from their Party object - resulting in an empty but valid party object of {}. This approach is efficient in that it can be done without touching anything else in the vCon. The vCon still indicates that SOMEONE was there, but there is no identifying information for them. Similarly, if a dialog contains emails and the desire is to remove the set of participants who were BCC'd, those parties can be removed from the corresponding parties array in the session object. String redaction can also be used to hide the identity of the party that was BCC'd, while still indicating that someone received the mail.
Audiovisual Content Rewriting For audio, a "beep" can be added; for video, the video can have blur effects applied or the entire video can be blackened. These all require codec-level operations. If they are done, the fact that they were done SHOULD be signaled with the inclusion of the redacted_segments field in the Dialog object.
String Redaction The vCon format supports a general purpose string redaction methodology, through the usage of the redacted_strings array. This can be used to remove any sensitive information present in string format anywhere in the vCon. When an audio or video recording has been transcribed, and the transcription is present in the vCon, if a segment of audio or video is redacted, it is RECOMMENDED to also redact the transcript of the transcribed version of that sensitive information, using string redaction. A tempting alternative to using the redacted_strings array is to just perform inline substitution of text, replacing (for example) a social security number with "XXX-XX-XXXX". This is NOT RECOMMENDED. Downstream processors cannot easily differentiate a redacted version of a field with a valid field, potentially breaking them.
Regeneration of the vCon In some cases, the goal of redaction is to also hide the fact that redaction was ever even done. In that case, the vCon can be regenerated. Regeneration produces a totally new vCon with no connections to the original, all arrays (like Party) reindexed to hide any missing information, and the redacted_from field removed. Similarly, sensitive strings like a social security number can be replaced with valid, but incorrect versions.
Security Considerations The security concerns for vCons can put into two categories: making the conversation immutable through integrity verification and protecting the confidentiality of privacy of the parties to the conversation and/or their PII. These requirements along with need to evolve a vCon (e.g. adding analysis, translations and transcriptions) conflict in some ways. To enable this, multiple versions of a vCon may be created. Versions of a vCon may add information (e.g. analysis added to a prior vCon referenced by the amended_from ()) and versions that remove information (e.g. redactions of privacy information removed from the vCon referenced in the redacted_from ()). Redactions may be at different levels for example:
  • PII masked to remove PII data in the text, audio, video or transcripts
  • De-identified to remove segments or whole recordings that might be used for voice printing or facial recognition
Different parts and versions of a vCon may be created in different security domains over a period of time. In addition, some conversation data may be referenced externally through an HTTPS URL as opposed to completely contained within the vCon. Typically a conversation of one mode, will be hosted or observed in a single domain. This will likely fall into one of the following hosting situations:
  • Enterprise Hosted Communications
  • Software as a Service (SaaS) Hosted Communications
  • Service Provider Hosted Communications
The distinction among these has gotten clouded over recent years. The import consideration is that each is a different security domain. Information about a conversation captured in an enterprise communications system (e.g. meta data and Dialog Object(s) recorded in an IP PBX) is a different security domain from a SaaS transcription service (i.e. an Analysis Object). Before a vCon leaves a security domain, it SHOULD be signed to prevent it from being altered. If the new security domain needs to alter it, a new vCon is created with the removed or added data and the prior version is referenced (i.e. via the redacted_from () or amended_from ()). See the redacted vCon object tree figure-1 and amended vCon object tree figure-2. If information is redacted for privacy reasons, the vCon referenced in the redacted_from (), if inline, SHOULD be encrypted to protect the privacy information in the unredacted version of the vCon. The secure storage and access of externally referenced conversation data is considered out of scope from this document. Secure mechanisms for HTTPS access and storage of files are well defined. Identity and credentials for accessing externally stored data will be exchanged out of band from the vCon. The one requirement for externally referenced data from the perspective of this document, is proof of integrity of that data. Using the above described approach for redaction and amending of data, we can reduce the security operations on a vCon to signing and encryption. Two approaches to signing are needed as we have data, in JSON format, that is contained within the vCon and may have data (typically media and file formats, often binary) not contained, inline in the vCon, that is externally referenced. Externally referenced data will be "signed" using hash which along with the URL of the externally referenced data is included in the vCon. was chosen due to the relatively low cost to generate and verify the signature for what could be very large externally referenced media files. As the hash for each externally referenced file is contained in the vCon which will be signed, the chain of authentication is provided via the signature on the vCon itself. This document specifies the JSON format for vCons. So it seemed the logical solution for signing vCons, is JOSE JSON Serialization and likewise for encrypting vCons is JOSE JSON Serialization. The solutions are well documents, implementations are readily available and tested. A redacted vCon SHOULD reference it's non-redacted version. The non-redacted version of the vCon referenced from the redacted vCon MUST be encrypted such that only those with permission to view the non-redacted content can decrypt it. Any time a vCon is shared outside its original security domain, it SHOULD be signed and optionally encrypted. Files externally referenced by a vCon SHOULD always be signed with the verification information included in the vCon that references the external file as defined in Externally Referenced Files and Signing Externally Referenced Files. Externally referenced files SHOULD only be transported over and SHOULD be access controlled to those who are permitted to read the contents of that non-redacted vCon. vCons transported over non-secure channels such as email MUST be in the encrypted form.
Signing Externally Referenced Files In some deployments, it is not practical to include all of the file contents of a vCon inline. In support of that, a file may be externally referenced. When external files are referenced, the signature on the vCon does not secure the file contents from modification. For this reason any externally referenced files SHOULD also have a signature. vCons use the hash method for integrity checking of externally referenced file content and include its url and content_hash in the vCon which are included in the integrity signature for the whole vCon. After retrieving externally referenced files, before using its content, the payload of the HTTPS request should be verified using the signature parameter value for the hash for the url body using the procedure defined in section 6.3 and 6.4 of .
Signed Form of vCon Object A signed vCon uses and takes the General JWS JSON Serialization Syntax form as defined in section 7.2.1 of . The vCon General JWS JSON Serialization MUST include x5c or x5u in the unprotected header.
  • payload: "String"
The value of the payload is the Base64Url Encoded string containing either: the unsigned form of the JSON vCon; or the gzipped unsigned form of the JSON vCon. The general construction of the payload string value is described in section 7.2.1 of
  • signatures: "Signature[]"
The value of signatures is an array of Signature Objects
Signature Object The Signature Object MUST contain a header and signature parameter as defined in section 7.2.1 of . The protected parameter MUST be present when the JWS Protected Header is not empty and MUST be absent otherwise, as defined in section 7.2.1 of .
  • header: "Header"
The value of header is defined in Header Object.
  • protected: "String" (present when the JWS Protected Header is not empty)
The string value of protected is the Base64Url encoded JWS Protected Header as defined in section 7.2.1 of .
  • signature: "String"
The string value of signature is the Base64Url encoded JWS Signature as defined in section 7.2.1 of .
Header Object The Header Object and its contents are defined in section 4 of . The Header Object for a signed vCon MUST include at least one of x5c or x5u. The alg parameter MUST be present in either the JWS Protected Header or the Header Object. The alg parameter SHOULD be present in the JWS Protected Header so that it is integrity protected. The alg parameter MUST NOT have the value "none". As defined in section 7.2.1 of , a header parameter MUST NOT be present in both the JWS Protected Header and the Header Object. The x5c or x5u requirement makes the management and use of vCons easier, allowing the certificate chain to be found as the vCon is moved. Other header parameters defined for MAY be present in the Header Object.
  • alg: "String" (MUST be present here or in the JWS Protected Header)
The string value of alg is defined in section 4.1.1 of . For a signed vCon this value SHOULD be "RS256" to maximize interoperability.
  • x5c: "String[]" (MUST provide at least one of x5c or x5u)
The array of string values for x5c are defined in section 4.1.6 of .
  • x5u: "String" (MUST provide at least one of x5c or x5u)
The string value of x5u MUST contain an URL as defined in section 4.1.5 of .
  • uuid: "String" (SHOULD be provided)
The string value of the UUID for the vCon contained in the payload parameter. This is added for convenience to not require verification of the signed vCon to get it's UUID. When the vCon is verified, the value of this uuid parameter SHOULD be verified against the UUID in the signed vCon.
Long Term Archiving of Signed vCons In some use cases, it may be necessary to store or archive signed vCons for compliances or records purposes for as long as 10 years or more. In most cases the keys and certificates used to sign the vCon and construct the or signed form of the vCon, will have an expiration on the order of a few years at best. Below is an approach on how integrity may be maintained on the archived vCon. There may be other approaches to this as well. For our example illustrated below, we have a vCon which was signed (labeled as JWS1). The certificate used to sign JWS1 has an expiration date. Before the expiration of the JWS1 signing certificate, the content of JWS1 (the vCon) is verified and then JWS1 is signed as the payload to construct JWS2. Before the expiration of the JWS2 certificate, the contents of JWS2 (JWS1) is verified and then JWS2 is signed as the payload to construct JWS3. The process is continued for the life of the vCon archiving. When it is desired to access the data in the archived vCon, first the outer JWS (JWS3 in diagram) is verified (payload of JWS2), then the vCon (payload in JWS1) is assumed to have valid integrity.
Encrypted Form of vCon Object A vCon MUST be signed first using JWS as defined in Signed Form of vCon Object, then encrypted using JWE as opposed to just encrypted with integrity protection. The rationale is that meta data and dialog will typically be collected in one security domain, then may be stored or exported to another. The signing is likely for the lifetime of the vCon, where the encryption may be shorter term or domain specific. vCons may be stored in unencrypted form, but the signed form MUST be maintained to ensure its integrity. An encrypted vCon uses and takes the General JWE JSON Serialization Syntax form as defined in section 7.2.1 of . The alg and enc header parameters MUST each be present in one of the header locations permitted by . The enc parameter is the same for all recipients and is present in either the JWE Protected Header or the Unprotected Object. The alg parameter is present in the JWE Protected Header, the Unprotected Object or the Header Object of each recipient. As defined in section 7.2.1 of , a header parameter MUST NOT be present in more than one of these locations.
  • protected: "String" (optional)
The string value of protected is the Base64Url encoded JWE Protected Header as defined in section 7.2.1 of .
  • unprotected: "Unprotected"
  • recipients: "Recipient[]"
  • iv: "String"
The string value of iv is the Initialization Vector as constructed as defined in section 7.2.1 of .
  • ciphertext: "String"
The string value of ciphertext is constructed as defined in section 7.2.1 of using the signed form of the vCon as the plaintext input for encryption.
  • tag: "String"
The string value of tag is the Authentication Tag as defined in section 7.2.1 of .
  • aad: "String" (optional)
The string value of aad is the Base64Url encoded Additional Authenticated Data as defined in section 7.2.1 of .
Unprotected Object
  • cty: "String"
The string value of cty SHOULD be either "application/vcon" or "application/vcon+gzip"
  • enc: "String" (MUST be present here or in the JWE Protected Header)
The string value of enc SHOULD be "A256CBC-HS512"
  • alg: "String" (MUST be present here, in the Header Object of each recipient or in the JWE Protected Header)
The string value of alg is defined in section 4.1.1 of .
  • uuid: "String" (SHOULD be provided)
The string value of the UUID for the vCon contained in the ciphertext parameter. This is provided for identification of the encrypted vCon without the need of the key to decrypt the vCon. The value of this uuid parameter SHOULD be verified when the vCon is decrypted. Other header parameters defined for MAY be present.
Recipient Object
  • header: "Header" (optional)
The value of header is defined in Header Object.
  • encrypted_key: "String" (present when the JWE Encrypted Key is not empty)
The string value of encrypted_key is defined in section 7.2.1 of .
Header Object
  • alg: "String" (MUST be present here, in the Unprotected Object or in the JWE Protected Header)
The string value of alg SHOULD be "RSA-OAEP". Other header parameters defined for MAY be present.
Differentiation of vCon forms vCons in the unsigned, signed and encrypted form are all valid JSON. A vCon in any of these forms may additionally be compressed using as described in . It is necessary to distinguish which form a vCon is in, and whether it is compressed, in order to properly handle it. For example a signed vCon needs to be verified. The following is the recommended approaches to identifying which form a particular vCon is in:
  • unsigned The presence of one or more of the following parameters indicates that the vCon is in the unsigned form:
    • parties
    • dialog
    • analysis
    • attachments
    • sessions
    • events
  • signed (JWS) The presence of both of the following parameters indicates that the vCon is in the signed (JWS) form:
    • payload
    • signatures
  • encrypted (JWE) The presence of both of the following parameters indicates that the vCon is in the encrypted (JWE) form:
    • ciphertext
    • recipients
A gzip compressed vCon is not JSON and is differentiated from the JSON forms before the above parameter based rules can be applied. The gzip compressed vCon SHOULD be identified by the media type "application/vcon+gzip" when a media type is available, such as in the Content-Type header. When no media type is available, a gzip compressed vCon can be identified by the gzip member header magic numbers defined in section 2.3.1 of . Once decompressed, the contained vCon is in one of the JSON forms and is differentiated using the parameter based rules above.
IANA Considerations This section includes the information required for IANA to register the application/vcon media type per .
JSON Format vCon Mediatype The JSON format for vCon is mandatory to implement.
  • Type name: application
  • Subtype name: vcon
  • Required parameters: N/A
  • Optional parameters: N/A; unrecognized parameters should be ignored.
  • Encoding considerations: 8bit
  • Additional information: format
  • Security considerations: See Security Considerations section of this document.
  • Interoperability considerations: The vCon schema is defined in RFC XXXX. The schema may be extended through extensions as defined there.
  • Published specification: This document: RFC XXXX
  • Applications that use this media type:
  • Fragment identifier considerations: N/A
  • Additional Information:
    • Deprecated alias names for this type: N/A
    • Magic number(s): N/A
    • File extension(s): "vcon"
    • Macintosh file type code(s): N/A
    • Windows Clipboard Name: VCON
  • Author: See the Author's Addresses section of this document.
  • Change controller: IETF
gzip Format vCon Mediatype A gzip format vCon is a JSON format vCon that has been compressed using the gzip compression algorithm. The gzip format is used to reduce the size of potentially very large vCons containing audio or video media in dialog objects. Applications SHOULD support the receiving of gzip format vCons, but do not need to use the gzip format when sending.
  • Type name: application
  • Subtype name: vcon+gzip
  • Required parameters: N/A
  • Optional parameters: N/A; unrecognized parameters should be ignored.
  • Encoding considerations: binary
  • Additional information: compression of format
  • Security considerations: See Security Considerations section of this document.
  • Interoperability considerations: The vCon schema is defined in RFC XXXX. The schema may be extended through extensions as defined there.
  • Published specification: This document: RFC XXXX
  • Applications that use this media type:
  • Fragment identifier considerations: N/A
  • Additional Information:
    • Deprecated alias names for this type: N/A
    • Magic number(s): N/A
    • File extension(s): "vcon"
    • Macintosh file type code(s): N/A
    • Windows Clipboard Name: VCON
  • Author: See the Author's Addresses section of this document.
  • Change controller: IETF
vCon JSON Registry This document defines a number of new IANA registries for the JSON vCon schema. Each Object (i.e. dict, map, dictionary) has its own registry of parameter names. All of those registries have the same registry template which is defined in the following subsection. When registering new entries, the following template should be used. The registration policy for these registries is Specification Required as defined in . The Designated Experts are expected to verify that the specification is publicly available, that the name follows the naming conventions of this document and that the registration does not duplicate the semantics of an existing registered entry. A registry created for a new Object defined in a vCon extension (see ) is named in the same form as the registries defined in this document, for example "Party Object Parameter Names Registry". It is created within the vCon JSON Registry group and uses the same registry template and registration policy as the registries defined in this document.
Object Registry Template Parameter Name: The string name of a parameter to be used within the Object. The name is case sensitive. Names may not match other registered names in a case-insensitive manner unless the Designated Experts state that there is a compelling reason to allow an exception. Parameter Description: Brief description of the parameter Change Controller: For Standards Track RFCs, list the "IESG". For others, give the name of the responsible party. Other details (e.g., postal address, email address, home page URI) may also be included. Specification Document(s): Reference to the document or documents that specify the parameter, preferably including URIs that can be used to retrieve copies of the documents. An indication of the relevant sections may also be included but is not required.
vCon Object Parameter Names Registry The following defines the initial values for the vCon Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
vcon Schema version number IESG RFC XXXX
uuid vCon instance UUID IESG RFC XXXX
extensions list of extensions used IESG RFC XXXX
critical list of incompatible extensions used IESG RFC XXXX
created_at creation date IESG RFC XXXX
updated_at modification date IESG RFC XXXX
subject conversation subject IESG RFC XXXX
redacted_from Redacted Object IESG RFC XXXX
amended_from Amended Object IESG RFC XXXX
group reserved for future extension IESG RFC XXXX
sessions Session Objects array IESG RFC XXXX
events Event Objects array IESG RFC XXXX
parties Party Objects array IESG RFC XXXX
dialog Dialog Objects array IESG RFC XXXX
analysis Analysis Objects array IESG RFC XXXX
attachments Attachment Objects array IESG RFC XXXX
redacted_strings Redacted Strings array IESG
Party Object Parameter Names Registry The following defines the initial values for the Party Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
tel tel URL IESG RFC XXXX
sip SIP URL IESG RFC XXXX
stir STIR token IESG RFC XXXX
mailto mailto URL IESG RFC XXXX
name participant name IESG RFC XXXX
validation validation method IESG RFC XXXX
gmlpos participant geolocation IESG RFC XXXX
civicaddress civic address IESG RFC XXXX
uuid participant unique identifier IESG RFC XXXX
type participant type IESG RFC XXXX
org participant organization IESG RFC XXXX
dept participant department IESG RFC XXXX
did decentralized identifier IESG RFC XXXX
Dialog Object Parameter Names Registry The following defines the initial values for the Dialog Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
type dialog type name IESG RFC XXXX
start dialog start time IESG RFC XXXX
duration dialog duration period IESG RFC XXXX
parties dialog parties list IESG RFC XXXX
mediatype dialog content media type IESG RFC XXXX
filename dialog content filename IESG RFC XXXX
body dialog inline content IESG RFC XXXX
encoding dialog inline content encoding IESG RFC XXXX
url dialog referenced content URL IESG RFC XXXX
content_hash dialog content hash IESG RFC XXXX
disposition dialog disposition IESG RFC XXXX
session_id RFC7989 session ID IESG RFC XXXX
application dialog source application IESG RFC XXXX
message_id dialog message id IESG RFC XXXX
redacted_segments redacted segments IESG RFC XXXX
Dialog Type Name Registry This document defines a new registry for the token name values that are permitted as values to the dialog type parameter.
Dialog Type Name Registration Template Dialog Type Name: The string token name of a Dialog Object Type The name is case sensitive. Names may not match other registered names in a case-insensitive manner unless the Designated Experts state that there is a compelling reason to allow an exception. Dialog Type Description: Brief description of the Dialog Object type Change Controller: For Standards Track RFCs, list the "IESG". For others, give the name of the responsible party. Other details (e.g., postal address, email address, home page URI) may also be included. Specification Document(s): Reference to the document or documents that specify the parameter, preferably including URIs that can be used to retrieve copies of the documents. An indication of the relevant sections may also be included but is not required.
Dialog Type Name Registration Initial Values The following table defines the initial values for the Dialog Object Types Registry.
Dialog Type Name Dialog Type Description Change Controller Specification Document(s)
text text dialog IESG RFC XXXX
recording recording dialog IESG RFC XXXX
incomplete incomplete dialog IESG RFC XXXX
Session Object Parameter Names Registry The following defines the initial values for the Session Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
start session start time IESG RFC XXXX
duration session duration period IESG RFC XXXX
parties session parties list IESG RFC XXXX
originator session originator party IESG RFC XXXX
session_id RFC7989 session ID IESG RFC XXXX
sessions Session_Reference Objects array IESG RFC XXXX
dialog session dialog index list IESG RFC XXXX
Session_Reference Object Parameter Names Registry The following defines the initial values for the Session_Reference Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
session referenced session index IESG RFC XXXX
type session relationship type IESG RFC XXXX
description session relationship description IESG RFC XXXX
Session_Reference Type Name Registry This document defines a new registry for the token name values that are permitted as values to the Session_Reference Object type parameter.
Session_Reference Type Name Registration Template Session_Reference Type Name: The string token name of a Session_Reference Object type. The name is case sensitive. Names may not match other registered names in a case-insensitive manner unless the Designated Experts state that there is a compelling reason to allow an exception. Session_Reference Type Description: Brief description of the Session_Reference Object type Change Controller: For Standards Track RFCs, list the "IESG". For others, give the name of the responsible party. Other details (e.g., postal address, email address, home page URI) may also be included. Specification Document(s): Reference to the document or documents that specify the parameter, preferably including URIs that can be used to retrieve copies of the documents. An indication of the relevant sections may also be included but is not required.
Session_Reference Type Name Registration Initial Values The following table defines the initial values for the Session_Reference Type Name Registry.
Session_Reference Type Name Session_Reference Type Description Change Controller Specification Document(s)
child contained session IESG RFC XXXX
peer parallel or overlapping session IESG RFC XXXX
precursor preceding session IESG RFC XXXX
breakout breakout session with a subset of the parties IESG RFC XXXX
Event Object Parameter Names Registry The initial values for the Event Object Parameter Names Registry are listed in the following table. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
type event type name IESG RFC XXXX
time time event occurred IESG RFC XXXX
sessions event session indices IESG RFC XXXX
party event party index IESG RFC XXXX
dialog event dialog index IESG RFC XXXX
channel recording channel index IESG RFC XXXX
contributors recording channel contributor party indices IESG RFC XXXX
button button label character or string IESG RFC XXXX
transferee transferee party index IESG RFC XXXX
transfer_target transfer target party index IESG RFC XXXX
consultation consultation session index IESG RFC XXXX
target_session target session index IESG RFC XXXX
Event Type Name Registry This document defines a new registry for the token name values that are permitted as values to the Event Object type parameter.
Event Type Name Registration Template Event Type Name: The string token name of an Event Object type. The name is case sensitive. Names may not match other registered names in a case-insensitive manner unless the Designated Experts state that there is a compelling reason to allow an exception. Event Type Description: Brief description of the Event Object type Change Controller: For Standards Track RFCs, list the "IESG". For others, give the name of the responsible party. Other details (e.g., postal address, email address, home page URI) may also be included. Specification Document(s): Reference to the document or documents that specify the parameter, preferably including URIs that can be used to retrieve copies of the documents. An indication of the relevant sections may also be included but is not required.
Event Type Name Registration Initial Values The following table defines the initial values for the Event Type Name Registry.
Event Type Name Event Type Description Change Controller Specification Document(s)
join party join event IESG RFC XXXX
drop party drop event IESG RFC XXXX
hold party on hold event IESG RFC XXXX
unhold party off hold event IESG RFC XXXX
mute party on mute event IESG RFC XXXX
unmute party off mute event IESG RFC XXXX
keydown DTMF/app key/button press event IESG RFC XXXX
keyup DTMF/app key/button release event IESG RFC XXXX
consultation-start transfer consultation start event IESG RFC XXXX
blind-transfer blind transfer event IESG RFC XXXX
consultative-transfer consultative transfer event IESG RFC XXXX
transfer-abandoned transfer abandoned event IESG RFC XXXX
channel-contributors recording channel contributors change event IESG RFC XXXX
Attachment Object Parameter Names Registry The following defines the initial values for the Attachment Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
purpose attachment object purpose description IESG RFC XXXX
start attachment start time IESG RFC XXXX
party sending party index IESG RFC XXXX
dialog associated dialog index IESG RFC XXXX
session associated session index IESG RFC XXXX
mediatype attachment body media type IESG RFC XXXX
filename attachment content filename IESG RFC XXXX
body attachment inline content IESG RFC XXXX
encoding attachment inline content encoding IESG RFC XXXX
url attachment referenced content URL IESG RFC XXXX
content_hash attachment content hash IESG RFC XXXX
Analysis Object Parameter Names Registry The following defines the initial values for the Analysis Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
type analysis type IESG RFC XXXX
dialog associated dialog index IESG RFC XXXX
sessions associated session indices IESG RFC XXXX
attachment associated attachment index IESG RFC XXXX
analysis associated analysis index IESG RFC XXXX
mediatype analysis body media type IESG RFC XXXX
filename analysis content filename IESG RFC XXXX
vendor vendor producing content IESG RFC XXXX
product vendor product producing content IESG RFC XXXX
schema product schema of content IESG RFC XXXX
body analysis inline content IESG RFC XXXX
encoding analysis inline content encoding IESG RFC XXXX
url analysis referenced content URL IESG RFC XXXX
content_hash analysis content hash IESG RFC XXXX
Redacted_from Object Parameter Names Registry The following defines the initial values for the Redacted_from Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
uuid less redacted vCon UUID IESG RFC XXXX
type redaction type or reason IESG RFC XXXX
url referenced less redacted vCon URL IESG RFC XXXX
content_hash less redacted vCon hash IESG RFC XXXX
Amended_from Object Parameter Names Registry The following defines the initial values for the Amended_from Object Parameter Names Registry. Use the template in Object Registry Template when registering additional entries to this table.
Parameter Name Parameter Description Change Controller Specification Document(s)
uuid prior vCon version UUID IESG RFC XXXX
url referenced prior version vCon URL IESG RFC XXXX
content_hash prior version vCon hash IESG RFC XXXX
vCon Extensions Names Registry This document defines and new registry for the token name values that are permitted as values to the parameter. However it does not define any values for this registry. Values for this registry are to be defined in subsequent documents which define extensions to the vCon schema. The registration policy for this registry is Specification Required as defined in .
Extensions Registration Template Extension Name: The string token name of an extension to the vCon JSON schema. The name is case sensitive. Names may not match other registered names in a case-insensitive manner unless the Designated Experts state that there is a compelling reason to allow an exception. Extension Description: Brief description of the vCon extension Change Controller: For Standards Track RFCs, list the "IESG". For others, give the name of the responsible party. Other details (e.g., postal address, email address, home page URI) may also be included. Specification Document(s): Reference to the document or documents that specify the parameter, preferably including URIs that can be used to retrieve copies of the documents. An indication of the relevant sections may also be included but is not required.
JSON Web Signature and Encryption Header Parameters This document registers the following new parameter in the JSON Web Signature and Encryption Header Parameters registry.
  • Header Parameter Name: "uuid"
  • Header Parameter Description: UUID of the signed object
  • Header Parameter Usage Location(s): JWS, JWE
  • Change Controller: IESG
  • Specification Document(s): Header Object, Unprotected Object of RFC XXXX
References Normative References Date and Time on the Internet: Timestamps This document defines a date and time format for use in Internet protocols that is a profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. Decentralized Identifiers (DIDs) v1.0 W3C A Presence-based GEOPRIV Location Object Format This document describes an object format for carrying geographical information on the Internet. This location object extends the Presence Information Data Format (PIDF), which was designed for communicating privacy-sensitive presence information and which has similar properties. [STANDARDS-TRACK] GZIP file format specification version 4.3 This specification defines a lossless compressed data format that is compatible with the widely used GZIP utility. This memo provides information for the Internet community. This memo does not specify an Internet standard of any kind. HTTP Semantics The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document describes the overall architecture of HTTP, establishes common terminology, and defines aspects of the protocol that are shared by all versions. In this definition are core protocol elements, extensibility mechanisms, and the "http" and "https" Uniform Resource Identifier (URI) schemes. This document updates RFC 3864 and obsoletes RFCs 2818, 7231, 7232, 7233, 7235, 7538, 7615, 7694, and portions of 7230. COSE Algorithms n.d. End-to-End Session Identifier for H.323 Systems H.460.27 The JSON Meta Application Protocol (JMAP) This document specifies a protocol for clients to efficiently query, fetch, and modify JSON-based data objects, with support for push notification of changes and fast resynchronisation and for out-of- band binary data upload/download. The JavaScript Object Notation (JSON) Data Interchange Format JavaScript Object Notation (JSON) is a lightweight, text-based, language-independent data interchange format. It was derived from the ECMAScript Programming Language Standard. JSON defines a small set of formatting rules for the portable representation of structured data. This document removes inconsistencies with other specifications of JSON, repairs specification errors, and offers experience-based interoperability guidance. JSON Web Signature (JWS) JSON Web Signature (JWS) represents content secured with digital signatures or Message Authentication Codes (MACs) using JSON-based data structures. Cryptographic algorithms and identifiers for use with this specification are described in the separate JSON Web Algorithms (JWA) specification and an IANA registry defined by that specification. Related encryption capabilities are described in the separate JSON Web Encryption (JWE) specification. JSON Web Encryption (JWE) JSON Web Encryption (JWE) represents encrypted content using JSON-based data structures. Cryptographic algorithms and identifiers for use with this specification are described in the separate JSON Web Algorithms (JWA) specification and IANA registries defined by that specification. Related digital signature and Message Authentication Code (MAC) capabilities are described in the separate JSON Web Signature (JWS) specification. The 'mailto' URI Scheme This document defines the format of Uniform Resource Identifiers (URIs) to identify resources that are reached using Internet mail. It adds better internationalization and compatibility with Internationalized Resource Identifiers (IRIs; RFC 3987) to the previous syntax of 'mailto' URIs (RFC 2368). [STANDARDS-TRACK] Media Type Specifications and Registration Procedures This document defines procedures for the specification and registration of media types for use in HTTP, MIME, and other Internet protocols. This memo documents an Internet Best Current Practice. Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies This initial document specifies the various headers used to describe the structure of MIME messages. [STANDARDS-TRACK] PASSporT: Personal Assertion Token This document defines a method for creating and validating a token that cryptographically verifies an originating identity or, more generally, a URI or telephone number representing the originator of personal communications. The Personal Assertion Token, PASSporT, is cryptographically signed to protect the integrity of the identity of the originator and to verify the assertion of the identity information at the destination. The cryptographic signature is defined with the intention that it can confidently verify the originating persona even when the signature is sent to the destination party over an insecure channel. PASSporT is particularly useful for many personal-communications applications over IP networks and other multi-hop interconnection scenarios where the originating and destination parties may not have a direct trusted relationship. GEOPRIV Presence Information Data Format Location Object (PIDF-LO) Usage Clarification, Considerations, and Recommendations The Presence Information Data Format Location Object (PIDF-LO) specification provides a flexible and versatile means to represent location information. There are, however, circumstances that arise when information needs to be constrained in how it is represented. In these circumstances, the range of options that need to be implemented are reduced. There is growing interest in being able to use location information contained in a PIDF-LO for routing applications. To allow successful interoperability between applications, location information needs to be normative and more tightly constrained than is currently specified in RFC 4119 (PIDF-LO). This document makes recommendations on how to constrain, represent, and interpret locations in a PIDF-LO. It further recommends a subset of Geography Markup Language (GML) 3.1.1 that is mandatory to implement by applications involved in location-based routing. [STANDARDS-TRACK] End-to-End Session Identification in IP-Based Multimedia Communication Networks This document describes an end-to-end session identifier for use in IP-based multimedia communication systems that enables endpoints, intermediary devices, and management systems to identify a session end-to-end, associate multiple endpoints with a given multipoint conference, track communication sessions when they are redirected, and associate one or more media flows with a given communication session. While the identifier is intended to work across multiple protocols, this document describes its usage in the Session Initiation Protocol (SIP). This document also describes a backwards-compatibility mechanism for an existing session identifier implementation (RFC 7329) that is sufficiently different from the procedures defined in this document. This document obsoletes RFC 7329. Simple Mail Transfer Protocol This document is a specification of the basic protocol for Internet electronic mail transport. It consolidates, updates, and clarifies several previous documents, making all or parts of most of them obsolete. It covers the SMTP extension mechanisms and best practices for the contemporary Internet, but does not provide details about particular extensions. Although SMTP was designed as a mail transport and delivery protocol, this specification also contains information that is important to its use as a "mail submission" protocol for "split-UA" (User Agent) mail reading systems and mobile environments. [STANDARDS-TRACK] The tel URI for Telephone Numbers This document specifies the URI (Uniform Resource Identifier) scheme "tel". The "tel" URI describes resources identified by telephone numbers. This document obsoletes RFC 2806. [STANDARDS-TRACK] New UUID Formats This document presents new Universally Unique Identifier (UUID) formats for use in modern applications and databases. Key words for use in RFCs to Indicate Requirement Levels In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings. Informative References Concise Binary Object Representation (CBOR) The Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. These design goals make it different from earlier binary serializations such as ASN.1 and MessagePack. This document obsoletes RFC 7049, providing editorial improvements, new details, and errata fixes while keeping full compatibility with the interchange format of RFC 7049. It does not create a new version of the format. Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures This document proposes a notational convention to express Concise Binary Object Representation (CBOR) data structures (RFC 7049). Its main goal is to provide an easy and unambiguous way to express structures for protocol messages and data formats that use CBOR or JSON. Information technology -- Coding of audio-visual objects -- Part 12: ISO base media file format ISO/IEC 14496-12:2022 JSON Web Token (JWT) JSON Web Token (JWT) is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure, enabling the claims to be digitally signed or integrity protected with a Message Authentication Code (MAC) and/or encrypted. Guidelines for Writing an IANA Considerations Section in RFCs Many protocols make use of points of extensibility that use constants to identify various protocol parameters. To ensure that the values in these fields do not have conflicting uses and to promote interoperability, their allocations are often coordinated by a central record keeper. For IETF protocols, that role is filled by the Internet Assigned Numbers Authority (IANA). To make assignments in a given registry prudently, guidance describing the conditions under which new values should be assigned, as well as when and how modifications to existing values can be made, is needed. This document defines a framework for the documentation of these guidelines by specification authors, in order to assure that the provided guidance for the IANA Considerations is clear and addresses the various issues that are likely in the operation of a registry. This is the third edition of this document; it obsoletes RFC 5226. US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF) Federal Information Processing Standard, FIPS SIP: Session Initiation Protocol This document describes Session Initiation Protocol (SIP), an application-layer control (signaling) protocol for creating, modifying, and terminating sessions with one or more participants. These sessions include Internet telephone calls, multimedia distribution, and multimedia conferences. [STANDARDS-TRACK] Session Initiation Protocol (SIP) Call Control - Transfer This document describes providing Call Transfer capabilities in the Session Initiation Protocol (SIP). SIP extensions such as REFER and Replaces are used to provide a number of transfer services including blind transfer, consultative transfer, and attended transfer. This work is part of the SIP multiparty call control framework. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. PASSporT Extension for Rich Call Data Somos Inc. Neustar Inc. This document extends PASSporT, a token for conveying cryptographically-signed call information about personal communications, to include rich meta-data about a call and caller that can be signed and integrity protected, transmitted, and subsequently rendered to the called party. This framework is intended to include and extend caller and call specific information beyond human-readable display name comparable to the "Caller ID" function common on the telephone network and is also enhanced with a integrity mechanism that is designed to protect the authoring and transport of this information for different authoritative use-cases. jCard: The JSON Format for vCard This specification defines "jCard", a JSON format for vCard data. The vCard data format is a text format for representing and exchanging information about individuals and other entities, for example, telephone numbers, email addresses, structured names, and delivery addresses. JSON is a lightweight, text-based, language- independent data interchange format commonly used in Internet applications. vCon: an Open Standard for Conversation Data STROLID Inc. SIPez LLC Conversational X TADHack and TADSummit n.d. Recommendation Q.825: Specification of TMN applications at the Q3 interface: Call detail recording ITU n.d. Python open source vCon command line interface, library and workflow server n.d.
Non-Upward Compatible Changes to the vCon Container This appendix outlines the changes between versions of the vCon container which are not upward compatible, and the high level operations needed to migrate a vCon from one version to the next. It does not describe every detail of the migration.
Version 0.4.0 to 0.5.0
  • The "vcon" parameter value was changed from "0.4.0" to "0.5.0".
  • The Session Object and the "sessions" array were added. A 0.4.0 vCon is migrated by adding a Session Object which references all of its Dialog Objects.
  • The "party_history" Dialog Object parameter was replaced by the Event Object and the "events" array. Each Party_History Object becomes an Event Object, with "event" renamed to "type", whose sessions parameter references the Session Object for the Dialog Object from which it came. The converted Event Object does not reference the Dialog Object, as the dialog parameter SHOULD NOT be present in the party and key event types.
  • The "transfer" type Dialog Object was replaced by the transfer Event Object types. Each "transfer" type Dialog Object becomes one or two Event Objects in which "transferor" becomes "party", and the Dialog Objects referenced by "original", "consultation" and "target_dialog" are each referenced through a Session Object.
  • The "originator" Dialog Object parameter was moved to the Session Object.
  • The Dialog Object "parties" parameter contains only the contributors, and the receivers are in the Session Object "parties" parameter. In 0.4.0, the parties parameter of a "text" type Dialog Object contained the sender and all of the receivers of the message, with the first party being the sender unless originator was set. A 0.4.0 "text" type Dialog Object is migrated by reducing its parties to the sender, and by including all of its parties, including the sender, in the parties of the Session Object for that message. Similarly, the parties of a 0.4.0 "incomplete" type Dialog Object are reduced to the originator, or the first party if originator is not set, and the remaining parties are included in the parties of the Session Object.
  • The "redacted" parameter was renamed to "redacted_from", and the Redacted Object was renamed to the Redacted_from Object.
  • The "amended" parameter was renamed to "amended_from", and the Amended Object was renamed to the Amended_from Object.
  • The "recording-set" type Dialog Object, and the "recordings" and "recording_set" Dialog Object parameters, were replaced by the Session Object. A 0.4.0 "recording-set" type Dialog Object is migrated by creating a Session Object which references the Dialog Objects listed in its recordings parameter, and by removing the recording_set parameter from the recording Dialog Objects which referenced it.
  • Each removed "transfer" and "recording-set" type Dialog Object is replaced by an empty Dialog Object (see ), so that the indices of the other Dialog Objects, and the references to them, do not change.
  • The alg parameter MUST NOT have the value "none". A 0.4.0 signed vCon which uses the alg value "none" is migrated by signing the vCon again with a permitted algorithm.
  • The extensions parameter MUST, rather than SHOULD, list the names of all vCon extensions used in the vCon. A 0.4.0 vCon which uses an extension that is not listed in its extensions parameter is migrated by adding the extension name.
  • Some implementations of version 0.4.0 repeated header parameters, with identical values, in more than one header of the signed and encrypted forms. Implementations which read vCons produced by those implementations may choose to accept them.
Version 0.3.0 to 0.4.0
  • The "appended" Object was renamed to "amended"
  • The "must_support" parameter was renamed to "critical" to be consistent with other IETF JSON schema extension mechanisms.
  • The "session_id" Dialog Object parameter was changes from a String to a SessionId Object.
Version 0.0.2 to 0.3.0
  • "transfer-target" parameter was renamed to "transfer_target" to be consistent with other compound names that use the underscore ("_").
  • "target-dialog" parameter was renamed to "target_dialog" to be consistent with other compound names that use the underscore ("_").
Version 0.0.1 to 0.0.2
  • "mimetype" parameters were renamed to "mediatype"
  • "alg" and "signature" were combined into "content_hash"
Example vCons This appendix contains example vCons in the unsigned, signed and encrypted form. The JSON has been indented for readability. The vCons have been formatted such that long text lines have been wrapped with a left hand white space indent for readability purposes. Links for unformatted versions of the vCons are provided for each of the examples. The example vCons in this document were generated using the command line interface.
Two Party Call vCon With Inline Recording This example vCon is for a simple 2 party PSTN call. It has a single Dialog Object which contains a single channel wav format recording with the two parties audio mixed into the single channel. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_int_rec.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Email Thread Multipart vCon The following is an unsigned form of an vCon for a 2 message email thread between 2 parties. The email messages are multipart MIME message bodies. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_email_acct_prob_thread.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Alice:
Please find the image attached.

Regards,
Bob

\r\n--- ---=_Part_388313_805631480.1663969465697--\r\n\r\n------= _Part_388314_1108189513.1663969465698\r\nContent-Type: im age/png\r\nContent-Transfer-Encoding: base64\r\nContent-D isposition: attachment; filename=\"=?UTF-8?b?c2NyZWVuc2hv dC5wbmc=?=\"\r\nContent-ID: \r\n\r\niVBORw0KGgoAAAANSUhEUgAAACYAAA AeCAIAAADPdvs5AAAAA3NCSVQICAjb4U/gAAAAGXRFWHRT\r\nb2Z0d2F yZQBnbm9tZS1zY3JlZW5zaG907wO/PgAAALpJREFUSInl1t0NgzAMBOC7 qPvP1gW6Qjdo\r\nj4f0J4qAJI6NROvniE8+mwCvtzv6imTnyf1K/UclH UFWjIvaIL3CHCABSPKKtJckWfY6zw+sj5dq\r\nISdVIzmj2klzTZG2Rm e7NKgOwY6qPrMcUs+2PqchL14P+oyz+fHx77K5Sv8xyxAyZ0uBaxn/Spc U\r\n8NxcosAut1Y3NtjVX7UjZlmpgWTSFyvVQPKB16tSqW53bFnKtyyZ vYT3rSsAWADWAlOjseYFfwAA\r\nAABJRU5ErkJggg==\r\n\r\n----- -=_Part_388314_1108189513.1663969465698--\r\n", "message_id": "<1126698042.388315.1663969465698@mail.yahoo. com>" }, { "type": "text", "start": "2022-09-23T21:44:59.000+00:00", "duration": 0, "parties": [ 1 ], "mediatype": "multipart/alternative; boundary=\"----=_Part_ 390234_811845464.1663969499935\"", "encoding": "none", "body": "------=_Part_390234_811845464.1663969499935\r\nCon tent-Type: text/plain; charset=UTF-8\r\nContent-Transfer- Encoding: 7bit\r\n\r\n Hi Bob:Got it. Thanks.\r\n\r\n On Friday, September 23, 2022, 9:44:40 PM UTC, Bob wrote: \r\n \r\n Alice:Please find the image a ttached.\r\n\r\nRegards,Bob\r\n \r\n------=_Part_390234_ 811845464.1663969499935\r\nContent-Type: text/html; chars et=UTF-8\r\nContent-Transfer-Encoding: 7bit\r\n\r\n
\r\n
Hi B ob:
Go t it. Thanks.


\r\n \r\n
\r\n
\r\n \r\n
\r\n On Friday, September 23, 2022, 9:44:40 PM UTC, Bo b <b@example.com> wrote:\r\n
\ r\n

\r\n
\r\n
Alice:
Please find the image attached.
< /div>

Regards,
Bob< /div>

\r\n
\r\n
\r\n------=_Par t_390234_811845464.1663969499935--\r\n", "message_id": "<2031327240.390235.1663969499936@mail.yahoo. com>" } ], "analysis": [], "attachments": [], "created_at": "2026-10-24T01:29:10.590+00:00", "subject": "Account problem", "sessions": [ { "start": "2022-09-23T21:44:25.000+00:00", "duration": 34, "parties": [ 0, 1 ], "dialog": [ 0, 1 ] } ], "uuid": "01a16b86-acc8-8c6d-b9a2-279e0d16bc46" } ]]>
Email Thread Text vCon The following is an unsigned form of an vCon for a 3 message email thread between 2 parties. The email messages are plain text message bodies. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_email_prob_followup_text_thread.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication. " }, { "type": "text", "start": "2022-09-23T23:34:32.000+00:00", "duration": 0, "parties": [ 1 ], "mediatype": "text/plain; charset=UTF-8", "encoding": "none", "body": "Hi Alice:\nAll is fine. Thanks.\n\n On Friday, September 23, 2022, 23:24:59 PM UTC, Alice wrote: \n \n Hi Bob:\n I just wanted to follow up to see that your account is ok now.\n \n Regards,\n Alic e\n", "message_id": "<1879233410.402112.1663976072118@mail.yahoo. com>" }, { "type": "text", "start": "2022-09-23T23:38:12.000+00:00", "duration": 0, "parties": [ 0 ], "mediatype": "text/plain", "encoding": "none", "body": "Awesome!\n\n On Friday, September 23, 2022, 23: 34: PM UTC, Bob wrote: \n\n Hi Alice:\n All is fine. Thanks.\n \n On Friday, September 23 , 2022, 23:24:59 PM UTC, Alice wrote: \n \n Hi Bob:\n I just wanted to follow up to see t hat your account is ok now.\n \n Regards,\n Alic e\n", "message_id": "<1535873320.402417.1663976292034@mail.yahoo. com>" } ], "analysis": [], "attachments": [], "created_at": "2026-10-24T01:29:12.007+00:00", "subject": "Account issue followup", "sessions": [ { "start": "2022-09-23T23:24:59.000+00:00", "duration": 793, "parties": [ 0, 1 ], "dialog": [ 0, 1, 2 ] } ], "uuid": "01a16b86-b24d-8057-b9a2-279e0d16bc46" } ]]>
Two Party Call vCon With Externally Referenced Recording This example vCon is for a simple 2 party PSTN call. It has a single Dialog Object which reference a single channel wav format recording with the two parties audio mixed into the single channel. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Two Party Call vCon with Analysis The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec_analysis.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Signed vCon This example vCon is the signed form of the Two Party Call vCon With Externally Referenced Recording example. The private key used to sign this can be found at: The certificate chain is included in the x5c parameter of the header Object. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec_signed.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Encrypted vCon This example vCon is the encrypted form of the Signed vCon example. The private key to decrypt it can be found at: The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec_encrypted.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
Redacted vCon This is an example redaction of the vCon in the example Two Party Call vCon With Externally Referenced Recording. Most notable is the Redacted_from object which references the lesser redacted version of this vCon. In addition the url parameter has been redacted from the Dialog Object, but the rest of the Dialog Object was left in the redaction. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec_redacted.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication. TODO: need a better conversation/recording to demonstrate redaction
Amended Signed vCon This is an example vCon with an Amended_from Object referencing the vCon that it amends or adds additional content. In this case it is referencing the signed vCon example above. An example text Dialog Object (index 1) is the amendment. The unformatted version of the following example can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/examples/ab_call_ext_rec_amended.vcon Note to the RFC Editor: This example, and its unformatted version at the URL above, contain the vcon parameter (see ), which is included in the Internet-Draft versions of this document to indicate the version of the schema upon which the example is based. The vcon parameter is to be removed from the example and its unformatted version before publication as an RFC. Please remove this note before publication.
vCon JSON Schema This JSON schema is provided as informational. The text in sections 1-6 of this document define the normative definition of the vCon schema. If the JSON schema provided below differs from that in the text of the above sections, the text should be taken as the definitive definition and the JSON Schema below should be consider incorrect. The JSON Schema is permissive: parameters and type values which are not defined in this document do not cause validation to fail. The JSON Schema definition below has been formatted with line breaks to print nicely on the page. The unformatted version of the JSON schema can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/vcon_json_schema.json
vCon CDDL This CDDL for vCon core is provided as informational. The text in sections 1-6 of this document define the normative definition of the vCon CDDL. If the CDDL provided below differs or conflicts from that in the text of the above sections, the text should be taken as the definitive definition and the CDDL below should be consider incorrect. The CDDL is strict: parameters and type values which are not defined in this document cause validation to fail unless the CDDL for the vCon extension which defines them is also used. Failing validation against this CDDL is not by itself a reason to reject a vCon (see ). any } ; Encrypted Form of vCon Object ;______________________________ ; Not enforced by this CDDL, as the JWE Protected Header is an ; opaque string here: ; - enc MUST be present in the JWE Protected Header or the ; Unprotected Object. ; - alg MUST be present in the JWE Protected Header, the ; Unprotected Object or the Header Object of each recipient. ; - A header parameter MUST NOT be present in more than one of ; those locations. encrypted_vcon_type = { ? protected: base64url_value_type, unprotected: unprotected_object_type, recipients: [+ recipient_object_type], iv: base64url_value_type, ciphertext: base64url_value_type, tag: base64url_value_type, ? aad: base64url_value_type, * $$encrypted-ext } ; Unprotected Object ; Other JWE header parameters MAY be present. unprotected_object_type = { ; cty SHOULD be "application/vcon" or "application/vcon+gzip" cty: tstr, ; enc SHOULD be "A256CBC-HS512" ? enc: tstr, ? alg: tstr, ? uuid: uuid_value_type, ; SHOULD be provided * tstr => any } ; Recipient Object ; A Recipient Object with no parameters is permitted. recipient_object_type = { ? header: recipient_header_object_type, ; present when the JWE Encrypted Key is not empty ? encrypted_key: base64url_value_type, * $$recipient-ext } ; Header Object of a recipient in the encrypted form ; Other JWE header parameters MAY be present. recipient_header_object_type = { ? alg: tstr, ; SHOULD be "RSA-OAEP" * tstr => any } ; Base64Url encoded string base64url_value_type = tstr .regexp "[A-Za-z0-9_-]+" ]]>
vCon Extension Template A template for writing a vCon extension Internet-Draft is provided in kramdown-rfc markdown. It contains the sections required of an extension document in Extending vCon, along with JSON Schema and CDDL appendices. The template can be downloaded from: https://raw.githubusercontent.com/ietf-wg-vcon/draft-ietf-vcon-vcon-core/refs/heads/main/template-draft-vcon-xxxx-extension.md
Acknowledgments
  • Thank you to Thomas McCarthy-Howe for inventing the concept of a vCon and the many discussions that we had while this concept was developed into reality.
  • Thank you to Jonathan Rosenberg and Andrew Siciliano for their input to the vCon container requirements in the form of I-D: draft-rosenberg-vcon-cc-usecases and for the data structure ideas to create Session Objects instead of recording-sets type Dialogs and elevating party_history event Objects into the Event Object array at the top level and the contribution for tagging redactions and enumerating the vCon redaction techniques possible in vCon.
  • Thank you to Rohan Mahy for his help in exploring the CDDL schema and CBOR format for vCon and testing out the extension framework with MIME.
  • The examples in this document were generated using the command line interface (CLI) from the py-vcon python open source project.
  • Thank you to Steve Lasker for formatting and spelling edits.
  • Thank you to Mike Jones for input and help media types, version and helping to form the extension framework.
  • Thank you to Jonathan Lennox for numerous inputs including separate single channel recordings per party and the extension framework.
  • Thank you to Marc Petit-Huguenin for sorting out session_id.
  • Thank you to Rob Sliwa for helping to review and test the JSON Schema.
  • Thank you to Mike Jones, Richard Barnes and Mike Ounsworth for their help with providing an approach to maintaining integrity for long term storage of signed vCons.
  • Thank you to Scott Godin for several thorough reviews and the idea and help on designing the multi-segment recording metadata concept for recording-set.
  • Thank you to Henk Birkholz for identifying a few ambiguities in the syntax and a few missing IANA entries.
  • Thank you to Eugene Tcipnjatov for pushing me to solve the recording topology case where the contributors change over time.