Simulating an Application (3.0 preview)

import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import com.zqnt.protos.application_simulation.v3.ApprovalAnswer;
import com.zqnt.protos.application_simulation.v3.NodeScenario;
import com.zqnt.protos.application_simulation.v3.SimulationTrace;
import com.zqnt.protos.application_simulation.v3.StartSimulationRequest;
import com.zqnt.protos.application_simulation.v3.TraceStep;
import com.zqnt.protos.application_simulation.v3.TraceTransition;
import com.zqnt.protos.application_simulation.v3.VirtualAsset;
import com.zqnt.protos.common.v3.GeoPoint;
import com.zqnt.protos.common.v3.RequestContext;
import com.zqnt.sdk.client.simulation.application.Simulations;

import java.time.Duration;

Simulations simulations = zequent.simulations();

StartSimulationRequest request = StartSimulationRequest.newBuilder()
        .setContext(RequestContext.newBuilder().setIdempotencyKey("patrol-check-2026-10-18"))
        .setApplicationId("perimeter-patrol-app")
        .setInputs(Struct.newBuilder()
                .putFields("altitude", Value.newBuilder().setNumberValue(60).build()))
        .addNodes(NodeScenario.newBuilder()
                .setCommandId("navigation.go_to")
                .setDelay(com.google.protobuf.Duration.newBuilder().setSeconds(12 * 60)))
        .addNodes(NodeScenario.newBuilder()
                .setNodeId("inspect")
                .setOutput(Struct.newBuilder()
                        .putFields("battery_percent", Value.newBuilder().setNumberValue(18).build())))
        .addNodes(NodeScenario.newBuilder()
                .setNodeId("approve-landing")
                .setApproval(ApprovalAnswer.APPROVAL_ANSWER_NO_ANSWER))
        .addFleet(VirtualAsset.newBuilder()
                .setSn("DRONE-A")
                .addCommands("flight.takeoff").addCommands("navigation.go_to").addCommands("flight.return_to_home")
                .setPosition(GeoPoint.newBuilder().setLatitude(52.5200).setLongitude(13.4050).setAltitude(34))
                .setBatteryPercent(64))
        .addFleet(VirtualAsset.newBuilder().setCopyOfSn("DOCK-1"))
        .build();

SimulationTrace trace = simulations
        .simulate(request, Duration.ofSeconds(1), Duration.ofMinutes(2))
        .join();

System.out.println(trace.getStatus() + " on " + trace.getAssetSn()
        + ", " + trace.getDuration().getSeconds() + " s simulated");
for (TraceStep step : trace.getStepsList()) {
    System.out.println("+" + step.getOffset().getSeconds() + " s  " + step.getNodeId()
            + "  " + step.getStatus() + "  (" + step.getSimulatedBy() + ")");
    for (TraceTransition next : step.getNextList()) {
        System.out.println("    -> " + next.getTargetNodeId() + ": " + next.getReason());
    }
}
System.out.println("not taken: " + trace.getSkippedNodeIdsList());

from google.protobuf import duration_pb2, struct_pb2
from zqnt_api.generated.zqnt.application_simulation.v3 import application_simulation_pb2 as sim
from zqnt_api.generated.zqnt.common.v3 import common_pb2


def struct(values: dict) -> struct_pb2.Struct:
    result = struct_pb2.Struct()
    result.update(values)
    return result


request = sim.StartSimulationRequest(
    context=common_pb2.RequestContext(idempotency_key="patrol-check-2026-10-18"),
    application_id="perimeter-patrol-app",
    inputs=struct({"altitude": 60}),
    nodes=[
        sim.NodeScenario(command_id="navigation.go_to", delay=duration_pb2.Duration(seconds=12 * 60)),
        sim.NodeScenario(node_id="inspect", output=struct({"battery_percent": 18})),
        sim.NodeScenario(node_id="approve-landing", approval=sim.APPROVAL_ANSWER_NO_ANSWER),
    ],
    fleet=[
        sim.VirtualAsset(
            sn="DRONE-A",
            commands=["flight.takeoff", "navigation.go_to", "flight.return_to_home"],
            position=common_pb2.GeoPoint(latitude=52.5200, longitude=13.4050, altitude=34),
            battery_percent=64,
        ),
        sim.VirtualAsset(copy_of_sn="DOCK-1"),
    ],
)

