restate

name	restate
description	This skill should be used when working with Restate durable execution framework, building workflows, virtual objects, or services that need automatic retries, state management, and fault tolerance. Use when the user mentions "restate", "durable execution", "durable workflows", needs to build resilient distributed systems, or when they invoke /restate.
user-invocable	true

Restate Durable Execution Framework

Restate is a durable execution framework that makes applications resilient to failures. Use this skill when building:

• Durable workflows with automatic retries
• Services with persisted state (Virtual Objects)
• Microservice orchestration with transactional guarantees
• Event processing with exactly-once semantics
• Long-running tasks that survive crashes

When to Use Restate

Use Restate when:

• Building workflows that must complete despite failures
• Need automatic retry and recovery without manual retry logic
• Building stateful services (shopping carts, user sessions, payment processing)
• Orchestrating multiple services with saga/compensation patterns
• Processing events with exactly-once delivery guarantees
• Scheduling durable timers and cron jobs

Core Concepts

Service Types

Restate supports three service types:

1. Services - Stateless handlers with durable execution

   • Use for: microservice orchestration, sagas, idempotent requests

2. Virtual Objects - Stateful handlers with K/V state isolated per key

   • Use for: entities (shopping cart), state machines, actors, stateful event processing
   • Only one handler runs at a time per object key (consistency guarantee)

3. Workflows - Special Virtual Objects where run handler executes exactly once

   • Use for: order processing, human-in-the-loop, long-running provisioning

See Services Concepts for detailed comparison.

Durable Building Blocks

Restate provides these building blocks through the SDK context:

• Journaled actions (ctx.run()) - Persist results of side effects
• State (ctx.get/set/clear) - K/V state for Virtual Objects
• Timers (ctx.sleep()) - Durable sleep that survives restarts
• Service calls (ctx.serviceClient()) - RPC with automatic retries
• Awakeables - Wait for external events/signals

See Durable Building Blocks.

TypeScript SDK Quick Reference

Installation

npm install @restatedev/restate-sdk

Basic Service

import * as restate from "@restatedev/restate-sdk";

const myService = restate.service({
  name: "MyService",
  handlers: {
    greet: async (ctx: restate.Context, name: string) => {
      return "Hello, " + name + "!";
    },
  },
});

restate.endpoint().bind(myService).listen(9080);

Virtual Object (Stateful)

const counter = restate.object({
  name: "Counter",
  handlers: {
    add: async (ctx: restate.ObjectContext, value: number) => {
      const current = (await ctx.get<number>("count")) ?? 0;
      ctx.set("count", current + value);
      return current + value;
    },
    get: restate.handlers.object.shared(
      async (ctx: restate.ObjectSharedContext) => {
        return (await ctx.get<number>("count")) ?? 0;
      }
    ),
  },
});

Workflow

const paymentWorkflow = restate.workflow({
  name: "PaymentWorkflow",
  handlers: {
    run: async (ctx: restate.WorkflowContext, payment: Payment) => {
      // Step 1: Reserve funds
      const reservation = await ctx.run("reserve", () =>
        reserveFunds(payment)
      );

      // Step 2: Wait for approval (awakeable)
      const approved = await ctx.promise<boolean>("approval");
      if (!approved) {
        await ctx.run("cancel", () => cancelReservation(reservation));
        return { status: "cancelled" };
      }

      // Step 3: Complete payment
      await ctx.run("complete", () => completePayment(reservation));
      return { status: "completed" };
    },

    approve: async (ctx: restate.WorkflowSharedContext) => {
      ctx.promise<boolean>("approval").();
    },

    :  (: restate.) => {
      ctx.<>().();
    },
  },
});

Key SDK Patterns

// Journaled action - result persisted, replayed on retry
const result = await ctx.run("action-name", async () => {
  return await callExternalApi();
});

// Durable timer - survives restarts
await ctx.sleep(60_000); // 60 seconds

// Call another service
const client = ctx.serviceClient(OtherService);
const response = await client.handler(input);

// Async call (fire and forget)
ctx.serviceSendClient(OtherService).handler(input);

// Delayed call
ctx.serviceSendClient(OtherService, { delay: 60_000 }).handler(input);

// Awakeable - wait for external signal
const { id, promise } = ctx.awakeable<string>();
// Give `id` to external system, then:
const result = await promise;

// Random (deterministic)
const value = ctx.rand.random();
const uuid = ctx.rand.uuidv4();

Running Locally

1. Start Restate server:

npx @restatedev/restate-server

2. Run your service:

npx ts-node src/app.ts

3. Register service with Restate:

npx @restatedev/restate deployments register http://localhost:9080

4. Invoke handlers via HTTP:

# Service handler
curl localhost:8080/MyService/greet -H 'content-type: application/json' -d '"World"'

# Virtual Object handler (with key)
curl localhost:8080/Counter/user123/add -H 'content-type: application/json' -d '5'

# Start workflow
curl localhost:8080/PaymentWorkflow/order-456/run -H 'content-type: application/json' -d '{"amount": 100}'

Documentation References

Concepts

• Services - Service types and use cases
• Invocations - How invocations work
• Durable Execution - Execution guarantees
• Durable Building Blocks - SDK primitives

TypeScript SDK

• Overview - SDK setup and service definitions
• State - K/V state management
• Journaling Results - Side effects and ctx.run()
• Durable Timers - Sleep and scheduling
• Service Communication - Calling other services
• Awakeables - External events
• Workflows - Workflow implementation
• Error Handling - Error patterns
• Serving - Running services
• Testing - Testing strategies
• Clients - Client SDK

Guides

• Error Handling - Comprehensive error handling
• Sagas - Saga pattern with compensations
• Cron Jobs - Scheduled tasks
• Parallelizing Work - Fan-out patterns
• Databases - Database integration
• Lambda Deployment - AWS Lambda deployment

Use Cases

• Workflows
• Async Tasks
• Event Processing
• Microservice Orchestration

Operations

• HTTP Invocation
• Service Registration
• Versioning
• Architecture

Important Guidelines

1. Side effects must be wrapped in ctx.run() - External calls, random values, timestamps must go through the context to be journaled and replayed correctly.

2. State access only in Virtual Objects/Workflows - Plain Services don't have state access.

3. Handlers must be deterministic - Same inputs should produce same outputs. Use ctx.rand for randomness.

4. One handler per Virtual Object key at a time - Restate ensures consistency by queuing concurrent requests to the same key.

5. Workflows run handler executes exactly once - Use other handlers to query/signal the workflow.

6. Register services after code changes - Run restate deployments register to update handler definitions.

---

Generated from Restate documentation. Run scripts/sync-docs.sh to update.

License

The content in the references/ directory is derived from the Restate documentation and TypeScript SDK.