Jargon SDK for the Jovo Framework
The Jargon SDK makes it easy for skill developers to manage their runtime content, and to support multiple languages from within their skill.
Need help localizing your skills to new languages and locales? Contact Jargon at email@example.com.
Jargon's Jovo plugin works with version 1.4 and later of the Jovo Framework.
Content resources and resource files
Content resources define the text that your Jovo application outputs to users, via the devices voice, card content, or screen content. It's important that these resources live outside of your applications's source code to make it possible to localize them into other languages.
The Jargon SDK expects resource files to live in the "resources" subdirectory within your Jovo code. Each locale has a single resouce file, named for that locale (e.g., "en-US.json").
Resource files are JSON, with a single top-level object (similar to package.json). The keys within that object are the identifiers you'll use to refer to specific resources within your source code. Nested objects are supported to help you organize your resources.
Resource value format
Resource values are in ICU MessageFormat. This format supports constructing text at runtime based on parameters passed in from your code, and selecting alternative forms to handle things like pluralization and gender.
It's important for voice applications to vary the words they use in response to users, lest they sound robotic. The Jargon SDK makes ths simple with built-in variation support. Variations are defined using nested objects:
When rendering the key
resourceWithVariations the Jargon SDK will choose a variation at random (with other more complex
methods coming in future versions). If you render the same resource multiple times within a single request (e.g., for spoken
content and for card or screen content) the SDK will by default consistently choose the same variation.
Note that you can always select a specific variation using its fully-qualified key (e.g.,
You can determine which variation the SDK chose via the ResourceManager's selectedVariation(s) routines.
After creating the Jovo application (which normally takes place in app/app.js) instantiate the Jargon plugin and register it wil the application:
const JargonPlugin =app
The Jargon plugin installs an event handler that runs for every requests. That event handler adds a
JovoJargon object to the
jovo object that's passed to your intent handlers.
The core class you'll work with. JovoJargon has methods that mirror the equivalent Jovo methods for constructing a response, but changes string parameters containing content presented to users to RenderItems.
/*** JovoJargon contains Jargon's additions to the core Jovo framework* class.*/
A RenderItem specifies a resource key, optional parameters, and options to control details of the rendering (which are themselves optional).
RenderParams are a map from parameter name to a string, number, or
The use of a
RenderItem instance as a parameter value makes it easy to compose multiple
resource together at runtime. This is useful when a parameter value varies across locales,
or when you want the SDK to select across multiple variations for a parameter value, and reduces
the need to chain together multiple calls into the
ri helper function simplifies constructing a
RenderOptions allows fine-grained control of rendering behavior for a specific call, overriding
the configuration set at the
JovoJargon uses a
ResourceManager to render strings and objects. You
can directly access the resource manager if desired, for use cases such as:
- obtaining locale-specific values that are used as parameters for later rendering operations
- incrementally or conditionally constructing complex content
- response directives that internally have locale-specific content (such as an upsell directive)
- batch rendering of multiple resources
- determining which variation the ResourceManager chose
Note that the render routines return
Promises to the rendered content, not the content directly.
ResourceManager is part of the package @jargon/sdk-core,
and can be used directly from code that isn't based on the Jovo framework.