trace = await client.simulations.simulate(request, interval=1.0, timeout=120)

print(sim.SimulationStatus.Name(trace.status), "on", trace.asset_sn, f"{trace.duration.seconds} s simulated")
for step in trace.steps:
    print(f"+{step.offset.seconds} s  {step.node_id}  {sim.NodeStatus.Name(step.status)}  ({step.simulated_by})")
    for next_step in step.next:
        print(f"    -> {next_step.target_node_id}: {next_step.reason}")
print("not taken:", list(trace.skipped_node_ids))

import (
    "fmt"
    "log"
    "time"

    simulationv3 "github.com/zequent/zqnt-api/go/v3/gen/zqnt/application_simulation/v3"
    commonv3 "github.com/zequent/zqnt-api/go/v3/gen/zqnt/common/v3"
    "github.com/zequent/zqnt-sdk-go/v3/client/config"
    "github.com/zequent/zqnt-sdk-go/v3/client/simulation"
    "google.golang.org/protobuf/types/known/durationpb"
    "google.golang.org/protobuf/types/known/structpb"
)

cfg, err := config.FromEnv()
if err != nil {
    log.Fatal(err)
}
conn, err := cfg.Dial(cfg.MissionAutonomy)
if err != nil {
    log.Fatal(err)
}
defer conn.Close()
sims := simulation.New(conn)

inputs, _ := structpb.NewStruct(map[string]any{"altitude": 60})
lowBattery, _ := structpb.NewStruct(map[string]any{"battery_percent": 18})
battery, altitude := 64.0, 34.0

trace, err := sims.Simulate(ctx, &simulationv3.StartSimulationRequest{
    Context:       &commonv3.RequestContext{IdempotencyKey: "patrol-check-2026-10-18"},
    ApplicationId: "perimeter-patrol-app",
    Inputs:        inputs,
    Nodes: []*simulationv3.NodeScenario{
        {CommandId: "navigation.go_to", Delay: durationpb.New(12 * time.Minute)},
        {NodeId: "inspect", Output: lowBattery},
        {NodeId: "approve-landing", Approval: simulationv3.ApprovalAnswer_APPROVAL_ANSWER_NO_ANSWER},
    },
    Fleet: []*simulationv3.VirtualAsset{
        {
            Sn:             "DRONE-A",
            Commands:       []string{"flight.takeoff", "navigation.go_to", "flight.return_to_home"},
            Position:       &commonv3.GeoPoint{Latitude: 52.5200, Longitude: 13.4050, Altitude: &altitude},
            BatteryPercent: &battery,
        },
        {CopyOfSn: "DOCK-1"},
    },
}, time.Second, 2*time.Minute)
if err != nil {
    log.Fatal(err)
}

fmt.Println(trace.GetStatus(), "on", trace.GetAssetSn(), trace.GetDuration().AsDuration(), "simulated")
for _, step := range trace.GetSteps() {
    fmt.Printf("+%s  %s  %s  (%s)\n", step.GetOffset().AsDuration(), step.GetNodeId(), step.GetStatus(), step.GetSimulatedBy())
    for _, next := range step.GetNext() {
        fmt.Printf("    -> %s: %s\n", next.GetTargetNodeId(), next.GetReason())
    }
}
fmt.Println("not taken:", trace.GetSkippedNodeIds())

StartSimulationResponse started = simulations.startSimulation(request.toBuilder().setRealTime(true).build()).join();
// ...
SimulationStatus status = simulations.cancelSimulation(started.getExecutionId()).join();
SimulationTrace trace = simulations.awaitSimulation(started.getExecutionId(), Duration.ofSeconds(1), Duration.ofSeconds(30)).join();

started = await client.simulations.start_simulation(request)
# ...
status = await client.simulations.cancel_simulation(started.execution_id)
trace = await client.simulations.wait_for_simulation(started.execution_id, timeout=30)

started, err := sims.StartSimulation(ctx, req)
// ...
status, err := sims.CancelSimulation(ctx, started.GetExecutionId())
trace, err := sims.WaitForSimulation(ctx, started.GetExecutionId(), time.Second, 30*time.Second)