> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/iii-hq/iii/llms.txt
> Use this file to discover all available pages before exploring further.
# Built-in Functions
> Complete reference for all built-in functions automatically registered by iii framework modules
Built-in functions are automatically registered by iii framework modules and can be invoked from any worker without manual registration. These functions provide core engine capabilities like worker management, key-value storage, and observability.
## Worker Module Functions
Functions for managing workers, channels, and registered functions.
### engine::channels::create
Create a streaming channel pair for real-time communication.
Channel buffer size (default: 64, max: 1024)
Writer channel reference for sending data
Reader channel reference for receiving data
```javascript theme={null}
const result = await invoke('engine::channels::create', {
buffer_size: 100
});
// { writer: { id: "...", ... }, reader: { id: "...", ... } }
```
### engine::functions::list
List all registered functions in the engine.
Include internal engine functions (engine.\* prefix)
Array of function information objects
Function identifier
Function description
Request schema (JSON Schema)
Response schema (JSON Schema)
Additional metadata
```javascript theme={null}
const result = await invoke('engine::functions::list', {
include_internal: false
});
// { functions: [{ function_id: "myService::myFunction", ... }] }
```
### engine::workers::list
List all connected workers with metrics.
Filter by specific worker ID
Array of worker information objects
Worker unique identifier
Worker name
Runtime environment (e.g., "node", "rust")
Worker version
Operating system
IP address
Worker status
Connection timestamp (milliseconds)
Number of registered functions
Array of function IDs
Current active invocations
Latest worker metrics
Query timestamp (milliseconds)
```javascript theme={null}
const result = await invoke('engine::workers::list', {});
// { workers: [{ id: "...", name: "worker-1", runtime: "node", ... }], timestamp: 1234567890 }
```
### engine::triggers::list
List all registered triggers.
Include internal engine triggers
Array of trigger information objects
Trigger unique identifier
Type of trigger
Target function ID
Trigger configuration
```javascript theme={null}
const result = await invoke('engine::triggers::list', {
include_internal: false
});
// { triggers: [{ id: "...", trigger_type: "cron", function_id: "...", config: {...} }] }
```
### engine::workers::register
Register or update worker metadata.
Worker ID (automatically injected)
Runtime environment (e.g., "node", "rust", "python")
Worker version
Worker name
Operating system information
Telemetry metadata
Language/locale
Project name
Framework name
Registration success status
```javascript theme={null}
const result = await invoke('engine::workers::register', {
runtime: 'node',
version: '1.0.0',
name: 'my-worker',
os: 'linux x64'
});
// { success: true }
```
***
## KV Server Functions
Key-value storage functions for persistent state.
### kv\_server::get
Get a value by key from the KV store.
Index name (namespace)
Key to retrieve
The stored value, or null if not found
```javascript theme={null}
const value = await invoke('kv_server::get', {
index: 'users',
key: 'user:123'
});
// { name: "Alice", email: "alice@example.com" }
```
### kv\_server::set
Set a value by key in the KV store.
Index name (namespace)
Key to set
Value to store (any JSON-serializable data)
The key that was set
The value that was stored
Whether this was a new key (true) or update (false)
```javascript theme={null}
const result = await invoke('kv_server::set', {
index: 'users',
key: 'user:123',
value: { name: 'Alice', email: 'alice@example.com' }
});
// { key: "user:123", value: {...}, created: true }
```
### kv\_server::delete
Delete a value by key from the KV store.
Index name (namespace)
Key to delete
Whether the key was deleted
The previous value, if it existed
```javascript theme={null}
const result = await invoke('kv_server::delete', {
index: 'users',
key: 'user:123'
});
// { deleted: true, old_value: {...} }
```
### kv\_server::update
Update a value with atomic operations.
Index name (namespace)
Key to update
Array of update operations
The value before the update
The value after the update
**Update Operations:**
* `Set { path, value }` - Set a field at the specified path
* `Merge { path, value }` - Merge an object with the existing value
* `Increment { path, by }` - Add a numeric value to a field
* `Decrement { path, by }` - Subtract a numeric value from a field
* `Remove { path }` - Remove a field at the specified path
```javascript theme={null}
import { UpdateOp } from 'iii-sdk';
const result = await invoke('kv_server::update', {
index: 'users',
key: 'user:123',
ops: [
UpdateOp.increment('loginCount', 1),
UpdateOp.set('lastLogin', Date.now())
]
});
// { old_value: {...}, new_value: {...} }
```
### kv\_server::list
List all values in an index.
Index name (namespace)
Array of all values in the index
```javascript theme={null}
const result = await invoke('kv_server::list', {
index: 'users'
});
// [{ key: "user:123", value: {...} }, { key: "user:456", value: {...} }]
```
### kv\_server::list\_keys\_with\_prefix
List all keys with a specific prefix.
Key prefix to filter by
Array of matching keys
```javascript theme={null}
const result = await invoke('kv_server::list_keys_with_prefix', {
prefix: 'user:'
});
// ["user:123", "user:456", "user:789"]
```
***
## Observability Functions
Functions for logging, tracing, metrics, and monitoring.
## Logging Functions
OTEL-native logging functions with structured data support.
### engine::log::info
Log an informational message.
Log message
Structured data/attributes
Trace ID for correlation
Span ID for correlation
Service name (defaults to function name)
```javascript theme={null}
await invoke('engine::log::info', {
message: 'User logged in',
data: { userId: '123', ip: '192.168.1.1' }
});
```
### engine::log::warn
Log a warning message.
Parameters are identical to `engine::log::info`.
```javascript theme={null}
await invoke('engine::log::warn', {
message: 'Rate limit approaching',
data: { current: 950, limit: 1000 }
});
```
### engine::log::error
Log an error message.
Parameters are identical to `engine::log::info`.
```javascript theme={null}
await invoke('engine::log::error', {
message: 'Database connection failed',
data: { error: err.message, retries: 3 }
});
```
### engine::log::debug
Log a debug message.
Parameters are identical to `engine::log::info`.
```javascript theme={null}
await invoke('engine::log::debug', {
message: 'Processing request',
data: { requestId: '...' }
});
```
### engine::log::trace
Log a trace-level message.
Parameters are identical to `engine::log::info`.
```javascript theme={null}
await invoke('engine::log::trace', {
message: 'Function entry',
data: { args: [...] }
});
```
## Baggage Functions
Access and manage OpenTelemetry baggage for context propagation.
### engine::baggage::get
Get a baggage item value from the current context.
Baggage key to retrieve
Baggage value, or null if not found
```javascript theme={null}
const result = await invoke('engine::baggage::get', {
key: 'user-id'
});
// { value: "123" }
```
### engine::baggage::set
Set a baggage item value.
Baggage in OpenTelemetry is immutable. This function creates a new context but cannot propagate it back to the caller. For real baggage propagation, use SDK-level baggage headers.
Baggage key to set
Baggage value
```javascript theme={null}
await invoke('engine::baggage::set', {
key: 'user-id',
value: '123'
});
```
### engine::baggage::get\_all
Get all baggage items from the current context.
Object with all baggage key-value pairs
```javascript theme={null}
const result = await invoke('engine::baggage::get_all', {});
// { baggage: { "user-id": "123", "request-id": "..." } }
```
## Traces Functions
Query and manage distributed traces.
Trace storage is only available when the OTEL exporter is set to `memory` or `both` in configuration.
### engine::traces::list
List stored traces with filtering and pagination.
Filter by specific trace ID
Pagination offset
Maximum number of spans to return
Filter by service name (substring match)
Filter by span name (substring match)
Filter by status (substring match)
Minimum span duration in milliseconds
Maximum span duration in milliseconds
Start time in Unix timestamp milliseconds
End time in Unix timestamp milliseconds
Sort field: "duration", "start\_time", or "name"
Sort order: "asc" or "desc"
Filter by attributes (array of \[key, value] pairs)
Include internal engine traces
Array of span objects
Total number of matching spans
Current offset
Current limit
```javascript theme={null}
const result = await invoke('engine::traces::list', {
service_name: 'api',
min_duration_ms: 100,
limit: 50
});
// { spans: [...], total: 150, offset: 0, limit: 50 }
```
### engine::traces::tree
Get trace tree with nested children for a specific trace.
Trace ID to build the tree for
Array of root span tree nodes with nested children
```javascript theme={null}
const result = await invoke('engine::traces::tree', {
trace_id: '1234567890abcdef'
});
// { roots: [{ span: {...}, children: [...] }] }
```
### engine::traces::clear
Clear all stored traces from memory.
Clear operation success status
```javascript theme={null}
const result = await invoke('engine::traces::clear', {});
// { success: true }
```
## Metrics Functions
Query engine and SDK metrics.
### engine::metrics::list
List current metrics values.
Start time in Unix timestamp milliseconds
End time in Unix timestamp milliseconds
Filter by metric name
Aggregate interval in seconds
Engine internal metrics
Function invocation counters
Worker lifecycle counters
Performance statistics (avg, p50, p95, p99, min, max duration)
SDK-recorded metrics
Time-aggregated metrics (if aggregate\_interval specified)
Query timestamp
```javascript theme={null}
const result = await invoke('engine::metrics::list', {
start_time: Date.now() - 3600000,
end_time: Date.now(),
aggregate_interval: 60
});
// { engine_metrics: {...}, sdk_metrics: [...], timestamp: ... }
```
### engine::rollups::list
Get pre-aggregated metrics rollups.
Start time in Unix timestamp milliseconds (default: 1 hour ago)
End time in Unix timestamp milliseconds (default: now)
Rollup level: 0 = 1 minute, 1 = 5 minutes, 2 = 1 hour
Filter by metric name
Array of metric rollups
Array of histogram rollups
Rollup level used
```javascript theme={null}
const result = await invoke('engine::rollups::list', {
level: 1, // 5-minute rollups
metric_name: 'http.requests'
});
// { rollups: [...], histogram_rollups: [...], level: 1 }
```
## Logs Functions
Query and manage stored logs.
### engine::logs::list
List stored OTEL logs with filtering.
Filter by trace ID
Filter by span ID
Minimum severity number (1-24, higher = more severe)
Filter by severity text (e.g., "ERROR", "WARN", "INFO")
Start time in Unix timestamp milliseconds
End time in Unix timestamp milliseconds
Pagination offset
Maximum number of logs to return
Array of log entries
Total number of matching logs
```javascript theme={null}
const result = await invoke('engine::logs::list', {
severity_text: 'ERROR',
start_time: Date.now() - 3600000
});
// { logs: [...], total: 42, timestamp: ... }
```
### engine::logs::clear
Clear all stored OTEL logs.
Clear operation success status
```javascript theme={null}
const result = await invoke('engine::logs::clear', {});
// { success: true }
```
## Health and Diagnostics
### engine::health::check
Check system health status.
Overall health status
Health status of individual components
OTEL configuration status
Metrics storage status
Logs storage status
Spans storage status
Check timestamp
Engine version
```javascript theme={null}
const result = await invoke('engine::health::check', {});
// { status: "healthy", components: {...}, timestamp: ..., version: "0.7.0" }
```
### engine::sampling::rules
Get active sampling rules configuration.
Trace sampling configuration
Default sampling ratio (0.0-1.0)
Per-operation sampling rules
Whether to respect parent sampling decisions
Log sampling configuration
Log sampling ratio (0.0-1.0)
```javascript theme={null}
const result = await invoke('engine::sampling::rules', {});
// { traces: { default_ratio: 1.0, rules: [...], parent_based: true }, logs: { sampling_ratio: 1.0 } }
```
## Alerts Functions
Manage and query alert states.
### engine::alerts::list
List current alert states.
Array of alert state objects
Number of currently firing alerts
```javascript theme={null}
const result = await invoke('engine::alerts::list', {});
// { alerts: [...], firing_count: 2, timestamp: ... }
```
### engine::alerts::evaluate
Manually trigger alert evaluation.
Whether evaluation occurred
Array of alerts that triggered
```javascript theme={null}
const result = await invoke('engine::alerts::evaluate', {});
// { evaluated: true, triggered_alerts: [...], timestamp: ... }
```
***
## Error Handling
All built-in functions return errors in a consistent format:
```javascript theme={null}
{
code: "error_code",
message: "Human-readable error message"
}
```
Common error codes:
* `memory_exporter_not_enabled` - Trace/log storage not available
* `serialization_error` - Failed to serialize response data
* `invalid_input` - Invalid input parameters
***
## Best Practices
Set `include_internal: false` when querying functions, triggers, or traces to exclude engine internals from results.
Use `kv_server::update` with multiple operations instead of multiple `set` calls for better performance.
When using memory exporters, regularly clear old traces and logs to prevent memory growth.
Always include the `data` parameter with structured attributes in log functions for better queryability.
## Related Resources
Learn about iii framework modules
Configure OTEL and monitoring
Using the KV store for state
Creating custom modules