Defaults reference

Canonical reference for default values across the Resonate server and SDKs (TypeScript, Python, Rust).

This page is the single source of truth for default values across the Resonate server and SDKs. Every value below is sourced from a specific file and line in the canonical source repositories; if a default changes in source, this page is wrong until it is updated.

If you only want to know "what does ctx.run retry by default?" — see ctx.run / per-call options and Retry policies.

Server defaults#

The Resonate server is a Rust binary. Its source lives at resonatehq/resonate; every default below is sourced from src/config.rs. The CLI flag name is the kebab-case path through the config struct (e.g. tasks.lease_timeout → --tasks-lease-timeout); the equivalent environment variable uses double-underscore nesting (e.g. RESONATE_TASKS__LEASE_TIMEOUT). Loading order: built-in defaults → optional resonate.toml → env vars.

HTTP server#

Storage#

Tasks + background scans#

Transports#

Observability#

SDK init defaults#

The SDK init defaults are the values you get from calling new Resonate() (TypeScript), Resonate() (Python), or Resonate::local() / Resonate::new(ResonateConfig::default()) (Rust) with no arguments.

TypeScript#

There is no workers / concurrency parameter in the TypeScript SDK — task execution runs on the Node/Bun event loop with no SDK-side cap.

See TypeScript SDK Defaults for surface-scoped framing.

Python#

See Python SDK Defaults for surface-scoped framing.

Rust#

The Rust SDK has no workers parameter — function execution runs on the user-supplied Tokio runtime.

See Rust SDK Defaults for surface-scoped framing.

ctx.run / per-call options#

These are the defaults applied to a single ctx.run(...), ctx.rpc(...), or top-level resonate.run(...) call when no per-call options are passed.

TypeScript#

The TypeScript Options class sets the following defaults in its constructor:

So the practical answer to "what is the default retry behaviour of ctx.run in the TypeScript SDK?" is: Exponential() with its own defaults (see below) for regular async functions, and Never() for generator functions.

See TypeScript SDK Defaults for surface-scoped framing.

Python#

The Python Options dataclass:

See Python SDK Defaults for surface-scoped framing.

Rust#

The Rust Options struct currently exposes only structural fields:

See Rust SDK Defaults for surface-scoped framing.

Retry policies#

Retry policies are constructible by users and supplied via the per-call options. The four built-in policies share the same shape across TypeScript and Python with one important difference: TypeScript times are in milliseconds, Python times are in seconds.

Exponential#

Both SDKs use the formula min(delay * factor^attempt, maxDelay) for the n-th retry, with attempt 0 returning 0.

Constant#

Linear#

The n-th retry delay is delay * attempt in both SDKs.

Never#

Never takes no parameters in either SDK. It returns 0 on attempt 0 and null / None for all later attempts.

• TypeScript — resonate-sdk-ts/src/retries.ts:118-135
• Python — resonate-sdk-py/resonate/retry_policies/never.py

Rust#

The Rust SDK does not yet ship Exponential / Constant / Linear / Never retry-policy types — there is no per-invocation retry policy on the Rust Options struct (see the callout above). Retry behaviour for Rust workers is determined server-side via --tasks-retry-timeout.

Cross-SDK parity#

Asymmetries to call out:

• Per-call timeout. TypeScript and Rust default to 24 h; Python defaults to 1 year. Same field, very different envelope.
• ttl. TypeScript and Rust use milliseconds; Python uses seconds. Same name, different unit.
• Retry-policy time units. TypeScript retry policies are configured in milliseconds; Python retry policies are configured in seconds. The behaviour curve is identical; the numbers are not.
• Per-call retry policy. Available in TypeScript and Python; not yet on the Rust Options struct. Rust retries are governed by the server's --tasks-retry-timeout flag.
• Worker concurrency cap. Only Python imposes one (min(32, ...)). TypeScript and Rust lean on the host event-loop / runtime.

Environment variables#

The SDKs share a common set of RESONATE_* environment variables. Defaults below are the fallbacks applied when both the constructor argument and the env var are unset.

Server-side RESONATE_* environment variables (storage, auth, transports) follow the RESONATE_<SECTION>__<FIELD> convention. See Run a server › Environment variables for the complete list — those defaults track the server flag table above.