Capabilities
io.Intelligence Working Context transforms how your applications understand user activity by providing comprehensive capabilities for automatically collecting and managing contextual information from multiple data sources within io.Connect. This page explains what Working Context offers and how its capabilities enable intelligent, context-aware applications.
Capability Overview
Working Context brings together schema-driven collection, source flexibility, type validation, and reactive updates.
The approved content on this page is unchanged in meaning. The new top-level framing simply makes the core capability areas easier to scan in the same style as the newer module pages.
Capability Areas at a Glance
Schema-driven configuration
Describe what you want to track and where it lives instead of hand-writing context collection logic.
Flexible source coverage
Collect data from global contexts, workspaces, channels, and application instances inside io.Connect.
Validation and path resolution
Validate values against declared types and extract nested data through dot-notation paths.
Reactive multi-source tracking
Monitor multiple sources in parallel and notify subscribers as soon as context changes occur.
Schema-Driven Configuration
At the heart of Working Context is a declarative configuration approach. Rather than manually writing code to fetch and track data from various sources, you define a schema that describes what data you want to track, where to find it, and how to access it. Working Context handles all the tracking, updating, and aggregation automatically.
Benefits of Schema-Driven Configuration
| Benefit | Description |
|---|---|
| Declarative | Describe what you need, not how to get it |
| Maintainable | Configuration changes don't require code changes |
| Type-Safe | Built-in type validation ensures data integrity |
| Centralized | All context tracking defined in one place |
Schema Structure
Each property in your schema defines:
| Element | Purpose |
|---|---|
| Name | A unique identifier for the property |
| Type | The expected data type (string, number, boolean, object, or array) |
| Description | Optional human-readable explanation of the property's purpose |
| Source | Configuration specifying where to find the data and how to access it |
{
propertyName: {
type: "string",
description: "Human-readable description",
source: {
context: {
location: { /* source location */ },
path: "nested.path.to.value"
}
}
}
}
Context Sources
Working Context can collect data from four distinct types of context sources within the io.Connect environment. Each source type provides access to different scopes of contextual information.
Global Context
Global contexts are shared across the entire io.Connect environment, making them ideal for tracking user profiles, application settings, or any data that should be accessible system-wide.
| Capability | Description |
|---|---|
| Multi-Context Tracking | Track data from one or multiple global context names |
| Automatic Monitoring | Automatically updates across all specified contexts |
| First-Found Strategy | When multiple contexts are specified, uses the first available value |
- User authentication and profile information
- Organization-wide configuration settings
- Shared reference data
Workspace Context
Workspace contexts provide access to data specific to io.Connect workspaces, enabling tracking of workspace-specific information and user workflow states.
| Target | Description |
|---|---|
"my" | Track the user's current workspace |
"focused" | Track the focused workspace (Desktop only) |
"hybrid" | Combined tracking mode (Desktop only) |
The "focused" and "hybrid" workspace targets are currently supported only in io.Connect Desktop environments.
- Active document or record tracking
- Workspace-specific user preferences
- Current workflow state
Channel Context
Channel contexts enable tracking of data published to specific io.Connect channels, facilitating cross-application data sharing and coordination.
| Capability | Description |
|---|---|
| Current Channel | Track the user's current channel ("my") |
| Named Channels | Track specific named channels |
| Real-Time Updates | Automatic updates when channel data changes |
- Real-time market data
- Shared selections across applications
- Collaborative filtering and coordination
Application Instance Context
Application instance contexts allow tracking of data from specific running application instances, enabling context awareness of what other applications are doing.
| Capability | Description |
|---|---|
| Multi-App Tracking | Track data from one or multiple application instances by name |
| First-Found Strategy | When multiple app names are specified, uses the first available |
| Lifecycle Management | Automatically handles application lifecycle events |
- Monitoring data from specific tools (e.g., trading blotters)
- Integration with specialized applications
- Cross-application workflow coordination
Property Types
Working Context supports five fundamental data types, each validated automatically to ensure type safety.
| Type | Description | Example Values |
|---|---|---|
string | Text values | "John Doe", "AAPL" |
number | Numeric values | 42, 3.14, -100 |
boolean | True/false values | true, false |
object | Complex objects (non-array) | { name: "...", age: 30 } |
array | Array values | ["item1", "item2"], [1, 2, 3] |
Type Validation
Working Context automatically validates values against their declared types:
| Scenario | Behavior |
|---|---|
| Valid values | Stored and exposed through the API |
| Invalid values | Logged with warnings and ignored |
| Missing values | Treated as undefined until available |
Data Path Resolution
Access nested data within complex objects using dot notation paths. Working Context handles the traversal automatically, extracting values from deeply nested structures.
// Context data:
{
organization: {
division: {
department: {
name: "Engineering"
}
}
}
}
// Path configuration:
path: "organization.division.department.name"
// Extracted value: "Engineering"
Reactive Updates
Working Context provides real-time reactivity to context changes across all configured sources. Changes are automatically detected and propagated to subscribers without polling or manual refresh.
How It Works
| Step | Description |
|---|---|
| 1. Automatic Monitoring | Establishes subscriptions to all configured context sources |
| 2. Change Detection | When any source data changes, automatically re-evaluates affected properties |
| 3. Value Extraction | Extracts new values using configured paths and validates them against types |
| 4. Notification | Notifies subscribers of the updated context state |
Benefits
| Benefit | Description |
|---|---|
| No Polling | Event-driven updates eliminate the need for polling or manual refresh cycles |
| Efficient Processing | Only changed properties trigger re-evaluation, minimizing unnecessary work |
| Real-Time Updates | Updates propagate immediately when sources change, keeping context current |
| Reliable Foundation | Built on io.Connect's robust context APIs for enterprise-grade reliability |
Multi-Source Tracking
Track multiple sources within a single configuration, creating a unified view of your application's context from diverse data sources.
| Capability | Description |
|---|---|
| Source Diversity | Combine data from global contexts, workspaces, channels, and app instances |
| Independent Configuration | Each property can specify its own source |
| Parallel Tracking | Independent tracking and updates per property |
| Unified Access | Consolidated access through a single API |
Example Scenario
Track user profile (global), active document (workspace), market data (channel), and portfolio (app instance) simultaneously:
{
schema: {
userName: { /* global context */ },
activeDocument: { /* workspace context */ },
marketData: { /* channel context */ },
portfolio: { /* app instance context */ }
}
}
Next Steps
- Integration — Learn how to integrate Working Context into your application
- API Reference — Complete configuration and API documentation
- Overview — Return to the Working Context overview